(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
'use strict';

var _jquery = require('jquery');

var _jquery2 = _interopRequireDefault(_jquery);

var _Modeler = require('bpmn-js/lib/Modeler');

var _Modeler2 = _interopRequireDefault(_Modeler);

var _bpmnJsPropertiesPanel = require('bpmn-js-properties-panel');

var _bpmnJsPropertiesPanel2 = _interopRequireDefault(_bpmnJsPropertiesPanel);

var _camunda = require('bpmn-js-properties-panel/lib/provider/camunda');

var _camunda2 = _interopRequireDefault(_camunda);

var _camunda3 = require('camunda-bpmn-moddle/resources/camunda');

var _camunda4 = _interopRequireDefault(_camunda3);

var _minDash = require('min-dash');

var _newDiagram = require('../resources/newDiagram.bpmn');

var _newDiagram2 = _interopRequireDefault(_newDiagram);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var container = (0, _jquery2.default)('#js-drop-zone');

var canvas = (0, _jquery2.default)('#js-canvas');

var bpmnModeler = new _Modeler2.default({
  container: canvas,
  propertiesPanel: {
    parent: '#js-properties-panel'
  },
  additionalModules: [_bpmnJsPropertiesPanel2.default, _camunda2.default],
  moddleExtensions: {
    camunda: _camunda4.default
  }
});
container.removeClass('with-diagram');

function createNewDiagram() {
  openDiagram(_newDiagram2.default);
}

function openDiagram(xml) {

  bpmnModeler.importXML(xml, function (err) {

    if (err) {
      container.removeClass('with-diagram').addClass('with-error');

      container.find('.error pre').text(err.message);

      console.error(err);
    } else {
      container.removeClass('with-error').addClass('with-diagram');
    }
  });
}

function saveSVG(done) {
  bpmnModeler.saveSVG(done);
}

function saveDiagram(done) {

  bpmnModeler.saveXML({ format: true }, function (err, xml) {
    done(err, xml);
  });
}

function registerFileDrop(container, callback) {

  function handleFileSelect(e) {
    e.stopPropagation();
    e.preventDefault();

    var files = e.dataTransfer.files;

    var file = files[0];

    var reader = new FileReader();

    reader.onload = function (e) {

      var xml = e.target.result;

      callback(xml);
    };

    reader.readAsText(file);
  }

  function handleDragOver(e) {
    e.stopPropagation();
    e.preventDefault();

    e.dataTransfer.dropEffect = 'copy'; // Explicitly show this is a copy.
  }

  container.get(0).addEventListener('dragover', handleDragOver, false);
  container.get(0).addEventListener('drop', handleFileSelect, false);
}

////// file drag / drop ///////////////////////

// check file api availability
if (!window.FileList || !window.FileReader) {
  window.alert('Looks like you use an older browser that does not support drag and drop. ' + 'Try using Chrome, Firefox or the Internet Explorer > 10.');
} else {
  registerFileDrop(container, openDiagram);
}

// bootstrap diagram functions

(0, _jquery2.default)(function () {

  (0, _jquery2.default)('#js-create-diagram').click(function (e) {
    e.stopPropagation();
    e.preventDefault();

    createNewDiagram();
  });

  var downloadLink = (0, _jquery2.default)('#js-download-diagram');
  var downloadSvgLink = (0, _jquery2.default)('#js-download-svg');

  (0, _jquery2.default)('.buttons a').click(function (e) {
    if (!(0, _jquery2.default)(this).is('.active')) {
      e.preventDefault();
      e.stopPropagation();
    }
  });

  function setEncoded(link, name, data) {
    var encodedData = encodeURIComponent(data);

    if (data) {
      link.addClass('active').attr({
        'href': 'data:application/bpmn20-xml;charset=UTF-8,' + encodedData,
        'download': name
      });
    } else {
      link.removeClass('active');
    }
  }

  var exportArtifacts = (0, _minDash.debounce)(function () {

    saveSVG(function (err, svg) {
      setEncoded(downloadSvgLink, 'diagram.svg', err ? null : svg);
    });

    saveDiagram(function (err, xml) {
      setEncoded(downloadLink, 'diagram.bpmn', err ? null : xml);
    });
  }, 500);

  bpmnModeler.on('commandStack.changed', exportArtifacts);
});

},{"../resources/newDiagram.bpmn":536,"bpmn-js-properties-panel":2,"bpmn-js-properties-panel/lib/provider/camunda":62,"bpmn-js/lib/Modeler":114,"camunda-bpmn-moddle/resources/camunda":229,"jquery":416,"min-dash":505}],2:[function(require,module,exports){
'use strict';

module.exports = require('./lib');

},{"./lib":32}],3:[function(require,module,exports){
'use strict';

var DEFAULT_PRIORITY = 1000;

/**
 * A component that decides upon the visibility / editable
 * state of properties in the properties panel.
 *
 * Implementors must subclass this component and override
 * {@link PropertiesActivator#isEntryVisible} and
 * {@link PropertiesActivator#isPropertyEditable} to provide
 * custom behavior.
 *
 * @class
 * @constructor
 *
 * @param {EventBus} eventBus
 * @param {Number} [priority] at which priority to hook into the activation
 */
function PropertiesActivator(eventBus, priority) {
  var self = this;

  priority = priority || DEFAULT_PRIORITY;

  eventBus.on('propertiesPanel.isEntryVisible', priority, function (e) {
    return self.isEntryVisible(e.entry, e.element);
  });

  eventBus.on('propertiesPanel.isPropertyEditable', priority, function (e) {
    return self.isPropertyEditable(e.entry, e.propertyName, e.element);
  });
}

PropertiesActivator.$inject = ['eventBus'];

module.exports = PropertiesActivator;

/**
 * Should the given entry be visible for the specified element.
 *
 * @method  PropertiesActivator#isEntryVisible
 *
 * @param {EntryDescriptor} entry
 * @param {ModdleElement} element
 *
 * @returns {Boolean}
 */
PropertiesActivator.prototype.isEntryVisible = function (entry, element) {
  return true;
};

/**
 * Should the given property be editable for the specified element
 *
 * @method  PropertiesActivator#isPropertyEditable
 *
 * @param {EntryDescriptor} entry
 * @param {String} propertyName
 * @param {ModdleElement} element
 *
 * @returns {Boolean}
 */
PropertiesActivator.prototype.isPropertyEditable = function (entry, propertyName, element) {
  return true;
};

},{}],4:[function(require,module,exports){
'use strict';

var domify = require('min-dom/lib/domify'),
    domQuery = require('min-dom/lib/query'),
    domRemove = require('min-dom/lib/remove'),
    domClasses = require('min-dom/lib/classes'),
    domClosest = require('min-dom/lib/closest'),
    domAttr = require('min-dom/lib/attr'),
    domDelegate = require('min-dom/lib/delegate'),
    domMatches = require('min-dom/lib/matches');

var forEach = require('lodash/collection/forEach'),
    filter = require('lodash/collection/filter'),
    get = require('lodash/object/get'),
    keys = require('lodash/object/keys'),
    isEmpty = require('lodash/lang/isEmpty'),
    isArray = require('lodash/lang/isArray'),
    xor = require('lodash/array/xor'),
    debounce = require('lodash/function/debounce');

var updateSelection = require('selection-update');

var scrollTabs = require('scroll-tabs');

var getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject;

var HIDE_CLASS = 'bpp-hidden';
var DEBOUNCE_DELAY = 300;

function isToggle(node) {
  return node.type === 'checkbox' || node.type === 'radio';
}

function isSelect(node) {
  return node.type === 'select-one';
}

function isContentEditable(node) {
  return domAttr(node, 'contenteditable');
}

function getPropertyPlaceholders(node) {
  var selector = 'input[name], textarea[name], [data-value], [contenteditable]';
  var placeholders = domQuery.all(selector, node);
  if ((!placeholders || !placeholders.length) && domMatches(node, selector)) {
    placeholders = [node];
  }
  return placeholders;
}

/**
 * Return all active form controls.
 * This excludes the invisible controls unless all is true
 *
 * @param {Element} node
 * @param {Boolean} [all=false]
 */
function getFormControls(node, all) {
  var controls = domQuery.all('input[name], textarea[name], select[name], [contenteditable]', node);

  if (!controls || !controls.length) {
    controls = domMatches(node, 'option') ? [node] : controls;
  }

  if (!all) {
    controls = filter(controls, function (node) {
      return !domClosest(node, '.' + HIDE_CLASS);
    });
  }

  return controls;
}

function getFormControlValuesInScope(entryNode) {
  var values = {};

  var controlNodes = getFormControls(entryNode);

  forEach(controlNodes, function (controlNode) {
    var value = controlNode.value;

    var name = domAttr(controlNode, 'name') || domAttr(controlNode, 'data-name');

    // take toggle state into account for radio / checkboxes
    if (isToggle(controlNode)) {
      if (controlNode.checked) {
        if (!domAttr(controlNode, 'value')) {
          value = true;
        } else {
          value = controlNode.value;
        }
      } else {
        value = null;
      }
    } else if (isContentEditable(controlNode)) {
      value = controlNode.innerText;
    }

    if (value !== null) {
      // return the actual value
      // handle serialization in entry provider
      // (ie. if empty string should be serialized or not)
      values[name] = value;
    }
  });

  return values;
}

/**
 * Extract input values from entry node
 *
 * @param  {DOMElement} entryNode
 * @returns {Object}
 */
function getFormControlValues(entryNode) {

  var values;

  var listContainer = domQuery('[data-list-entry-container]', entryNode);
  if (listContainer) {
    values = [];
    var listNodes = listContainer.children || [];
    forEach(listNodes, function (listNode) {
      values.push(getFormControlValuesInScope(listNode));
    });
  } else {
    values = getFormControlValuesInScope(entryNode);
  }

  return values;
}

/**
 * Return true if the given form extracted value equals
 * to an old cached version.
 *
 * @param {Object} value
 * @param {Object} oldValue
 * @return {Boolean}
 */
function valueEqual(value, oldValue) {

  if (value && !oldValue) {
    return false;
  }

  var allKeys = keys(value).concat(keys(oldValue));

  return allKeys.every(function (key) {
    return value[key] === oldValue[key];
  });
}

/**
 * Return true if the given form extracted value(s)
 * equal an old cached version.
 *
 * @param {Array<Object>|Object} values
 * @param {Array<Object>|Object} oldValues
 * @return {Boolean}
 */
function valuesEqual(values, oldValues) {

  if (isArray(values)) {

    if (values.length !== oldValues.length) {
      return false;
    }

    return values.every(function (v, idx) {
      return valueEqual(v, oldValues[idx]);
    });
  }

  return valueEqual(values, oldValues);
}

/**
 * Return a mapping of { id: entry } for all entries in the given groups in the given tabs.
 *
 * @param {Object} tabs
 * @return {Object}
 */
function extractEntries(tabs) {
  return indexBy(flattenDeep(map(flattenDeep(map(tabs, 'groups')), 'entries')), 'id');
}

/**
 * Return a mapping of { id: group } for all groups in the given tabs.
 *
 * @param {Object} tabs
 * @return {Object}
 */
function extractGroups(tabs) {
  return indexBy(flattenDeep(map(tabs, 'groups')), 'id');
}

/**
 * A properties panel implementation.
 *
 * To use it provide a `propertiesProvider` component that knows
 * about which properties to display.
 *
 * Properties edit state / visibility can be intercepted
 * via a custom {@link PropertiesActivator}.
 *
 * @class
 * @constructor
 *
 * @param {Object} config
 * @param {EventBus} eventBus
 * @param {Modeling} modeling
 * @param {PropertiesProvider} propertiesProvider
 * @param {Canvas} canvas
 * @param {CommandStack} commandStack
 */
function PropertiesPanel(config, eventBus, modeling, propertiesProvider, commandStack, canvas) {

  this._eventBus = eventBus;
  this._modeling = modeling;
  this._commandStack = commandStack;
  this._canvas = canvas;
  this._propertiesProvider = propertiesProvider;

  this._init(config);
}

PropertiesPanel.$inject = ['config.propertiesPanel', 'eventBus', 'modeling', 'propertiesProvider', 'commandStack', 'canvas'];

module.exports = PropertiesPanel;

PropertiesPanel.prototype._init = function (config) {

  var eventBus = this._eventBus;

  var self = this;

  /**
   * Select the root element once it is added to the canvas
   */
  eventBus.on('root.added', function (e) {
    self.update(e.element);
  });

  eventBus.on('selection.changed', function (e) {
    var newElement = e.newSelection[0];

    self.update(newElement);
  });

  // add / update tab-bar scrolling
  eventBus.on(['propertiesPanel.changed', 'propertiesPanel.resized'], function (event) {

    var tabBarNode = domQuery('.bpp-properties-tab-bar', self._container);

    if (!tabBarNode) {
      return;
    }

    var scroller = scrollTabs.get(tabBarNode);

    if (!scroller) {

      // we did not initialize yet, do that
      // now and make sure we select the active
      // tab on scroll update
      scroller = scrollTabs(tabBarNode, {
        selectors: {
          tabsContainer: '.bpp-properties-tabs-links',
          tab: '.bpp-properties-tabs-links li',
          ignore: '.bpp-hidden',
          active: '.bpp-active'
        }
      });

      scroller.on('scroll', function (newActiveNode, oldActiveNode, direction) {

        var linkNode = domQuery('[data-tab-target]', newActiveNode);

        var tabId = domAttr(linkNode, 'data-tab-target');

        self.activateTab(tabId);
      });
    }

    // react on tab changes and or tabContainer resize
    // and make sure the active tab is shown completely
    scroller.update();
  });

  eventBus.on('elements.changed', function (e) {

    var current = self._current;
    var element = current && current.element;

    if (element) {
      if (e.elements.indexOf(element) !== -1) {
        self.update(element);
      }
    }
  });

  eventBus.on('elementTemplates.changed', function () {
    var current = self._current;
    var element = current && current.element;

    if (element) {
      self.update(element);
    }
  });

  eventBus.on('diagram.destroy', function () {
    self.detach();
  });

  this._container = domify('<div class="bpp-properties-panel"></div>');

  this._bindListeners(this._container);

  if (config && config.parent) {
    this.attachTo(config.parent);
  }
};

PropertiesPanel.prototype.attachTo = function (parentNode) {

  if (!parentNode) {
    throw new Error('parentNode required');
  }

  // ensure we detach from the
  // previous, old parent
  this.detach();

  // unwrap jQuery if provided
  if (parentNode.get && parentNode.constructor.prototype.jquery) {
    parentNode = parentNode.get(0);
  }

  if (typeof parentNode === 'string') {
    parentNode = domQuery(parentNode);
  }

  var container = this._container;

  parentNode.appendChild(container);

  this._emit('attach');
};

PropertiesPanel.prototype.detach = function () {

  var container = this._container,
      parentNode = container.parentNode;

  if (!parentNode) {
    return;
  }

  this._emit('detach');

  parentNode.removeChild(container);
};

/**
 * Select the given tab within the properties panel.
 *
 * @param {Object|String} tab
 */
PropertiesPanel.prototype.activateTab = function (tab) {

  var tabId = typeof tab === 'string' ? tab : tab.id;

  var current = this._current;

  var panelNode = current.panel;

  var allTabNodes = domQuery.all('.bpp-properties-tab', panelNode),
      allTabLinkNodes = domQuery.all('.bpp-properties-tab-link', panelNode);

  forEach(allTabNodes, function (tabNode) {

    var currentTabId = domAttr(tabNode, 'data-tab');

    domClasses(tabNode).toggle('bpp-active', tabId === currentTabId);
  });

  forEach(allTabLinkNodes, function (tabLinkNode) {

    var tabLink = domQuery('[data-tab-target]', tabLinkNode),
        currentTabId = domAttr(tabLink, 'data-tab-target');

    domClasses(tabLinkNode).toggle('bpp-active', tabId === currentTabId);
  });
};

/**
 * Update the DOM representation of the properties panel
 */
PropertiesPanel.prototype.update = function (element) {
  var current = this._current;

  // no actual selection change
  var needsCreate = true;

  if (typeof element === 'undefined') {

    // use RootElement of BPMN diagram to generate properties panel if no element is selected
    element = this._canvas.getRootElement();
  }

  var newTabs = this._propertiesProvider.getTabs(element);

  if (current && current.element === element) {
    // see if we can reuse the existing panel

    needsCreate = this._entriesChanged(current, newTabs);
  }

  if (needsCreate) {

    if (current) {

      // get active tab from the existing panel before remove it
      var activeTabNode = domQuery('.bpp-properties-tab.bpp-active', current.panel);

      var activeTabId;
      if (activeTabNode) {
        activeTabId = domAttr(activeTabNode, 'data-tab');
      }

      // remove old panel
      domRemove(current.panel);
    }

    this._current = this._create(element, newTabs);

    // activate the saved active tab from the remove panel or the first tab
    activeTabId ? this.activateTab(activeTabId) : this.activateTab(this._current.tabs[0]);
  }

  if (this._current) {
    // make sure correct tab contents are visible
    this._updateActivation(this._current);
  }

  this._emit('changed');
};

/**
 * Returns true if one of two groups has different entries than the other.
 *
 * @param  {Object} current
 * @param  {Object} newTabs
 * @return {Booelan}
 */
PropertiesPanel.prototype._entriesChanged = function (current, newTabs) {

  var oldEntryIds = keys(current.entries),
      newEntryIds = keys(extractEntries(newTabs));

  return !isEmpty(xor(oldEntryIds, newEntryIds));
};

PropertiesPanel.prototype._emit = function (event) {
  this._eventBus.fire('propertiesPanel.' + event, { panel: this, current: this._current });
};

PropertiesPanel.prototype._bindListeners = function (container) {

  var self = this;

  // handles a change for a given event
  var handleChange = function handleChange(event) {

    // see if we handle a change inside a [data-entry] element.
    // if not, drop out
    var node = domClosest(event.delegateTarget, '[data-entry]'),
        entryId,
        entry;

    // change from outside a [data-entry] element, simply ignore
    if (!node) {
      return;
    }

    entryId = domAttr(node, 'data-entry');
    entry = self.getEntry(entryId);

    var values = getFormControlValues(node);

    if (event.type === 'change') {

      // - if the "data-on-change" attribute is present and a value is changed,
      //   then the associated action is performed.
      // - if the associated action returns "true" then an update to the business
      //   object is done
      // - if it does not return "true", then only the DOM content is updated
      var onChangeAction = event.delegateTarget.getAttribute('data-on-change');

      if (onChangeAction) {
        var isEntryDirty = self.executeAction(entry, node, onChangeAction, event);

        if (!isEntryDirty) {
          return self.update(self._current.element);
        }
      }
    }
    self.applyChanges(entry, values, node);
    self.updateState(entry, node);
  };

  // debounce update only elements that are target of key events,
  // i.e. INPUT and TEXTAREA. SELECTs will trigger an immediate update anyway.
  domDelegate.bind(container, 'input, textarea, [contenteditable]', 'input', debounce(handleChange, DEBOUNCE_DELAY));
  domDelegate.bind(container, 'input, textarea, select, [contenteditable]', 'change', handleChange);

  domDelegate.bind(container, '[data-action]', 'click', function onClick(event) {

    // triggers on all inputs
    var inputNode = event.delegateTarget;
    var entryNode = domClosest(inputNode, '[data-entry]');

    var actionId = domAttr(inputNode, 'data-action'),
        entryId = domAttr(entryNode, 'data-entry');

    var entry = self.getEntry(entryId);

    var isEntryDirty = self.executeAction(entry, entryNode, actionId, event);

    if (isEntryDirty) {
      var values = getFormControlValues(entryNode);

      self.applyChanges(entry, values, entryNode);
    }

    self.updateState(entry, entryNode);
  });

  function handleInput(event, element) {
    // triggers on all inputs
    var inputNode = event.delegateTarget;

    var entryNode = domClosest(inputNode, '[data-entry]');

    // only work on data entries
    if (!entryNode) {
      return;
    }

    var eventHandlerId = domAttr(inputNode, 'data-blur'),
        entryId = domAttr(entryNode, 'data-entry');

    var entry = self.getEntry(entryId);

    var isEntryDirty = self.executeAction(entry, entryNode, eventHandlerId, event);

    if (isEntryDirty) {
      var values = getFormControlValues(entryNode);

      self.applyChanges(entry, values, entryNode);
    }

    self.updateState(entry, entryNode);
  }

  domDelegate.bind(container, '[data-blur]', 'blur', handleInput, true);

  // make tab links interactive
  domDelegate.bind(container, '.bpp-properties-tabs-links [data-tab-target]', 'click', function (event) {
    event.preventDefault();

    var delegateTarget = event.delegateTarget;

    var tabId = domAttr(delegateTarget, 'data-tab-target');

    // activate tab on link click
    self.activateTab(tabId);
  });
};

PropertiesPanel.prototype.updateState = function (entry, entryNode) {
  this.updateShow(entry, entryNode);
  this.updateDisable(entry, entryNode);
};

/**
 * Update the visibility of the entry node in the DOM
 */
PropertiesPanel.prototype.updateShow = function (entry, node) {

  var current = this._current;

  if (!current) {
    return;
  }

  var showNodes = domQuery.all('[data-show]', node) || [];

  forEach(showNodes, function (showNode) {

    var expr = domAttr(showNode, 'data-show');
    var fn = get(entry, expr);
    if (fn) {
      var scope = domClosest(showNode, '[data-scope]') || node;
      var shouldShow = fn(current.element, node, showNode, scope) || false;
      if (shouldShow) {
        domClasses(showNode).remove(HIDE_CLASS);
      } else {
        domClasses(showNode).add(HIDE_CLASS);
      }
    }
  });
};

/**
 * Evaluates a given function. If it returns true, then the
 * node is marked as "disabled".
 */
PropertiesPanel.prototype.updateDisable = function (entry, node) {
  var current = this._current;

  if (!current) {
    return;
  }

  var nodes = domQuery.all('[data-disable]', node) || [];

  forEach(nodes, function (currentNode) {
    var expr = domAttr(currentNode, 'data-disable');
    var fn = get(entry, expr);
    if (fn) {
      var scope = domClosest(currentNode, '[data-scope]') || node;
      var shouldDisable = fn(current.element, node, currentNode, scope) || false;
      domAttr(currentNode, 'disabled', shouldDisable ? '' : null);
    }
  });
};

PropertiesPanel.prototype.executeAction = function (entry, entryNode, actionId, event) {
  var current = this._current;

  if (!current) {
    return;
  }

  var fn = get(entry, actionId);
  if (fn) {
    var scopeNode = domClosest(event.target, '[data-scope]') || entryNode;
    return fn.apply(entry, [current.element, entryNode, event, scopeNode]);
  }
};

/**
 * Apply changes to the business object by executing a command
 */
PropertiesPanel.prototype.applyChanges = function (entry, values, containerElement) {

  var element = this._current.element;

  // ensure we only update the model if we got dirty changes
  if (valuesEqual(values, entry.oldValues)) {
    return;
  }

  var command = entry.set(element, values, containerElement);

  var commandToExecute;

  if (isArray(command)) {
    if (command.length) {
      commandToExecute = {
        cmd: 'properties-panel.multi-command-executor',
        context: flattenDeep(command)
      };
    }
  } else {
    commandToExecute = command;
  }

  if (commandToExecute) {
    this._commandStack.execute(commandToExecute.cmd, commandToExecute.context || { element: element });
  } else {
    this.update(element);
  }
};

/**
 * apply validation errors in the DOM and show or remove an error message near the entry node.
 */
PropertiesPanel.prototype.applyValidationErrors = function (validationErrors, entryNode) {

  var valid = true;

  var controlNodes = getFormControls(entryNode, true);

  forEach(controlNodes, function (controlNode) {

    var name = domAttr(controlNode, 'name') || domAttr(controlNode, 'data-name');

    var error = validationErrors && validationErrors[name];

    var errorMessageNode = domQuery('.bpp-error-message', controlNode.parentNode);

    if (error) {
      valid = false;

      if (!errorMessageNode) {
        errorMessageNode = domify('<div></div>');

        domClasses(errorMessageNode).add('bpp-error-message');

        // insert errorMessageNode after controlNode
        controlNode.parentNode.insertBefore(errorMessageNode, controlNode.nextSibling);
      }

      errorMessageNode.innerHTML = error;

      domClasses(controlNode).add('invalid');
    } else {
      domClasses(controlNode).remove('invalid');

      if (errorMessageNode) {
        controlNode.parentNode.removeChild(errorMessageNode);
      }
    }
  });

  return valid;
};

/**
 * Check if the entry contains valid input
 */
PropertiesPanel.prototype.validate = function (entry, values, entryNode) {
  var self = this;

  var current = this._current;

  var valid = true;

  entryNode = entryNode || domQuery('[data-entry="' + entry.id + '"]', current.panel);

  if (values instanceof Array) {
    var listContainer = domQuery('[data-list-entry-container]', entryNode),
        listEntryNodes = listContainer.children || [];

    // create new elements
    for (var i = 0; i < values.length; i++) {
      var listValue = values[i];

      if (entry.validateListItem) {

        var validationErrors = entry.validateListItem(current.element, listValue, entryNode, i),
            listEntryNode = listEntryNodes[i];

        valid = self.applyValidationErrors(validationErrors, listEntryNode) && valid;
      }
    }
  } else {
    if (entry.validate) {
      this.validationErrors = entry.validate(current.element, values, entryNode);

      valid = self.applyValidationErrors(this.validationErrors, entryNode) && valid;
    }
  }

  return valid;
};

PropertiesPanel.prototype.getEntry = function (id) {
  return this._current && this._current.entries[id];
};

var flattenDeep = require('lodash/array/flattenDeep'),
    indexBy = require('lodash/collection/indexBy'),
    map = require('lodash/collection/map');

PropertiesPanel.prototype._create = function (element, tabs) {

  if (!element) {
    return null;
  }

  var containerNode = this._container;

  var panelNode = this._createPanel(element, tabs);

  containerNode.appendChild(panelNode);

  var entries = extractEntries(tabs);
  var groups = extractGroups(tabs);

  return {
    tabs: tabs,
    groups: groups,
    entries: entries,
    element: element,
    panel: panelNode
  };
};

/**
 * Update variable parts of the entry node on element changes.
 *
 * @param {djs.model.Base} element
 * @param {EntryDescriptor} entry
 * @param {Object} values
 * @param {HTMLElement} entryNode
 * @param {Number} idx
 */
PropertiesPanel.prototype._bindTemplate = function (element, entry, values, entryNode, idx) {

  var eventBus = this._eventBus;

  function isPropertyEditable(entry, propertyName) {
    return eventBus.fire('propertiesPanel.isPropertyEditable', {
      entry: entry,
      propertyName: propertyName,
      element: element
    });
  }

  var inputNodes = getPropertyPlaceholders(entryNode);

  forEach(inputNodes, function (node) {

    var name, newValue, editable;

    // we deal with an input element
    if ('value' in node || isContentEditable(node) === 'true') {
      name = domAttr(node, 'name') || domAttr(node, 'data-name');
      newValue = values[name];

      editable = isPropertyEditable(entry, name);
      if (editable && entry.editable) {
        editable = entry.editable(element, entryNode, node, name, newValue, idx);
      }

      domAttr(node, 'readonly', editable ? null : '');
      domAttr(node, 'disabled', editable ? null : '');

      // take full control over setting the value
      // and possibly updating the input in entry#setControlValue
      if (entry.setControlValue) {
        entry.setControlValue(element, entryNode, node, name, newValue, idx);
      } else if (isToggle(node)) {
        setToggleValue(node, newValue);
      } else if (isSelect(node)) {
        setSelectValue(node, newValue);
      } else {
        setInputValue(node, newValue);
      }
    }

    // we deal with some non-editable html element
    else {
        name = domAttr(node, 'data-value');
        newValue = values[name];
        if (entry.setControlValue) {
          entry.setControlValue(element, entryNode, node, name, newValue, idx);
        } else {
          setTextValue(node, newValue);
        }
      }
  });
};

// TODO(nikku): WTF freaking name? Change / clarify.
PropertiesPanel.prototype._updateActivation = function (current) {
  var self = this;

  var eventBus = this._eventBus;

  var element = current.element;

  function isEntryVisible(entry) {
    return eventBus.fire('propertiesPanel.isEntryVisible', {
      entry: entry,
      element: element
    });
  }

  function isGroupVisible(group, element, groupNode) {
    if (typeof group.enabled === 'function') {
      return group.enabled(element, groupNode);
    } else {
      return true;
    }
  }

  function isTabVisible(tab, element) {
    if (typeof tab.enabled === 'function') {
      return tab.enabled(element);
    } else {
      return true;
    }
  }

  function toggleVisible(node, visible) {
    domClasses(node).toggle(HIDE_CLASS, !visible);
  }

  // check whether the active tab is visible
  // if not: set the first tab as active tab
  function checkActiveTabVisibility(node, visible) {
    var isActive = domClasses(node).has('bpp-active');
    if (!visible && isActive) {
      self.activateTab(current.tabs[0]);
    }
  }

  function updateLabel(element, selector, text) {
    var labelNode = domQuery(selector, element);

    if (!labelNode) {
      return;
    }

    labelNode.textContent = text;
  }

  var panelNode = current.panel;

  forEach(current.tabs, function (tab) {

    var tabNode = domQuery('[data-tab=' + tab.id + ']', panelNode);
    var tabLinkNode = domQuery('[data-tab-target=' + tab.id + ']', panelNode).parentNode;

    var tabVisible = false;

    forEach(tab.groups, function (group) {

      var groupVisible = false;

      var groupNode = domQuery('[data-group=' + group.id + ']', tabNode);

      forEach(group.entries, function (entry) {

        var entryNode = domQuery('[data-entry="' + entry.id + '"]', groupNode);

        var entryVisible = isEntryVisible(entry);

        groupVisible = groupVisible || entryVisible;

        toggleVisible(entryNode, entryVisible);

        var values = 'get' in entry ? entry.get(element, entryNode) : {};

        if (values instanceof Array) {
          var listEntryContainer = domQuery('[data-list-entry-container]', entryNode);
          var existingElements = listEntryContainer.children || [];

          for (var i = 0; i < values.length; i++) {
            var listValue = values[i];
            var listItemNode = existingElements[i];
            if (!listItemNode) {
              listItemNode = domify(entry.createListEntryTemplate(listValue, i, listEntryContainer));
              listEntryContainer.appendChild(listItemNode);
            }
            domAttr(listItemNode, 'data-index', i);

            self._bindTemplate(element, entry, listValue, listItemNode, i);
          }

          var entriesToRemove = existingElements.length - values.length;

          for (var j = 0; j < entriesToRemove; j++) {
            // remove orphaned element
            listEntryContainer.removeChild(listEntryContainer.lastChild);
          }
        } else {
          self._bindTemplate(element, entry, values, entryNode);
        }

        // update conditionally visible elements
        self.updateState(entry, entryNode);
        self.validate(entry, values, entryNode);

        // remember initial state for later dirty checking
        entry.oldValues = getFormControlValues(entryNode);
      });

      if (typeof group.label === 'function') {
        updateLabel(groupNode, '.group-label', group.label(element, groupNode));
      }

      groupVisible = groupVisible && isGroupVisible(group, element, groupNode);

      tabVisible = tabVisible || groupVisible;

      toggleVisible(groupNode, groupVisible);
    });

    tabVisible = tabVisible && isTabVisible(tab, element);

    toggleVisible(tabNode, tabVisible);
    toggleVisible(tabLinkNode, tabVisible);

    checkActiveTabVisibility(tabNode, tabVisible);
  });

  // inject elements id into header
  updateLabel(panelNode, '[data-label-id]', getBusinessObject(element).id || '');
};

PropertiesPanel.prototype._createPanel = function (element, tabs) {
  var self = this;

  var panelNode = domify('<div class="bpp-properties"></div>'),
      headerNode = domify('<div class="bpp-properties-header">' + '<div class="label" data-label-id></div>' + '<div class="search">' + '<input type="search" placeholder="Search for property" />' + '<button><span>Search</span></button>' + '</div>' + '</div>'),
      tabBarNode = domify('<div class="bpp-properties-tab-bar"></div>'),
      tabLinksNode = domify('<ul class="bpp-properties-tabs-links"></ul>'),
      tabContainerNode = domify('<div class="bpp-properties-tabs-container"></div>');

  panelNode.appendChild(headerNode);

  forEach(tabs, function (tab, tabIndex) {

    if (!tab.id) {
      throw new Error('tab must have an id');
    }

    var tabNode = domify('<div class="bpp-properties-tab" data-tab="' + tab.id + '"></div>'),
        tabLinkNode = domify('<li class="bpp-properties-tab-link">' + '<a href data-tab-target="' + tab.id + '">' + tab.label + '</a>' + '</li>');

    var groups = tab.groups;

    forEach(groups, function (group) {

      if (!group.id) {
        throw new Error('group must have an id');
      }

      var groupNode = domify('<div class="bpp-properties-group" data-group="' + group.id + '">' + '<span class="group-toggle"></span>' + '<span class="group-label">' + group.label + '</span>' + '</div>');

      // TODO(nre): use event delegation to handle that...
      groupNode.querySelector('.group-toggle').addEventListener('click', function (evt) {
        domClasses(groupNode).toggle('group-closed');
        evt.preventDefault();
        evt.stopPropagation();
      });
      groupNode.addEventListener('click', function (evt) {
        if (!evt.defaultPrevented && domClasses(groupNode).has('group-closed')) {
          domClasses(groupNode).remove('group-closed');
        }
      });

      forEach(group.entries, function (entry) {

        if (!entry.id) {
          throw new Error('entry must have an id');
        }

        var html = entry.html;

        if (typeof html === 'string') {
          html = domify(html);
        }

        // unwrap jquery
        if (html.get && html.constructor.prototype.jquery) {
          html = html.get(0);
        }

        var entryNode = domify('<div class="bpp-properties-entry" data-entry="' + entry.id + '"></div>');

        forEach(entry.cssClasses || [], function (cssClass) {
          domClasses(entryNode).add(cssClass);
        });

        entryNode.appendChild(html);

        groupNode.appendChild(entryNode);

        // update conditionally visible elements
        self.updateState(entry, entryNode);
      });

      tabNode.appendChild(groupNode);
    });

    tabLinksNode.appendChild(tabLinkNode);
    tabContainerNode.appendChild(tabNode);
  });

  tabBarNode.appendChild(tabLinksNode);

  panelNode.appendChild(tabBarNode);
  panelNode.appendChild(tabContainerNode);

  return panelNode;
};

function setInputValue(node, value) {

  var contentEditable = isContentEditable(node);

  var oldValue = contentEditable ? node.innerText : node.value;

  var selection;

  // prevents input fields from having the value 'undefined'
  if (value === undefined) {
    value = '';
  }

  if (oldValue === value) {
    return;
  }

  // update selection on undo/redo
  if (document.activeElement === node) {
    selection = updateSelection(getSelection(node), oldValue, value);
  }

  if (contentEditable) {
    node.innerText = value;
  } else {
    node.value = value;
  }

  if (selection) {
    setSelection(node, selection);
  }
}

function setSelectValue(node, value) {
  if (value !== undefined) {
    node.value = value;
  }
}

function setToggleValue(node, value) {
  var nodeValue = node.value;

  node.checked = value === nodeValue || !domAttr(node, 'value') && value;
}

function setTextValue(node, value) {
  node.textContent = value;
}

function getSelection(node) {

  return isContentEditable(node) ? getContentEditableSelection(node) : {
    start: node.selectionStart,
    end: node.selectionEnd
  };
}

function getContentEditableSelection(node) {

  var selection = window.getSelection();

  var focusNode = selection.focusNode,
      focusOffset = selection.focusOffset,
      anchorOffset = selection.anchorOffset;

  if (!focusNode) {
    throw new Error('not selected');
  }

  // verify we have selection on the current element
  if (!node.contains(focusNode)) {
    throw new Error('not selected');
  }

  return {
    start: Math.min(focusOffset, anchorOffset),
    end: Math.max(focusOffset, anchorOffset)
  };
}

function setSelection(node, selection) {

  if (isContentEditable(node)) {
    setContentEditableSelection(node, selection);
  } else {
    node.selectionStart = selection.start;
    node.selectionEnd = selection.end;
  }
}

function setContentEditableSelection(node, selection) {

  var focusNode, domRange, domSelection;

  focusNode = node.firstChild || node, domRange = document.createRange();
  domRange.setStart(focusNode, selection.start);
  domRange.setEnd(focusNode, selection.end);

  domSelection = window.getSelection();
  domSelection.removeAllRanges();
  domSelection.addRange(domRange);
}

},{"bpmn-js/lib/util/ModelUtil":216,"lodash/array/flattenDeep":417,"lodash/array/xor":419,"lodash/collection/filter":420,"lodash/collection/forEach":422,"lodash/collection/indexBy":423,"lodash/collection/map":424,"lodash/function/debounce":426,"lodash/lang/isArray":489,"lodash/lang/isEmpty":490,"lodash/object/get":497,"lodash/object/keys":498,"min-dom/lib/attr":105,"min-dom/lib/classes":106,"min-dom/lib/closest":108,"min-dom/lib/delegate":109,"min-dom/lib/domify":110,"min-dom/lib/matches":111,"min-dom/lib/query":112,"min-dom/lib/remove":113,"scroll-tabs":525,"selection-update":533}],5:[function(require,module,exports){
'use strict';

var domQuery = require('min-dom/lib/query'),
    domClear = require('min-dom/lib/clear'),
    is = require('bpmn-js/lib/util/ModelUtil').is,
    forEach = require('lodash/collection/forEach'),
    domify = require('min-dom/lib/domify'),
    Ids = require('ids');

var SPACE_REGEX = /\s/;

// for QName validation as per http://www.w3.org/TR/REC-xml/#NT-NameChar
var QNAME_REGEX = /^([a-z][\w-.]*:)?[a-z_][\w-.]*$/i;

// for ID validation as per BPMN Schema (QName - Namespace)
var ID_REGEX = /^[a-z_][\w-.]*$/i;

var PLACEHOLDER_REGEX = /\$\{([^\}]*)\}/g;

function selectedOption(selectBox) {
  if (selectBox.selectedIndex >= 0) {
    return selectBox.options[selectBox.selectedIndex].value;
  }
}

module.exports.selectedOption = selectedOption;

function selectedType(elementSyntax, inputNode) {
  var typeSelect = domQuery(elementSyntax, inputNode);
  return selectedOption(typeSelect);
}

module.exports.selectedType = selectedType;

/**
 * Retrieve the root element the document this
 * business object is contained in.
 *
 * @return {ModdleElement}
 */
function getRoot(businessObject) {
  var parent = businessObject;
  while (parent.$parent) {
    parent = parent.$parent;
  }
  return parent;
}

module.exports.getRoot = getRoot;

/**
 * filters all elements in the list which have a given type.
 * removes a new list
 */
function filterElementsByType(objectList, type) {
  var list = objectList || [];
  var result = [];
  forEach(list, function (obj) {
    if (is(obj, type)) {
      result.push(obj);
    }
  });
  return result;
}

module.exports.filterElementsByType = filterElementsByType;

function findRootElementsByType(businessObject, referencedType) {
  var root = getRoot(businessObject);

  return filterElementsByType(root.rootElements, referencedType);
}

module.exports.findRootElementsByType = findRootElementsByType;

function removeAllChildren(domElement) {
  while (domElement.firstChild) {
    domElement.removeChild(domElement.firstChild);
  }
}

module.exports.removeAllChildren = removeAllChildren;

/**
 * adds an empty option to the list
 */
function addEmptyParameter(list) {
  return list.push({ 'label': '', 'value': '', 'name': '' });
}

module.exports.addEmptyParameter = addEmptyParameter;

/**
 * returns a list with all root elements for the given parameter 'referencedType'
 */
function refreshOptionsModel(businessObject, referencedType) {
  var model = [];
  var referableObjects = findRootElementsByType(businessObject, referencedType);
  forEach(referableObjects, function (obj) {
    model.push({
      label: (obj.name || '') + ' (id=' + obj.id + ')',
      value: obj.id,
      name: obj.name
    });
  });
  return model;
}

module.exports.refreshOptionsModel = refreshOptionsModel;

/**
 * fills the drop down with options
 */
function updateOptionsDropDown(domSelector, businessObject, referencedType, entryNode) {
  var options = refreshOptionsModel(businessObject, referencedType);
  addEmptyParameter(options);
  var selectBox = domQuery(domSelector, entryNode);
  domClear(selectBox);

  forEach(options, function (option) {
    var optionEntry = domify('<option value="' + option.value + '">' + option.label + '</option>');
    selectBox.appendChild(optionEntry);
  });
  return options;
}

module.exports.updateOptionsDropDown = updateOptionsDropDown;

/**
 * checks whether the id value is valid
 *
 * @param {ModdleElement} bo
 * @param {String} idValue
 *
 * @return {String} error message
 */
function isIdValid(bo, idValue) {
  var assigned = bo.$model.ids.assigned(idValue);

  var idExists = assigned && assigned !== bo;

  if (!idValue || idExists) {
    return 'Element must have an unique id.';
  }

  return validateId(idValue);
}

module.exports.isIdValid = isIdValid;

function validateId(idValue) {

  idValue = stripPlaceholders(idValue);

  if (containsSpace(idValue)) {
    return 'Id must not contain spaces.';
  }

  if (!ID_REGEX.test(idValue)) {

    if (QNAME_REGEX.test(idValue)) {
      return 'Id must not contain prefix.';
    }

    return 'Id must be a valid QName.';
  }
}

module.exports.validateId = validateId;

function containsSpace(value) {
  return SPACE_REGEX.test(value);
}

module.exports.containsSpace = containsSpace;

function stripPlaceholders(idValue) {

  // replace expression e.g. ${VERSION_TAG}
  // use only the content between ${}
  // for the REGEX check
  return idValue.replace(PLACEHOLDER_REGEX, '$1');
}

/**
 * generate a semantic id with given prefix
 */
function nextId(prefix) {
  var ids = new Ids([32, 32, 1]);

  return ids.nextPrefixed(prefix);
}

module.exports.nextId = nextId;

function triggerClickEvent(element) {
  var evt;
  var eventType = 'click';

  if (document.createEvent) {
    try {
      // Chrome, Safari, Firefox
      evt = new MouseEvent(eventType, { view: window, bubbles: true, cancelable: true });
    } catch (e) {
      // IE 11, PhantomJS (wat!)
      evt = document.createEvent('MouseEvent');

      evt.initEvent(eventType, true, true);
    }
    return element.dispatchEvent(evt);
  } else {
    // Welcome IE
    evt = document.createEventObject();

    return element.fireEvent('on' + eventType, evt);
  }
}

module.exports.triggerClickEvent = triggerClickEvent;

},{"bpmn-js/lib/util/ModelUtil":216,"ids":414,"lodash/collection/forEach":422,"min-dom/lib/clear":107,"min-dom/lib/domify":110,"min-dom/lib/query":112}],6:[function(require,module,exports){
'use strict';

var elementHelper = require('../helper/ElementHelper');

/**
 * A handler capable of creating a new element under a provided parent
 * and updating / creating a reference to it in one atomic action.
 *
 * @class
 * @constructor
 */
function CreateAndReferenceElementHandler(elementRegistry, bpmnFactory) {
  this._elementRegistry = elementRegistry;
  this._bpmnFactory = bpmnFactory;
}

CreateAndReferenceElementHandler.$inject = ['elementRegistry', 'bpmnFactory'];

module.exports = CreateAndReferenceElementHandler;

function ensureNotNull(prop, name) {
  if (!prop) {
    throw new Error(name + ' required');
  }
  return prop;
}

////// api /////////////////////////////////////////////

/**
 * Creates a new element under a provided parent and updates / creates a reference to it in
 * one atomic action.
 *
 * @method  CreateAndReferenceElementHandler#execute
 *
 * @param {Object} context
 * @param {djs.model.Base} context.element which is the context for the reference
 * @param {moddle.referencingObject} context.referencingObject the object which creates the reference
 * @param {String} context.referenceProperty the property of the referencingObject which makes the reference
 * @param {moddle.newObject} context.newObject the new object to add
 * @param {moddle.newObjectContainer} context.newObjectContainer the container for the new object
 *
 * @returns {Array<djs.mode.Base>} the updated element
 */
CreateAndReferenceElementHandler.prototype.execute = function (context) {

  var referencingObject = ensureNotNull(context.referencingObject, 'referencingObject'),
      referenceProperty = ensureNotNull(context.referenceProperty, 'referenceProperty'),
      newObject = ensureNotNull(context.newObject, 'newObject'),
      newObjectContainer = ensureNotNull(context.newObjectContainer, 'newObjectContainer'),
      newObjectParent = ensureNotNull(context.newObjectParent, 'newObjectParent'),
      changed = [context.element]; // this will not change any diagram-js elements

  // create new object
  var referencedObject = elementHelper.createElement(newObject.type, newObject.properties, newObjectParent, this._bpmnFactory);
  context.referencedObject = referencedObject;

  // add to containing list
  newObjectContainer.push(referencedObject);

  // adjust reference attribute
  context.previousReference = referencingObject[referenceProperty];
  referencingObject[referenceProperty] = referencedObject;

  context.changed = changed;

  // indicate changed on objects affected by the update
  return changed;
};

/**
 * Reverts the update
 *
 * @method  CreateAndReferenceElementHandler#revert
 *
 * @param {Object} context
 *
 * @returns {djs.mode.Base} the updated element
 */
CreateAndReferenceElementHandler.prototype.revert = function (context) {

  var referencingObject = context.referencingObject,
      referenceProperty = context.referenceProperty,
      previousReference = context.previousReference,
      referencedObject = context.referencedObject,
      newObjectContainer = context.newObjectContainer;

  // reset reference
  referencingObject.set(referenceProperty, previousReference);

  // remove new element
  newObjectContainer.splice(newObjectContainer.indexOf(referencedObject), 1);

  return context.changed;
};

},{"../helper/ElementHelper":25}],7:[function(require,module,exports){
'use strict';

var forEach = require('lodash/collection/forEach');

var elementHelper = require('../helper/ElementHelper');

/**
 * A handler that implements a BPMN 2.0 property update
 * for business objects which are not represented in the
 * diagram.
 *
 * This is useful in the context of the properties panel in
 * order to update child elements of elements visible in
 * the diagram.
 *
 * Example: perform an update of a specific event definition
 * of an intermediate event.
 *
 * @class
 * @constructor
 */
function CreateBusinessObjectListHandler(elementRegistry, bpmnFactory) {
  this._elementRegistry = elementRegistry;
  this._bpmnFactory = bpmnFactory;
}

CreateBusinessObjectListHandler.$inject = ['elementRegistry', 'bpmnFactory'];

module.exports = CreateBusinessObjectListHandler;

function ensureNotNull(prop, name) {
  if (!prop) {
    throw new Error(name + ' required');
  }
  return prop;
}
function ensureList(prop, name) {
  if (!prop || Object.prototype.toString.call(prop) !== '[object Array]') {
    throw new Error(name + ' needs to be a list');
  }
  return prop;
}

////// api /////////////////////////////////////////////

/**
 * Creates a new element under a provided parent and updates / creates a reference to it in
 * one atomic action.
 *
 * @method  CreateBusinessObjectListHandler#execute
 *
 * @param {Object} context
 * @param {djs.model.Base} context.element which is the context for the reference
 * @param {moddle.referencingObject} context.referencingObject the object which creates the reference
 * @param {String} context.referenceProperty the property of the referencingObject which makes the reference
 * @param {moddle.newObject} context.newObject the new object to add
 * @param {moddle.newObjectContainer} context.newObjectContainer the container for the new object
 *
 * @return {Array<djs.mode.Base>} the updated element
 */
CreateBusinessObjectListHandler.prototype.execute = function (context) {

  var currentObject = ensureNotNull(context.currentObject, 'currentObject'),
      propertyName = ensureNotNull(context.propertyName, 'propertyName'),
      newObjects = ensureList(context.newObjects, 'newObjects'),
      changed = [context.element]; // this will not change any diagram-js elements


  var childObjects = [];
  var self = this;

  // create new array of business objects
  forEach(newObjects, function (obj) {
    var element = elementHelper.createElement(obj.type, obj.properties, currentObject, self._bpmnFactory);

    childObjects.push(element);
  });
  context.childObject = childObjects;

  // adjust array reference in the parent business object
  context.previousChilds = currentObject[propertyName];
  currentObject[propertyName] = childObjects;

  context.changed = changed;

  // indicate changed on objects affected by the update
  return changed;
};

/**
 * Reverts the update
 *
 * @method  CreateBusinessObjectListHandler#revert
 *
 * @param {Object} context
 *
 * @return {djs.mode.Base} the updated element
 */
CreateBusinessObjectListHandler.prototype.revert = function (context) {

  var currentObject = context.currentObject,
      propertyName = context.propertyName,
      previousChilds = context.previousChilds;

  // remove new element
  currentObject.set(propertyName, previousChilds);

  return context.changed;
};

},{"../helper/ElementHelper":25,"lodash/collection/forEach":422}],8:[function(require,module,exports){
'use strict';

var forEach = require('lodash/collection/forEach');

/**
 * A handler that combines and executes multiple commands.
 *
 * All updates are bundled on the command stack and executed in one step.
 * This also makes it possible to revert the changes in one step.
 *
 * Example use case: remove the camunda:formKey attribute and in addition
 * add all form fields needed for the camunda:formData property.
 *
 * @class
 * @constructor
 */
function MultiCommandHandler(commandStack) {
  this._commandStack = commandStack;
}

MultiCommandHandler.$inject = ['commandStack'];

module.exports = MultiCommandHandler;

MultiCommandHandler.prototype.preExecute = function (context) {

  var commandStack = this._commandStack;

  forEach(context, function (command) {
    commandStack.execute(command.cmd, command.context);
  });
};

},{"lodash/collection/forEach":422}],9:[function(require,module,exports){
'use strict';

var reduce = require('lodash/object/transform'),
    is = require('bpmn-js/lib/util/ModelUtil').is,
    keys = require('lodash/object/keys'),
    forEach = require('lodash/collection/forEach');

/**
 * A handler that implements a BPMN 2.0 property update
 * for business objects which are not represented in the
 * diagram.
 *
 * This is useful in the context of the properties panel in
 * order to update child elements of elements visible in
 * the diagram.
 *
 * Example: perform an update of a specific event definition
 * of an intermediate event.
 *
 * @class
 * @constructor
 */
function UpdateBusinessObjectHandler(elementRegistry) {
  this._elementRegistry = elementRegistry;
}

UpdateBusinessObjectHandler.$inject = ['elementRegistry'];

module.exports = UpdateBusinessObjectHandler;

/**
 * returns the root element
 */
function getRoot(businessObject) {
  var parent = businessObject;
  while (parent.$parent) {
    parent = parent.$parent;
  }
  return parent;
}

function getProperties(businessObject, propertyNames) {
  return reduce(propertyNames, function (result, key) {
    result[key] = businessObject.get(key);
    return result;
  }, {});
}

function setProperties(businessObject, properties) {
  forEach(properties, function (value, key) {
    businessObject.set(key, value);
  });
}

////// api /////////////////////////////////////////////

/**
 * Updates a business object with a list of new properties
 *
 * @method  UpdateBusinessObjectHandler#execute
 *
 * @param {Object} context
 * @param {djs.model.Base} context.element the element which has a child business object updated
 * @param {moddle.businessObject} context.businessObject the businessObject to update
 * @param {Object} context.properties a list of properties to set on the businessObject
 *
 * @return {Array<djs.mode.Base>} the updated element
 */
UpdateBusinessObjectHandler.prototype.execute = function (context) {

  var element = context.element,
      businessObject = context.businessObject,
      rootElements = getRoot(businessObject).rootElements,
      referenceType = context.referenceType,
      referenceProperty = context.referenceProperty,
      changed = [element]; // this will not change any diagram-js elements

  if (!element) {
    throw new Error('element required');
  }

  if (!businessObject) {
    throw new Error('businessObject required');
  }

  var properties = context.properties,
      oldProperties = context.oldProperties || getProperties(businessObject, keys(properties));

  // check if there the update needs an external element for reference
  if (typeof referenceType !== 'undefined' && typeof referenceProperty !== 'undefined') {
    forEach(rootElements, function (rootElement) {
      if (is(rootElement, referenceType)) {
        if (rootElement.id === properties[referenceProperty]) {
          properties[referenceProperty] = rootElement;
        }
      }
    });
  }

  // update properties
  setProperties(businessObject, properties);

  // store old values
  context.oldProperties = oldProperties;
  context.changed = changed;

  // indicate changed on objects affected by the update
  return changed;
};

/**
 * Reverts the update
 *
 * @method  UpdateBusinessObjectHandler#revert
 *
 * @param {Object} context
 *
 * @return {djs.mode.Base} the updated element
 */
UpdateBusinessObjectHandler.prototype.revert = function (context) {

  var oldProperties = context.oldProperties,
      businessObject = context.businessObject;

  // update properties
  setProperties(businessObject, oldProperties);

  return context.changed;
};

},{"bpmn-js/lib/util/ModelUtil":216,"lodash/collection/forEach":422,"lodash/object/keys":498,"lodash/object/transform":501}],10:[function(require,module,exports){
'use strict';

var forEach = require('lodash/collection/forEach');

/**
 * A handler that implements a BPMN 2.0 property update
 * for business object lists which are not represented in the
 * diagram.
 *
 * This is useful in the context of the properties panel in
 * order to update child elements of elements visible in
 * the diagram.
 *
 * Example: perform an update of a specific event definition
 * of an intermediate event.
 *
 * @class
 * @constructor
 */
function UpdateBusinessObjectListHandler(elementRegistry, bpmnFactory) {
  this._elementRegistry = elementRegistry;
  this._bpmnFactory = bpmnFactory;
}

UpdateBusinessObjectListHandler.$inject = ['elementRegistry', 'bpmnFactory'];

module.exports = UpdateBusinessObjectListHandler;

function ensureNotNull(prop, name) {
  if (!prop) {
    throw new Error(name + 'required');
  }
  return prop;
}

////// api /////////////////////////////////////////////

/**
 * Updates a element under a provided parent.
 */
UpdateBusinessObjectListHandler.prototype.execute = function (context) {

  var currentObject = ensureNotNull(context.currentObject, 'currentObject'),
      propertyName = ensureNotNull(context.propertyName, 'propertyName'),
      updatedObjectList = context.updatedObjectList,
      objectsToRemove = context.objectsToRemove || [],
      objectsToAdd = context.objectsToAdd || [],
      changed = [context.element],
      // this will not change any diagram-js elements
  referencePropertyName;

  if (context.referencePropertyName) {
    referencePropertyName = context.referencePropertyName;
  }

  var objectList = currentObject[propertyName];
  // adjust array reference in the parent business object
  context.previousList = currentObject[propertyName];

  if (updatedObjectList) {
    currentObject[propertyName] = updatedObjectList;
  } else {
    var listCopy = [];
    // remove all objects which should be removed
    forEach(objectList, function (object) {
      if (objectsToRemove.indexOf(object) == -1) {
        listCopy.push(object);
      }
    });
    // add all objects which should be added
    listCopy = listCopy.concat(objectsToAdd);

    // set property to new list
    if (listCopy.length > 0 || !referencePropertyName) {

      // as long as there are elements in the list update the list
      currentObject[propertyName] = listCopy;
    } else if (referencePropertyName) {

      // remove the list when it is empty
      var parentObject = currentObject.$parent;
      parentObject.set(referencePropertyName, undefined);
    }
  }

  context.changed = changed;

  // indicate changed on objects affected by the update
  return changed;
};

/**
 * Reverts the update
 *
 * @method  CreateBusinessObjectListHandler#revert
 *
 * @param {Object} context
 *
 * @return {djs.mode.Base} the updated element
 */
UpdateBusinessObjectListHandler.prototype.revert = function (context) {

  var currentObject = context.currentObject,
      propertyName = context.propertyName,
      previousList = context.previousList,
      parentObject = currentObject.$parent;

  if (context.referencePropertyName) {
    parentObject.set(context.referencePropertyName, currentObject);
  }

  // remove new element
  currentObject.set(propertyName, previousList);

  return context.changed;
};

},{"lodash/collection/forEach":422}],11:[function(require,module,exports){
'use strict';

var forEach = require('lodash/collection/forEach');

var HANDLERS = {
  'properties-panel.update-businessobject': require('./UpdateBusinessObjectHandler'),
  'properties-panel.create-and-reference': require('./CreateAndReferenceHandler'),
  'properties-panel.create-businessobject-list': require('./CreateBusinessObjectListHandler'),
  'properties-panel.update-businessobject-list': require('./UpdateBusinessObjectListHandler'),
  'properties-panel.multi-command-executor': require('./MultiCommandHandler')
};

function CommandInitializer(eventBus, commandStack) {

  eventBus.on('diagram.init', function () {
    forEach(HANDLERS, function (handler, id) {
      commandStack.registerHandler(id, handler);
    });
  });
}

CommandInitializer.$inject = ['eventBus', 'commandStack'];

module.exports = {
  __init__: [CommandInitializer]
};

},{"./CreateAndReferenceHandler":6,"./CreateBusinessObjectListHandler":7,"./MultiCommandHandler":8,"./UpdateBusinessObjectHandler":9,"./UpdateBusinessObjectListHandler":10,"lodash/collection/forEach":422}],12:[function(require,module,exports){
'use strict';

var getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject,
    cmdHelper = require('../helper/CmdHelper');

var entryFieldDescription = require('./EntryFieldDescription');

var checkbox = function checkbox(options, defaultParameters) {
  var resource = defaultParameters,
      label = options.label || resource.id,
      canBeDisabled = !!options.disabled && typeof options.disabled === 'function',
      canBeHidden = !!options.hidden && typeof options.hidden === 'function',
      description = options.description;

  resource.html = '<input id="camunda-' + resource.id + '" ' + 'type="checkbox" ' + 'name="' + options.modelProperty + '" ' + (canBeDisabled ? 'data-disable="isDisabled"' : '') + (canBeHidden ? 'data-show="isHidden"' : '') + ' />' + '<label for="camunda-' + resource.id + '" ' + (canBeDisabled ? 'data-disable="isDisabled"' : '') + (canBeHidden ? 'data-show="isHidden"' : '') + '>' + label + '</label>';

  // add description below checkbox entry field
  if (description) {
    resource.html += entryFieldDescription(description);
  }

  resource.get = function (element) {
    var bo = getBusinessObject(element),
        res = {};

    res[options.modelProperty] = bo.get(options.modelProperty);

    return res;
  };
  resource.set = function (element, values) {
    var res = {};

    res[options.modelProperty] = !!values[options.modelProperty];

    return cmdHelper.updateProperties(element, res);
  };

  if (typeof options.set === 'function') {
    resource.set = options.set;
  }

  if (typeof options.get === 'function') {
    resource.get = options.get;
  }

  if (canBeDisabled) {
    resource.isDisabled = function () {
      return options.disabled.apply(resource, arguments);
    };
  }

  if (canBeHidden) {
    resource.isHidden = function () {
      return !options.hidden.apply(resource, arguments);
    };
  }

  resource.cssClasses = ['bpp-checkbox'];

  return resource;
};

module.exports = checkbox;

},{"../helper/CmdHelper":24,"./EntryFieldDescription":15,"bpmn-js/lib/util/ModelUtil":216}],13:[function(require,module,exports){
'use strict';

var assign = require('lodash/object/assign'),
    find = require('lodash/collection/find');

var domQuery = require('min-dom/lib/query');

var selectEntryFactory = require('./SelectEntryFactory'),
    entryFieldDescription = require('./EntryFieldDescription');

/**
 * The combo box is a special implementation of the select entry and adds the option 'custom' to the
 * select box. If 'custom' is selected, an additional text input field is shown which allows to define
 * a custom value.
 *
 * @param  {Object} options
 * @param  {string} options.id
 * @param  {string} options.label
 * @param  {Array<Object>} options.selectOptions list of name/value pairs
 * @param  {string} options.modelProperty
 * @param  {function} options.get
 * @param  {function} options.set
 * @param  {string} [options.customValue] custom select option value (default: 'custom')
 * @param  {string} [options.customName] custom select option name visible in the select box (default: 'custom')
 *
 * @return {Object}
 */
var comboBox = function comboBox(options) {

  var selectOptions = options.selectOptions,
      modelProperty = options.modelProperty,
      customValue = options.customValue || 'custom',
      customName = options.customName || 'custom ' + modelProperty,
      description = options.description;

  // check if a value is not a built in value
  var isCustomValue = function isCustomValue(value) {
    if (typeof value[modelProperty] === 'undefined') {
      return false;
    }

    var isCustom = !find(selectOptions, function (option) {
      return value[modelProperty] === option.value;
    });

    return isCustom;
  };

  var comboOptions = assign({}, options);

  // true if the selected value in the select box is customValue
  comboOptions.showCustomInput = function (element, node) {
    var selectBox = domQuery('[data-entry="' + options.id + '"] select', node.parentNode);

    if (selectBox) {
      return selectBox.value === customValue;
    }

    return false;
  };

  comboOptions.get = function (element, node) {
    var value = options.get(element, node);

    var modifiedValues = {};

    if (!isCustomValue(value)) {
      modifiedValues[modelProperty] = value[modelProperty] || '';

      return modifiedValues;
    }

    modifiedValues[modelProperty] = customValue;
    modifiedValues['custom-' + modelProperty] = value[modelProperty];

    return modifiedValues;
  };

  comboOptions.set = function (element, values, node) {
    var modifiedValues = {};

    // if the custom select option has been selected
    // take the value from the text input field
    if (values[modelProperty] === customValue) {
      modifiedValues[modelProperty] = values['custom-' + modelProperty] || '';
    } else if (options.emptyParameter && values[modelProperty] === '') {
      modifiedValues[modelProperty] = undefined;
    } else {
      modifiedValues[modelProperty] = values[modelProperty];
    }
    return options.set(element, modifiedValues, node);
  };

  comboOptions.selectOptions.push({ name: customName, value: customValue });

  var comboBoxEntry = assign({}, selectEntryFactory(comboOptions, comboOptions));

  comboBoxEntry.html += '<div class="bpp-field-wrapper bpp-combo-input" ' + 'data-show="showCustomInput"' + '>' + '<input id="camunda-' + options.id + '-input" type="text" name="custom-' + modelProperty + '" ' + ' />' + '</div>';

  // add description below combo box entry field
  if (description) {
    comboBoxEntry.html += entryFieldDescription(description);
  }

  return comboBoxEntry;
};

module.exports = comboBox;

},{"./EntryFieldDescription":15,"./SelectEntryFactory":18,"lodash/collection/find":421,"lodash/object/assign":496,"min-dom/lib/query":112}],14:[function(require,module,exports){
'use strict';

var getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject;

// input entities
var textInputField = require('./TextInputEntryFactory'),
    checkboxField = require('./CheckboxEntryFactory'),
    selectBoxField = require('./SelectEntryFactory'),
    comboBoxField = require('./ComboEntryFactory'),
    textBoxField = require('./TextBoxEntryFactory'),
    validationAwareTextInputField = require('./ValidationAwareTextInput'),
    tableField = require('./TableEntryFactory'),
    labelEntry = require('./LabelFactory'),
    link = require('./LinkEntryFactory');

var cmdHelper = require('../helper/CmdHelper');

// helpers ////////////////////////////////////////

function ensureNotNull(prop) {
  if (!prop) {
    throw new Error(prop + ' must be set.');
  }

  return prop;
}

/**
 * sets the default parameters which are needed to create an entry
 *
 * @param options
 * @returns {{id: *, description: (*|string), get: (*|Function), set: (*|Function),
 *            validate: (*|Function), html: string}}
 */
var setDefaultParameters = function setDefaultParameters(options) {

  // default method to fetch the current value of the input field
  var defaultGet = function defaultGet(element) {
    var bo = getBusinessObject(element),
        res = {},
        prop = ensureNotNull(options.modelProperty);
    res[prop] = bo.get(prop);

    return res;
  };

  // default method to set a new value to the input field
  var defaultSet = function defaultSet(element, values) {
    var res = {},
        prop = ensureNotNull(options.modelProperty);
    if (values[prop] !== '') {
      res[prop] = values[prop];
    } else {
      res[prop] = undefined;
    }

    return cmdHelper.updateProperties(element, res);
  };

  // default validation method
  var defaultValidate = function defaultValidate() {
    return {};
  };

  return {
    id: options.id,
    description: options.description || '',
    get: options.get || defaultGet,
    set: options.set || defaultSet,
    validate: options.validate || defaultValidate,
    html: ''
  };
};

function EntryFactory() {}

/**
 * Generates an text input entry object for a property panel.
 * options are:
 * - id: id of the entry - String
 *
 * - description: description of the property - String
 *
 * - label: label for the input field - String
 *
 * - set: setter method - Function
 *
 * - get: getter method - Function
 *
 * - validate: validation mehtod - Function
 *
 * - modelProperty: name of the model property - String
 *
 * - buttonAction: Object which contains the following properties: - Object
 * ---- name: name of the [data-action] callback - String
 * ---- method: callback function for [data-action] - Function
 *
 * - buttonShow: Object which contains the following properties: - Object
 * ---- name: name of the [data-show] callback - String
 * ---- method: callback function for [data-show] - Function
 *
 * @param options
 * @returns the propertyPanel entry resource object
 */
EntryFactory.textField = function (options) {
  return textInputField(options, setDefaultParameters(options));
};

EntryFactory.validationAwareTextField = function (options) {
  return validationAwareTextInputField(options, setDefaultParameters(options));
};

/**
 * Generates a checkbox input entry object for a property panel.
 * options are:
 * - id: id of the entry - String
 *
 * - description: description of the property - String
 *
 * - label: label for the input field - String
 *
 * - set: setter method - Function
 *
 * - get: getter method - Function
 *
 * - validate: validation mehtod - Function
 *
 * - modelProperty: name of the model property - String
 *
 * @param options
 * @returns the propertyPanel entry resource object
 */
EntryFactory.checkbox = function (options) {
  return checkboxField(options, setDefaultParameters(options));
};

EntryFactory.textBox = function (options) {
  return textBoxField(options, setDefaultParameters(options));
};

EntryFactory.selectBox = function (options) {
  return selectBoxField(options, setDefaultParameters(options));
};

EntryFactory.comboBox = function (options) {
  return comboBoxField(options);
};

EntryFactory.table = function (options) {
  return tableField(options);
};

EntryFactory.label = function (options) {
  return labelEntry(options);
};

EntryFactory.link = function (options) {
  return link(options);
};

module.exports = EntryFactory;

},{"../helper/CmdHelper":24,"./CheckboxEntryFactory":12,"./ComboEntryFactory":13,"./LabelFactory":16,"./LinkEntryFactory":17,"./SelectEntryFactory":18,"./TableEntryFactory":19,"./TextBoxEntryFactory":20,"./TextInputEntryFactory":21,"./ValidationAwareTextInput":22,"bpmn-js/lib/util/ModelUtil":216}],15:[function(require,module,exports){
'use strict';

var MARKDOWN_LINK_REGEX = /\[([^\)]+)\]\(([^\]]+)\)/g;

/**
 * Replace MarkDown Link Syntax with HTML Link Syntax
 * [myLink](http://www.myLink.de) -> <a href=http://www.myLink.de>myLink</a>
 *
 * @param {String} value
 *
 * @return {String}
 */
function linkify(text) {
  return text.replace(MARKDOWN_LINK_REGEX, '<a href="$2" target="_blank">$1</a>');
}

module.exports = function entryFieldDescription(description) {
  description = linkify(description);

  return '<div class="bpp-field-description">' + description + '</div>';
};

},{}],16:[function(require,module,exports){
'use strict';

/**
 * The label factory provides a label entry. For the label text
 * it expects either a string provided by the options.labelText
 * parameter or it could be generated programmatically using a
 * function passed as the options.get parameter.
 *
 * @param  {Object} options
 * @param  {string} options.id
 * @param  {string} [options.labelText]
 * @param  {Function} [options.get]
 * @param  {Function} [options.showLabel]
 * @param  {Boolean} [options.divider] adds a divider at the top of the label if true; default: false
 */

var label = function label(options) {
  return {
    id: options.id,
    html: '<label data-value="label" ' + 'data-show="showLabel" ' + 'class="entry-label' + (options.divider ? ' divider' : '') + '">' + '</label>',
    get: function get(element, node) {
      if (typeof options.get === 'function') {
        return options.get(element, node);
      }
      return { label: options.labelText };
    },
    showLabel: function showLabel(element, node) {
      if (typeof options.showLabel === 'function') {
        return options.showLabel(element, node);
      }
      return true;
    }
  };
};

module.exports = label;

},{}],17:[function(require,module,exports){
'use strict';

var utils = require('../Utils');

var entryFieldDescription = require('./EntryFieldDescription');

var link = function link(options, defaultParameters) {

  var id = options.id,
      label = options.label || id,
      hideLink = options.hideLink,
      canBeHidden = typeof hideLink === 'function',
      getClickableElement = options.getClickableElement,
      description = options.description;

  var resource = { id: id };

  resource.html = '<a data-action="linkSelected" ' + (canBeHidden ? 'data-show="hideLink" ' : '') + 'class="bpp-entry-link' + (options.cssClasses ? ' ' + options.cssClasses : '') + '">' + label + '</a>';

  // add description below link entry field
  if (description) {
    resource.html += entryFieldDescription(description);
  }

  resource.linkSelected = function (element, node, event, scopeNode) {
    if (typeof getClickableElement === 'function') {

      var link = getClickableElement.apply(resource, [element, node, event, scopeNode]);
      link && utils.triggerClickEvent(link);
    }

    return false;
  };

  if (canBeHidden) {
    resource.hideLink = function () {
      return !hideLink.apply(resource, arguments);
    };
  }

  return resource;
};

module.exports = link;

},{"../Utils":5,"./EntryFieldDescription":15}],18:[function(require,module,exports){
'use strict';

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

var domify = require('min-dom/lib/domify');

var forEach = require('lodash/collection/forEach');

var entryFieldDescription = require('./EntryFieldDescription');

var isList = function isList(list) {
  return !(!list || Object.prototype.toString.call(list) !== '[object Array]');
};

var addEmptyParameter = function addEmptyParameter(list) {
  return list.concat([{ name: '', value: '' }]);
};

var createOption = function createOption(option) {
  return '<option value="' + option.value + '">' + option.name + '</option>';
};

/**
 * @param  {Object} options
 * @param  {string} options.id
 * @param  {string} [options.label]
 * @param  {Array<Object>} options.selectOptions
 * @param  {string} options.modelProperty
 * @param  {boolean} options.emptyParameter
 * @param  {function} options.disabled
 * @param  {function} options.hidden
 * @param  {Object} defaultParameters
 *
 * @return {Object}
 */
var selectbox = function selectbox(options, defaultParameters) {
  var resource = defaultParameters,
      label = options.label || resource.id,
      selectOptions = options.selectOptions || [{ name: '', value: '' }],
      modelProperty = options.modelProperty,
      emptyParameter = options.emptyParameter,
      canBeDisabled = !!options.disabled && typeof options.disabled === 'function',
      canBeHidden = !!options.hidden && typeof options.hidden === 'function',
      description = options.description;

  if (emptyParameter) {
    selectOptions = addEmptyParameter(selectOptions);
  }

  resource.html = '<label for="camunda-' + resource.id + '"' + (canBeDisabled ? 'data-disable="isDisabled" ' : '') + (canBeHidden ? 'data-show="isHidden" ' : '') + '>' + label + '</label>' + '<select id="camunda-' + resource.id + '-select" name="' + modelProperty + '"' + (canBeDisabled ? 'data-disable="isDisabled" ' : '') + (canBeHidden ? 'data-show="isHidden" ' : '') + ' data-value>';

  if (isList(selectOptions)) {
    forEach(selectOptions, function (option) {
      resource.html += '<option value="' + option.value + '">' + (option.name || '') + '</option>';
    });
  }

  resource.html += '</select>';

  // add description below select box entry field
  if (description && !_typeof(options.showCustomInput) === 'function') {
    resource.html += entryFieldDescription(description);
  }

  /**
   * Fill the select box options dynamically.
   *
   * Calls the defined function #selectOptions in the entry to get the
   * values for the options and set the value to the inputNode.
   *
   * @param {djs.model.Base} element
   * @param {HTMLElement} entryNode
   * @param {EntryDescriptor} inputNode
   * @param {Object} inputName
   * @param {Object} newValue
   */
  resource.setControlValue = function (element, entryNode, inputNode, inputName, newValue) {
    if (typeof selectOptions === 'function') {

      var options = selectOptions(element, inputNode);

      if (options) {

        // remove existing options
        while (inputNode.firstChild) {
          inputNode.removeChild(inputNode.firstChild);
        }

        // add options
        forEach(options, function (option) {
          var template = domify(createOption(option));

          inputNode.appendChild(template);
        });
      }
    }

    // set select value
    if (newValue !== undefined) {
      inputNode.value = newValue;
    }
  };

  if (canBeDisabled) {
    resource.isDisabled = function () {
      return options.disabled.apply(resource, arguments);
    };
  }

  if (canBeHidden) {
    resource.isHidden = function () {
      return !options.hidden.apply(resource, arguments);
    };
  }

  resource.cssClasses = ['bpp-dropdown'];

  return resource;
};

module.exports = selectbox;

},{"./EntryFieldDescription":15,"lodash/collection/forEach":422,"min-dom/lib/domify":110}],19:[function(require,module,exports){
'use strict';

var cmdHelper = require('../helper/CmdHelper');

var domQuery = require('min-dom/lib/query'),
    domAttr = require('min-dom/lib/attr'),
    domClosest = require('min-dom/lib/closest');

var filter = require('lodash/collection/filter'),
    forEach = require('lodash/collection/forEach'),
    keys = require('lodash/object/keys');

var domify = require('min-dom/lib/domify');

var entryFieldDescription = require('./EntryFieldDescription');

var updateSelection = require('selection-update');

var TABLE_ROW_DIV_SNIPPET = '<div class="bpp-field-wrapper bpp-table-row">';
var DELETE_ROW_BUTTON_SNIPPET = '<button class="clear" data-action="deleteElement">' + '<span>X</span>' + '</button>';

function createInputRowTemplate(properties, canRemove) {
  var template = TABLE_ROW_DIV_SNIPPET;
  template += createInputTemplate(properties, canRemove);
  template += canRemove ? DELETE_ROW_BUTTON_SNIPPET : '';
  template += '</div>';

  return template;
}

function createInputTemplate(properties, canRemove) {
  var columns = properties.length;
  var template = '';
  forEach(properties, function (prop) {
    template += '<input class="bpp-table-row-columns-' + columns + ' ' + (canRemove ? 'bpp-table-row-removable' : '') + '" ' + 'id="camunda-table-row-cell-input-value" ' + 'type="text" ' + 'name="' + prop + '" />';
  });
  return template;
}

function createLabelRowTemplate(labels) {
  var template = TABLE_ROW_DIV_SNIPPET;
  template += createLabelTemplate(labels);
  template += '</div>';

  return template;
}

function createLabelTemplate(labels) {
  var columns = labels.length;
  var template = '';
  forEach(labels, function (label) {
    template += '<label class="bpp-table-row-columns-' + columns + '">' + label + '</label>';
  });
  return template;
}

function pick(elements, properties) {
  return (elements || []).map(function (elem) {
    var newElement = {};
    forEach(properties, function (prop) {
      newElement[prop] = elem[prop] || '';
    });
    return newElement;
  });
}

function diff(element, node, values, oldValues, editable) {
  return filter(values, function (value, idx) {
    return !valueEqual(element, node, value, oldValues[idx], editable, idx);
  });
}

function valueEqual(element, node, value, oldValue, editable, idx) {
  if (value && !oldValue) {
    return false;
  }
  var allKeys = keys(value).concat(keys(oldValue));

  return allKeys.every(function (key) {
    var n = value[key] || undefined;
    var o = oldValue[key] || undefined;
    return !editable(element, node, key, idx) || n === o;
  });
}

function getEntryNode(node) {
  return domClosest(node, '[data-entry]', true);
}

function getContainer(node) {
  return domQuery('div[data-list-entry-container]', node);
}

function getSelection(node) {
  return {
    start: node.selectionStart,
    end: node.selectionEnd
  };
}

function setSelection(node, selection) {
  node.selectionStart = selection.start;
  node.selectionEnd = selection.end;
}

/**
 * @param  {Object} options
 * @param  {string} options.id
 * @param  {string} options.description
 * @param  {Array<string>} options.modelProperties
 * @param  {Array<string>} options.labels
 * @param  {Function} options.getElements - this callback function must return a list of business object items
 * @param  {Function} options.removeElement
 * @param  {Function} options.addElement
 * @param  {Function} options.updateElement
 * @param  {Function} options.editable
 * @param  {Function} options.setControlValue
 * @param  {Function} options.show
 *
 * @return {Object}
 */
module.exports = function (options) {

  var id = options.id,
      modelProperties = options.modelProperties,
      labels = options.labels,
      description = options.description;

  var labelRow = createLabelRowTemplate(labels);

  var getElements = options.getElements;

  var removeElement = options.removeElement,
      canRemove = typeof removeElement === 'function';

  var addElement = options.addElement,
      canAdd = typeof addElement === 'function',
      addLabel = options.addLabel || 'Add Value';

  var updateElement = options.updateElement,
      canUpdate = typeof updateElement === 'function';

  var _editable = options.editable || function () {
    return true;
  },
      setControlValue = options.setControlValue;

  var _show = options.show,
      canBeShown = typeof _show === 'function';

  var elements = function elements(element, node) {
    return pick(getElements(element, node), modelProperties);
  };

  var factory = {
    id: id,
    html: (canAdd ? '<div class="bpp-table-add-row" ' + (canBeShown ? 'data-show="show"' : '') + '>' + '<label>' + addLabel + '</label>' + '<button class="add" data-action="addElement"><span>+</span></button>' + '</div>' : '') + '<div class="bpp-table" data-show="showTable">' + '<div class="bpp-field-wrapper bpp-table-row">' + labelRow + '</div>' + '<div data-list-entry-container>' + '</div>' + '</div>' + (

    // add description below table entry field
    description ? entryFieldDescription(description) : ''),

    get: function get(element, node) {
      var boElements = elements(element, node, this.__invalidValues);

      var invalidValues = this.__invalidValues;

      delete this.__invalidValues;

      forEach(invalidValues, function (value, idx) {
        var element = boElements[idx];

        forEach(modelProperties, function (prop) {
          element[prop] = value[prop];
        });
      });

      return boElements;
    },

    set: function set(element, values, node) {
      var action = this.__action || {};
      delete this.__action;

      if (action.id === 'delete-element') {
        return removeElement(element, node, action.idx);
      } else if (action.id === 'add-element') {
        return addElement(element, node);
      } else if (canUpdate) {
        var commands = [],
            valuesToValidate = values;

        if (typeof options.validate !== 'function') {
          valuesToValidate = diff(element, node, values, elements(element, node), _editable);
        }

        var self = this;

        forEach(valuesToValidate, function (value) {
          var validationError,
              idx = values.indexOf(value);

          if (typeof options.validate === 'function') {
            validationError = options.validate(element, value, node, idx);
          }

          if (!validationError) {
            var cmd = updateElement(element, value, node, idx);

            if (cmd) {
              commands.push(cmd);
            }
          } else {
            // cache invalid value in an object by index as key
            self.__invalidValues = self.__invalidValues || {};
            self.__invalidValues[idx] = value;

            // execute a command, which does not do anything
            commands.push(cmdHelper.updateProperties(element, {}));
          }
        });

        return commands;
      }
    },
    createListEntryTemplate: function createListEntryTemplate(value, index, selectBox) {
      return createInputRowTemplate(modelProperties, canRemove);
    },

    addElement: function addElement(element, node, event, scopeNode) {
      var template = domify(createInputRowTemplate(modelProperties, canRemove));

      var container = getContainer(node);
      container.appendChild(template);

      this.__action = {
        id: 'add-element'
      };

      return true;
    },

    deleteElement: function deleteElement(element, node, event, scopeNode) {
      var container = getContainer(node);
      var rowToDelete = event.delegateTarget.parentNode;
      var idx = parseInt(domAttr(rowToDelete, 'data-index'), 10);

      container.removeChild(rowToDelete);

      this.__action = {
        id: 'delete-element',
        idx: idx
      };

      return true;
    },

    editable: function editable(element, rowNode, input, prop, value, idx) {
      var entryNode = domClosest(rowNode, '[data-entry]');
      return _editable(element, entryNode, prop, idx);
    },

    show: function show(element, entryNode, node, scopeNode) {
      entryNode = getEntryNode(entryNode);
      return _show(element, entryNode, node, scopeNode);
    },

    showTable: function showTable(element, entryNode, node, scopeNode) {
      entryNode = getEntryNode(entryNode);
      var elems = elements(element, entryNode);
      return elems && elems.length && (!canBeShown || _show(element, entryNode, node, scopeNode));
    },

    validateListItem: function validateListItem(element, value, node, idx) {
      if (typeof options.validate === 'function') {
        return options.validate(element, value, node, idx);
      }
    }

  };

  // Update/set the selection on the correct position.
  // It's the same code like for an input value in the PropertiesPanel.js.
  if (setControlValue) {
    factory.setControlValue = function (element, rowNode, input, prop, value, idx) {
      var entryNode = getEntryNode(rowNode);

      var isReadOnly = domAttr(input, 'readonly');
      var oldValue = input.value;

      var selection;

      // prevents input fields from having the value 'undefined'
      if (value === undefined) {
        value = '';
      }

      // when the attribute 'readonly' exists, ignore the comparison
      // with 'oldValue' and 'value'
      if (!!isReadOnly && oldValue === value) {
        return;
      }

      // update selection on undo/redo
      if (document.activeElement === input) {
        selection = updateSelection(getSelection(input), oldValue, value);
      }

      setControlValue(element, entryNode, input, prop, value, idx);

      if (selection) {
        setSelection(input, selection);
      }
    };
  }

  return factory;
};

},{"../helper/CmdHelper":24,"./EntryFieldDescription":15,"lodash/collection/filter":420,"lodash/collection/forEach":422,"lodash/object/keys":498,"min-dom/lib/attr":105,"min-dom/lib/closest":108,"min-dom/lib/domify":110,"min-dom/lib/query":112,"selection-update":533}],20:[function(require,module,exports){
'use strict';

var entryFieldDescription = require('./EntryFieldDescription');

var textBox = function textBox(options, defaultParameters) {

  var resource = defaultParameters,
      label = options.label || resource.id,
      canBeShown = !!options.show && typeof options.show === 'function',
      description = options.description;

  resource.html = '<label for="camunda-' + resource.id + '" ' + (canBeShown ? 'data-show="isShown"' : '') + '>' + label + '</label>' + '<div class="bpp-field-wrapper" ' + (canBeShown ? 'data-show="isShown"' : '') + '>' + '<div contenteditable="true" id="camunda-' + resource.id + '" ' + 'name="' + options.modelProperty + '" />' + '</div>';

  // add description below text box entry field
  if (description) {
    resource.html += entryFieldDescription(description);
  }

  if (canBeShown) {
    resource.isShown = function () {
      return options.show.apply(resource, arguments);
    };
  }

  resource.cssClasses = ['bpp-textbox'];

  return resource;
};

module.exports = textBox;

},{"./EntryFieldDescription":15}],21:[function(require,module,exports){
'use strict';

var domQuery = require('min-dom/lib/query');

var entryFieldDescription = require('./EntryFieldDescription');

var textField = function textField(options, defaultParameters) {

  // Default action for the button next to the input-field
  var defaultButtonAction = function defaultButtonAction(element, inputNode) {
    var input = domQuery('input[name="' + options.modelProperty + '"]', inputNode);
    input.value = '';

    return true;
  };

  // default method to determine if the button should be visible
  var defaultButtonShow = function defaultButtonShow(element, inputNode) {
    var input = domQuery('input[name="' + options.modelProperty + '"]', inputNode);

    return input.value !== '';
  };

  var resource = defaultParameters,
      label = options.label || resource.id,
      dataValueLabel = options.dataValueLabel,
      buttonLabel = options.buttonLabel || 'X',
      actionName = typeof options.buttonAction != 'undefined' ? options.buttonAction.name : 'clear',
      actionMethod = typeof options.buttonAction != 'undefined' ? options.buttonAction.method : defaultButtonAction,
      showName = typeof options.buttonShow != 'undefined' ? options.buttonShow.name : 'canClear',
      showMethod = typeof options.buttonShow != 'undefined' ? options.buttonShow.method : defaultButtonShow,
      canBeDisabled = !!options.disabled && typeof options.disabled === 'function',
      canBeHidden = !!options.hidden && typeof options.hidden === 'function',
      description = options.description;

  resource.html = '<label for="camunda-' + resource.id + '" ' + (canBeDisabled ? 'data-disable="isDisabled" ' : '') + (canBeHidden ? 'data-show="isHidden" ' : '') + (dataValueLabel ? 'data-value="' + dataValueLabel + '"' : '') + '>' + label + '</label>' + '<div class="bpp-field-wrapper" ' + (canBeDisabled ? 'data-disable="isDisabled"' : '') + (canBeHidden ? 'data-show="isHidden"' : '') + '>' + '<input id="camunda-' + resource.id + '" type="text" name="' + options.modelProperty + '" ' + (canBeDisabled ? 'data-disable="isDisabled"' : '') + (canBeHidden ? 'data-show="isHidden"' : '') + ' />' + '<button class="' + actionName + '" data-action="' + actionName + '" data-show="' + showName + '" ' + (canBeDisabled ? 'data-disable="isDisabled"' : '') + (canBeHidden ? ' data-show="isHidden"' : '') + '>' + '<span>' + buttonLabel + '</span>' + '</button>' + '</div>';

  // add description below text input entry field
  if (description) {
    resource.html += entryFieldDescription(description);
  }

  resource[actionName] = actionMethod;
  resource[showName] = showMethod;

  if (canBeDisabled) {
    resource.isDisabled = function () {
      return options.disabled.apply(resource, arguments);
    };
  }

  if (canBeHidden) {
    resource.isHidden = function () {
      return !options.hidden.apply(resource, arguments);
    };
  }

  resource.cssClasses = ['bpp-textfield'];

  return resource;
};

module.exports = textField;

},{"./EntryFieldDescription":15,"min-dom/lib/query":112}],22:[function(require,module,exports){
'use strict';

var textField = require('./TextInputEntryFactory');

/**
 * This function is a wrapper around TextInputEntryFactory.
 * It adds functionality to cache an invalid value entered in the
 * text input, instead of setting it on the business object.
 */
var validationAwareTextField = function validationAwareTextField(options, defaultParameters) {

  var modelProperty = options.modelProperty;

  defaultParameters.get = function (element, node) {
    var value = this.__lastInvalidValue;

    delete this.__lastInvalidValue;

    var properties = {};

    properties[modelProperty] = value !== undefined ? value : options.getProperty(element, node);

    return properties;
  };

  defaultParameters.set = function (element, values, node) {
    var validationErrors = validate.apply(this, [element, values, node]),
        propertyValue = values[modelProperty];

    // make sure we do not update the id
    if (validationErrors && validationErrors[modelProperty]) {
      this.__lastInvalidValue = propertyValue;

      return options.setProperty(element, {}, node);
    } else {
      var properties = {};

      properties[modelProperty] = propertyValue;

      return options.setProperty(element, properties, node);
    }
  };

  var validate = defaultParameters.validate = function (element, values, node) {
    var value = values[modelProperty] || this.__lastInvalidValue;

    var property = {};
    property[modelProperty] = value;

    return options.validate(element, property, node);
  };

  return textField(options, defaultParameters);
};

module.exports = validationAwareTextField;

},{"./TextInputEntryFactory":21}],23:[function(require,module,exports){
'use strict';

var map = require('lodash/collection/map');

var extensionElementsHelper = require('./ExtensionElementsHelper');

/**
 * Returns true if the attribute 'camunda:asyncBefore' is set
 * to true.
 *
 * @param  {ModdleElement} bo
 *
 * @return {boolean} a boolean value
 */
function isAsyncBefore(bo) {
  return !!(bo.get('camunda:asyncBefore') || bo.get('camunda:async'));
}

module.exports.isAsyncBefore = isAsyncBefore;

/**
 * Returns true if the attribute 'camunda:asyncAfter' is set
 * to true.
 *
 * @param  {ModdleElement} bo
 *
 * @return {boolean} a boolean value
 */
function isAsyncAfter(bo) {
  return !!bo.get('camunda:asyncAfter');
}

module.exports.isAsyncAfter = isAsyncAfter;

/**
 * Returns true if the attribute 'camunda:exclusive' is set
 * to true.
 *
 * @param  {ModdleElement} bo
 *
 * @return {boolean} a boolean value
 */
function isExclusive(bo) {
  return !!bo.get('camunda:exclusive');
}

module.exports.isExclusive = isExclusive;

/**
 * Get first 'camunda:FailedJobRetryTimeCycle' from the business object.
 *
 * @param  {ModdleElement} bo
 *
 * @return {Array<ModdleElement>} a list of 'camunda:FailedJobRetryTimeCycle'
 */
function getFailedJobRetryTimeCycle(bo) {
  return (extensionElementsHelper.getExtensionElements(bo, 'camunda:FailedJobRetryTimeCycle') || [])[0];
}

module.exports.getFailedJobRetryTimeCycle = getFailedJobRetryTimeCycle;

/**
 * Removes all existing 'camunda:FailedJobRetryTimeCycle' from the business object
 *
 * @param  {ModdleElement} bo
 *
 * @return {Array<ModdleElement>} a list of 'camunda:FailedJobRetryTimeCycle'
 */
function removeFailedJobRetryTimeCycle(bo, element) {
  var retryTimeCycles = extensionElementsHelper.getExtensionElements(bo, 'camunda:FailedJobRetryTimeCycle');
  return map(retryTimeCycles, function (cycle) {
    return extensionElementsHelper.removeEntry(bo, element, cycle);
  });
}

module.exports.removeFailedJobRetryTimeCycle = removeFailedJobRetryTimeCycle;

},{"./ExtensionElementsHelper":27,"lodash/collection/map":424}],24:[function(require,module,exports){
'use strict';

var CmdHelper = {};
module.exports = CmdHelper;

CmdHelper.updateProperties = function (element, properties) {
  return {
    cmd: 'element.updateProperties',
    context: { element: element, properties: properties }
  };
};

CmdHelper.updateBusinessObject = function (element, businessObject, newProperties) {
  return {
    cmd: 'properties-panel.update-businessobject',
    context: {
      element: element,
      businessObject: businessObject,
      properties: newProperties
    }
  };
};

CmdHelper.addElementsTolist = function (element, businessObject, listPropertyName, objectsToAdd) {
  return {
    cmd: 'properties-panel.update-businessobject-list',
    context: {
      element: element,
      currentObject: businessObject,
      propertyName: listPropertyName,
      objectsToAdd: objectsToAdd
    }
  };
};

CmdHelper.removeElementsFromList = function (element, businessObject, listPropertyName, referencePropertyName, objectsToRemove) {

  return {
    cmd: 'properties-panel.update-businessobject-list',
    context: {
      element: element,
      currentObject: businessObject,
      propertyName: listPropertyName,
      referencePropertyName: referencePropertyName,
      objectsToRemove: objectsToRemove
    }
  };
};

CmdHelper.addAndRemoveElementsFromList = function (element, businessObject, listPropertyName, referencePropertyName, objectsToAdd, objectsToRemove) {

  return {
    cmd: 'properties-panel.update-businessobject-list',
    context: {
      element: element,
      currentObject: businessObject,
      propertyName: listPropertyName,
      referencePropertyName: referencePropertyName,
      objectsToAdd: objectsToAdd,
      objectsToRemove: objectsToRemove
    }
  };
};

CmdHelper.setList = function (element, businessObject, listPropertyName, updatedObjectList) {
  return {
    cmd: 'properties-panel.update-businessobject-list',
    context: {
      element: element,
      currentObject: businessObject,
      propertyName: listPropertyName,
      updatedObjectList: updatedObjectList
    }
  };
};

},{}],25:[function(require,module,exports){
'use strict';

var ElementHelper = {};
module.exports = ElementHelper;

/**
 * Creates a new element and set the parent to it
 *
 * @method ElementHelper#createElement
 *
 * @param {String} elementType of the new element
 * @param {Object} properties of the new element in key-value pairs
 * @param {moddle.object} parent of the new element
 * @param {BpmnFactory} factory which creates the new element
 *
 * @returns {djs.model.Base} element which is created
 */
ElementHelper.createElement = function (elementType, properties, parent, factory) {
  var element = factory.create(elementType, properties);
  element.$parent = parent;

  return element;
};

},{}],26:[function(require,module,exports){
'use strict';

var getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject,
    is = require('bpmn-js/lib/util/ModelUtil').is,
    forEach = require('lodash/collection/forEach');

var EventDefinitionHelper = {};

module.exports = EventDefinitionHelper;

EventDefinitionHelper.getEventDefinition = function (element, eventType) {

  var bo = getBusinessObject(element),
      eventDefinition = null;

  if (bo.eventDefinitions) {
    forEach(bo.eventDefinitions, function (event) {
      if (is(event, eventType)) {
        eventDefinition = event;
      }
    });
  }

  return eventDefinition;
};

EventDefinitionHelper.getTimerEventDefinition = function (element) {
  return this.getEventDefinition(element, 'bpmn:TimerEventDefinition');
};

EventDefinitionHelper.getMessageEventDefinition = function (element) {
  return this.getEventDefinition(element, 'bpmn:MessageEventDefinition');
};

EventDefinitionHelper.getSignalEventDefinition = function (element) {
  return this.getEventDefinition(element, 'bpmn:SignalEventDefinition');
};

EventDefinitionHelper.getErrorEventDefinition = function (element) {
  return this.getEventDefinition(element, 'bpmn:ErrorEventDefinition');
};

EventDefinitionHelper.getEscalationEventDefinition = function (element) {
  return this.getEventDefinition(element, 'bpmn:EscalationEventDefinition');
};

EventDefinitionHelper.getCompensateEventDefinition = function (element) {
  return this.getEventDefinition(element, 'bpmn:CompensateEventDefinition');
};

EventDefinitionHelper.getLinkEventDefinition = function (element) {
  return this.getEventDefinition(element, 'bpmn:LinkEventDefinition');
};

EventDefinitionHelper.getConditionalEventDefinition = function (element) {
  return this.getEventDefinition(element, 'bpmn:ConditionalEventDefinition');
};

},{"bpmn-js/lib/util/ModelUtil":216,"lodash/collection/forEach":422}],27:[function(require,module,exports){
'use strict';

var cmdHelper = require('./CmdHelper'),
    elementHelper = require('./ElementHelper');

var is = require('bpmn-js/lib/util/ModelUtil').is;

var ExtensionElementsHelper = {};

var getExtensionElements = function getExtensionElements(bo) {
  return bo.get('extensionElements');
};

ExtensionElementsHelper.getExtensionElements = function (bo, type) {
  var extensionElements = getExtensionElements(bo);
  if (typeof extensionElements !== 'undefined') {
    var extensionValues = extensionElements.get('values');
    if (typeof extensionValues !== 'undefined') {
      var elements = extensionValues.filter(function (value) {
        return is(value, type);
      });
      if (elements.length) {
        return elements;
      }
    }
  }
};

ExtensionElementsHelper.addEntry = function (bo, element, entry, bpmnFactory) {
  var extensionElements = bo.get('extensionElements');

  // if there is no extensionElements list, create one
  if (!extensionElements) {
    // TODO: Ask Daniel which operation costs more
    extensionElements = elementHelper.createElement('bpmn:ExtensionElements', { values: [entry] }, bo, bpmnFactory);
    return { extensionElements: extensionElements };
  } else {
    // add new failedJobRetryExtensionElement to existing extensionElements list
    return cmdHelper.addElementsTolist(element, extensionElements, 'values', [entry]);
  }
};

ExtensionElementsHelper.removeEntry = function (bo, element, entry) {
  var extensionElements = bo.get('extensionElements');

  if (!extensionElements) {
    // return an empty command when there is no extensionElements list
    return {};
  }

  return cmdHelper.removeElementsFromList(element, extensionElements, 'values', 'extensionElements', [entry]);
};

module.exports = ExtensionElementsHelper;

},{"./CmdHelper":24,"./ElementHelper":25,"bpmn-js/lib/util/ModelUtil":216}],28:[function(require,module,exports){
'use strict';

var getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject,
    getExtensionElements = require('./ExtensionElementsHelper').getExtensionElements;

var FormHelper = {};

module.exports = FormHelper;

/**
 * Return form data from business object or undefined if none exist
 *
 * @param  {djs.model.Base} element
 *
 * @return {ModdleElement|undefined} formData
 */
FormHelper.getFormData = function (element) {
  var bo = getBusinessObject(element);

  var formData = getExtensionElements(bo, 'camunda:FormData');

  if (typeof formData !== 'undefined') {
    return formData[0];
  }
};

/**
 * Return all form fields existing in the business object, and
 * an empty array if none exist.
 *
 * @param  {djs.model.Base} element
 *
 * @return {Array} a list of form field objects
 */
FormHelper.getFormFields = function (element) {
  var formData = this.getFormData(element);

  if (typeof formData === 'undefined') {
    return [];
  }

  return formData.fields;
};

/**
 * Get a form field from the business object at given index
 *
 * @param {djs.model.Base} element
 * @param {number} idx
 *
 * @return {ModdleElement} the form field
 */
FormHelper.getFormField = function (element, idx) {

  var formFields = this.getFormFields(element);

  return formFields[idx];
};

/**
 * Get all constraints for a specific form field from the business object
 *
 * @param  {ModdleElement} formField
 *
 * @return {Array<ModdleElement>} a list of constraint objects
 */
FormHelper.getConstraints = function (formField) {
  if (formField && formField.validation && formField.validation.constraints) {
    return formField.validation.constraints;
  }
  return [];
};

/**
 * Get all camunda:value objects for a specific form field from the business object
 *
 * @param  {ModdleElement} formField
 *
 * @return {Array<ModdleElement>} a list of camunda:value objects
 */
FormHelper.getEnumValues = function (formField) {
  if (formField && formField.values) {
    return formField.values;
  }
  return [];
};

},{"./ExtensionElementsHelper":27,"bpmn-js/lib/util/ModelUtil":216}],29:[function(require,module,exports){
'use strict';

var ModelUtil = require('bpmn-js/lib/util/ModelUtil'),
    is = ModelUtil.is,
    getBusinessObject = ModelUtil.getBusinessObject;

var eventDefinitionHelper = require('./EventDefinitionHelper');
var extensionsElementHelper = require('./ExtensionElementsHelper');

var ImplementationTypeHelper = {};

module.exports = ImplementationTypeHelper;

/**
 * Returns 'true' if the given element is 'camunda:ServiceTaskLike'
 *
 * @param {djs.model.Base} element
 *
 * @return {boolean} a boolean value
 */
ImplementationTypeHelper.isServiceTaskLike = function (element) {
  return is(element, 'camunda:ServiceTaskLike');
};

/**
 * Returns 'true' if the given element is 'camunda:DmnCapable'
 *
 * @param {djs.model.Base} element
 *
 * @return {boolean} a boolean value
 */
ImplementationTypeHelper.isDmnCapable = function (element) {
  return is(element, 'camunda:DmnCapable');
};

/**
 * Returns 'true' if the given element is 'camunda:ExternalCapable'
 *
 * @param {djs.model.Base} element
 *
 * @return {boolean} a boolean value
 */
ImplementationTypeHelper.isExternalCapable = function (element) {
  return is(element, 'camunda:ExternalCapable');
};

/**
 * Returns 'true' if the given element is 'camunda:TaskListener'
 *
 * @param {djs.model.Base} element
 *
 * @return {boolean} a boolean value
 */
ImplementationTypeHelper.isTaskListener = function (element) {
  return is(element, 'camunda:TaskListener');
};

/**
 * Returns 'true' if the given element is 'camunda:ExecutionListener'
 *
 * @param {djs.model.Base} element
 *
 * @return {boolean} a boolean value
 */
ImplementationTypeHelper.isExecutionListener = function (element) {
  return is(element, 'camunda:ExecutionListener');
};

/**
 * Returns 'true' if the given element is 'camunda:ExecutionListener' or
 * 'camunda:TaskListener'
 *
 * @param {djs.model.Base} element
 *
 * @return {boolean} a boolean value
 */
ImplementationTypeHelper.isListener = function (element) {
  return this.isTaskListener(element) || this.isExecutionListener(element);
};

/**
 * Returns 'true' if the given element is 'bpmn:SequenceFlow'
 *
 * @param {djs.model.Base} element
 *
 * @return {boolean} a boolean value
 */
ImplementationTypeHelper.isSequenceFlow = function (element) {
  return is(element, 'bpmn:SequenceFlow');
};

/**
 * Get a 'camunda:ServiceTaskLike' business object.
 *
 * If the given element is not a 'camunda:ServiceTaskLike', then 'false'
 * is returned.
 *
 * @param {djs.model.Base} element
 *
 * @return {ModdleElement} the 'camunda:ServiceTaskLike' business object
 */
ImplementationTypeHelper.getServiceTaskLikeBusinessObject = function (element) {

  if (is(element, 'bpmn:IntermediateThrowEvent') || is(element, 'bpmn:EndEvent')) {
    /**
     * change business object to 'messageEventDefinition' when
     * the element is a message intermediate throw event or message end event
     * because the camunda extensions (e.g. camunda:class) are in the message
     * event definition tag and not in the intermediate throw event or end event tag
     */
    var messageEventDefinition = eventDefinitionHelper.getMessageEventDefinition(element);
    if (messageEventDefinition) {
      element = messageEventDefinition;
    }
  }

  return this.isServiceTaskLike(element) && getBusinessObject(element);
};

/**
 * Returns the implementation type of the given element.
 *
 * Possible implementation types are:
 * - dmn
 * - connector
 * - external
 * - class
 * - expression
 * - delegateExpression
 * - script
 * - or undefined, when no matching implementation type is found
 *
 * @param  {djs.model.Base} element
 *
 * @return {String} the implementation type
 */
ImplementationTypeHelper.getImplementationType = function (element) {

  var bo = this.getServiceTaskLikeBusinessObject(element);

  if (!bo) {
    if (this.isListener(element)) {
      bo = element;
    } else {
      return;
    }
  }

  if (this.isDmnCapable(bo)) {
    var decisionRef = bo.get('camunda:decisionRef');
    if (typeof decisionRef !== 'undefined') {
      return 'dmn';
    }
  }

  if (this.isServiceTaskLike(bo)) {
    var connectors = extensionsElementHelper.getExtensionElements(bo, 'camunda:Connector');
    if (typeof connectors !== 'undefined') {
      return 'connector';
    }
  }

  if (this.isExternalCapable(bo)) {
    var type = bo.get('camunda:type');
    if (type === 'external') {
      return 'external';
    }
  }

  var cls = bo.get('camunda:class');
  if (typeof cls !== 'undefined') {
    return 'class';
  }

  var expression = bo.get('camunda:expression');
  if (typeof expression !== 'undefined') {
    return 'expression';
  }

  var delegateExpression = bo.get('camunda:delegateExpression');
  if (typeof delegateExpression !== 'undefined') {
    return 'delegateExpression';
  }

  if (this.isListener(bo)) {
    var script = bo.get('script');
    if (typeof script !== 'undefined') {
      return 'script';
    }
  }
};

},{"./EventDefinitionHelper":26,"./ExtensionElementsHelper":27,"bpmn-js/lib/util/ModelUtil":216}],30:[function(require,module,exports){
'use strict';

var ModelUtil = require('bpmn-js/lib/util/ModelUtil'),
    is = ModelUtil.is,
    getBusinessObject = ModelUtil.getBusinessObject;

var extensionElementsHelper = require('./ExtensionElementsHelper'),
    implementationTypeHelper = require('./ImplementationTypeHelper');

var InputOutputHelper = {};

module.exports = InputOutputHelper;

function getElements(bo, type, prop) {
  var elems = extensionElementsHelper.getExtensionElements(bo, type) || [];
  return !prop ? elems : (elems[0] || {})[prop] || [];
}

function getParameters(element, prop, insideConnector) {
  var inputOutput = InputOutputHelper.getInputOutput(element, insideConnector);
  return inputOutput && inputOutput.get(prop) || [];
}

/**
 * Get a inputOutput from the business object
 *
 * @param {djs.model.Base} element
 * @param  {boolean} insideConnector
 *
 * @return {ModdleElement} the inputOutput object
 */
InputOutputHelper.getInputOutput = function (element, insideConnector) {
  if (!insideConnector) {
    var bo = getBusinessObject(element);
    return (getElements(bo, 'camunda:InputOutput') || [])[0];
  }
  var connector = this.getConnector(element);
  return connector && connector.get('inputOutput');
};

/**
 * Get a connector from the business object
 *
 * @param {djs.model.Base} element
 *
 * @return {ModdleElement} the connector object
 */
InputOutputHelper.getConnector = function (element) {
  var bo = implementationTypeHelper.getServiceTaskLikeBusinessObject(element);
  return bo && (getElements(bo, 'camunda:Connector') || [])[0];
};

/**
 * Return all input parameters existing in the business object, and
 * an empty array if none exist.
 *
 * @param  {djs.model.Base} element
 * @param  {boolean} insideConnector
 *
 * @return {Array} a list of input parameter objects
 */
InputOutputHelper.getInputParameters = function (element, insideConnector) {
  return getParameters.apply(this, [element, 'inputParameters', insideConnector]);
};

/**
 * Return all output parameters existing in the business object, and
 * an empty array if none exist.
 *
 * @param  {djs.model.Base} element
 * @param  {boolean} insideConnector
 *
 * @return {Array} a list of output parameter objects
 */
InputOutputHelper.getOutputParameters = function (element, insideConnector) {
  return getParameters.apply(this, [element, 'outputParameters', insideConnector]);
};

/**
 * Get a input parameter from the business object at given index
 *
 * @param {djs.model.Base} element
 * @param  {boolean} insideConnector
 * @param {number} idx
 *
 * @return {ModdleElement} input parameter
 */
InputOutputHelper.getInputParameter = function (element, insideConnector, idx) {
  return this.getInputParameters(element, insideConnector)[idx];
};

/**
 * Get a output parameter from the business object at given index
 *
 * @param {djs.model.Base} element
 * @param  {boolean} insideConnector
 * @param {number} idx
 *
 * @return {ModdleElement} output parameter
 */
InputOutputHelper.getOutputParameter = function (element, insideConnector, idx) {
  return this.getOutputParameters(element, insideConnector)[idx];
};

/**
 * Returns 'true' if the given element supports inputOutput
 *
 * @param {djs.model.Base} element
 * @param  {boolean} insideConnector
 *
 * @return {boolean} a boolean value
 */
InputOutputHelper.isInputOutputSupported = function (element, insideConnector) {
  var bo = getBusinessObject(element);
  return insideConnector || is(bo, 'bpmn:FlowNode') && !is(bo, 'bpmn:StartEvent') && !is(bo, 'bpmn:BoundaryEvent') && !(is(bo, 'bpmn:SubProcess') && bo.get('triggeredByEvent'));
};

/**
 * Returns 'true' if the given element supports output parameters
 *
 * @param {djs.model.Base} element
 * @param  {boolean} insideConnector
 *
 * @return {boolean} a boolean value
 */
InputOutputHelper.areOutputParametersSupported = function (element, insideConnector) {
  var bo = getBusinessObject(element);
  return insideConnector || !is(bo, 'bpmn:EndEvent') && !bo.loopCharacteristics;
};

},{"./ExtensionElementsHelper":27,"./ImplementationTypeHelper":29,"bpmn-js/lib/util/ModelUtil":216}],31:[function(require,module,exports){
'use strict';

var is = require('bpmn-js/lib/util/ModelUtil').is,
    getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject,
    cmdHelper = require('./CmdHelper');

var ParticipantHelper = {};

module.exports = ParticipantHelper;

ParticipantHelper.modifyProcessBusinessObject = function (element, property, values) {
  if (!is(element, 'bpmn:Participant')) {
    return {};
  }

  var bo = getBusinessObject(element).get('processRef'),
      properties = {};

  properties[property] = values[property];

  return cmdHelper.updateBusinessObject(element, bo, properties);
};

ParticipantHelper.getProcessBusinessObject = function (element, propertyName) {
  if (!is(element, 'bpmn:Participant')) {
    return {};
  }

  var bo = getBusinessObject(element).get('processRef'),
      properties = {};

  properties[propertyName] = bo.get(propertyName);

  return properties;
};

},{"./CmdHelper":24,"bpmn-js/lib/util/ModelUtil":216}],32:[function(require,module,exports){
'use strict';

module.exports = {
  __depends__: [require('./cmd'), require('diagram-js/lib/i18n/translate')],
  __init__: ['propertiesPanel'],
  propertiesPanel: ['type', require('./PropertiesPanel')]
};

},{"./PropertiesPanel":4,"./cmd":11,"diagram-js/lib/i18n/translate":376}],33:[function(require,module,exports){
'use strict';

var entryFactory = require('../../../factory/EntryFactory'),
    cmdHelper = require('../../../helper/CmdHelper');

var ModelUtil = require('bpmn-js/lib/util/ModelUtil'),
    is = ModelUtil.is,
    getBusinessObject = ModelUtil.getBusinessObject;

module.exports = function (group, element, bpmnFactory, translate) {

  var getValue = function getValue(businessObject) {
    return function (element) {
      var documentations = businessObject && businessObject.get('documentation'),
          text = documentations && documentations.length > 0 ? documentations[0].text : '';

      return { documentation: text };
    };
  };

  var setValue = function setValue(businessObject) {
    return function (element, values) {
      var newObjectList = [];

      if (typeof values.documentation !== 'undefined' && values.documentation !== '') {
        newObjectList.push(bpmnFactory.create('bpmn:Documentation', {
          text: values.documentation
        }));
      }

      return cmdHelper.setList(element, businessObject, 'documentation', newObjectList);
    };
  };

  // Element Documentation
  var elementDocuEntry = entryFactory.textBox({
    id: 'documentation',
    label: translate('Element Documentation'),
    modelProperty: 'documentation'
  });

  elementDocuEntry.set = setValue(getBusinessObject(element));

  elementDocuEntry.get = getValue(getBusinessObject(element));

  group.entries.push(elementDocuEntry);

  var processRef;

  // Process Documentation when having a Collaboration Diagram
  if (is(element, 'bpmn:Participant')) {

    processRef = getBusinessObject(element).processRef;

    // do not show for collapsed Pools/Participants
    if (processRef) {
      var processDocuEntry = entryFactory.textBox({
        id: 'process-documentation',
        label: translate('Process Documentation'),
        modelProperty: 'documentation'
      });

      processDocuEntry.set = setValue(processRef);

      processDocuEntry.get = getValue(processRef);

      group.entries.push(processDocuEntry);
    }
  }
};

},{"../../../factory/EntryFactory":14,"../../../helper/CmdHelper":24,"bpmn-js/lib/util/ModelUtil":216}],34:[function(require,module,exports){
'use strict';

var is = require('bpmn-js/lib/util/ModelUtil').is,
    isAny = require('bpmn-js/lib/features/modeling/util/ModelingUtil').isAny,
    isEventSubProcess = require('bpmn-js/lib/util/DiUtil').isEventSubProcess,
    getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject,
    eventDefinitionHelper = require('../../../helper/EventDefinitionHelper');

var forEach = require('lodash/collection/forEach');

var message = require('./implementation/MessageEventDefinition'),
    signal = require('./implementation/SignalEventDefinition'),
    error = require('./implementation/ErrorEventDefinition'),
    escalation = require('./implementation/EscalationEventDefinition'),
    timer = require('./implementation/TimerEventDefinition'),
    compensation = require('./implementation/CompensateEventDefinition'),
    condition = require('./implementation/ConditionalEventDefinition');

module.exports = function (group, element, bpmnFactory, elementRegistry, translate) {
  var events = ['bpmn:StartEvent', 'bpmn:EndEvent', 'bpmn:IntermediateThrowEvent', 'bpmn:BoundaryEvent', 'bpmn:IntermediateCatchEvent'];

  // Message and Signal Event Definition
  forEach(events, function (event) {
    if (is(element, event)) {

      var messageEventDefinition = eventDefinitionHelper.getMessageEventDefinition(element),
          signalEventDefinition = eventDefinitionHelper.getSignalEventDefinition(element);

      if (messageEventDefinition) {
        message(group, element, bpmnFactory, messageEventDefinition);
      }

      if (signalEventDefinition) {
        signal(group, element, bpmnFactory, signalEventDefinition);
      }
    }
  });

  // Special Case: Receive Task
  if (is(element, 'bpmn:ReceiveTask')) {
    message(group, element, bpmnFactory, getBusinessObject(element));
  }

  // Error Event Definition
  var errorEvents = ['bpmn:StartEvent', 'bpmn:BoundaryEvent', 'bpmn:EndEvent'];

  forEach(errorEvents, function (event) {
    if (is(element, event)) {

      var errorEventDefinition = eventDefinitionHelper.getErrorEventDefinition(element);

      if (errorEventDefinition) {
        var isCatchingErrorEvent = is(element, 'bpmn:StartEvent') || is(element, 'bpmn:BoundaryEvent');

        var showErrorCodeVariable = isCatchingErrorEvent,
            showErrorMessageVariable = isCatchingErrorEvent;

        error(group, element, bpmnFactory, errorEventDefinition, showErrorCodeVariable, showErrorMessageVariable);
      }
    }
  });

  // Escalation Event Definition
  var escalationEvents = ['bpmn:StartEvent', 'bpmn:BoundaryEvent', 'bpmn:IntermediateThrowEvent', 'bpmn:EndEvent'];

  forEach(escalationEvents, function (event) {
    if (is(element, event)) {

      var showEscalationCodeVariable = is(element, 'bpmn:StartEvent') || is(element, 'bpmn:BoundaryEvent');

      // get business object
      var escalationEventDefinition = eventDefinitionHelper.getEscalationEventDefinition(element);

      if (escalationEventDefinition) {
        escalation(group, element, bpmnFactory, escalationEventDefinition, showEscalationCodeVariable);
      }
    }
  });

  // Timer Event Definition
  var timerEvents = ['bpmn:StartEvent', 'bpmn:BoundaryEvent', 'bpmn:IntermediateCatchEvent'];

  forEach(timerEvents, function (event) {
    if (is(element, event)) {

      // get business object
      var timerEventDefinition = eventDefinitionHelper.getTimerEventDefinition(element);

      if (timerEventDefinition) {
        timer(group, element, bpmnFactory, timerEventDefinition);
      }
    }
  });

  // Compensate Event Definition
  var compensationEvents = ['bpmn:EndEvent', 'bpmn:IntermediateThrowEvent'];

  forEach(compensationEvents, function (event) {
    if (is(element, event)) {

      // get business object
      var compensateEventDefinition = eventDefinitionHelper.getCompensateEventDefinition(element);

      if (compensateEventDefinition) {
        compensation(group, element, bpmnFactory, compensateEventDefinition, elementRegistry);
      }
    }
  });

  // Conditional Event Defintion
  var conditionalEvents = ['bpmn:BoundaryEvent', 'bpmn:IntermediateThrowEvent', 'bpmn:IntermediateCatchEvent'];

  if (isAny(element, conditionalEvents) || is(element, 'bpmn:StartEvent') && isEventSubProcess(element.parent)) {

    // get business object
    var conditionalEventDefinition = eventDefinitionHelper.getConditionalEventDefinition(element);

    if (conditionalEventDefinition) {
      condition(group, element, bpmnFactory, conditionalEventDefinition, elementRegistry);
    }
  }
};

},{"../../../helper/EventDefinitionHelper":26,"./implementation/CompensateEventDefinition":40,"./implementation/ConditionalEventDefinition":41,"./implementation/ErrorEventDefinition":43,"./implementation/EscalationEventDefinition":44,"./implementation/MessageEventDefinition":46,"./implementation/SignalEventDefinition":48,"./implementation/TimerEventDefinition":49,"bpmn-js/lib/features/modeling/util/ModelingUtil":189,"bpmn-js/lib/util/DiUtil":214,"bpmn-js/lib/util/ModelUtil":216,"lodash/collection/forEach":422}],35:[function(require,module,exports){
'use strict';

var is = require('bpmn-js/lib/util/ModelUtil').is,
    getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject;

var entryFactory = require('../../../factory/EntryFactory');

var participantHelper = require('../../../helper/ParticipantHelper');

module.exports = function (group, element, translate) {

  var bo = getBusinessObject(element);

  if (!bo) {
    return;
  }

  if (is(element, 'bpmn:Process') || is(element, 'bpmn:Participant') && bo.get('processRef')) {

    var executableEntry = entryFactory.checkbox({
      id: 'process-is-executable',
      label: translate('Executable'),
      modelProperty: 'isExecutable'
    });

    // in participants we have to change the default behavior of set and get
    if (is(element, 'bpmn:Participant')) {
      executableEntry.get = function (element) {
        return participantHelper.getProcessBusinessObject(element, 'isExecutable');
      };

      executableEntry.set = function (element, values) {
        return participantHelper.modifyProcessBusinessObject(element, 'isExecutable', values);
      };
    }

    group.entries.push(executableEntry);
  }
};

},{"../../../factory/EntryFactory":14,"../../../helper/ParticipantHelper":31,"bpmn-js/lib/util/ModelUtil":216}],36:[function(require,module,exports){
'use strict';

var entryFactory = require('../../../factory/EntryFactory'),
    getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject,
    utils = require('../../../Utils'),
    cmdHelper = require('../../../helper/CmdHelper');

module.exports = function (group, element, translate) {

  // Id
  group.entries.push(entryFactory.validationAwareTextField({
    id: 'id',
    label: translate('Id'),
    modelProperty: 'id',
    getProperty: function getProperty(element) {
      return getBusinessObject(element).id;
    },
    setProperty: function setProperty(element, properties) {

      element = element.labelTarget || element;

      return cmdHelper.updateProperties(element, properties);
    },
    validate: function validate(element, values) {
      var idValue = values.id;

      var bo = getBusinessObject(element);

      var idError = utils.isIdValid(bo, idValue);

      return idError ? { id: idError } : {};
    }
  }));
};

},{"../../../Utils":5,"../../../factory/EntryFactory":14,"../../../helper/CmdHelper":24,"bpmn-js/lib/util/ModelUtil":216}],37:[function(require,module,exports){
'use strict';

var is = require('bpmn-js/lib/util/ModelUtil').is,
    getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject,
    entryFactory = require('../../../factory/EntryFactory'),
    cmdHelper = require('../../../helper/CmdHelper');

var forEach = require('lodash/collection/forEach');

function getLinkEventDefinition(element) {

  var bo = getBusinessObject(element);

  var linkEventDefinition = null;
  if (bo.eventDefinitions) {
    forEach(bo.eventDefinitions, function (eventDefinition) {
      if (is(eventDefinition, 'bpmn:LinkEventDefinition')) {
        linkEventDefinition = eventDefinition;
      }
    });
  }

  return linkEventDefinition;
}

module.exports = function (group, element, translate) {
  var linkEvents = ['bpmn:IntermediateThrowEvent', 'bpmn:IntermediateCatchEvent'];

  forEach(linkEvents, function (event) {
    if (is(element, event)) {

      var linkEventDefinition = getLinkEventDefinition(element);

      if (linkEventDefinition) {
        var entry = entryFactory.textField({
          id: 'link-event',
          label: translate('Link Name'),
          modelProperty: 'link-name'
        });

        entry.get = function () {
          return { 'link-name': linkEventDefinition.get('name') };
        };

        entry.set = function (element, values) {
          var newProperties = {
            name: values['link-name']
          };
          return cmdHelper.updateBusinessObject(element, linkEventDefinition, newProperties);
        };

        group.entries.push(entry);
      }
    }
  });
};

},{"../../../factory/EntryFactory":14,"../../../helper/CmdHelper":24,"bpmn-js/lib/util/ModelUtil":216,"lodash/collection/forEach":422}],38:[function(require,module,exports){
'use strict';

var nameEntryFactory = require('./implementation/Name'),
    is = require('bpmn-js/lib/util/ModelUtil').is;

module.exports = function (group, element, translate) {

  if (!is(element, 'bpmn:Collaboration')) {

    var options;
    if (is(element, 'bpmn:TextAnnotation')) {
      options = { modelProperty: 'text' };
    }

    // name
    group.entries = group.entries.concat(nameEntryFactory(element, options, translate));
  }
};

},{"./implementation/Name":47,"bpmn-js/lib/util/ModelUtil":216}],39:[function(require,module,exports){
'use strict';

var is = require('bpmn-js/lib/util/ModelUtil').is,
    entryFactory = require('../../../factory/EntryFactory'),
    participantHelper = require('../../../helper/ParticipantHelper'),
    getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject,
    nameEntryFactory = require('./implementation/Name'),
    utils = require('../../../Utils');

module.exports = function (group, element, translate) {
  var businessObject = getBusinessObject(element);

  if (is(element, 'bpmn:Process') || is(element, 'bpmn:Participant') && businessObject.get('processRef')) {

    /**
     * processId
     */
    if (is(element, 'bpmn:Participant')) {
      var idEntry = entryFactory.validationAwareTextField({
        id: 'process-id',
        label: translate('Process Id'),
        modelProperty: 'processId'
      });

      // in participants we have to change the default behavior of set and get
      idEntry.get = function (element) {
        var properties = participantHelper.getProcessBusinessObject(element, 'id');
        return { processId: properties.id };
      };

      idEntry.set = function (element, values) {
        return participantHelper.modifyProcessBusinessObject(element, 'id', { id: values.processId });
      };

      idEntry.validate = function (element, values) {
        var idValue = values.processId;

        var bo = getBusinessObject(element);

        var processIdError = utils.isIdValid(bo.processRef, idValue);

        return processIdError ? { processId: processIdError } : {};
      };

      group.entries.push(idEntry);

      /**
       * process name
       */
      var processNameEntry = nameEntryFactory(element, {
        id: 'process-name',
        label: translate('Process Name')
      })[0];

      // in participants we have to change the default behavior of set and get
      processNameEntry.get = function (element) {
        return participantHelper.getProcessBusinessObject(element, 'name');
      };

      processNameEntry.set = function (element, values) {
        return participantHelper.modifyProcessBusinessObject(element, 'name', values);
      };

      group.entries.push(processNameEntry);
    }
  }
};

},{"../../../Utils":5,"../../../factory/EntryFactory":14,"../../../helper/ParticipantHelper":31,"./implementation/Name":47,"bpmn-js/lib/util/ModelUtil":216}],40:[function(require,module,exports){
'use strict';

var entryFactory = require('../../../../factory/EntryFactory');

var cmdHelper = require('../../../../helper/CmdHelper'),
    eventDefinitionHelper = require('../../../../helper/EventDefinitionHelper'),
    utils = require('../../../../Utils');

var getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject,
    is = require('bpmn-js/lib/util/ModelUtil').is;

var forEach = require('lodash/collection/forEach'),
    find = require('lodash/collection/find'),
    filter = require('lodash/collection/filter');

function getContainedActivities(element) {
  return getFlowElements(element, 'bpmn:Activity');
}

function getContainedBoundaryEvents(element) {
  return getFlowElements(element, 'bpmn:BoundaryEvent');
}

function getFlowElements(element, type) {
  return utils.filterElementsByType(element.flowElements, type);
}

function isCompensationEventAttachedToActivity(activity, boundaryEvents) {
  var activityId = activity.id;
  var boundaryEvent = find(boundaryEvents, function (boundaryEvent) {
    var compensateEventDefinition = eventDefinitionHelper.getCompensateEventDefinition(boundaryEvent);
    var attachedToRef = boundaryEvent.attachedToRef;
    return compensateEventDefinition && attachedToRef && attachedToRef.id === activityId;
  });
  return !!boundaryEvent;
}

// subprocess: only when it is not triggeredByEvent
// activity: only when it attach a compensation boundary event
// callActivity: no limitation
function canActivityBeCompensated(activity, boundaryEvents) {
  return is(activity, 'bpmn:SubProcess') && !activity.triggeredByEvent || is(activity, 'bpmn:CallActivity') || isCompensationEventAttachedToActivity(activity, boundaryEvents);
}

function getActivitiesForCompensation(element) {
  var boundaryEvents = getContainedBoundaryEvents(element);
  return filter(getContainedActivities(element), function (activity) {
    return canActivityBeCompensated(activity, boundaryEvents);
  });
}

function getActivitiesForActivityRef(element) {
  var bo = getBusinessObject(element);
  var parent = bo.$parent;

  var activitiesForActivityRef = getActivitiesForCompensation(parent);

  // if throwing compensation event is in an event sub process:
  // get also all activities outside of the event sub process
  if (is(parent, 'bpmn:SubProcess') && parent.triggeredByEvent) {
    parent = parent.$parent;
    if (parent) {
      activitiesForActivityRef = activitiesForActivityRef.concat(getActivitiesForCompensation(parent));
    }
  }

  return activitiesForActivityRef;
}

function createActivityRefOptions(element) {
  var options = [{ value: '' }];

  var activities = getActivitiesForActivityRef(element);
  forEach(activities, function (activity) {
    var activityId = activity.id;
    var name = (activity.name ? activity.name + ' ' : '') + '(id=' + activityId + ')';
    options.push({ value: activityId, name: name });
  });

  return options;
}

module.exports = function (group, element, bpmnFactory, compensateEventDefinition, elementRegistry) {

  group.entries.push(entryFactory.checkbox({
    id: 'wait-for-completion',
    label: 'Wait for Completion',
    modelProperty: 'waitForCompletion',

    get: function get(element, node) {
      return {
        waitForCompletion: compensateEventDefinition.waitForCompletion
      };
    },

    set: function set(element, values) {
      values.waitForCompletion = values.waitForCompletion || false;
      return cmdHelper.updateBusinessObject(element, compensateEventDefinition, values);
    }
  }));

  group.entries.push(entryFactory.selectBox({
    id: 'activity-ref',
    label: 'Activity Ref',
    selectOptions: createActivityRefOptions(element),
    modelProperty: 'activityRef',

    get: function get(element, node) {
      var activityRef = compensateEventDefinition.activityRef;
      activityRef = activityRef && activityRef.id;
      return {
        activityRef: activityRef || ''
      };
    },

    set: function set(element, values) {
      var activityRef = values.activityRef || undefined;
      activityRef = activityRef && getBusinessObject(elementRegistry.get(activityRef));
      return cmdHelper.updateBusinessObject(element, compensateEventDefinition, {
        activityRef: activityRef
      });
    }
  }));
};

},{"../../../../Utils":5,"../../../../factory/EntryFactory":14,"../../../../helper/CmdHelper":24,"../../../../helper/EventDefinitionHelper":26,"bpmn-js/lib/util/ModelUtil":216,"lodash/collection/filter":420,"lodash/collection/find":421,"lodash/collection/forEach":422}],41:[function(require,module,exports){
'use strict';

var entryFactory = require('../../../../factory/EntryFactory'),
    elementHelper = require('../../../../helper/ElementHelper'),
    cmdHelper = require('../../../../helper/CmdHelper');

function createFormalExpression(parent, body, bpmnFactory) {
  body = body || undefined;
  return elementHelper.createElement('bpmn:FormalExpression', { body: body }, parent, bpmnFactory);
}

module.exports = function (group, element, bpmnFactory, conditionalEventDefinition) {

  var getValue = function getValue(modelProperty) {
    return function (element) {
      var modelPropertyValue = conditionalEventDefinition.get('camunda:' + modelProperty);
      var value = {};

      value[modelProperty] = modelPropertyValue;
      return value;
    };
  };

  var setValue = function setValue(modelProperty) {
    return function (element, values) {
      var props = {};

      props['camunda:' + modelProperty] = values[modelProperty] || undefined;

      return cmdHelper.updateBusinessObject(element, conditionalEventDefinition, props);
    };
  };

  group.entries.push(entryFactory.textField({
    id: 'condition',
    label: 'Condition',
    modelProperty: 'condition',
    get: function get(element) {
      var condition = conditionalEventDefinition.get('condition'),
          body = condition && condition.get('body');

      return { condition: body || '' };
    },
    set: function set(element, values) {
      var condition = conditionalEventDefinition.get('condition');

      // remove condition expression from the business object when text field is empty
      if (values.condition === '') {
        return cmdHelper.updateBusinessObject(element, conditionalEventDefinition, { condition: undefined });
      }

      // if no condition expression is set yet, create one
      if (!condition) {
        condition = createFormalExpression(conditionalEventDefinition, values.condition, bpmnFactory);

        return cmdHelper.updateBusinessObject(element, conditionalEventDefinition, { condition: condition });

        // if a condition expression and a text field value exists, update business object
      } else {
        return cmdHelper.updateBusinessObject(element, condition, {
          body: values.condition || undefined
        });
      }
    },
    validate: function validate(element, values) {
      if (values['condition'] === '') {
        return { condition: 'Must provide a value' };
      }
    }
  }));

  group.entries.push(entryFactory.textField({
    id: 'variableName',
    label: 'Variable Name',
    modelProperty: 'variableName',

    get: getValue('variableName'),
    set: setValue('variableName')
  }));

  group.entries.push(entryFactory.textField({
    id: 'variableEvent',
    label: 'Variable Event',
    description: 'Specify more than one variable change event as a comma separated list.',
    modelProperty: 'variableEvent',

    get: getValue('variableEvent'),
    set: setValue('variableEvent')
  }));
};

},{"../../../../factory/EntryFactory":14,"../../../../helper/CmdHelper":24,"../../../../helper/ElementHelper":25}],42:[function(require,module,exports){
'use strict';

var entryFactory = require('../../../../factory/EntryFactory');

var cmdHelper = require('../../../../helper/CmdHelper');

/**
 * Create an entry to modify a property of an element which
 * is referenced by a event definition.
 *
 * @param  {djs.model.Base} element
 * @param  {ModdleElement} definition
 * @param  {BpmnFactory} bpmnFactory
 * @param  {Object} options
 * @param  {string} options.id the id of the entry
 * @param  {string} options.label the label of the entry
 * @param  {string} options.referenceProperty the name of referencing property
 * @param  {string} options.modelProperty the name of property to modify
 * @param  {string} options.shouldValidate a flag indicate whether to validate or not
 *
 * @return {Array<Object>} return an array containing the entries
 */
module.exports = function (element, definition, bpmnFactory, options) {

  var id = options.id || 'element-property';
  var label = options.label;
  var referenceProperty = options.referenceProperty;
  var modelProperty = options.modelProperty || 'name';
  var shouldValidate = options.shouldValidate || false;

  var entry = entryFactory.textField({
    id: id,
    label: label,
    modelProperty: modelProperty,

    get: function get(element, node) {
      var reference = definition.get(referenceProperty);
      var props = {};
      props[modelProperty] = reference && reference.get(modelProperty);
      return props;
    },

    set: function set(element, values, node) {
      var reference = definition.get(referenceProperty);
      var props = {};
      props[modelProperty] = values[modelProperty] || undefined;
      return cmdHelper.updateBusinessObject(element, reference, props);
    },

    hidden: function hidden(element, node) {
      return !definition.get(referenceProperty);
    }
  });

  if (shouldValidate) {
    entry.validate = function (element, values, node) {
      var reference = definition.get(referenceProperty);
      if (reference && !values[modelProperty]) {
        var validationErrors = {};
        validationErrors[modelProperty] = 'Must provide a value';
        return validationErrors;
      }
    };
  }

  return [entry];
};

},{"../../../../factory/EntryFactory":14,"../../../../helper/CmdHelper":24}],43:[function(require,module,exports){
'use strict';

var entryFactory = require('../../../../factory/EntryFactory'),
    cmdHelper = require('../../../../helper/CmdHelper');

var eventDefinitionReference = require('./EventDefinitionReference'),
    elementReferenceProperty = require('./ElementReferenceProperty');

module.exports = function (group, element, bpmnFactory, errorEventDefinition, showErrorCodeVariable, showErrorMessageVariable) {

  var getValue = function getValue(modelProperty) {
    return function (element) {
      var modelPropertyValue = errorEventDefinition.get('camunda:' + modelProperty);
      var value = {};

      value[modelProperty] = modelPropertyValue;
      return value;
    };
  };

  var setValue = function setValue(modelProperty) {
    return function (element, values) {
      var props = {};

      props['camunda:' + modelProperty] = values[modelProperty] || undefined;

      return cmdHelper.updateBusinessObject(element, errorEventDefinition, props);
    };
  };

  group.entries = group.entries.concat(eventDefinitionReference(element, errorEventDefinition, bpmnFactory, {
    label: 'Error',
    elementName: 'error',
    elementType: 'bpmn:Error',
    referenceProperty: 'errorRef',
    newElementIdPrefix: 'Error_'
  }));

  group.entries = group.entries.concat(elementReferenceProperty(element, errorEventDefinition, bpmnFactory, {
    id: 'error-element-name',
    label: 'Error Name',
    referenceProperty: 'errorRef',
    modelProperty: 'name',
    shouldValidate: true
  }));

  group.entries = group.entries.concat(elementReferenceProperty(element, errorEventDefinition, bpmnFactory, {
    id: 'error-element-code',
    label: 'Error Code',
    referenceProperty: 'errorRef',
    modelProperty: 'errorCode'
  }));

  if (showErrorCodeVariable) {
    group.entries.push(entryFactory.textField({
      id: 'errorCodeVariable',
      label: 'Error Code Variable',
      modelProperty: 'errorCodeVariable',

      get: getValue('errorCodeVariable'),
      set: setValue('errorCodeVariable')
    }));
  }

  if (showErrorMessageVariable) {
    group.entries.push(entryFactory.textField({
      id: 'errorMessageVariable',
      label: 'Error Message Variable',
      modelProperty: 'errorMessageVariable',

      get: getValue('errorMessageVariable'),
      set: setValue('errorMessageVariable')
    }));
  }
};

},{"../../../../factory/EntryFactory":14,"../../../../helper/CmdHelper":24,"./ElementReferenceProperty":42,"./EventDefinitionReference":45}],44:[function(require,module,exports){
'use strict';

var entryFactory = require('../../../../factory/EntryFactory'),
    cmdHelper = require('../../../../helper/CmdHelper');

var eventDefinitionReference = require('./EventDefinitionReference'),
    elementReferenceProperty = require('./ElementReferenceProperty');

module.exports = function (group, element, bpmnFactory, escalationEventDefinition, showEscalationCodeVariable) {

  group.entries = group.entries.concat(eventDefinitionReference(element, escalationEventDefinition, bpmnFactory, {
    label: 'Escalation',
    elementName: 'escalation',
    elementType: 'bpmn:Escalation',
    referenceProperty: 'escalationRef',
    newElementIdPrefix: 'Escalation_'
  }));

  group.entries = group.entries.concat(elementReferenceProperty(element, escalationEventDefinition, bpmnFactory, {
    id: 'escalation-element-name',
    label: 'Escalation Name',
    referenceProperty: 'escalationRef',
    modelProperty: 'name',
    shouldValidate: true
  }));

  group.entries = group.entries.concat(elementReferenceProperty(element, escalationEventDefinition, bpmnFactory, {
    id: 'escalation-element-code',
    label: 'Escalation Code',
    referenceProperty: 'escalationRef',
    modelProperty: 'escalationCode'
  }));

  if (showEscalationCodeVariable) {
    group.entries.push(entryFactory.textField({
      id: 'escalationCodeVariable',
      label: 'Escalation Code Variable',
      modelProperty: 'escalationCodeVariable',

      get: function get(element) {
        var codeVariable = escalationEventDefinition.get('camunda:escalationCodeVariable');
        return {
          escalationCodeVariable: codeVariable
        };
      },

      set: function set(element, values) {
        return cmdHelper.updateBusinessObject(element, escalationEventDefinition, {
          'camunda:escalationCodeVariable': values.escalationCodeVariable || undefined
        });
      }
    }));
  }
};

},{"../../../../factory/EntryFactory":14,"../../../../helper/CmdHelper":24,"./ElementReferenceProperty":42,"./EventDefinitionReference":45}],45:[function(require,module,exports){
'use strict';

var cmdHelper = require('../../../../helper/CmdHelper');

var domQuery = require('min-dom/lib/query'),
    domify = require('min-dom/lib/domify'),
    domAttr = require('min-dom/lib/attr');

var forEach = require('lodash/collection/forEach'),
    find = require('lodash/collection/find');

var elementHelper = require('../../../../helper/ElementHelper');
var utils = require('../../../../Utils');

var selector = 'select[name=selectedElement]';

/**
 * Get select box containing all elements.
 *
 * @param {DOMElement} node
 *
 * @return {DOMElement} the select box
 */
function getSelectBox(node) {
  return domQuery(selector, node.parentElement);
}

/**
 * Find element by given id.
 *
 * @param {ModdleElement} eventDefinition
 *
 * @return {ModdleElement} an element
 */
function findElementById(eventDefinition, type, id) {
  var elements = utils.findRootElementsByType(eventDefinition, type);
  return find(elements, function (element) {
    return element.id === id;
  });
}

/**
 * Create an entry to modify the reference to an element from an
 * event definition.
 *
 * @param  {djs.model.Base} element
 * @param  {ModdleElement} definition
 * @param  {BpmnFactory} bpmnFactory
 * @param  {Object} options
 * @param  {string} options.label the label of the entry
 * @param  {string} options.description the description of the entry
 * @param  {string} options.elementName the name of the element
 * @param  {string} options.elementType the type of the element
 * @param  {string} options.referenceProperty the name of referencing property
 * @param  {string} options.newElementIdPrefix the prefix of a new created element
 *
 * @return {Array<Object>} return an array containing the entries
 */
module.exports = function (element, definition, bpmnFactory, options) {

  var elementName = options.elementName || '',
      elementType = options.elementType,
      referenceProperty = options.referenceProperty;

  var newElementIdPrefix = options.newElementIdPrefix || 'elem_';

  var label = options.label || '',
      description = options.description || '';

  var entries = [];

  entries.push({

    id: 'event-definitions-' + elementName,
    description: description,
    html: '<div class="bpp-row bpp-select">' + '<label for="camunda-' + elementName + '">' + label + '</label>' + '<div class="bpp-field-wrapper">' + '<select id="camunda-' + elementName + '" name="selectedElement" data-value>' + '</select>' + '<button class="add" id="addElement" data-action="addElement"><span>+</span></button>' + '</div>' + '</div>',

    get: function get(element, entryNode) {
      utils.updateOptionsDropDown(selector, definition, elementType, entryNode);
      var reference = definition.get(referenceProperty);
      return {
        selectedElement: reference && reference.id || ''
      };
    },

    set: function set(element, values) {
      var selection = values.selectedElement;

      var props = {};

      if (!selection || typeof selection === 'undefined') {
        // remove reference to element
        props[referenceProperty] = undefined;
        return cmdHelper.updateBusinessObject(element, definition, props);
      }

      var commands = [];

      var selectedElement = findElementById(definition, elementType, selection);
      if (!selectedElement) {
        var root = utils.getRoot(definition);

        // create a new element
        selectedElement = elementHelper.createElement(elementType, { name: selection }, root, bpmnFactory);
        commands.push(cmdHelper.addAndRemoveElementsFromList(element, root, 'rootElements', null, [selectedElement]));
      }

      // update reference to element
      props[referenceProperty] = selectedElement;
      commands.push(cmdHelper.updateBusinessObject(element, definition, props));

      return commands;
    },

    addElement: function addElement(element, inputNode) {
      // note: this generated id will be used as name
      // of the element and not as id
      var id = utils.nextId(newElementIdPrefix);

      var optionTemplate = domify('<option value="' + id + '"> (id=' + id + ')' + '</option>');

      // add new option
      var selectBox = getSelectBox(inputNode);
      selectBox.insertBefore(optionTemplate, selectBox.firstChild);

      // select new element in the select box
      forEach(selectBox, function (option) {
        if (option.value === id) {
          domAttr(option, 'selected', 'selected');
        } else {
          domAttr(option, 'selected', null);
        }
      });

      return true;
    }

  });

  return entries;
};

},{"../../../../Utils":5,"../../../../helper/CmdHelper":24,"../../../../helper/ElementHelper":25,"lodash/collection/find":421,"lodash/collection/forEach":422,"min-dom/lib/attr":105,"min-dom/lib/domify":110,"min-dom/lib/query":112}],46:[function(require,module,exports){
'use strict';

var eventDefinitionReference = require('./EventDefinitionReference'),
    elementReferenceProperty = require('./ElementReferenceProperty');

module.exports = function (group, element, bpmnFactory, messageEventDefinition) {

  group.entries = group.entries.concat(eventDefinitionReference(element, messageEventDefinition, bpmnFactory, {
    label: 'Message',
    elementName: 'message',
    elementType: 'bpmn:Message',
    referenceProperty: 'messageRef',
    newElementIdPrefix: 'Message_'
  }));

  group.entries = group.entries.concat(elementReferenceProperty(element, messageEventDefinition, bpmnFactory, {
    id: 'message-element-name',
    label: 'Message Name',
    referenceProperty: 'messageRef',
    modelProperty: 'name',
    shouldValidate: true
  }));
};

},{"./ElementReferenceProperty":42,"./EventDefinitionReference":45}],47:[function(require,module,exports){
'use strict';

var entryFactory = require('../../../../factory/EntryFactory');

/**
 * Create an entry to modify the name of an an element.
 *
 * @param  {djs.model.Base} element
 * @param  {Object} options
 * @param  {string} options.id the id of the entry
 * @param  {string} options.label the label of the entry
 *
 * @return {Array<Object>} return an array containing
 *                         the entry to modify the name
 */
module.exports = function (element, options, translate) {

  options = options || {};
  var id = options.id || 'name',
      label = options.label || translate('Name'),
      modelProperty = options.modelProperty || 'name';

  var nameEntry = entryFactory.textBox({
    id: id,
    label: label,
    modelProperty: modelProperty
  });

  return [nameEntry];
};

},{"../../../../factory/EntryFactory":14}],48:[function(require,module,exports){
'use strict';

var eventDefinitionReference = require('./EventDefinitionReference'),
    elementReferenceProperty = require('./ElementReferenceProperty');

module.exports = function (group, element, bpmnFactory, signalEventDefinition) {

  group.entries = group.entries.concat(eventDefinitionReference(element, signalEventDefinition, bpmnFactory, {
    label: 'Signal',
    elementName: 'signal',
    elementType: 'bpmn:Signal',
    referenceProperty: 'signalRef',
    newElementIdPrefix: 'Signal_'
  }));

  group.entries = group.entries.concat(elementReferenceProperty(element, signalEventDefinition, bpmnFactory, {
    id: 'signal-element-name',
    label: 'Signal Name',
    referenceProperty: 'signalRef',
    modelProperty: 'name',
    shouldValidate: true
  }));
};

},{"./ElementReferenceProperty":42,"./EventDefinitionReference":45}],49:[function(require,module,exports){
'use strict';

var elementHelper = require('../../../../helper/ElementHelper'),
    cmdHelper = require('../../../../helper/CmdHelper');

var entryFactory = require('../../../../factory/EntryFactory');

/**
 * Get the timer definition type for a given timer event definition.
 *
 * @param {ModdleElement<bpmn:TimerEventDefinition>} timer
 *
 * @return {string|undefined} the timer definition type
 */
function getTimerDefinitionType(timer) {
  var timeDate = timer.get('timeDate');
  if (typeof timeDate !== 'undefined') {
    return 'timeDate';
  }

  var timeCycle = timer.get('timeCycle');
  if (typeof timeCycle !== 'undefined') {
    return 'timeCycle';
  }

  var timeDuration = timer.get('timeDuration');
  if (typeof timeDuration !== 'undefined') {
    return 'timeDuration';
  }
}

/**
 * Creates 'bpmn:FormalExpression' element.
 *
 * @param {ModdleElement} parent
 * @param {string} body
 * @param {BpmnFactory} bpmnFactory
 *
 * @return {ModdleElement<bpmn:FormalExpression>} a formal expression
 */
function createFormalExpression(parent, body, bpmnFactory) {
  body = body || undefined;
  return elementHelper.createElement('bpmn:FormalExpression', { body: body }, parent, bpmnFactory);
}

function TimerEventDefinition(group, element, bpmnFactory, timerEventDefinition) {

  var selectOptions = [{ value: 'timeDate', name: 'Date' }, { value: 'timeDuration', name: 'Duration' }, { value: 'timeCycle', name: 'Cycle' }];

  group.entries.push(entryFactory.selectBox({
    id: 'timer-event-definition-type',
    label: 'Timer Definition Type',
    selectOptions: selectOptions,
    emptyParameter: true,
    modelProperty: 'timerDefinitionType',

    get: function get(element, node) {
      return {
        timerDefinitionType: getTimerDefinitionType(timerEventDefinition) || ''
      };
    },

    set: function set(element, values) {
      var props = {
        timeDuration: undefined,
        timeDate: undefined,
        timeCycle: undefined
      };

      var newType = values.timerDefinitionType;
      if (values.timerDefinitionType) {
        var oldType = getTimerDefinitionType(timerEventDefinition);

        var value;
        if (oldType) {
          var definition = timerEventDefinition.get(oldType);
          value = definition.get('body');
        }

        props[newType] = createFormalExpression(timerEventDefinition, value, bpmnFactory);
      }

      return cmdHelper.updateBusinessObject(element, timerEventDefinition, props);
    }

  }));

  group.entries.push(entryFactory.textField({
    id: 'timer-event-definition',
    label: 'Timer Definition',
    modelProperty: 'timerDefinition',

    get: function get(element, node) {
      var type = getTimerDefinitionType(timerEventDefinition);
      var definition = type && timerEventDefinition.get(type);
      var value = definition && definition.get('body');
      return {
        timerDefinition: value
      };
    },

    set: function set(element, values) {
      var type = getTimerDefinitionType(timerEventDefinition);
      var definition = type && timerEventDefinition.get(type);

      if (definition) {
        return cmdHelper.updateBusinessObject(element, definition, {
          body: values.timerDefinition || undefined
        });
      }
    },

    validate: function validate(element) {
      var type = getTimerDefinitionType(timerEventDefinition);
      var definition = type && timerEventDefinition.get(type);
      if (definition) {
        var value = definition.get('body');
        if (!value) {
          return {
            timerDefinition: 'Must provide a value'
          };
        }
      }
    },

    hidden: function hidden(element) {
      return !getTimerDefinitionType(timerEventDefinition);
    }

  }));
}

module.exports = TimerEventDefinition;

},{"../../../../factory/EntryFactory":14,"../../../../helper/CmdHelper":24,"../../../../helper/ElementHelper":25}],50:[function(require,module,exports){
'use strict';

var inherits = require('inherits');

var PropertiesActivator = require('../../PropertiesActivator');

var asyncCapableHelper = require('../../helper/AsyncCapableHelper'),
    ImplementationTypeHelper = require('../../helper/ImplementationTypeHelper');

var is = require('bpmn-js/lib/util/ModelUtil').is;

// bpmn properties
var processProps = require('../bpmn/parts/ProcessProps'),
    eventProps = require('../bpmn/parts/EventProps'),
    linkProps = require('../bpmn/parts/LinkProps'),
    documentationProps = require('../bpmn/parts/DocumentationProps'),
    idProps = require('../bpmn/parts/IdProps'),
    nameProps = require('../bpmn/parts/NameProps'),
    executableProps = require('../bpmn/parts/ExecutableProps');

// camunda properties
var serviceTaskDelegateProps = require('./parts/ServiceTaskDelegateProps'),
    userTaskProps = require('./parts/UserTaskProps'),
    asynchronousContinuationProps = require('./parts/AsynchronousContinuationProps'),
    callActivityProps = require('./parts/CallActivityProps'),
    multiInstanceProps = require('./parts/MultiInstanceLoopProps'),
    sequenceFlowProps = require('./parts/SequenceFlowProps'),
    scriptProps = require('./parts/ScriptTaskProps'),
    formProps = require('./parts/FormProps'),
    startEventInitiator = require('./parts/StartEventInitiator'),
    variableMapping = require('./parts/VariableMappingProps'),
    versionTag = require('./parts/VersionTagProps');

var listenerProps = require('./parts/ListenerProps'),
    listenerDetails = require('./parts/ListenerDetailProps'),
    listenerFields = require('./parts/ListenerFieldInjectionProps');

var elementTemplateChooserProps = require('./element-templates/parts/ChooserProps'),
    elementTemplateCustomProps = require('./element-templates/parts/CustomProps');

// Input/Output
var inputOutput = require('./parts/InputOutputProps'),
    inputOutputParameter = require('./parts/InputOutputParameterProps');

// Connector
var connectorDetails = require('./parts/ConnectorDetailProps'),
    connectorInputOutput = require('./parts/ConnectorInputOutputProps'),
    connectorInputOutputParameter = require('./parts/ConnectorInputOutputParameterProps');

// properties
var properties = require('./parts/PropertiesProps');

// job configuration
var jobConfiguration = require('./parts/JobConfigurationProps');

// history time to live
var historyTimeToLive = require('./parts/HistoryTimeToLiveProps');

// external task configuration
var externalTaskConfiguration = require('./parts/ExternalTaskConfigurationProps');

// field injection
var fieldInjections = require('./parts/FieldInjectionProps');

var getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject,
    eventDefinitionHelper = require('../../helper/EventDefinitionHelper'),
    implementationTypeHelper = require('../../helper/ImplementationTypeHelper');

// helpers ////////////////////////////////////////

var isExternalTaskPriorityEnabled = function isExternalTaskPriorityEnabled(element) {
  var businessObject = getBusinessObject(element);

  // show only if element is a process, a participant ...
  if (is(element, 'bpmn:Process') || is(element, 'bpmn:Participant') && businessObject.get('processRef')) {
    return true;
  }

  var externalBo = ImplementationTypeHelper.getServiceTaskLikeBusinessObject(element),
      isExternalTask = ImplementationTypeHelper.getImplementationType(externalBo) === 'external';

  // ... or an external task with selected external implementation type
  return !!ImplementationTypeHelper.isExternalCapable(externalBo) && isExternalTask;
};

var isJobConfigEnabled = function isJobConfigEnabled(element) {
  var businessObject = getBusinessObject(element);

  if (is(element, 'bpmn:Process') || is(element, 'bpmn:Participant') && businessObject.get('processRef')) {
    return true;
  }

  // async behavior
  var bo = getBusinessObject(element);
  if (asyncCapableHelper.isAsyncBefore(bo) || asyncCapableHelper.isAsyncAfter(bo)) {
    return true;
  }

  // timer definition
  if (is(element, 'bpmn:Event')) {
    return !!eventDefinitionHelper.getTimerEventDefinition(element);
  }

  return false;
};

var getInputOutputParameterLabel = function getInputOutputParameterLabel(param, translate) {

  if (is(param, 'camunda:InputParameter')) {
    return translate('Input Parameter');
  }

  if (is(param, 'camunda:OutputParameter')) {
    return translate('Output Parameter');
  }

  return '';
};

var getListenerLabel = function getListenerLabel(param, translate) {

  if (is(param, 'camunda:ExecutionListener')) {
    return translate('Execution Listener');
  }

  if (is(param, 'camunda:TaskListener')) {
    return translate('Task Listener');
  }

  return '';
};

function createGeneralTabGroups(element, bpmnFactory, elementRegistry, elementTemplates, translate) {

  var generalGroup = {
    id: 'general',
    label: translate('General'),
    entries: []
  };
  idProps(generalGroup, element, translate);
  nameProps(generalGroup, element, translate);
  processProps(generalGroup, element, translate);
  versionTag(generalGroup, element, translate);
  executableProps(generalGroup, element, translate);
  elementTemplateChooserProps(generalGroup, element, elementTemplates, translate);

  var customFieldsGroups = elementTemplateCustomProps(element, elementTemplates, bpmnFactory, translate);

  var detailsGroup = {
    id: 'details',
    label: translate('Details'),
    entries: []
  };
  serviceTaskDelegateProps(detailsGroup, element, bpmnFactory, translate);
  userTaskProps(detailsGroup, element, translate);
  scriptProps(detailsGroup, element, bpmnFactory, translate);
  linkProps(detailsGroup, element, translate);
  callActivityProps(detailsGroup, element, bpmnFactory, translate);
  eventProps(detailsGroup, element, bpmnFactory, elementRegistry, translate);
  sequenceFlowProps(detailsGroup, element, bpmnFactory, translate);
  startEventInitiator(detailsGroup, element, translate); // this must be the last element of the details group!

  var multiInstanceGroup = {
    id: 'multiInstance',
    label: translate('Multi Instance'),
    entries: []
  };
  multiInstanceProps(multiInstanceGroup, element, bpmnFactory, translate);

  var asyncGroup = {
    id: 'async',
    label: translate('Asynchronous Continuations'),
    entries: []
  };
  asynchronousContinuationProps(asyncGroup, element, bpmnFactory, translate);

  var jobConfigurationGroup = {
    id: 'jobConfiguration',
    label: translate('Job Configuration'),
    entries: [],
    enabled: isJobConfigEnabled
  };
  jobConfiguration(jobConfigurationGroup, element, bpmnFactory, translate);

  var externalTaskGroup = {
    id: 'externalTaskConfiguration',
    label: translate('External Task Configuration'),
    entries: [],
    enabled: isExternalTaskPriorityEnabled
  };
  externalTaskConfiguration(externalTaskGroup, element, bpmnFactory, translate);

  var documentationGroup = {
    id: 'documentation',
    label: translate('Documentation'),
    entries: []
  };
  documentationProps(documentationGroup, element, bpmnFactory, translate);

  var historyTimeToLiveGroup = {
    id: 'historyConfiguration',
    label: translate('History Configuration'),
    entries: []
  };
  historyTimeToLive(historyTimeToLiveGroup, element, bpmnFactory, translate);

  var groups = [];
  groups.push(generalGroup);
  customFieldsGroups.forEach(function (group) {
    groups.push(group);
  });
  groups.push(detailsGroup);
  groups.push(externalTaskGroup);
  groups.push(multiInstanceGroup);
  groups.push(asyncGroup);
  groups.push(jobConfigurationGroup);
  groups.push(documentationGroup);
  groups.push(historyTimeToLiveGroup);

  return groups;
}

function createVariablesTabGroups(element, bpmnFactory, elementRegistry, translate) {
  var variablesGroup = {
    id: 'variables',
    label: translate('Variables'),
    entries: []
  };
  variableMapping(variablesGroup, element, bpmnFactory, translate);

  return [variablesGroup];
}

function createFormsTabGroups(element, bpmnFactory, elementRegistry, translate) {
  var formGroup = {
    id: 'forms',
    label: translate('Forms'),
    entries: []
  };
  formProps(formGroup, element, bpmnFactory, translate);

  return [formGroup];
}

function createListenersTabGroups(element, bpmnFactory, elementRegistry, translate) {

  var listenersGroup = {
    id: 'listeners',
    label: translate('Listeners'),
    entries: []
  };

  var options = listenerProps(listenersGroup, element, bpmnFactory, translate);

  var listenerDetailsGroup = {
    id: 'listener-details',
    entries: [],
    enabled: function enabled(element, node) {
      return options.getSelectedListener(element, node);
    },
    label: function label(element, node) {
      var param = options.getSelectedListener(element, node);
      return getListenerLabel(param, translate);
    }
  };

  listenerDetails(listenerDetailsGroup, element, bpmnFactory, options, translate);

  var listenerFieldsGroup = {
    id: 'listener-fields',
    label: translate('Field Injection'),
    entries: [],
    enabled: function enabled(element, node) {
      return options.getSelectedListener(element, node);
    }
  };

  listenerFields(listenerFieldsGroup, element, bpmnFactory, options, translate);

  return [listenersGroup, listenerDetailsGroup, listenerFieldsGroup];
}

function createInputOutputTabGroups(element, bpmnFactory, elementRegistry, translate) {

  var inputOutputGroup = {
    id: 'input-output',
    label: translate('Parameters'),
    entries: []
  };

  var options = inputOutput(inputOutputGroup, element, bpmnFactory, translate);

  var inputOutputParameterGroup = {
    id: 'input-output-parameter',
    entries: [],
    enabled: function enabled(element, node) {
      return options.getSelectedParameter(element, node);
    },
    label: function label(element, node) {
      var param = options.getSelectedParameter(element, node);
      return getInputOutputParameterLabel(param, translate);
    }
  };

  inputOutputParameter(inputOutputParameterGroup, element, bpmnFactory, options, translate);

  return [inputOutputGroup, inputOutputParameterGroup];
}

function createConnectorTabGroups(element, bpmnFactory, elementRegistry, translate) {
  var connectorDetailsGroup = {
    id: 'connector-details',
    label: translate('Details'),
    entries: []
  };

  connectorDetails(connectorDetailsGroup, element, bpmnFactory, translate);

  var connectorInputOutputGroup = {
    id: 'connector-input-output',
    label: translate('Input/Output'),
    entries: []
  };

  var options = connectorInputOutput(connectorInputOutputGroup, element, bpmnFactory, translate);

  var connectorInputOutputParameterGroup = {
    id: 'connector-input-output-parameter',
    entries: [],
    enabled: function enabled(element, node) {
      return options.getSelectedParameter(element, node);
    },
    label: function label(element, node) {
      var param = options.getSelectedParameter(element, node);
      return getInputOutputParameterLabel(param, translate);
    }
  };

  connectorInputOutputParameter(connectorInputOutputParameterGroup, element, bpmnFactory, options, translate);

  return [connectorDetailsGroup, connectorInputOutputGroup, connectorInputOutputParameterGroup];
}

function createFieldInjectionsTabGroups(element, bpmnFactory, elementRegistry, translate) {

  var fieldGroup = {
    id: 'field-injections-properties',
    label: translate('Field Injections'),
    entries: []
  };

  fieldInjections(fieldGroup, element, bpmnFactory, translate);

  return [fieldGroup];
}

function createExtensionElementsGroups(element, bpmnFactory, elementRegistry, translate) {

  var propertiesGroup = {
    id: 'extensionElements-properties',
    label: translate('Properties'),
    entries: []
  };
  properties(propertiesGroup, element, bpmnFactory, translate);

  return [propertiesGroup];
}

// Camunda Properties Provider /////////////////////////////////////


/**
 * A properties provider for Camunda related properties.
 *
 * @param {EventBus} eventBus
 * @param {BpmnFactory} bpmnFactory
 * @param {ElementRegistry} elementRegistry
 * @param {ElementTemplates} elementTemplates
 */
function CamundaPropertiesProvider(eventBus, bpmnFactory, elementRegistry, elementTemplates, translate) {

  PropertiesActivator.call(this, eventBus);

  this.getTabs = function (element) {

    var generalTab = {
      id: 'general',
      label: translate('General'),
      groups: createGeneralTabGroups(element, bpmnFactory, elementRegistry, elementTemplates, translate)
    };

    var variablesTab = {
      id: 'variables',
      label: translate('Variables'),
      groups: createVariablesTabGroups(element, bpmnFactory, elementRegistry, translate)
    };

    var formsTab = {
      id: 'forms',
      label: translate('Forms'),
      groups: createFormsTabGroups(element, bpmnFactory, elementRegistry, translate)
    };

    var listenersTab = {
      id: 'listeners',
      label: translate('Listeners'),
      groups: createListenersTabGroups(element, bpmnFactory, elementRegistry, translate),
      enabled: function enabled(element) {
        return !eventDefinitionHelper.getLinkEventDefinition(element) || !is(element, 'bpmn:IntermediateThrowEvent') && eventDefinitionHelper.getLinkEventDefinition(element);
      }
    };

    var inputOutputTab = {
      id: 'input-output',
      label: translate('Input/Output'),
      groups: createInputOutputTabGroups(element, bpmnFactory, elementRegistry, translate)
    };

    var connectorTab = {
      id: 'connector',
      label: translate('Connector'),
      groups: createConnectorTabGroups(element, bpmnFactory, elementRegistry, translate),
      enabled: function enabled(element) {
        var bo = implementationTypeHelper.getServiceTaskLikeBusinessObject(element);
        return bo && implementationTypeHelper.getImplementationType(bo) === 'connector';
      }
    };

    var fieldInjectionsTab = {
      id: 'field-injections',
      label: translate('Field Injections'),
      groups: createFieldInjectionsTabGroups(element, bpmnFactory, elementRegistry, translate)
    };

    var extensionsTab = {
      id: 'extensionElements',
      label: translate('Extensions'),
      groups: createExtensionElementsGroups(element, bpmnFactory, elementRegistry, translate)
    };

    return [generalTab, variablesTab, connectorTab, formsTab, listenersTab, inputOutputTab, fieldInjectionsTab, extensionsTab];
  };
}

CamundaPropertiesProvider.$inject = ['eventBus', 'bpmnFactory', 'elementRegistry', 'elementTemplates', 'translate'];

inherits(CamundaPropertiesProvider, PropertiesActivator);

module.exports = CamundaPropertiesProvider;

},{"../../PropertiesActivator":3,"../../helper/AsyncCapableHelper":23,"../../helper/EventDefinitionHelper":26,"../../helper/ImplementationTypeHelper":29,"../bpmn/parts/DocumentationProps":33,"../bpmn/parts/EventProps":34,"../bpmn/parts/ExecutableProps":35,"../bpmn/parts/IdProps":36,"../bpmn/parts/LinkProps":37,"../bpmn/parts/NameProps":38,"../bpmn/parts/ProcessProps":39,"./element-templates/parts/ChooserProps":60,"./element-templates/parts/CustomProps":61,"./parts/AsynchronousContinuationProps":63,"./parts/CallActivityProps":64,"./parts/ConnectorDetailProps":65,"./parts/ConnectorInputOutputParameterProps":66,"./parts/ConnectorInputOutputProps":67,"./parts/ExternalTaskConfigurationProps":68,"./parts/FieldInjectionProps":69,"./parts/FormProps":70,"./parts/HistoryTimeToLiveProps":71,"./parts/InputOutputParameterProps":72,"./parts/InputOutputProps":73,"./parts/JobConfigurationProps":74,"./parts/ListenerDetailProps":75,"./parts/ListenerFieldInjectionProps":76,"./parts/ListenerProps":77,"./parts/MultiInstanceLoopProps":78,"./parts/PropertiesProps":79,"./parts/ScriptTaskProps":80,"./parts/SequenceFlowProps":81,"./parts/ServiceTaskDelegateProps":82,"./parts/StartEventInitiator":83,"./parts/UserTaskProps":84,"./parts/VariableMappingProps":85,"./parts/VersionTagProps":86,"bpmn-js/lib/util/ModelUtil":216,"inherits":415}],51:[function(require,module,exports){
'use strict';

var assign = require('lodash/object/assign');

/**
 * Create an input parameter representing the given
 * binding and value.
 *
 * @param {PropertyBinding} binding
 * @param {String} value
 * @param {BpmnFactory} bpmnFactory
 *
 * @return {ModdleElement}
 */
function createInputParameter(binding, value, bpmnFactory) {
  var scriptFormat = binding.scriptFormat,
      parameterValue,
      parameterDefinition;

  if (scriptFormat) {
    parameterDefinition = bpmnFactory.create('camunda:Script', {
      scriptFormat: scriptFormat,
      value: value
    });
  } else {
    parameterValue = value;
  }

  return bpmnFactory.create('camunda:InputParameter', {
    name: binding.name,
    value: parameterValue,
    definition: parameterDefinition
  });
}

module.exports.createInputParameter = createInputParameter;

/**
 * Create an output parameter representing the given
 * binding and value.
 *
 * @param {PropertyBinding} binding
 * @param {String} value
 * @param {BpmnFactory} bpmnFactory
 *
 * @return {ModdleElement}
 */
function createOutputParameter(binding, value, bpmnFactory) {
  var scriptFormat = binding.scriptFormat,
      parameterValue,
      parameterDefinition;

  if (scriptFormat) {
    parameterDefinition = bpmnFactory.create('camunda:Script', {
      scriptFormat: scriptFormat,
      value: binding.source
    });
  } else {
    parameterValue = binding.source;
  }

  return bpmnFactory.create('camunda:OutputParameter', {
    name: value,
    value: parameterValue,
    definition: parameterDefinition
  });
}

module.exports.createOutputParameter = createOutputParameter;

/**
 * Create camunda property from the given binding.
 *
 * @param {PropertyBinding} binding
 * @param {String} value
 * @param {BpmnFactory} bpmnFactory
 *
 * @return {ModdleElement}
 */
function createCamundaProperty(binding, value, bpmnFactory) {
  return bpmnFactory.create('camunda:Property', {
    name: binding.name,
    value: value || ''
  });
}

module.exports.createCamundaProperty = createCamundaProperty;

/**
 * Create camunda:in element from given binding.
 *
 * @param {PropertyBinding} binding
 * @param {String} value
 * @param {BpmnFactory} bpmnFactory
 *
 * @return {ModdleElement}
 */
function createCamundaIn(binding, value, bpmnFactory) {

  var properties = createCamundaInOutAttrs(binding, value);

  return bpmnFactory.create('camunda:In', properties);
}

module.exports.createCamundaIn = createCamundaIn;

/**
 * Create camunda:in with businessKey element from given binding.
 *
 * @param {PropertyBinding} binding
 * @param {String} value
 * @param {BpmnFactory} bpmnFactory
 *
 * @return {ModdleElement}
 */
function createCamundaInWithBusinessKey(binding, value, bpmnFactory) {
  return bpmnFactory.create('camunda:In', {
    businessKey: value
  });
}

module.exports.createCamundaInWithBusinessKey = createCamundaInWithBusinessKey;

/**
 * Create camunda:out element from given binding.
 *
 * @param {PropertyBinding} binding
 * @param {String} value
 * @param {BpmnFactory} bpmnFactory
 *
 * @return {ModdleElement}
 */
function createCamundaOut(binding, value, bpmnFactory) {
  var properties = createCamundaInOutAttrs(binding, value);

  return bpmnFactory.create('camunda:Out', properties);
}

module.exports.createCamundaOut = createCamundaOut;

/**
 * Create camunda:executionListener element containing an inline script from given binding.
 *
 * @param {PropertyBinding} binding
 * @param {String} value
 * @param {BpmnFactory} bpmnFactory
 *
 * @return {ModdleElement}
 */
function createCamundaExecutionListenerScript(binding, value, bpmnFactory) {
  var scriptFormat = binding.scriptFormat,
      parameterValue,
      parameterDefinition;

  if (scriptFormat) {
    parameterDefinition = bpmnFactory.create('camunda:Script', {
      scriptFormat: scriptFormat,
      value: value
    });
  } else {
    parameterValue = value;
  }

  return bpmnFactory.create('camunda:ExecutionListener', {
    event: binding.event,
    value: parameterValue,
    script: parameterDefinition
  });
}

module.exports.createCamundaExecutionListenerScript = createCamundaExecutionListenerScript;

/**
 * Create camunda:field element containing string or expression from given binding.
 *
 * @param {PropertyBinding} binding
 * @param {String} value
 * @param {BpmnFactory} bpmnFactory
 *
 * @return {ModdleElement}
 */
function createCamundaFieldInjection(binding, value, bpmnFactory) {
  var DEFAULT_PROPS = {
    'string': undefined,
    'expression': undefined,
    'name': undefined
  };

  var props = assign({}, DEFAULT_PROPS);

  if (!binding.expression) {
    props.string = value;
  } else {
    props.expression = value;
  }
  props.name = binding.name;

  return bpmnFactory.create('camunda:Field', props);
}
module.exports.createCamundaFieldInjection = createCamundaFieldInjection;

/////////// helpers ////////////////////////////

/**
 * Create properties for camunda:in and camunda:out types.
 */
function createCamundaInOutAttrs(binding, value) {

  var properties = {};

  // camunda:in source(Expression) target
  if (binding.target) {

    properties.target = binding.target;

    if (binding.expression) {
      properties.sourceExpression = value;
    } else {
      properties.source = value;
    }
  } else

    // camunda:(in|out) variables local
    if (binding.variables) {
      properties.variables = 'all';

      if (binding.variables === 'local') {
        properties.local = true;
      }
    }

    // camunda:out source(Expression) target
    else {
        properties.target = value;

        ['source', 'sourceExpression'].forEach(function (k) {
          if (binding[k]) {
            properties[k] = binding[k];
          }
        });
      }

  return properties;
}

},{"lodash/object/assign":496}],52:[function(require,module,exports){
'use strict';

var inherits = require('inherits');

var getTemplate = require('./Helper').getTemplate;

var PropertiesActivator = require('../../../PropertiesActivator');

var HIGHER_PRIORITY = 1100;

/**
 * Applies template visibility settings.
 *
 * Controlled using `entriesVisible` on template config object:
 *
 * ```json
 *     "entriesVisible": {
 *       "_all": true|false,
 *       "entryName": true|false,
 *       ...
 *     }
 * ```
 *
 * @param {EventBus} eventBus
 * @param {ElementTemplates} elementTemplates
 */
function CustomElementsPropertiesActivator(eventBus, elementTemplates) {
  PropertiesActivator.call(this, eventBus, HIGHER_PRIORITY);

  this.isEntryVisible = function (entry, element) {

    var template = getTemplate(element, elementTemplates);

    if (template && !isEntryVisible(entry, template)) {
      return false;
    }
  };

  this.isPropertyEditable = function (entry, propertyName, element) {

    var template = getTemplate(element, elementTemplates);

    if (template && !isEntryEditable(entry, template)) {
      return false;
    }
  };
}

CustomElementsPropertiesActivator.$inject = ['eventBus', 'elementTemplates'];

inherits(CustomElementsPropertiesActivator, PropertiesActivator);

module.exports = CustomElementsPropertiesActivator;

////// helpers ////////////////////////////////////


var CUSTOM_PROPERTIES_PATTERN = /^custom-/;

var DEFAULT_ENTRIES_VISIBLE = {
  _all: false,
  id: true,
  name: true
};

function isCustomEntry(entry) {
  return CUSTOM_PROPERTIES_PATTERN.test(entry.id);
}

function isEntryVisible(entry, template) {

  var entryId = entry.id;

  if (entryId === 'elementTemplate-chooser' || isCustomEntry(entry)) {
    return true;
  }

  var entriesVisible = template.entriesVisible || DEFAULT_ENTRIES_VISIBLE;

  if (typeof entriesVisible === 'boolean') {
    return entriesVisible;
  }

  var defaultVisible = entriesVisible._all || false,
      entryVisible = entriesVisible[entryId];

  // d = true, e = false => false
  // d = false, e = true => true
  // d = false, e = false
  return defaultVisible === true && entryVisible !== false || defaultVisible === false && entryVisible === true;
}

function isEntryEditable(entry, template) {

  var property;

  if (isCustomEntry(entry)) {
    property = getProperty(template, entry);

    return property && property.editable !== false;
  }

  return true;
}

function getProperty(template, entry) {

  var index;
  var idx = entry.id.replace('custom-' + template.id + '-', '');
  if (idx.indexOf('-') !== -1) {
    var indexes = idx.split('-');
    if (indexes.length == 2) {
      var scopeName = indexes[0].replace(/_/g, ':');
      index = parseInt(indexes[1], 10);
      if (scopeName && !isNaN(index)) {
        return template.scopes[scopeName].properties[index];
      }
    }
  } else {
    index = parseInt(idx, 10);
    if (!isNaN(index)) {
      return template.properties[index];
    }
  }

  throw new Error('cannot extract property index for entry <' + entry.id + '>');
}

},{"../../../PropertiesActivator":3,"./Helper":55,"inherits":415}],53:[function(require,module,exports){
'use strict';

var values = require('lodash/object/values');

/**
 * The guy knowing all configured element templates.
 *
 * This registry won't validate. Use the {@link Validator}
 * to verify a template is valid prior to adding it to
 * this registry.
 */
function ElementTemplates() {

  this._templates = {};

  /**
   * Sets the known element templates.
   *
   * @param {Array<TemplateDescriptor>} descriptors
   *
   * @return {ElementTemplates}
   */
  this.set = function (descriptors) {

    var templates = this._templates = {};

    descriptors.forEach(function (descriptor) {
      templates[descriptor.id] = descriptor;
    });

    return this;
  };

  /**
   * Get template descriptor with given id.
   *
   * @param {String} id
   *
   * @return {TemplateDescriptor}
   */
  this.get = function (id) {
    return this._templates[id];
  };

  /**
   * Return all known template descriptors.
   *
   * @return {Array<TemplateDescriptor>}
   */
  this.getAll = function () {
    return values(this._templates);
  };
}

module.exports = ElementTemplates;

},{"lodash/object/values":502}],54:[function(require,module,exports){
'use strict';

var Validator = require('./Validator');

/**
 * The guy responsible for template loading.
 *
 * Provide the actual templates via the `config.elementTemplates`.
 *
 * That configuration can either be an array of template
 * descriptors or a node style callback to retrieve
 * the templates asynchronously.
 *
 * @param {Array<TemplateDescriptor>|Function} loadTemplates
 * @param {EventBus} eventBus
 * @param {ElementTemplates} elementTemplates
 */
function ElementTemplatesLoader(loadTemplates, eventBus, elementTemplates) {
  this._loadTemplates = loadTemplates;
  this._eventBus = eventBus;
  this._elementTemplates = elementTemplates;

  var self = this;

  eventBus.on('diagram.init', function () {
    self.reload();
  });
}

module.exports = ElementTemplatesLoader;

ElementTemplatesLoader.$inject = ['config.elementTemplates', 'eventBus', 'elementTemplates'];

ElementTemplatesLoader.prototype.reload = function () {

  var self = this;

  var loadTemplates = this._loadTemplates;

  // no templates specified
  if (typeof loadTemplates === 'undefined') {
    return;
  }

  // template loader function specified
  if (typeof loadTemplates === 'function') {

    return loadTemplates(function (err, templates) {

      if (err) {
        return self.templateErrors([err]);
      }

      self.setTemplates(templates);
    });
  }

  // templates array specified
  if (loadTemplates.length) {
    return this.setTemplates(loadTemplates);
  }
};

ElementTemplatesLoader.prototype.setTemplates = function (templates) {

  var elementTemplates = this._elementTemplates;

  var validator = new Validator().addAll(templates);

  var errors = validator.getErrors(),
      validTemplates = validator.getValidTemplates();

  elementTemplates.set(validTemplates);

  if (errors.length) {
    this.templateErrors(errors);
  }

  this.templatesChanged();
};

ElementTemplatesLoader.prototype.templatesChanged = function () {
  this._eventBus.fire('elementTemplates.changed');
};

ElementTemplatesLoader.prototype.templateErrors = function (errors) {
  this._eventBus.fire('elementTemplates.errors', {
    errors: errors
  });
};

},{"./Validator":56}],55:[function(require,module,exports){
'use strict';

var getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject;

var is = require('bpmn-js/lib/util/ModelUtil').is,
    isAny = require('bpmn-js/lib/features/modeling/util/ModelingUtil').isAny;

var find = require('lodash/collection/find');

var TEMPLATE_ATTR = 'camunda:modelerTemplate';

/**
 * The BPMN 2.0 extension attribute name under
 * which the element template is stored.
 *
 * @type {String}
 */
module.exports.TEMPLATE_ATTR = TEMPLATE_ATTR;

/**
 * Get template id for a given diagram element.
 *
 * @param {djs.model.Base} element
 *
 * @return {String}
 */
function getTemplateId(element) {

  var bo = getBusinessObject(element);

  if (bo) {
    return bo.get(TEMPLATE_ATTR);
  }
}

module.exports.getTemplateId = getTemplateId;

/**
 * Get template of a given element.
 *
 * @param {Element} element
 * @param {ElementTemplates} elementTemplates
 *
 * @return {TemplateDefinition}
 */
function getTemplate(element, elementTemplates) {
  var id = getTemplateId(element);

  return id && elementTemplates.get(id);
}

module.exports.getTemplate = getTemplate;

/**
 * Get default template for a given element.
 *
 * @param {Element} element
 * @param {ElementTemplates} elementTemplates
 *
 * @return {TemplateDefinition}
 */
function getDefaultTemplate(element, elementTemplates) {

  // return first default template, if any exists
  return elementTemplates.getAll().filter(function (t) {
    return isAny(element, t.appliesTo) && t.isDefault;
  })[0];
}

module.exports.getDefaultTemplate = getDefaultTemplate;

/**
 * Find extension with given type in
 * BPMN element, diagram element or ExtensionElement.
 *
 * @param {ModdleElement|djs.model.Base} element
 * @param {String} type
 *
 * @return {ModdleElement} the extension
 */
function findExtension(element, type) {
  var bo = getBusinessObject(element);

  var extensionElements;

  if (is(bo, 'bpmn:ExtensionElements')) {
    extensionElements = bo;
  } else {
    extensionElements = bo.extensionElements;
  }

  if (!extensionElements) {
    return null;
  }

  return find(extensionElements.get('values'), function (e) {
    return is(e, type);
  });
}

module.exports.findExtension = findExtension;

function findExtensions(element, types) {
  var extensionElements = getExtensionElements(element);

  if (!extensionElements) {
    return [];
  }

  return extensionElements.get('values').filter(function (e) {
    return isAny(e, types);
  });
}

module.exports.findExtensions = findExtensions;

function findCamundaInOut(element, binding) {

  var extensionElements = getExtensionElements(element);

  if (!extensionElements) {
    return;
  }

  var matcher;

  if (binding.type === 'camunda:in') {
    matcher = function matcher(e) {
      return is(e, 'camunda:In') && isInOut(e, binding);
    };
  } else if (binding.type === 'camunda:out') {
    matcher = function matcher(e) {
      return is(e, 'camunda:Out') && isInOut(e, binding);
    };
  } else if (binding.type === 'camunda:in:businessKey') {
    matcher = function matcher(e) {
      return is(e, 'camunda:In') && 'businessKey' in e;
    };
  }

  return find(extensionElements.get('values'), matcher);
}

module.exports.findCamundaInOut = findCamundaInOut;

function findCamundaProperty(camundaProperties, binding) {
  return find(camundaProperties.get('values'), function (p) {
    return p.name === binding.name;
  });
}

module.exports.findCamundaProperty = findCamundaProperty;

function findInputParameter(inputOutput, binding) {
  var parameters = inputOutput.get('inputParameters');

  return find(parameters, function (p) {
    return p.name === binding.name;
  });
}

module.exports.findInputParameter = findInputParameter;

function findOutputParameter(inputOutput, binding) {
  var parameters = inputOutput.get('outputParameters');

  return find(parameters, function (p) {
    var value = p.value;

    if (!binding.scriptFormat) {
      return value === binding.source;
    }

    var definition = p.definition;

    if (!definition || binding.scriptFormat !== definition.scriptFormat) {
      return false;
    }

    return definition.value === binding.source;
  });
}

module.exports.findOutputParameter = findOutputParameter;

//////// helpers /////////////////////////////////

function getExtensionElements(element) {
  var bo = getBusinessObject(element);

  if (is(bo, 'bpmn:ExtensionElements')) {
    return bo;
  } else {
    return bo.extensionElements;
  }
}

function isInOut(element, binding) {

  if (binding.type === 'camunda:in') {
    // find based on target attribute
    if (binding.target) {
      return element.target === binding.target;
    }
  }

  if (binding.type === 'camunda:out') {
    // find based on source / sourceExpression
    if (binding.source) {
      return element.source === binding.source;
    }

    if (binding.sourceExpression) {
      return element.sourceExpression === binding.sourceExpression;
    }
  }

  // find based variables / local combination
  if (binding.variables) {
    return element.variables === 'all' && (binding.variables !== 'local' || element.local);
  }
}

},{"bpmn-js/lib/features/modeling/util/ModelingUtil":189,"bpmn-js/lib/util/ModelUtil":216,"lodash/collection/find":421}],56:[function(require,module,exports){
'use strict';

var isArray = require('lodash/lang/isArray');
var isObject = require('lodash/lang/isObject');

var DROPDOWN_TYPE = 'Dropdown';

var VALID_TYPES = ['String', 'Text', 'Boolean', 'Hidden', DROPDOWN_TYPE];

var PROPERTY_TYPE = 'property',
    CAMUNDA_PROPERTY_TYPE = 'camunda:property',
    CAMUNDA_INPUT_PARAMETER_TYPE = 'camunda:inputParameter',
    CAMUNDA_OUTPUT_PARAMETER_TYPE = 'camunda:outputParameter',
    CAMUNDA_IN_TYPE = 'camunda:in',
    CAMUNDA_OUT_TYPE = 'camunda:out',
    CAMUNDA_IN_BUSINESS_KEY_TYPE = 'camunda:in:businessKey',
    CAMUNDA_EXECUTION_LISTENER = 'camunda:executionListener',
    CAMUNDA_FIELD = 'camunda:field';

var VALID_BINDING_TYPES = [PROPERTY_TYPE, CAMUNDA_PROPERTY_TYPE, CAMUNDA_INPUT_PARAMETER_TYPE, CAMUNDA_OUTPUT_PARAMETER_TYPE, CAMUNDA_IN_TYPE, CAMUNDA_OUT_TYPE, CAMUNDA_IN_BUSINESS_KEY_TYPE, CAMUNDA_EXECUTION_LISTENER, CAMUNDA_FIELD];

/**
 * A element template validator.
 */
function Validator() {

  this._templatesById = {};

  this._validTemplates = [];
  this._errors = [];

  /**
   * Adds the templates.
   *
   * @param {Array<TemplateDescriptor>} templates
   *
   * @return {Validator} self
   */
  this.addAll = function (templates) {

    if (!isArray(templates)) {
      this._logError('templates must be []');
    } else {
      templates.forEach(this.add, this);
    }

    return this;
  };

  /**
   * Add the given element template, if it is valid.
   *
   * @param {TemplateDescriptor} template
   *
   * @return {Validator} self
   */
  this.add = function (template) {

    var err = this._validateTemplate(template);

    if (!err) {
      this._templatesById[template.id] = template;

      this._validTemplates.push(template);
    }

    return this;
  };

  /**
   * Validate given template and return error (if any).
   *
   * @param {TemplateDescriptor} template
   *
   * @return {Error} validation error, if any
   */
  this._validateTemplate = function (template) {

    var err,
        id = template.id,
        appliesTo = template.appliesTo,
        properties = template.properties,
        scopes = template.scopes;

    if (!id) {
      return this._logError('missing template id');
    }

    if (id in this._templatesById) {
      return this._logError('template id <' + id + '> already used');
    }

    if (!isArray(appliesTo)) {
      err = this._logError('missing appliesTo=[]', template);
    }

    if (!isArray(properties)) {
      err = this._logError('missing properties=[]', template);
    } else {
      if (!this._validateProperties(properties)) {
        err = new Error('invalid properties');
      }
    }

    if (scopes) {
      err = this._validateScopes(template, scopes);
    }

    return err;
  };

  this._validateScopes = function (template, scopes) {

    var err, scope, scopeName;

    if (!isObject(scopes) || isArray(scopes)) {
      return this._logError('invalid scopes, should be scopes={}', template);
    }

    for (scopeName in scopes) {
      scope = scopes[scopeName];

      if (!isObject(scope) || isArray(scope)) {
        err = this._logError('invalid scope, should be scope={}', template);
      }

      if (!isArray(scope.properties)) {
        err = this._logError('missing properties=[] in scope <' + scopeName + '>', template);
      } else {
        if (!this._validateProperties(scope.properties)) {
          err = new Error('invalid properties in scope <' + scopeName + '>');
        }
      }
    }

    return err;
  };

  /**
   * Validate properties and return false if any is invalid.
   *
   * @param {Array<PropertyDescriptor>} properties
   *
   * @return {Boolean} true if all properties are valid
   */
  this._validateProperties = function (properties) {
    var validProperties = properties.filter(this._validateProperty, this);

    return properties.length === validProperties.length;
  };

  /**
   * Validate property and return false, if there was
   * a validation error.
   *
   * @param {PropertyDescriptor} property
   *
   * @return {Boolean} true if property is valid
   */
  this._validateProperty = function (property) {

    var type = property.type,
        binding = property.binding;

    var err;

    var bindingType = binding.type;

    if (VALID_TYPES.indexOf(type) === -1) {
      err = this._logError('invalid property type <' + type + '>; ' + 'must be any of { ' + VALID_TYPES.join(', ') + ' }');
    }

    if (type === DROPDOWN_TYPE && bindingType !== CAMUNDA_EXECUTION_LISTENER) {
      if (!isArray(property.choices)) {
        err = this._logError('must provide choices=[] with ' + DROPDOWN_TYPE + ' type');
      } else if (!property.choices.every(isDropdownChoiceValid)) {
        err = this._logError('{ name, value } must be specified for ' + DROPDOWN_TYPE + ' choices');
      }
    }

    if (!binding) {
      return this._logError('property missing binding');
    }

    if (VALID_BINDING_TYPES.indexOf(bindingType) === -1) {
      err = this._logError('invalid property.binding type <' + bindingType + '>; ' + 'must be any of { ' + VALID_BINDING_TYPES.join(', ') + ' }');
    }

    if (bindingType === PROPERTY_TYPE || bindingType === CAMUNDA_PROPERTY_TYPE || bindingType === CAMUNDA_INPUT_PARAMETER_TYPE || bindingType === CAMUNDA_FIELD) {

      if (!binding.name) {
        err = this._logError('property.binding <' + bindingType + '> requires name');
      }
    }

    if (bindingType === CAMUNDA_OUTPUT_PARAMETER_TYPE) {
      if (!binding.source) {
        err = this._logError('property.binding <' + bindingType + '> requires source');
      }
    }

    if (bindingType === CAMUNDA_IN_TYPE) {

      if (!binding.variables && !binding.target) {
        err = this._logError('property.binding <' + bindingType + '> requires ' + 'variables or target');
      }
    }

    if (bindingType === CAMUNDA_OUT_TYPE) {

      if (!binding.variables && !binding.source && !binding.sourceExpression) {
        err = this._logError('property.binding <' + bindingType + '> requires ' + 'variables, sourceExpression or source');
      }
    }

    if (bindingType === CAMUNDA_EXECUTION_LISTENER) {

      if (type !== 'Hidden') {
        err = this._logError('invalid property type <' + type + '> for ' + CAMUNDA_EXECUTION_LISTENER + '; ' + 'must be <Hidden>');
      }
    }

    return !err;
  };

  this._logError = function (err, template) {

    if (typeof err === 'string') {
      if (template) {
        err = 'template(id: ' + template.id + ') ' + err;
      }

      err = new Error(err);
    }

    this._errors.push(err);

    return err;
  };

  this.getErrors = function () {
    return this._errors;
  };

  this.getValidTemplates = function () {
    return this._validTemplates;
  };
}

module.exports = Validator;

//////// helpers ///////////////////////////////////

function isDropdownChoiceValid(c) {
  return 'name' in c && 'value' in c;
}

},{"lodash/lang/isArray":489,"lodash/lang/isObject":493}],57:[function(require,module,exports){
'use strict';

var findExtension = require('../Helper').findExtension,
    findExtensions = require('../Helper').findExtensions;

var createCamundaProperty = require('../CreateHelper').createCamundaProperty,
    createInputParameter = require('../CreateHelper').createInputParameter,
    createOutputParameter = require('../CreateHelper').createOutputParameter,
    createCamundaIn = require('../CreateHelper').createCamundaIn,
    createCamundaOut = require('../CreateHelper').createCamundaOut,
    createCamundaInWithBusinessKey = require('../CreateHelper').createCamundaInWithBusinessKey,
    createCamundaExecutionListenerScript = require('../CreateHelper').createCamundaExecutionListenerScript,
    createCamundaFieldInjection = require('../CreateHelper').createCamundaFieldInjection;

var forEach = require('lodash/collection/forEach');

var CAMUNDA_SERVICE_TASK_LIKE = ['camunda:class', 'camunda:delegateExpression', 'camunda:expression'];

/**
 * A handler that changes the modeling template of a BPMN element.
 */
function ChangeElementTemplateHandler(modeling, commandStack, bpmnFactory) {

  function getOrCreateExtensionElements(element) {

    var bo = element.businessObject;

    var extensionElements = bo.extensionElements;

    // add extension elements
    if (!extensionElements) {
      extensionElements = bpmnFactory.create('bpmn:ExtensionElements', {
        values: []
      });

      modeling.updateProperties(element, {
        extensionElements: extensionElements
      });
    }

    return extensionElements;
  }

  function updateModelerTemplate(element, newTemplate) {
    modeling.updateProperties(element, {
      'camunda:modelerTemplate': newTemplate && newTemplate.id
    });
  }

  function updateIoMappings(element, newTemplate, context) {

    var newMappings = createInputOutputMappings(newTemplate, bpmnFactory),
        oldMappings;

    if (!newMappings) {
      return;
    }

    if (context) {
      commandStack.execute('properties-panel.update-businessobject', {
        element: element,
        businessObject: context,
        properties: { inputOutput: newMappings }
      });
    } else {
      context = getOrCreateExtensionElements(element);
      oldMappings = findExtension(element, 'camunda:InputOutput');
      commandStack.execute('properties-panel.update-businessobject-list', {
        element: element,
        currentObject: context,
        propertyName: 'values',
        objectsToAdd: [newMappings],
        objectsToRemove: oldMappings ? [oldMappings] : []
      });
    }
  }

  function updateCamundaField(element, newTemplate, context) {

    var newMappings = createCamundaFieldInjections(newTemplate, bpmnFactory),
        oldMappings;

    if (!newMappings) {
      return;
    }
    if (context) {
      commandStack.execute('properties-panel.update-businessobject', {
        element: element,
        businessObject: context,
        properties: { field: newMappings }
      });
    } else {
      context = getOrCreateExtensionElements(element);
      oldMappings = findExtensions(element, ['camunda:Field']);

      commandStack.execute('properties-panel.update-businessobject-list', {
        element: element,
        currentObject: context,
        propertyName: 'values',
        objectsToAdd: newMappings,
        objectsToRemove: oldMappings ? oldMappings : []
      });
    }
  }

  function updateCamundaProperties(element, newTemplate, context) {

    var newProperties = createCamundaProperties(newTemplate, bpmnFactory),
        oldProperties;

    if (!newProperties) {
      return;
    }

    if (context) {
      commandStack.execute('properties-panel.update-businessobject', {
        element: element,
        businessObject: context,
        properties: { properties: newProperties }
      });
    } else {
      context = getOrCreateExtensionElements(element);
      oldProperties = findExtension(element, 'camunda:Properties');

      commandStack.execute('properties-panel.update-businessobject-list', {
        element: element,
        currentObject: context,
        propertyName: 'values',
        objectsToAdd: [newProperties],
        objectsToRemove: oldProperties ? [oldProperties] : []
      });
    }
  }

  function updateProperties(element, newTemplate, context) {

    var newProperties = createBpmnPropertyUpdates(newTemplate, bpmnFactory);

    var newPropertiesCount = Object.keys(newProperties).length;

    if (!newPropertiesCount) {
      return;
    }

    if (context) {
      commandStack.execute('properties-panel.update-businessobject', {
        element: element,
        businessObject: context,
        properties: newProperties
      });
    } else {
      modeling.updateProperties(element, newProperties);
    }
  }

  function updateInOut(element, newTemplate, context) {

    var newInOut = createCamundaInOut(newTemplate, bpmnFactory),
        oldInOut;

    if (!newInOut) {
      return;
    }

    if (context) {
      commandStack.execute('properties-panel.update-businessobject', {
        element: element,
        businessObject: context,
        properties: { inout: newInOut }
      });
    } else {
      context = getOrCreateExtensionElements(element);
      oldInOut = findExtensions(context, ['camunda:In', 'camunda:Out']);

      commandStack.execute('properties-panel.update-businessobject-list', {
        element: element,
        currentObject: context,
        propertyName: 'values',
        objectsToAdd: newInOut,
        objectsToRemove: oldInOut
      });
    }
  }

  function updateExecutionListener(element, newTemplate, context) {

    var newExecutionListeners = createCamundaExecutionListeners(newTemplate, bpmnFactory),
        oldExecutionsListeners;

    if (!newExecutionListeners.length) {
      return;
    }

    if (context) {
      commandStack.execute('properties-panel.update-businessobject', {
        element: element,
        businessObject: context,
        properties: { executionListener: newExecutionListeners }
      });
    } else {
      context = getOrCreateExtensionElements(element);
      oldExecutionsListeners = findExtensions(context, ['camunda:ExecutionListener']);

      commandStack.execute('properties-panel.update-businessobject-list', {
        element: element,
        currentObject: context,
        propertyName: 'values',
        objectsToAdd: newExecutionListeners,
        objectsToRemove: oldExecutionsListeners
      });
    }
  }

  /**
   * Update / recreate a scoped element.
   *
   * @param {djs.model.Base} element the diagram parent element
   * @param {String} scopeName name of the scope, i.e. camunda:Connector
   * @param {Object} scopeDefinition
   */
  function updateScopeElements(element, scopeName, scopeDefinition) {

    var scopeElement = bpmnFactory.create(scopeName);

    // update camunda:inputOutput
    updateIoMappings(element, scopeDefinition, scopeElement);

    // update camunda:field
    updateCamundaField(element, scopeDefinition, scopeElement);

    // update camunda:properties
    updateCamundaProperties(element, scopeDefinition, scopeElement);

    // update other properties (bpmn:condition, camunda:async, ...)
    updateProperties(element, scopeDefinition, scopeElement);

    // update camunda:in and camunda:out
    updateInOut(element, scopeDefinition, scopeElement);

    // update camunda:executionListener
    updateExecutionListener(element, scopeDefinition, scopeElement);

    var extensionElements = getOrCreateExtensionElements(element);
    var oldScope = findExtension(extensionElements, scopeName);

    commandStack.execute('properties-panel.update-businessobject-list', {
      element: element,
      currentObject: extensionElements,
      propertyName: 'values',
      objectsToAdd: [scopeElement],
      objectsToRemove: oldScope ? [oldScope] : []
    });
  }

  /**
   * Compose an element template change action, updating all
   * necessary underlying properties.
   *
   * @param {Object} context
   * @param {Object} context.element
   * @param {Object} context.oldTemplate
   * @param {Object} context.newTemplate
   */
  this.preExecute = function (context) {

    var element = context.element,
        newTemplate = context.newTemplate;

    // update camunda:modelerTemplate attribute
    updateModelerTemplate(element, newTemplate);

    if (newTemplate) {

      // update camunda:inputOutput
      updateIoMappings(element, newTemplate);

      // update camunda:field
      updateCamundaField(element, newTemplate);

      // update camunda:properties
      updateCamundaProperties(element, newTemplate);

      // update other properties (bpmn:condition, camunda:async, ...)
      updateProperties(element, newTemplate);

      // update camunda:in and camunda:out
      updateInOut(element, newTemplate);

      // update camunda:executionListener
      updateExecutionListener(element, newTemplate);

      // loop on scopes properties
      forEach(newTemplate.scopes, function (scopeDefinition, scopeName) {
        updateScopeElements(element, scopeName, scopeDefinition);
      });
    }
  };
}

ChangeElementTemplateHandler.$inject = ['modeling', 'commandStack', 'bpmnFactory'];

module.exports = ChangeElementTemplateHandler;

/////// helpers /////////////////////////////

function createBpmnPropertyUpdates(template, bpmnFactory) {

  var propertyUpdates = {};

  template.properties.forEach(function (p) {

    var binding = p.binding,
        bindingTarget = binding.name,
        propertyValue;

    if (binding.type === 'property') {

      if (bindingTarget === 'conditionExpression') {
        propertyValue = bpmnFactory.create('bpmn:FormalExpression', {
          body: p.value,
          language: binding.scriptFormat
        });
      } else {
        propertyValue = p.value;
      }

      // assigning camunda:async to true|false
      // assigning bpmn:conditionExpression to { $type: 'bpmn:FormalExpression', ... }
      propertyUpdates[bindingTarget] = propertyValue;

      // make sure we unset other "implementation types"
      // when applying a camunda:class template onto a preconfigured
      // camunda:delegateExpression element
      if (CAMUNDA_SERVICE_TASK_LIKE.indexOf(bindingTarget) !== -1) {
        CAMUNDA_SERVICE_TASK_LIKE.forEach(function (prop) {
          if (prop !== bindingTarget) {
            propertyUpdates[prop] = undefined;
          }
        });
      }
    }
  });

  return propertyUpdates;
}

function createCamundaFieldInjections(template, bpmnFactory) {
  var injections = [];

  template.properties.forEach(function (p) {
    var binding = p.binding,
        bindingType = binding.type;
    if (bindingType === 'camunda:field') {
      injections.push(createCamundaFieldInjection(binding, p.value, bpmnFactory));
    }
  });

  if (injections.length) {
    return injections;
  }
}

function createCamundaProperties(template, bpmnFactory) {

  var properties = [];

  template.properties.forEach(function (p) {
    var binding = p.binding,
        bindingType = binding.type;

    if (bindingType === 'camunda:property') {
      properties.push(createCamundaProperty(binding, p.value, bpmnFactory));
    }
  });

  if (properties.length) {
    return bpmnFactory.create('camunda:Properties', {
      values: properties
    });
  }
}

function createInputOutputMappings(template, bpmnFactory) {

  var inputParameters = [],
      outputParameters = [];

  template.properties.forEach(function (p) {
    var binding = p.binding,
        bindingType = binding.type;

    if (bindingType === 'camunda:inputParameter') {
      inputParameters.push(createInputParameter(binding, p.value, bpmnFactory));
    }

    if (bindingType === 'camunda:outputParameter') {
      outputParameters.push(createOutputParameter(binding, p.value, bpmnFactory));
    }
  });

  // do we need to create new ioMappings (?)
  if (outputParameters.length || inputParameters.length) {
    return bpmnFactory.create('camunda:InputOutput', {
      inputParameters: inputParameters,
      outputParameters: outputParameters
    });
  }
}

function createCamundaInOut(template, bpmnFactory) {

  var inOuts = [];

  template.properties.forEach(function (p) {
    var binding = p.binding,
        bindingType = binding.type;

    if (bindingType === 'camunda:in') {
      inOuts.push(createCamundaIn(binding, p.value, bpmnFactory));
    } else if (bindingType === 'camunda:out') {
      inOuts.push(createCamundaOut(binding, p.value, bpmnFactory));
    } else if (bindingType === 'camunda:in:businessKey') {
      inOuts.push(createCamundaInWithBusinessKey(binding, p.value, bpmnFactory));
    }
  });

  return inOuts;
}

function createCamundaExecutionListeners(template, bpmnFactory) {

  var executionListener = [];

  template.properties.forEach(function (p) {
    var binding = p.binding,
        bindingType = binding.type;

    if (bindingType === 'camunda:executionListener') {
      executionListener.push(createCamundaExecutionListenerScript(binding, p.value, bpmnFactory));
    }
  });

  return executionListener;
}

},{"../CreateHelper":51,"../Helper":55,"lodash/collection/forEach":422}],58:[function(require,module,exports){
'use strict';

var ChangeElementTemplateHandler = require('./ChangeElementTemplateHandler');

var getTemplate = require('../Helper').getTemplate,
    getDefaultTemplate = require('../Helper').getDefaultTemplate;

function registerHandlers(commandStack, elementTemplates, eventBus, elementRegistry) {
  commandStack.registerHandler('propertiesPanel.camunda.changeTemplate', ChangeElementTemplateHandler);

  // apply default element templates on shape creation
  eventBus.on(['commandStack.shape.create.postExecuted'], function (context) {
    applyDefaultTemplate(context.context.shape, elementTemplates, commandStack);
  });

  // apply default element templates on connection creation
  eventBus.on(['commandStack.connection.create.postExecuted'], function (context) {
    applyDefaultTemplate(context.context.connection, elementTemplates, commandStack);
  });
}

registerHandlers.$inject = ['commandStack', 'elementTemplates', 'eventBus', 'elementRegistry'];

module.exports = {
  __init__: [registerHandlers]
};

function applyDefaultTemplate(element, elementTemplates, commandStack) {

  if (!getTemplate(element, elementTemplates) && getDefaultTemplate(element, elementTemplates)) {

    var command = 'propertiesPanel.camunda.changeTemplate';
    var commandContext = {
      element: element,
      newTemplate: getDefaultTemplate(element, elementTemplates)
    };

    commandStack.execute(command, commandContext);
  }
}

},{"../Helper":55,"./ChangeElementTemplateHandler":57}],59:[function(require,module,exports){
'use strict';

module.exports = {
  __depends__: [require('./cmd'), require('diagram-js/lib/i18n/translate')],
  __init__: ['customElementsPropertiesActivator', 'elementTemplatesLoader'],
  customElementsPropertiesActivator: ['type', require('./CustomElementsPropertiesActivator')],
  elementTemplates: ['type', require('./ElementTemplates')],
  elementTemplatesLoader: ['type', require('./ElementTemplatesLoader')]
};

},{"./CustomElementsPropertiesActivator":52,"./ElementTemplates":53,"./ElementTemplatesLoader":54,"./cmd":58,"diagram-js/lib/i18n/translate":376}],60:[function(require,module,exports){
'use strict';

var entryFactory = require('../../../../factory/EntryFactory'),
    is = require('bpmn-js/lib/util/ModelUtil').is,
    getTemplate = require('../Helper').getTemplate,
    getTemplateId = require('../Helper').getTemplateId;

var find = require('lodash/collection/find');

var TEMPLATE_ATTR = require('../Helper').TEMPLATE_ATTR;

function isAny(element, types) {
  return types.reduce(function (result, type) {
    return result || is(element, type);
  }, false);
}

module.exports = function (group, element, elementTemplates, translate) {

  var options = getTemplateOptions(element, elementTemplates);

  if (options.length === 1 && !options[0].isDefault) {
    return;
  }

  // select element template (via dropdown)
  group.entries.push(entryFactory.selectBox({
    id: 'elementTemplate-chooser',
    label: translate('Element Template'),
    modelProperty: 'camunda:modelerTemplate',
    selectOptions: options,
    set: function set(element, properties) {
      return applyTemplate(element, properties[TEMPLATE_ATTR], elementTemplates);
    },
    disabled: function disabled() {
      var template = getTemplate(element, elementTemplates);

      return template && isDefaultTemplate(template);
    }
  }));
};

////// helpers //////////////////////////////////////

function applyTemplate(element, newTemplateId, elementTemplates) {

  // cleanup
  // clear input output mappings
  // undo changes to properties defined in template

  // re-establish
  // set input output mappings
  // apply changes to properties as defined in new template

  var oldTemplate = getTemplate(element, elementTemplates),
      newTemplate = elementTemplates.get(newTemplateId);

  if (oldTemplate === newTemplate) {
    return;
  }

  return {
    cmd: 'propertiesPanel.camunda.changeTemplate',
    context: {
      element: element,
      oldTemplate: oldTemplate,
      newTemplate: newTemplate
    }
  };
}

function getTemplateOptions(element, elementTemplates) {

  var currentTemplateId = getTemplateId(element);

  var emptyOption = {
    name: '',
    value: ''
  };

  var allOptions = elementTemplates.getAll().reduce(function (templates, t) {
    if (!isAny(element, t.appliesTo)) {
      return templates;
    }

    return templates.concat({
      name: t.name,
      value: t.id,
      isDefault: t.isDefault
    });
  }, [emptyOption]);

  var defaultOption = find(allOptions, function (option) {
    return isDefaultTemplate(option);
  });

  var currentOption = find(allOptions, function (option) {
    return option.value === currentTemplateId;
  });

  if (currentTemplateId && !currentOption) {
    currentOption = unknownTemplate(currentTemplateId);

    allOptions.push(currentOption);
  }

  if (!defaultOption) {

    // return all options, including empty
    // and optionally unknownTemplate option
    return allOptions;
  }

  // special limited handling for
  // default options

  var options = [];

  // current template not set
  if (!currentTemplateId) {
    options.push({
      name: '',
      value: ''
    });
  }

  // current template not default
  if (currentOption && currentOption !== defaultOption) {
    options.push(currentOption);
  }

  options.push(defaultOption);

  // [ (empty), (current), defaultOption ]
  return options;
}

function unknownTemplate(templateId) {
  return {
    name: '[unknown template: ' + templateId + ']',
    value: templateId
  };
}

function isDefaultTemplate(elementTemplate) {
  return elementTemplate.isDefault;
}

},{"../../../../factory/EntryFactory":14,"../Helper":55,"bpmn-js/lib/util/ModelUtil":216,"lodash/collection/find":421}],61:[function(require,module,exports){
'use strict';

var assign = require('lodash/object/assign');

var entryFactory = require('../../../../factory/EntryFactory'),
    getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject,
    getTemplate = require('../Helper').getTemplate,
    cmdHelper = require('../../../../helper/CmdHelper'),
    elementHelper = require('../../../../helper/ElementHelper');

var findExtension = require('../Helper').findExtension,
    findExtensions = require('../Helper').findExtensions,
    findInputParameter = require('../Helper').findInputParameter,
    findOutputParameter = require('../Helper').findOutputParameter,
    findCamundaProperty = require('../Helper').findCamundaProperty,
    findCamundaInOut = require('../Helper').findCamundaInOut;

var createCamundaProperty = require('../CreateHelper').createCamundaProperty,
    createInputParameter = require('../CreateHelper').createInputParameter,
    createOutputParameter = require('../CreateHelper').createOutputParameter,
    createCamundaIn = require('../CreateHelper').createCamundaIn,
    createCamundaOut = require('../CreateHelper').createCamundaOut,
    createCamundaInWithBusinessKey = require('../CreateHelper').createCamundaInWithBusinessKey,
    createCamundaFieldInjection = require('../CreateHelper').createCamundaFieldInjection;

var CAMUNDA_PROPERTY_TYPE = 'camunda:property',
    CAMUNDA_INPUT_PARAMETER_TYPE = 'camunda:inputParameter',
    CAMUNDA_OUTPUT_PARAMETER_TYPE = 'camunda:outputParameter',
    CAMUNDA_IN_TYPE = 'camunda:in',
    CAMUNDA_OUT_TYPE = 'camunda:out',
    CAMUNDA_IN_BUSINESS_KEY_TYPE = 'camunda:in:businessKey',
    CAMUNDA_EXECUTION_LISTENER_TYPE = 'camunda:executionListener',
    CAMUNDA_FIELD = 'camunda:field';

var BASIC_MODDLE_TYPES = ['Boolean', 'Integer', 'String'];

var EXTENSION_BINDING_TYPES = [CAMUNDA_PROPERTY_TYPE, CAMUNDA_INPUT_PARAMETER_TYPE, CAMUNDA_OUTPUT_PARAMETER_TYPE, CAMUNDA_IN_TYPE, CAMUNDA_OUT_TYPE, CAMUNDA_IN_BUSINESS_KEY_TYPE, CAMUNDA_FIELD];

var IO_BINDING_TYPES = [CAMUNDA_INPUT_PARAMETER_TYPE, CAMUNDA_OUTPUT_PARAMETER_TYPE];

var IN_OUT_BINDING_TYPES = [CAMUNDA_IN_TYPE, CAMUNDA_OUT_TYPE, CAMUNDA_IN_BUSINESS_KEY_TYPE];

/**
 * Injects custom properties into the given group.
 *
 * @param {GroupDescriptor} group
 * @param {djs.model.Base} element
 * @param {ElementTemplates} elementTemplates
 * @param {BpmnFactory} bpmnFactory
 */
module.exports = function (element, elementTemplates, bpmnFactory, translate) {

  var template = getTemplate(element, elementTemplates);

  if (!template) {
    return [];
  }

  var renderCustomField = function renderCustomField(id, p, idx) {
    var propertyType = p.type;

    var entryOptions = {
      id: id,
      description: p.description,
      label: p.label,
      modelProperty: id,
      get: propertyGetter(id, p),
      set: propertySetter(id, p, bpmnFactory),
      validate: propertyValidator(id, p)
    };

    var entry;

    if (propertyType === 'Boolean') {
      entry = entryFactory.checkbox(entryOptions);
    }

    if (propertyType === 'String') {
      entry = entryFactory.textField(entryOptions);
    }

    if (propertyType === 'Text') {
      entry = entryFactory.textBox(entryOptions);
    }

    if (propertyType === 'Dropdown') {
      entryOptions.selectOptions = p.choices;

      entry = entryFactory.selectBox(entryOptions);
    }

    return entry;
  };

  var groups = [];
  var id, entry;

  var customFieldsGroup = {
    id: 'customField',
    label: translate('Custom Fields'),
    entries: []
  };
  template.properties.forEach(function (p, idx) {

    id = 'custom-' + template.id + '-' + idx;

    entry = renderCustomField(id, p, idx);
    if (entry) {
      customFieldsGroup.entries.push(entry);
    }
  });
  if (customFieldsGroup.entries.length > 0) {
    groups.push(customFieldsGroup);
  }

  if (template.scopes) {
    for (var scopeName in template.scopes) {

      var scope = template.scopes[scopeName];
      var idScopeName = scopeName.replace(/:/g, '_');

      var customScopeFieldsGroup = {
        id: 'customField-' + idScopeName,
        label: translate('Custom Fields for scope: ') + scopeName,
        entries: []
      };

      scope.properties.forEach(function (p, idx) {

        var propertyId = 'custom-' + template.id + '-' + idScopeName + '-' + idx;

        var scopedProperty = propertyWithScope(p, scopeName);

        entry = renderCustomField(propertyId, scopedProperty, idx);
        if (entry) {
          customScopeFieldsGroup.entries.push(entry);
        }
      });

      if (customScopeFieldsGroup.entries.length > 0) {
        groups.push(customScopeFieldsGroup);
      }
    }
  }

  return groups;
};

/////// getters, setters and validators ///////////////


/**
 * Return a getter that retrieves the given property.
 *
 * @param {String} name
 * @param {PropertyDescriptor} property
 *
 * @return {Function}
 */
function propertyGetter(name, property) {

  /* getter */
  return function get(element) {
    var value = getPropertyValue(element, property);

    return objectWithKey(name, value);
  };
}

/**
 * Return a setter that updates the given property.
 *
 * @param {String} name
 * @param {PropertyDescriptor} property
 * @param {BpmnFactory} bpmnFactory
 *
 * @return {Function}
 */
function propertySetter(name, property, bpmnFactory) {

  /* setter */
  return function set(element, values) {

    var value = values[name];

    return setPropertyValue(element, property, value, bpmnFactory);
  };
}

/**
 * Return a validator that ensures the property is ok.
 *
 * @param {String} name
 * @param {PropertyDescriptor} property
 *
 * @return {Function}
 */
function propertyValidator(name, property) {

  /* validator */
  return function validate(element, values) {
    var value = values[name];

    var error = validateValue(value, property);

    if (error) {
      return objectWithKey(name, error);
    }
  };
}

//////// get, set and validate helpers ///////////////////

/**
 * Return the value of the specified property descriptor,
 * on the passed diagram element.
 *
 * @param {djs.model.Base} element
 * @param {PropertyDescriptor} property
 *
 * @return {Any}
 */
function getPropertyValue(element, property) {

  var bo = getBusinessObject(element);

  var binding = property.binding,
      scope = property.scope;

  var bindingType = binding.type,
      bindingName = binding.name;

  var propertyValue = property.value || '';

  if (scope) {
    bo = findExtension(bo, scope.name);
    if (!bo) {
      return propertyValue;
    }
  }

  // property
  if (bindingType === 'property') {

    var value = bo.get(bindingName);

    if (bindingName === 'conditionExpression') {
      if (value) {
        return value.body;
      } else {
        // return defined default
        return propertyValue;
      }
    } else {
      // return value; default to defined default
      return typeof value !== 'undefined' ? value : propertyValue;
    }
  }

  var camundaProperties, camundaProperty;

  if (bindingType === CAMUNDA_PROPERTY_TYPE) {
    if (scope) {
      camundaProperties = bo.get('properties');
    } else {
      camundaProperties = findExtension(bo, 'camunda:Properties');
    }

    if (camundaProperties) {
      camundaProperty = findCamundaProperty(camundaProperties, binding);

      if (camundaProperty) {
        return camundaProperty.value;
      }
    }

    return propertyValue;
  }

  var inputOutput, ioParameter;

  if (IO_BINDING_TYPES.indexOf(bindingType) !== -1) {

    if (scope) {
      inputOutput = bo.get('inputOutput');
    } else {
      inputOutput = findExtension(bo, 'camunda:InputOutput');
    }

    if (!inputOutput) {
      // ioParameter cannot exist yet, return property value
      return propertyValue;
    }
  }

  // camunda input parameter
  if (bindingType === CAMUNDA_INPUT_PARAMETER_TYPE) {
    ioParameter = findInputParameter(inputOutput, binding);

    if (ioParameter) {
      if (binding.scriptFormat) {
        if (ioParameter.definition) {
          return ioParameter.definition.value;
        }
      } else {
        return ioParameter.value || '';
      }
    }

    return propertyValue;
  }

  // camunda output parameter
  if (binding.type === CAMUNDA_OUTPUT_PARAMETER_TYPE) {
    ioParameter = findOutputParameter(inputOutput, binding);

    if (ioParameter) {
      return ioParameter.name;
    }

    return propertyValue;
  }

  var ioElement;

  if (IN_OUT_BINDING_TYPES.indexOf(bindingType) != -1) {
    ioElement = findCamundaInOut(bo, binding);

    if (ioElement) {
      if (bindingType === CAMUNDA_IN_BUSINESS_KEY_TYPE) {
        return ioElement.businessKey;
      } else if (bindingType === CAMUNDA_OUT_TYPE) {
        return ioElement.target;
      } else if (bindingType === CAMUNDA_IN_TYPE) {
        return ioElement[binding.expression ? 'sourceExpression' : 'source'];
      }
    }

    return propertyValue;
  }

  if (bindingType === CAMUNDA_EXECUTION_LISTENER_TYPE) {
    var executionListener;
    if (scope) {
      executionListener = bo.get('executionListener');
    } else {
      executionListener = findExtension(bo, 'camunda:ExecutionListener');
    }

    return executionListener.script.value;
  }

  var fieldInjection;
  if (CAMUNDA_FIELD === bindingType) {
    var fieldInjections = findExtensions(bo, ['camunda:Field']);
    fieldInjections.forEach(function (item) {
      if (item.name === binding.name) {
        fieldInjection = item;
      }
    });
    if (fieldInjection) {
      return fieldInjection.string || fieldInjection.expression;
    } else {
      return '';
    }
  }

  throw unknownPropertyBinding(property);
}

module.exports.getPropertyValue = getPropertyValue;

/**
 * Return an update operation that changes the diagram
 * element's custom property to the given value.
 *
 * The response of this method will be processed via
 * {@link PropertiesPanel#applyChanges}.
 *
 * @param {djs.model.Base} element
 * @param {PropertyDescriptor} property
 * @param {String} value
 * @param {BpmnFactory} bpmnFactory
 *
 * @return {Object|Array<Object>} results to be processed
 */
function setPropertyValue(element, property, value, bpmnFactory) {
  var bo = getBusinessObject(element);

  var binding = property.binding,
      scope = property.scope;

  var bindingType = binding.type,
      bindingName = binding.name;

  var propertyValue;

  var updates = [];

  var extensionElements;

  if (EXTENSION_BINDING_TYPES.indexOf(bindingType) !== -1) {
    extensionElements = bo.get('extensionElements');

    // create extension elements, if they do not exist (yet)
    if (!extensionElements) {
      extensionElements = elementHelper.createElement('bpmn:ExtensionElements', null, element, bpmnFactory);

      updates.push(cmdHelper.updateBusinessObject(element, bo, objectWithKey('extensionElements', extensionElements)));
    }
  }

  if (scope) {
    bo = findExtension(bo, scope.name);
    if (!bo) {
      bo = elementHelper.createElement(scope.name, null, element, bpmnFactory);

      updates.push(cmdHelper.addElementsTolist(bo, extensionElements, 'values', [bo]));
    }
  }

  // property
  if (bindingType === 'property') {

    if (bindingName === 'conditionExpression') {

      propertyValue = elementHelper.createElement('bpmn:FormalExpression', {
        body: value,
        language: binding.scriptFormat
      }, bo, bpmnFactory);
    } else {

      var moddlePropertyDescriptor = bo.$descriptor.propertiesByName[bindingName];

      var moddleType = moddlePropertyDescriptor.type;

      // make sure we only update String, Integer, Real and
      // Boolean properties (do not accidentally override complex objects...)
      if (BASIC_MODDLE_TYPES.indexOf(moddleType) === -1) {
        throw new Error('cannot set moddle type <' + moddleType + '>');
      }

      if (moddleType === 'Boolean') {
        propertyValue = !!value;
      } else if (moddleType === 'Integer') {
        propertyValue = parseInt(value, 10);

        if (isNaN(propertyValue)) {
          // do not write NaN value
          propertyValue = undefined;
        }
      } else {
        propertyValue = value;
      }
    }

    if (propertyValue !== undefined) {
      updates.push(cmdHelper.updateBusinessObject(element, bo, objectWithKey(bindingName, propertyValue)));
    }
  }

  // camunda:property
  var camundaProperties, existingCamundaProperty, newCamundaProperty;

  if (bindingType === CAMUNDA_PROPERTY_TYPE) {

    if (scope) {
      camundaProperties = bo.get('properties');
    } else {
      camundaProperties = findExtension(extensionElements, 'camunda:Properties');
    }

    if (!camundaProperties) {
      camundaProperties = elementHelper.createElement('camunda:Properties', null, bo, bpmnFactory);

      if (scope) {
        updates.push(cmdHelper.updateBusinessObject(element, bo, { properties: camundaProperties }));
      } else {
        updates.push(cmdHelper.addElementsTolist(element, extensionElements, 'values', [camundaProperties]));
      }
    }

    existingCamundaProperty = findCamundaProperty(camundaProperties, binding);

    newCamundaProperty = createCamundaProperty(binding, value, bpmnFactory);

    updates.push(cmdHelper.addAndRemoveElementsFromList(element, camundaProperties, 'values', null, [newCamundaProperty], existingCamundaProperty ? [existingCamundaProperty] : []));
  }

  // camunda:inputParameter
  // camunda:outputParameter
  var inputOutput, existingIoParameter, newIoParameter;

  if (IO_BINDING_TYPES.indexOf(bindingType) !== -1) {

    if (scope) {
      inputOutput = bo.get('inputOutput');
    } else {
      inputOutput = findExtension(extensionElements, 'camunda:InputOutput');
    }

    // create inputOutput element, if it do not exist (yet)
    if (!inputOutput) {
      inputOutput = elementHelper.createElement('camunda:InputOutput', null, bo, bpmnFactory);

      if (scope) {
        updates.push(cmdHelper.updateBusinessObject(element, bo, { inputOutput: inputOutput }));
      } else {
        updates.push(cmdHelper.addElementsTolist(element, extensionElements, 'values', inputOutput));
      }
    }
  }

  if (bindingType === CAMUNDA_INPUT_PARAMETER_TYPE) {

    existingIoParameter = findInputParameter(inputOutput, binding);

    newIoParameter = createInputParameter(binding, value, bpmnFactory);

    updates.push(cmdHelper.addAndRemoveElementsFromList(element, inputOutput, 'inputParameters', null, [newIoParameter], existingIoParameter ? [existingIoParameter] : []));
  }

  if (bindingType === CAMUNDA_OUTPUT_PARAMETER_TYPE) {

    existingIoParameter = findOutputParameter(inputOutput, binding);

    newIoParameter = createOutputParameter(binding, value, bpmnFactory);

    updates.push(cmdHelper.addAndRemoveElementsFromList(element, inputOutput, 'outputParameters', null, [newIoParameter], existingIoParameter ? [existingIoParameter] : []));
  }

  // camunda:in
  // camunda:out
  // camunda:in:businessKey
  var existingInOut, newInOut;

  if (IN_OUT_BINDING_TYPES.indexOf(bindingType) !== -1) {

    existingInOut = findCamundaInOut(bo, binding);

    if (bindingType === CAMUNDA_IN_TYPE) {
      newInOut = createCamundaIn(binding, value, bpmnFactory);
    } else if (bindingType === CAMUNDA_OUT_TYPE) {
      newInOut = createCamundaOut(binding, value, bpmnFactory);
    } else {
      newInOut = createCamundaInWithBusinessKey(binding, value, bpmnFactory);
    }

    updates.push(cmdHelper.addAndRemoveElementsFromList(element, extensionElements, 'values', null, [newInOut], existingInOut ? [existingInOut] : []));
  }

  if (bindingType === CAMUNDA_FIELD) {
    var existingFieldInjections = findExtensions(bo, ['camunda:Field']);
    var newFieldInjections = [];

    if (existingFieldInjections.length > 0) {
      existingFieldInjections.forEach(function (item) {
        if (item.name === binding.name) {
          newFieldInjections.push(createCamundaFieldInjection(binding, value, bpmnFactory));
        } else {
          newFieldInjections.push(item);
        }
      });
    } else {
      newFieldInjections.push(createCamundaFieldInjection(binding, value, bpmnFactory));
    }

    updates.push(cmdHelper.addAndRemoveElementsFromList(element, extensionElements, 'values', null, newFieldInjections, existingFieldInjections ? existingFieldInjections : []));
  }

  if (updates.length) {
    return updates;
  }

  // quick warning for better debugging
  console.warn('no update', element, property, value);
}

/**
 * Validate value of a given property.
 *
 * @param {String} value
 * @param {PropertyDescriptor} property
 *
 * @return {Object} with validation errors
 */
function validateValue(value, property) {

  var constraints = property.constraints || {};

  if (constraints.notEmpty && isEmpty(value)) {
    return 'Must not be empty';
  }

  if (constraints.maxLength && value.length > constraints.maxLength) {
    return 'Must have max length ' + constraints.maxLength;
  }

  if (constraints.minLength && value.length < constraints.minLength) {
    return 'Must have min length ' + constraints.minLength;
  }

  var pattern = constraints.pattern,
      message;

  if (pattern) {

    if (typeof pattern !== 'string') {
      message = pattern.message;
      pattern = pattern.value;
    }

    if (!matchesPattern(value, pattern)) {
      return message || 'Must match pattern ' + pattern;
    }
  }
}

//////// misc helpers ///////////////////////////////

function propertyWithScope(property, scopeName) {
  if (!scopeName) {
    return property;
  }

  return assign({}, property, {
    scope: {
      name: scopeName
    }
  });
}

/**
 * Return an object with a single key -> value association.
 *
 * @param {String} key
 * @param {Any} value
 *
 * @return {Object}
 */
function objectWithKey(key, value) {
  var obj = {};

  obj[key] = value;

  return obj;
}

/**
 * Does the given string match the specified pattern?
 *
 * @param {String} str
 * @param {String} pattern
 *
 * @return {Boolean}
 */
function matchesPattern(str, pattern) {
  var regexp = new RegExp(pattern);

  return regexp.test(str);
}

function isEmpty(str) {
  return !str || /^\s*$/.test(str);
}

/**
 * Create a new {@link Error} indicating an unknown
 * property binding.
 *
 * @param {PropertyDescriptor} property
 *
 * @return {Error}
 */
function unknownPropertyBinding(property) {
  var binding = property.binding;

  return new Error('unknown binding: <' + binding.type + '>');
}

},{"../../../../factory/EntryFactory":14,"../../../../helper/CmdHelper":24,"../../../../helper/ElementHelper":25,"../CreateHelper":51,"../Helper":55,"bpmn-js/lib/util/ModelUtil":216,"lodash/object/assign":496}],62:[function(require,module,exports){
'use strict';

module.exports = {
  __depends__: [require('./element-templates'), require('diagram-js/lib/i18n/translate')],
  __init__: ['propertiesProvider'],
  propertiesProvider: ['type', require('./CamundaPropertiesProvider')]
};

},{"./CamundaPropertiesProvider":50,"./element-templates":59,"diagram-js/lib/i18n/translate":376}],63:[function(require,module,exports){
'use strict';

var getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject,
    is = require('bpmn-js/lib/util/ModelUtil').is,
    asyncContinuation = require('./implementation/AsyncContinuation');

module.exports = function (group, element, bpmnFactory, translate) {

  if (is(element, 'camunda:AsyncCapable')) {

    group.entries = group.entries.concat(asyncContinuation(element, bpmnFactory, {
      getBusinessObject: getBusinessObject
    }, translate));
  }
};

},{"./implementation/AsyncContinuation":87,"bpmn-js/lib/util/ModelUtil":216}],64:[function(require,module,exports){
'use strict';

var getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject,
    is = require('bpmn-js/lib/util/ModelUtil').is;

var entryFactory = require('../../../factory/EntryFactory');

var callable = require('./implementation/Callable');

var cmdHelper = require('../../../helper/CmdHelper');

var flattenDeep = require('lodash/array/flattenDeep');
var assign = require('lodash/object/assign');

function getCallableType(element) {
  var bo = getBusinessObject(element);

  var boCalledElement = bo.get('calledElement'),
      boCaseRef = bo.get('camunda:caseRef');

  var callActivityType = '';
  if (typeof boCalledElement !== 'undefined') {
    callActivityType = 'bpmn';
  } else if (typeof boCaseRef !== 'undefined') {
    callActivityType = 'cmmn';
  }

  return callActivityType;
}

var DEFAULT_PROPS = {
  calledElement: undefined,
  'camunda:calledElementBinding': 'latest',
  'camunda:calledElementVersion': undefined,
  'camunda:calledElementTenantId': undefined,
  'camunda:variableMappingClass': undefined,
  'camunda:variableMappingDelegateExpression': undefined,
  'camunda:caseRef': undefined,
  'camunda:caseBinding': 'latest',
  'camunda:caseVersion': undefined,
  'camunda:caseTenantId': undefined
};

module.exports = function (group, element, bpmnFactory, translate) {

  if (!is(element, 'camunda:CallActivity')) {
    return;
  }

  group.entries.push(entryFactory.selectBox({
    id: 'callActivity',
    label: translate('CallActivity Type'),
    selectOptions: [{ name: 'BPMN', value: 'bpmn' }, { name: 'CMMN', value: 'cmmn' }],
    emptyParameter: true,
    modelProperty: 'callActivityType',

    get: function get(element, node) {
      return {
        callActivityType: getCallableType(element)
      };
    },

    set: function set(element, values, node) {
      var type = values.callActivityType;

      var props = assign({}, DEFAULT_PROPS);

      if (type === 'bpmn') {
        props.calledElement = '';
      } else if (type === 'cmmn') {
        props['camunda:caseRef'] = '';
      }

      return cmdHelper.updateProperties(element, props);
    }

  }));

  group.entries.push(callable(element, bpmnFactory, {
    getCallableType: getCallableType
  }, translate));

  group.entries = flattenDeep(group.entries);
};

},{"../../../factory/EntryFactory":14,"../../../helper/CmdHelper":24,"./implementation/Callable":88,"bpmn-js/lib/util/ModelUtil":216,"lodash/array/flattenDeep":417,"lodash/object/assign":496}],65:[function(require,module,exports){
'use strict';

var ImplementationTypeHelper = require('../../../helper/ImplementationTypeHelper'),
    InputOutputHelper = require('../../../helper/InputOutputHelper');

var entryFactory = require('../../../factory/EntryFactory'),
    cmdHelper = require('../../../helper/CmdHelper');

function getImplementationType(element) {
  return ImplementationTypeHelper.getImplementationType(element);
}

function getBusinessObject(element) {
  return ImplementationTypeHelper.getServiceTaskLikeBusinessObject(element);
}

function getConnector(bo) {
  return InputOutputHelper.getConnector(bo);
}

function isConnector(element) {
  return getImplementationType(element) === 'connector';
}

module.exports = function (group, element, bpmnFactory, translate) {

  group.entries.push(entryFactory.textField({
    id: 'connectorId',
    label: translate('Connector Id'),
    modelProperty: 'connectorId',

    get: function get(element, node) {
      var bo = getBusinessObject(element);
      var connector = bo && getConnector(bo);
      var value = connector && connector.get('connectorId');
      return { connectorId: value };
    },

    set: function set(element, values, node) {
      var bo = getBusinessObject(element);
      var connector = getConnector(bo);
      return cmdHelper.updateBusinessObject(element, connector, {
        connectorId: values.connectorId || undefined
      });
    },

    validate: function validate(element, values, node) {
      return isConnector(element) && !values.connectorId ? { connectorId: translate('Must provide a value') } : {};
    },

    hidden: function hidden(element, node) {
      return !isConnector(element);
    }

  }));
};

},{"../../../factory/EntryFactory":14,"../../../helper/CmdHelper":24,"../../../helper/ImplementationTypeHelper":29,"../../../helper/InputOutputHelper":30}],66:[function(require,module,exports){
'use strict';

var assign = require('lodash/object/assign');

var inputOutputParameter = require('./implementation/InputOutputParameter');

module.exports = function (group, element, bpmnFactory, options, translate) {

  options = assign({
    idPrefix: 'connector-',
    insideConnector: true
  }, options);

  group.entries = group.entries.concat(inputOutputParameter(element, bpmnFactory, options, translate));
};

},{"./implementation/InputOutputParameter":97,"lodash/object/assign":496}],67:[function(require,module,exports){
'use strict';

var inputOutput = require('./implementation/InputOutput');

module.exports = function (group, element, bpmnFactory, translate) {

  var inputOutputEntry = inputOutput(element, bpmnFactory, {
    idPrefix: 'connector-',
    insideConnector: true
  }, translate);

  group.entries = group.entries.concat(inputOutputEntry.entries);

  return {
    getSelectedParameter: inputOutputEntry.getSelectedParameter
  };
};

},{"./implementation/InputOutput":96}],68:[function(require,module,exports){
'use strict';

var is = require('bpmn-js/lib/util/ModelUtil').is,
    getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject;

var ImplementationTypeHelper = require('../../../helper/ImplementationTypeHelper');

var externalTaskPriority = require('./implementation/ExternalTaskPriority');

function getServiceTaskLikeBusinessObject(element) {
  var bo = ImplementationTypeHelper.getServiceTaskLikeBusinessObject(element);

  // if the element is not a serviceTaskLike element, fetch the normal business object
  // This avoids the loss of the process / participant business object
  if (!bo) {
    bo = getBusinessObject(element);
  }

  return bo;
}

module.exports = function (group, element, bpmnFactory, translate) {

  var bo = getServiceTaskLikeBusinessObject(element);

  if (!bo) {
    return;
  }

  if (is(bo, 'camunda:TaskPriorized') || is(bo, 'bpmn:Participant') && bo.get('processRef')) {
    group.entries = group.entries.concat(externalTaskPriority(element, bpmnFactory, {
      getBusinessObject: function getBusinessObject(element) {
        if (!is(bo, 'bpmn:Participant')) {
          return bo;
        }
        return bo.get('processRef');
      }
    }, translate));
  }
};

},{"../../../helper/ImplementationTypeHelper":29,"./implementation/ExternalTaskPriority":92,"bpmn-js/lib/util/ModelUtil":216}],69:[function(require,module,exports){
'use strict';

var ImplementationTypeHelper = require('../../../helper/ImplementationTypeHelper');

var fieldInjection = require('./implementation/FieldInjection');

module.exports = function (group, element, bpmnFactory, translate) {

  var bo = ImplementationTypeHelper.getServiceTaskLikeBusinessObject(element);

  if (!bo) {
    return;
  }

  var fieldInjectionEntry = fieldInjection(element, bpmnFactory, translate, { businessObject: bo });

  if (fieldInjectionEntry && fieldInjectionEntry.length > 0) {
    group.entries = group.entries.concat(fieldInjectionEntry);
  }
};

},{"../../../helper/ImplementationTypeHelper":29,"./implementation/FieldInjection":93}],70:[function(require,module,exports){
'use strict';

var getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject,
    getExtensionElements = require('../../../helper/ExtensionElementsHelper').getExtensionElements,
    extensionElements = require('./implementation/ExtensionElements'),
    properties = require('./implementation/Properties'),
    entryFactory = require('../../../factory/EntryFactory'),
    elementHelper = require('../../../helper/ElementHelper'),
    cmdHelper = require('../../../helper/CmdHelper'),
    formHelper = require('../../../helper/FormHelper'),
    utils = require('../../../Utils'),
    is = require('bpmn-js/lib/util/ModelUtil').is,
    find = require('lodash/collection/find'),
    each = require('lodash/collection/forEach');

function generateValueId() {
  return utils.nextId('Value_');
}

/**
 * Generate a form field specific textField using entryFactory.
 *
 * @param  {string} options.id
 * @param  {string} options.label
 * @param  {string} options.modelProperty
 * @param  {function} options.validate
 *
 * @return {Object} an entryFactory.textField object
 */
function formFieldTextField(options, getSelectedFormField) {

  var id = options.id,
      label = options.label,
      modelProperty = options.modelProperty,
      validate = options.validate;

  return entryFactory.textField({
    id: id,
    label: label,
    modelProperty: modelProperty,
    get: function get(element, node) {
      var selectedFormField = getSelectedFormField(element, node) || {},
          values = {};

      values[modelProperty] = selectedFormField[modelProperty];

      return values;
    },

    set: function set(element, values, node) {
      var commands = [];

      if (typeof options.set === 'function') {
        var cmd = options.set(element, values, node);

        if (cmd) {
          commands.push(cmd);
        }
      }

      var formField = getSelectedFormField(element, node),
          properties = {};

      properties[modelProperty] = values[modelProperty] || undefined;

      commands.push(cmdHelper.updateBusinessObject(element, formField, properties));

      return commands;
    },
    hidden: function hidden(element, node) {
      return !getSelectedFormField(element, node);
    },
    validate: validate
  });
}

function ensureFormKeyAndDataSupported(element) {
  return is(element, 'bpmn:StartEvent') && !is(element.parent, 'bpmn:SubProcess') || is(element, 'bpmn:UserTask');
}

module.exports = function (group, element, bpmnFactory, translate) {

  if (!ensureFormKeyAndDataSupported(element)) {
    return;
  }

  /**
   * Return the currently selected form field querying the form field select box
   * from the DOM.
   *
   * @param  {djs.model.Base} element
   * @param  {DOMElement} node - DOM element of any form field text input
   *
   * @return {ModdleElement} the currently selected form field
   */
  function getSelectedFormField(element, node) {
    var selected = formFieldsEntry.getSelected(element, node.parentNode);

    if (selected.idx === -1) {
      return;
    }

    return formHelper.getFormField(element, selected.idx);
  }

  //[FormKey] form key text input field
  group.entries.push(entryFactory.textField({
    id: 'form-key',
    label: translate('Form Key'),
    modelProperty: 'formKey',
    get: function get(element, node) {
      var bo = getBusinessObject(element);

      return {
        formKey: bo.get('camunda:formKey')
      };
    },
    set: function set(element, values, node) {
      var bo = getBusinessObject(element),
          formKey = values.formKey || undefined;

      return cmdHelper.updateBusinessObject(element, bo, { 'camunda:formKey': formKey });
    }
  }));

  // [FormData] form field select box
  var formFieldsEntry = extensionElements(element, bpmnFactory, {
    id: 'form-fields',
    label: translate('Form Fields'),
    modelProperty: 'id',
    prefix: 'FormField',
    createExtensionElement: function createExtensionElement(element, extensionElements, value) {
      var bo = getBusinessObject(element),
          commands = [];

      if (!extensionElements) {
        extensionElements = elementHelper.createElement('bpmn:ExtensionElements', { values: [] }, bo, bpmnFactory);
        commands.push(cmdHelper.updateProperties(element, { extensionElements: extensionElements }));
      }

      var formData = formHelper.getFormData(element);

      if (!formData) {
        formData = elementHelper.createElement('camunda:FormData', { fields: [] }, extensionElements, bpmnFactory);
        commands.push(cmdHelper.addAndRemoveElementsFromList(element, extensionElements, 'values', 'extensionElements', [formData], []));
      }

      var field = elementHelper.createElement('camunda:FormField', { id: value }, formData, bpmnFactory);
      if (typeof formData.fields !== 'undefined') {
        commands.push(cmdHelper.addElementsTolist(element, formData, 'fields', [field]));
      } else {
        commands.push(cmdHelper.updateBusinessObject(element, formData, {
          fields: [field]
        }));
      }
      return commands;
    },
    removeExtensionElement: function removeExtensionElement(element, extensionElements, value, idx) {
      var formData = getExtensionElements(getBusinessObject(element), 'camunda:FormData')[0],
          entry = formData.fields[idx],
          commands = [];

      commands.push(cmdHelper.removeElementsFromList(element, formData, 'fields', null, [entry]));

      if (entry.id === formData.get('businessKey')) {
        commands.push(cmdHelper.updateBusinessObject(element, formData, { 'businessKey': undefined }));
      }

      return commands;
    },
    getExtensionElements: function getExtensionElements(element) {
      return formHelper.getFormFields(element);
    },
    hideExtensionElements: function hideExtensionElements(element, node) {
      return false;
    }
  });
  group.entries.push(formFieldsEntry);

  // [FormData] business key form field select box
  var formBusinessKeyFormFieldEntry = entryFactory.selectBox({
    id: 'form-business-key',
    label: translate('Business Key'),
    modelProperty: 'businessKey',
    selectOptions: function selectOptions(element, inputNode) {
      var selectOptions = [{ name: '', value: '' }];
      var formFields = formHelper.getFormFields(element);
      each(formFields, function (field) {
        if (field.type !== 'boolean') {
          selectOptions.push({ name: field.id, value: field.id });
        }
      });
      return selectOptions;
    },
    get: function get(element, node) {
      var result = { businessKey: '' };
      var bo = getBusinessObject(element);
      var formDataExtension = getExtensionElements(bo, 'camunda:FormData');
      if (formDataExtension) {
        var formData = formDataExtension[0];
        var storedValue = formData.get('businessKey');
        result = { businessKey: storedValue };
      }
      return result;
    },
    set: function set(element, values, node) {
      var formData = getExtensionElements(getBusinessObject(element), 'camunda:FormData')[0];
      return cmdHelper.updateBusinessObject(element, formData, { 'businessKey': values.businessKey || undefined });
    },
    hidden: function hidden(element, node) {
      var isStartEvent = is(element, 'bpmn:StartEvent');
      return !(isStartEvent && formHelper.getFormFields(element).length > 0);
    }
  });
  group.entries.push(formBusinessKeyFormFieldEntry);

  // [FormData] Form Field label
  group.entries.push(entryFactory.label({
    id: 'form-field-header',
    labelText: translate('Form Field'),
    showLabel: function showLabel(element, node) {
      return !!getSelectedFormField(element, node);
    }
  }));

  // [FormData] form field id text input field
  group.entries.push(entryFactory.validationAwareTextField({
    id: 'form-field-id',
    label: translate('ID'),
    modelProperty: 'id',

    getProperty: function getProperty(element, node) {
      var selectedFormField = getSelectedFormField(element, node) || {};

      return selectedFormField.id;
    },

    setProperty: function setProperty(element, properties, node) {
      var formField = getSelectedFormField(element, node);

      return cmdHelper.updateBusinessObject(element, formField, properties);
    },

    hidden: function hidden(element, node) {
      return !getSelectedFormField(element, node);
    },

    validate: function validate(element, values, node) {

      var formField = getSelectedFormField(element, node);

      if (formField) {

        var idValue = values.id;

        if (!idValue || idValue.trim() === '') {
          return { id: 'Form field id must not be empty' };
        }

        var formFields = formHelper.getFormFields(element);

        var existingFormField = find(formFields, function (f) {
          return f !== formField && f.id === idValue;
        });

        if (existingFormField) {
          return { id: 'Form field id already used in form data.' };
        }
      }
    }
  }));

  // [FormData] form field type combo box
  group.entries.push(entryFactory.comboBox({
    id: 'form-field-type',
    label: translate('Type'),
    selectOptions: [{ name: 'string', value: 'string' }, { name: 'long', value: 'long' }, { name: 'boolean', value: 'boolean' }, { name: 'date', value: 'date' }, { name: 'enum', value: 'enum' }],
    modelProperty: 'type',
    emptyParameter: true,

    get: function get(element, node) {
      var selectedFormField = getSelectedFormField(element, node);

      if (selectedFormField) {
        return { type: selectedFormField.type };
      } else {
        return {};
      }
    },
    set: function set(element, values, node) {
      var selectedFormField = getSelectedFormField(element, node),
          formData = getExtensionElements(getBusinessObject(element), 'camunda:FormData')[0],
          commands = [];

      if (selectedFormField.type === 'enum' && values.type !== 'enum') {
        // delete camunda:value objects from formField.values when switching from type enum
        commands.push(cmdHelper.updateBusinessObject(element, selectedFormField, { values: undefined }));
      }
      if (values.type === 'boolean' && selectedFormField.get('id') === formData.get('businessKey')) {
        commands.push(cmdHelper.updateBusinessObject(element, formData, { 'businessKey': undefined }));
      }
      commands.push(cmdHelper.updateBusinessObject(element, selectedFormField, values));

      return commands;
    },
    hidden: function hidden(element, node) {
      return !getSelectedFormField(element, node);
    }
  }));

  // [FormData] form field label text input field
  group.entries.push(formFieldTextField({
    id: 'form-field-label',
    label: translate('Label'),
    modelProperty: 'label'
  }, getSelectedFormField));

  // [FormData] form field defaultValue text input field
  group.entries.push(formFieldTextField({
    id: 'form-field-defaultValue',
    label: translate('Default Value'),
    modelProperty: 'defaultValue'
  }, getSelectedFormField));

  // [FormData] form field enum values label
  group.entries.push(entryFactory.label({
    id: 'form-field-enum-values-header',
    labelText: translate('Values'),
    divider: true,
    showLabel: function showLabel(element, node) {
      var selectedFormField = getSelectedFormField(element, node);

      return selectedFormField && selectedFormField.type === 'enum';
    }
  }));

  // [FormData] form field enum values table
  group.entries.push(entryFactory.table({
    id: 'form-field-enum-values',
    labels: [translate('Id'), translate('Name')],
    modelProperties: ['id', 'name'],
    show: function show(element, node) {
      var selectedFormField = getSelectedFormField(element, node);

      return selectedFormField && selectedFormField.type === 'enum';
    },
    getElements: function getElements(element, node) {
      var selectedFormField = getSelectedFormField(element, node);

      return formHelper.getEnumValues(selectedFormField);
    },
    addElement: function addElement(element, node) {
      var selectedFormField = getSelectedFormField(element, node),
          id = generateValueId();

      var enumValue = elementHelper.createElement('camunda:Value', { id: id, name: undefined }, getBusinessObject(element), bpmnFactory);

      return cmdHelper.addElementsTolist(element, selectedFormField, 'values', [enumValue]);
    },
    removeElement: function removeElement(element, node, idx) {
      var selectedFormField = getSelectedFormField(element, node),
          enumValue = selectedFormField.values[idx];

      return cmdHelper.removeElementsFromList(element, selectedFormField, 'values', null, [enumValue]);
    },
    updateElement: function updateElement(element, value, node, idx) {
      var selectedFormField = getSelectedFormField(element, node),
          enumValue = selectedFormField.values[idx];

      value.name = value.name || undefined;
      return cmdHelper.updateBusinessObject(element, enumValue, value);
    },
    validate: function validate(element, value, node, idx) {

      var selectedFormField = getSelectedFormField(element, node),
          enumValue = selectedFormField.values[idx];

      if (enumValue) {
        // check if id is valid
        var validationError = utils.isIdValid(enumValue, value.id);

        if (validationError) {
          return { id: validationError };
        }
      }
    }
  }));

  // [FormData] Validation label
  group.entries.push(entryFactory.label({
    id: 'form-field-validation-header',
    labelText: translate('Validation'),
    divider: true,
    showLabel: function showLabel(element, node) {
      return !!getSelectedFormField(element, node);
    }
  }));

  // [FormData] form field constraints table
  group.entries.push(entryFactory.table({
    id: 'constraints-list',
    modelProperties: ['name', 'config'],
    labels: [translate('Name'), translate('Config')],
    addLabel: translate('Add Constraint'),
    getElements: function getElements(element, node) {
      var formField = getSelectedFormField(element, node);

      return formHelper.getConstraints(formField);
    },
    addElement: function addElement(element, node) {

      var commands = [],
          formField = getSelectedFormField(element, node),
          validation = formField.validation;

      if (!validation) {
        // create validation business object and add it to form data, if it doesn't exist
        validation = elementHelper.createElement('camunda:Validation', {}, getBusinessObject(element), bpmnFactory);

        commands.push(cmdHelper.updateBusinessObject(element, formField, { 'validation': validation }));
      }

      var newConstraint = elementHelper.createElement('camunda:Constraint', { name: undefined, config: undefined }, validation, bpmnFactory);

      commands.push(cmdHelper.addElementsTolist(element, validation, 'constraints', [newConstraint]));

      return commands;
    },
    updateElement: function updateElement(element, value, node, idx) {
      var formField = getSelectedFormField(element, node),
          constraint = formHelper.getConstraints(formField)[idx];

      value.name = value.name || undefined;
      value.config = value.config || undefined;

      return cmdHelper.updateBusinessObject(element, constraint, value);
    },
    removeElement: function removeElement(element, node, idx) {
      var commands = [],
          formField = getSelectedFormField(element, node),
          constraints = formHelper.getConstraints(formField),
          currentConstraint = constraints[idx];

      commands.push(cmdHelper.removeElementsFromList(element, formField.validation, 'constraints', null, [currentConstraint]));

      if (constraints.length === 1) {
        // remove camunda:validation if the last existing constraint has been removed
        commands.push(cmdHelper.updateBusinessObject(element, formField, { validation: undefined }));
      }

      return commands;
    },
    show: function show(element, node) {
      return !!getSelectedFormField(element, node);
    }
  }));

  // [FormData] Properties label
  group.entries.push(entryFactory.label({
    id: 'form-field-properties-header',
    labelText: translate('Properties'),
    divider: true,
    showLabel: function showLabel(element, node) {
      return !!getSelectedFormField(element, node);
    }
  }));

  // [FormData] camunda:properties table
  group.entries.push(properties(element, bpmnFactory, {
    id: 'form-field-properties',
    modelProperties: ['id', 'value'],
    labels: [translate('Id'), translate('Value')],
    getParent: function getParent(element, node) {
      return getSelectedFormField(element, node);
    },
    show: function show(element, node) {
      return !!getSelectedFormField(element, node);
    }
  }, translate));
};

},{"../../../Utils":5,"../../../factory/EntryFactory":14,"../../../helper/CmdHelper":24,"../../../helper/ElementHelper":25,"../../../helper/ExtensionElementsHelper":27,"../../../helper/FormHelper":28,"./implementation/ExtensionElements":90,"./implementation/Properties":102,"bpmn-js/lib/util/ModelUtil":216,"lodash/collection/find":421,"lodash/collection/forEach":422}],71:[function(require,module,exports){
'use strict';

var is = require('bpmn-js/lib/util/ModelUtil').is,
    _getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject;

var historyTimeToLive = require('./implementation/HistoryTimeToLive');

module.exports = function (group, element, bpmnFactory, translate) {
  var businessObject = _getBusinessObject(element);

  if (is(element, 'camunda:Process') || is(element, 'bpmn:Participant') && businessObject.get('processRef')) {

    group.entries = group.entries.concat(historyTimeToLive(element, bpmnFactory, {
      getBusinessObject: function getBusinessObject(element) {
        var bo = _getBusinessObject(element);

        if (!is(bo, 'bpmn:Participant')) {
          return bo;
        }

        return bo.get('processRef');
      }
    }, translate));
  }
};

},{"./implementation/HistoryTimeToLive":94,"bpmn-js/lib/util/ModelUtil":216}],72:[function(require,module,exports){
'use strict';

var inputOutputParameter = require('./implementation/InputOutputParameter');

var assign = require('lodash/object/assign');

module.exports = function (group, element, bpmnFactory, options, translate) {

  group.entries = group.entries.concat(inputOutputParameter(element, bpmnFactory, assign({}, options), translate));
};

},{"./implementation/InputOutputParameter":97,"lodash/object/assign":496}],73:[function(require,module,exports){
'use strict';

var inputOutput = require('./implementation/InputOutput');

module.exports = function (group, element, bpmnFactory, translate) {

  var inputOutputEntry = inputOutput(element, bpmnFactory, {}, translate);

  group.entries = group.entries.concat(inputOutputEntry.entries);

  return {
    getSelectedParameter: inputOutputEntry.getSelectedParameter
  };
};

},{"./implementation/InputOutput":96}],74:[function(require,module,exports){
'use strict';

var is = require('bpmn-js/lib/util/ModelUtil').is,
    _getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject;

var jobPriority = require('./implementation/JobPriority'),
    jobRetryTimeCycle = require('./implementation/JobRetryTimeCycle');

module.exports = function (group, element, bpmnFactory, translate) {
  var businessObject = _getBusinessObject(element);

  if (is(element, 'camunda:JobPriorized') || is(element, 'bpmn:Participant') && businessObject.get('processRef')) {

    group.entries = group.entries.concat(jobPriority(element, bpmnFactory, {
      getBusinessObject: function getBusinessObject(element) {
        var bo = _getBusinessObject(element);

        if (!is(bo, 'bpmn:Participant')) {
          return bo;
        }

        return bo.get('processRef');
      }
    }, translate));
  }

  if (is(element, 'camunda:AsyncCapable')) {
    group.entries = group.entries.concat(jobRetryTimeCycle(element, bpmnFactory, {
      getBusinessObject: _getBusinessObject
    }, translate));
  }
};

},{"./implementation/JobPriority":98,"./implementation/JobRetryTimeCycle":99,"bpmn-js/lib/util/ModelUtil":216}],75:[function(require,module,exports){
'use strict';

var entryFactory = require('../../../factory/EntryFactory');

var cmdHelper = require('../../../helper/CmdHelper'),
    ImplementationTypeHelper = require('../../../helper/ImplementationTypeHelper'),
    script = require('./implementation/Script')('scriptFormat', 'value', true);

var LISTENER_TYPE_LABEL = {
  class: 'Java Class',
  expression: 'Expression',
  delegateExpression: 'Delegate Expression',
  script: 'Script'
};

module.exports = function (group, element, bpmnFactory, options, translate) {

  options = options || {};

  var getSelectedListener = options.getSelectedListener;

  var classProp = 'class',
      expressionProp = 'expression',
      delegateExpressionProp = 'delegateExpression',
      scriptProp = 'script';

  var executionListenerEventTypeOptions = ImplementationTypeHelper.isSequenceFlow(element) ? [{ name: 'take', value: 'take' }] : [{ name: 'start', value: 'start' }, { name: 'end', value: 'end' }];

  var taskListenerEventTypeOptions = [{ name: 'create', value: 'create' }, { name: 'assignment', value: 'assignment' }, { name: 'complete', value: 'complete' }, { name: 'delete', value: 'delete' }];

  var isSelected = function isSelected(element, node) {
    return getSelectedListener(element, node);
  };

  group.entries.push(entryFactory.selectBox({
    id: 'listener-event-type',
    label: translate('Event Type'),
    modelProperty: 'eventType',
    emptyParameter: false,

    get: function get(element, node) {

      var listener = getSelectedListener(element, node);

      var eventType = listener && listener.get('event');

      return {
        eventType: eventType
      };
    },

    set: function set(element, values, node) {
      var eventType = values.eventType;

      return cmdHelper.updateBusinessObject(element, getSelectedListener(element, node), { event: eventType });
    },

    selectOptions: function selectOptions(element, node) {
      var eventTypeOptions;

      var selectedListener = getSelectedListener(element, node);
      if (ImplementationTypeHelper.isTaskListener(selectedListener)) {
        eventTypeOptions = taskListenerEventTypeOptions;
      } else if (ImplementationTypeHelper.isExecutionListener(selectedListener)) {
        eventTypeOptions = executionListenerEventTypeOptions;
      }

      return eventTypeOptions;
    },

    hidden: function hidden(element, node) {
      return !isSelected(element, node);
    }

  }));

  group.entries.push(entryFactory.selectBox({
    id: 'listener-type',
    label: translate('Listener Type'),
    selectOptions: [{ value: classProp, name: translate('Java Class') }, { value: expressionProp, name: translate('Expression') }, { value: delegateExpressionProp, name: translate('Delegate Expression') }, { value: scriptProp, name: translate('Script') }],
    modelProperty: 'listenerType',
    emptyParameter: false,

    get: function get(element, node) {
      var listener = getSelectedListener(element, node);
      return {
        listenerType: ImplementationTypeHelper.getImplementationType(listener)
      };
    },

    set: function set(element, values, node) {
      var listener = getSelectedListener(element, node),
          listenerType = values.listenerType || undefined,
          update = {};

      update[classProp] = listenerType === classProp ? '' : undefined;
      update[expressionProp] = listenerType === expressionProp ? '' : undefined;
      update[delegateExpressionProp] = listenerType === delegateExpressionProp ? '' : undefined;
      update[scriptProp] = listenerType === scriptProp ? bpmnFactory.create('camunda:Script') : undefined;

      return cmdHelper.updateBusinessObject(element, listener, update);
    },

    hidden: function hidden(element, node) {
      return !isSelected(element, node);
    }

  }));

  group.entries.push(entryFactory.textField({
    id: 'listener-value',
    dataValueLabel: 'listenerValueLabel',
    modelProperty: 'listenerValue',

    get: function get(element, node) {
      var value = {},
          listener = getSelectedListener(element, node),
          listenerType = ImplementationTypeHelper.getImplementationType(listener);

      value.listenerValueLabel = LISTENER_TYPE_LABEL[listenerType] || '';
      value.listenerValue = listener && listener.get(listenerType) || undefined;

      return value;
    },

    set: function set(element, values, node) {
      var update = {},
          listener = getSelectedListener(element, node),
          listenerType = ImplementationTypeHelper.getImplementationType(listener);

      update[listenerType] = values.listenerValue || '';

      return cmdHelper.updateBusinessObject(element, listener, update);
    },

    hidden: function hidden(element, node) {
      var listener = getSelectedListener(element, node);
      return !listener || listener.script;
    },

    validate: function validate(element, values) {
      var value = values.listenerValue,
          validate = {};

      if (!value) {
        validate.listenerValue = translate('Must provide a value');
      }

      return validate;
    }

  }));

  group.entries.push({
    id: 'listener-script-value',
    html: '<div data-show="isScript">' + script.template + '</div>',

    get: function get(element, node) {
      var listener = getSelectedListener(element, node);
      return listener && listener.script ? script.get(element, listener.script) : {};
    },

    set: function set(element, values, node) {
      var listener = getSelectedListener(element, node);
      var update = script.set(element, values, listener);
      return cmdHelper.updateBusinessObject(element, listener.script, update);
    },

    validate: function validate(element, values, node) {
      var listener = getSelectedListener(element, node);
      return listener && listener.script ? script.validate(element, values) : {};
    },

    isScript: function isScript(element, node) {
      var listener = getSelectedListener(element, node);
      return listener && listener.script;
    },

    script: script

  });
};

},{"../../../factory/EntryFactory":14,"../../../helper/CmdHelper":24,"../../../helper/ImplementationTypeHelper":29,"./implementation/Script":104}],76:[function(require,module,exports){
'use strict';

var assign = require('lodash/object/assign');

var fieldInjection = require('./implementation/FieldInjection');

module.exports = function (group, element, bpmnFactory, options, translate) {

  options = assign({
    idPrefix: 'listener-',
    insideListener: true
  }, options);

  var fieldInjectionEntry = fieldInjection(element, bpmnFactory, translate, options);

  if (fieldInjectionEntry && fieldInjectionEntry.length > 0) {
    group.entries = group.entries.concat(fieldInjectionEntry);
  }
};

},{"./implementation/FieldInjection":93,"lodash/object/assign":496}],77:[function(require,module,exports){
'use strict';

var listener = require('./implementation/Listener');

module.exports = function (group, element, bpmnFactory, translate) {

  var listenerEntry = listener(element, bpmnFactory, {}, translate);

  group.entries = group.entries.concat(listenerEntry.entries);

  return {
    getSelectedListener: listenerEntry.getSelectedListener
  };
};

},{"./implementation/Listener":100}],78:[function(require,module,exports){
'use strict';

var getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject,
    is = require('bpmn-js/lib/util/ModelUtil').is;

var multiInstanceLoopCharacteristics = require('./implementation/MultiInstanceLoopCharacteristics');

var jobRetryTimeCycle = require('./implementation/JobRetryTimeCycle'),
    asyncContinuation = require('./implementation/AsyncContinuation');

function getLoopCharacteristics(element) {
  var bo = getBusinessObject(element);
  return bo.loopCharacteristics;
}

function ensureMultiInstanceSupported(element) {
  var loopCharacteristics = getLoopCharacteristics(element);
  return !!loopCharacteristics && is(loopCharacteristics, 'camunda:Collectable');
}

module.exports = function (group, element, bpmnFactory, translate) {

  if (!ensureMultiInstanceSupported(element)) {
    return;
  }

  // multi instance properties
  group.entries = group.entries.concat(multiInstanceLoopCharacteristics(element, bpmnFactory, translate));

  // async continuation ///////////////////////////////////////////////////////
  group.entries = group.entries.concat(asyncContinuation(element, bpmnFactory, {
    getBusinessObject: getLoopCharacteristics,
    idPrefix: 'multiInstance-',
    labelPrefix: translate('Multi Instance ')
  }, translate));

  // retry time cycle //////////////////////////////////////////////////////////
  group.entries = group.entries.concat(jobRetryTimeCycle(element, bpmnFactory, {
    getBusinessObject: getLoopCharacteristics,
    idPrefix: 'multiInstance-',
    labelPrefix: translate('Multi Instance ')
  }, translate));
};

},{"./implementation/AsyncContinuation":87,"./implementation/JobRetryTimeCycle":99,"./implementation/MultiInstanceLoopCharacteristics":101,"bpmn-js/lib/util/ModelUtil":216}],79:[function(require,module,exports){
'use strict';

var properties = require('./implementation/Properties'),
    elementHelper = require('../../../helper/ElementHelper'),
    cmdHelper = require('../../../helper/CmdHelper');

module.exports = function (group, element, bpmnFactory, translate) {

  var propertiesEntry = properties(element, bpmnFactory, {
    id: 'properties',
    modelProperties: ['name', 'value'],
    labels: [translate('Name'), translate('Value')],

    getParent: function getParent(element, node, bo) {
      return bo.extensionElements;
    },

    createParent: function createParent(element, bo) {
      var parent = elementHelper.createElement('bpmn:ExtensionElements', { values: [] }, bo, bpmnFactory);
      var cmd = cmdHelper.updateBusinessObject(element, bo, { extensionElements: parent });
      return {
        cmd: cmd,
        parent: parent
      };
    }
  }, translate);

  if (propertiesEntry) {
    group.entries.push(propertiesEntry);
  }
};

},{"../../../helper/CmdHelper":24,"../../../helper/ElementHelper":25,"./implementation/Properties":102}],80:[function(require,module,exports){
'use strict';

var getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject,
    is = require('bpmn-js/lib/util/ModelUtil').is,
    entryFactory = require('../../../factory/EntryFactory'),
    cmdHelper = require('../../../helper/CmdHelper'),
    script = require('./implementation/Script')('scriptFormat', 'script', false);

module.exports = function (group, element, bpmnFactory, translate) {
  var bo;

  if (is(element, 'bpmn:ScriptTask')) {
    bo = getBusinessObject(element);
  }

  if (!bo) {
    return;
  }

  group.entries.push({
    id: 'script-implementation',
    label: translate('Script'),
    html: script.template,

    get: function get(element) {
      return script.get(element, bo);
    },

    set: function set(element, values, containerElement) {
      var properties = script.set(element, values, containerElement);

      return cmdHelper.updateProperties(element, properties);
    },

    validate: function validate(element, values) {
      return script.validate(element, values);
    },

    script: script,

    cssClasses: ['bpp-textfield']

  });

  group.entries.push(entryFactory.textField({
    id: 'scriptResultVariable',
    label: translate('Result Variable'),
    modelProperty: 'scriptResultVariable',

    get: function get(element, propertyName) {
      var boResultVariable = bo.get('camunda:resultVariable');

      return { scriptResultVariable: boResultVariable };
    },

    set: function set(element, values, containerElement) {
      return cmdHelper.updateProperties(element, {
        'camunda:resultVariable': values.scriptResultVariable.length ? values.scriptResultVariable : undefined
      });
    }

  }));
};

},{"../../../factory/EntryFactory":14,"../../../helper/CmdHelper":24,"./implementation/Script":104,"bpmn-js/lib/util/ModelUtil":216}],81:[function(require,module,exports){
'use strict';

var is = require('bpmn-js/lib/util/ModelUtil').is,
    isAny = require('bpmn-js/lib/features/modeling/util/ModelingUtil').isAny,
    getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject,
    domQuery = require('min-dom/lib/query'),
    cmdHelper = require('../../../helper/CmdHelper'),
    elementHelper = require('../../../helper/ElementHelper'),
    script = require('./implementation/Script')('language', 'body', true);

module.exports = function (group, element, bpmnFactory, translate) {
  var bo;

  if (is(element, 'bpmn:SequenceFlow')) {
    bo = getBusinessObject(element);
  }

  if (!bo) {
    return;
  }

  if (!isConditionalSource(element.source)) {
    return;
  }

  group.entries.push({
    id: 'condition',
    label: translate('Condition'),
    html: '<div class="bpp-row">' + '<label for="cam-condition-type">' + translate('Condition Type') + '</label>' + '<div class="bpp-field-wrapper">' + '<select id="cam-condition-type" name="conditionType" data-value>' + '<option value="expression">' + translate('Expression') + '</option>' + '<option value="script">' + translate('Script') + '</option>' + '<option value="" selected></option>' + '</select>' + '</div>' + '</div>' +

    // expression
    '<div class="bpp-row">' + '<label for="cam-condition" data-show="isExpression">' + translate('Expression') + '</label>' + '<div class="bpp-field-wrapper" data-show="isExpression">' + '<input id="cam-condition" type="text" name="condition" />' + '<button class="clear" data-action="clear" data-show="canClear">' + '<span>X</span>' + '</button>' + '</div>' + '<div data-show="isScript">' + script.template + '</div>' + '</div>',

    get: function get(element, propertyName) {

      // read values from xml:
      var conditionExpression = bo.conditionExpression;

      var values = {},
          conditionType = '';

      if (conditionExpression) {
        var conditionLanguage = conditionExpression.language;
        if (typeof conditionLanguage !== 'undefined') {
          conditionType = 'script';
          values = script.get(element, conditionExpression);
        } else {
          conditionType = 'expression';
          values.condition = conditionExpression.get('body');
        }
      }

      values.conditionType = conditionType;

      return values;
    },

    set: function set(element, values, containerElement) {
      var conditionType = values.conditionType;
      var commands = [];

      var conditionProps = {
        body: undefined
      };

      if (conditionType === 'script') {
        conditionProps = script.set(element, values, containerElement);
      } else {
        var condition = values.condition;
        conditionProps.body = condition;
      }

      var update = {
        'conditionExpression': undefined
      };

      if (conditionType) {
        update.conditionExpression = elementHelper.createElement('bpmn:FormalExpression', conditionProps, bo, bpmnFactory);

        var source = element.source;

        // if default-flow, remove default-property from source
        if (source.businessObject.default === bo) {
          commands.push(cmdHelper.updateProperties(source, { 'default': undefined }));
        }
      }

      commands.push(cmdHelper.updateBusinessObject(element, bo, update));

      return commands;
    },

    validate: function validate(element, values) {
      var validationResult = {};

      if (!values.condition && values.conditionType === 'expression') {
        validationResult.condition = 'Must provide a value';
      } else if (values.conditionType === 'script') {
        validationResult = script.validate(element, values);
      }

      return validationResult;
    },

    isExpression: function isExpression(element, inputNode) {
      var conditionType = domQuery('select[name=conditionType]', inputNode);
      if (conditionType.selectedIndex >= 0) {
        return conditionType.options[conditionType.selectedIndex].value === 'expression';
      }
    },

    isScript: function isScript(element, inputNode) {
      var conditionType = domQuery('select[name=conditionType]', inputNode);
      if (conditionType.selectedIndex >= 0) {
        return conditionType.options[conditionType.selectedIndex].value === 'script';
      }
    },

    clear: function clear(element, inputNode) {
      // clear text input
      domQuery('input[name=condition]', inputNode).value = '';

      return true;
    },

    canClear: function canClear(element, inputNode) {
      var input = domQuery('input[name=condition]', inputNode);

      return input.value !== '';
    },

    script: script,

    cssClasses: ['bpp-textfield']
  });
};

////// utilities //////////////////////////

var CONDITIONAL_SOURCES = ['bpmn:Activity', 'bpmn:ExclusiveGateway', 'bpmn:InclusiveGateway', 'bpmn:ComplexGateway'];

function isConditionalSource(element) {
  return isAny(element, CONDITIONAL_SOURCES);
}

},{"../../../helper/CmdHelper":24,"../../../helper/ElementHelper":25,"./implementation/Script":104,"bpmn-js/lib/features/modeling/util/ModelingUtil":189,"bpmn-js/lib/util/ModelUtil":216,"min-dom/lib/query":112}],82:[function(require,module,exports){
'use strict';

var ImplementationTypeHelper = require('../../../helper/ImplementationTypeHelper'),
    InputOutputHelper = require('../../../helper/InputOutputHelper');

var implementationType = require('./implementation/ImplementationType'),
    delegate = require('./implementation/Delegate'),
    external = require('./implementation/External'),
    callable = require('./implementation/Callable'),
    resultVariable = require('./implementation/ResultVariable');

var entryFactory = require('../../../factory/EntryFactory');

var domQuery = require('min-dom/lib/query'),
    domClosest = require('min-dom/lib/closest'),
    domClasses = require('min-dom/lib/classes');

function getImplementationType(element) {
  return ImplementationTypeHelper.getImplementationType(element);
}

function getBusinessObject(element) {
  return ImplementationTypeHelper.getServiceTaskLikeBusinessObject(element);
}

function isDmnCapable(element) {
  return ImplementationTypeHelper.isDmnCapable(element);
}

function isExternalCapable(element) {
  return ImplementationTypeHelper.isExternalCapable(element);
}

function isServiceTaskLike(element) {
  return ImplementationTypeHelper.isServiceTaskLike(element);
}

module.exports = function (group, element, bpmnFactory, translate) {

  if (!isServiceTaskLike(getBusinessObject(element))) {
    return;
  }

  var hasDmnSupport = isDmnCapable(element);
  var hasExternalSupport = isExternalCapable(getBusinessObject(element));

  // implementation type ////////////////////////////////////

  group.entries = group.entries.concat(implementationType(element, bpmnFactory, {
    getBusinessObject: getBusinessObject,
    getImplementationType: getImplementationType,
    hasDmnSupport: hasDmnSupport,
    hasExternalSupport: hasExternalSupport,
    hasServiceTaskLikeSupport: true
  }, translate));

  // delegate (class, expression, delegateExpression) //////////

  group.entries = group.entries.concat(delegate(element, bpmnFactory, {
    getBusinessObject: getBusinessObject,
    getImplementationType: getImplementationType
  }, translate));

  // result variable /////////////////////////////////////////

  group.entries = group.entries.concat(resultVariable(element, bpmnFactory, {
    getBusinessObject: getBusinessObject,
    getImplementationType: getImplementationType,
    hideResultVariable: function hideResultVariable(element, node) {
      return getImplementationType(element) !== 'expression';
    }
  }, translate));

  // external //////////////////////////////////////////////////

  if (hasExternalSupport) {
    group.entries = group.entries.concat(external(element, bpmnFactory, {
      getBusinessObject: getBusinessObject,
      getImplementationType: getImplementationType
    }, translate));
  }

  // dmn ////////////////////////////////////////////////////////

  if (hasDmnSupport) {
    group.entries = group.entries.concat(callable(element, bpmnFactory, {
      getCallableType: getImplementationType
    }, translate));
  }

  // connector ////////////////////////////////////////////////

  var isConnector = function isConnector(element) {
    return getImplementationType(element) === 'connector';
  };

  group.entries.push(entryFactory.link({
    id: 'configureConnectorLink',
    label: translate('Configure Connector'),
    getClickableElement: function getClickableElement(element, node) {
      var panel = domClosest(node, 'div.bpp-properties-panel');
      return domQuery('a[data-tab-target="connector"]', panel);
    },
    hideLink: function hideLink(element, node) {
      var link = domQuery('a', node);
      link.innerHTML = link.textContent = '';
      domClasses(link).remove('bpp-error-message');

      if (isConnector(element)) {
        var connectorId = InputOutputHelper.getConnector(element).get('connectorId');
        if (connectorId) {
          link.textContent = translate('Configure Connector');
        } else {
          link.innerHTML = '<span class="bpp-icon-warning"></span> Must configure Connector';
          domClasses(link).add('bpp-error-message');
        }

        return false;
      }
      return true;
    }
  }));
};

},{"../../../factory/EntryFactory":14,"../../../helper/ImplementationTypeHelper":29,"../../../helper/InputOutputHelper":30,"./implementation/Callable":88,"./implementation/Delegate":89,"./implementation/External":91,"./implementation/ImplementationType":95,"./implementation/ResultVariable":103,"min-dom/lib/classes":106,"min-dom/lib/closest":108,"min-dom/lib/query":112}],83:[function(require,module,exports){
'use strict';

var entryFactory = require('../../../factory/EntryFactory'),
    is = require('bpmn-js/lib/util/ModelUtil').is,
    getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject;

module.exports = function (group, element, translate) {

  var bo = getBusinessObject(element);

  if (!bo) {
    return;
  }

  if (is(element, 'camunda:Initiator') && !is(element.parent, 'bpmn:SubProcess')) {
    group.entries.push(entryFactory.textField({
      id: 'initiator',
      label: translate('Initiator'),
      modelProperty: 'initiator'
    }));
  }
};

},{"../../../factory/EntryFactory":14,"bpmn-js/lib/util/ModelUtil":216}],84:[function(require,module,exports){
'use strict';

var is = require('bpmn-js/lib/util/ModelUtil').is,
    entryFactory = require('../../../factory/EntryFactory');

module.exports = function (group, element, translate) {
  if (is(element, 'camunda:Assignable')) {

    // Assignee
    group.entries.push(entryFactory.textField({
      id: 'assignee',
      label: translate('Assignee'),
      modelProperty: 'assignee'
    }));

    // Candidate Users
    group.entries.push(entryFactory.textField({
      id: 'candidateUsers',
      label: translate('Candidate Users'),
      modelProperty: 'candidateUsers'
    }));

    // Candidate Groups
    group.entries.push(entryFactory.textField({
      id: 'candidateGroups',
      label: translate('Candidate Groups'),
      modelProperty: 'candidateGroups'
    }));

    // Due Date
    group.entries.push(entryFactory.textField({
      id: 'dueDate',
      description: translate('The due date as an EL expression (e.g. ${someDate} or an ISO date (e.g. 2015-06-26T09:54:00)'),
      label: translate('Due Date'),
      modelProperty: 'dueDate'
    }));

    // FollowUp Date
    group.entries.push(entryFactory.textField({
      id: 'followUpDate',
      description: translate('The follow up date as an EL expression (e.g. ${someDate} or an ' + 'ISO date (e.g. 2015-06-26T09:54:00)'),
      label: translate('Follow Up Date'),
      modelProperty: 'followUpDate'
    }));

    // priority
    group.entries.push(entryFactory.textField({
      id: 'priority',
      label: translate('Priority'),
      modelProperty: 'priority'
    }));
  }
};

},{"../../../factory/EntryFactory":14,"bpmn-js/lib/util/ModelUtil":216}],85:[function(require,module,exports){
'use strict';

var is = require('bpmn-js/lib/util/ModelUtil').is,
    getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject;

var filter = require('lodash/collection/filter');

var extensionElementsHelper = require('../../../helper/ExtensionElementsHelper'),
    cmdHelper = require('../../../helper/CmdHelper'),
    elementHelper = require('../../../helper/ElementHelper');

var extensionElementsEntry = require('./implementation/ExtensionElements');

var entryFactory = require('../../../factory/EntryFactory');

var inOutTypeOptions = [{
  name: 'Source',
  value: 'source'
}, {
  name: 'Source Expression',
  value: 'sourceExpression'
}, {
  name: 'All',
  value: 'variables'
}];

/**
  * return depend on parameter 'type' camunda:in or camunda:out extension elements
  */
function getCamundaInOutMappings(element, type) {
  var bo = getBusinessObject(element);
  return extensionElementsHelper.getExtensionElements(bo, type) || [];
}

/**
  * return depend on parameter 'type' camunda:in or camunda:out extension elements
  * with source or sourceExpression attribute
  */
function getVariableMappings(element, type) {
  var camundaMappings = getCamundaInOutMappings(element, type);
  return filter(camundaMappings, function (mapping) {
    return !mapping.businessKey;
  });
}

function getInOutType(mapping) {
  var inOutType = 'source';

  if (mapping.variables === 'all') {
    inOutType = 'variables';
  } else if (typeof mapping.source !== 'undefined') {
    inOutType = 'source';
  } else if (typeof mapping.sourceExpression !== 'undefined') {
    inOutType = 'sourceExpression';
  }

  return inOutType;
}

var CAMUNDA_IN_EXTENSION_ELEMENT = 'camunda:In',
    CAMUNDA_OUT_EXTENSION_ELEMENT = 'camunda:Out';

module.exports = function (group, element, bpmnFactory, translate) {

  if (!is(element, 'camunda:CallActivity')) {
    return;
  }

  var isSelected = function isSelected(element, node) {
    return !!getSelected(element, node);
  };

  var getSelected = function getSelected(element, node) {
    var parentNode = node.parentNode;
    var selection = inEntry.getSelected(element, parentNode);

    var parameter = getVariableMappings(element, CAMUNDA_IN_EXTENSION_ELEMENT)[selection.idx];
    if (!parameter && outEntry) {
      selection = outEntry.getSelected(element, parentNode);
      parameter = getVariableMappings(element, CAMUNDA_OUT_EXTENSION_ELEMENT)[selection.idx];
    }
    return parameter;
  };

  var setOptionLabelValue = function setOptionLabelValue(type) {
    return function (element, node, option, property, value, idx) {
      var label = idx + ' : ';

      var variableMappings = getVariableMappings(element, type);
      var mappingValue = variableMappings[idx];
      var mappingType = getInOutType(mappingValue);

      if (mappingType === 'variables') {
        label = label + 'all';
      } else if (mappingType === 'source') {
        label = label + (mappingValue.source || '<empty>');
      } else if (mappingType === 'sourceExpression') {
        label = label + (mappingValue.sourceExpression || '<empty>');
      } else {
        label = label + '<empty>';
      }

      option.text = label;
    };
  };

  var newElement = function newElement(type) {
    return function (element, extensionElements, value) {
      var newElem = elementHelper.createElement(type, { source: '' }, extensionElements, bpmnFactory);
      return cmdHelper.addElementsTolist(element, extensionElements, 'values', [newElem]);
    };
  };

  var removeElement = function removeElement(type) {
    return function (element, extensionElements, value, idx) {
      var variablesMappings = getVariableMappings(element, type);
      var mapping = variablesMappings[idx];
      if (mapping) {
        return extensionElementsHelper.removeEntry(getBusinessObject(element), element, mapping);
      }
    };
  };

  // in mapping for source and sourceExpression ///////////////////////////////////////////////////////////////

  var inEntry = extensionElementsEntry(element, bpmnFactory, {
    id: 'variableMapping-in',
    label: translate('In Mapping'),
    modelProperty: 'source',
    prefix: 'In',
    idGeneration: false,
    resizable: true,

    createExtensionElement: newElement(CAMUNDA_IN_EXTENSION_ELEMENT),
    removeExtensionElement: removeElement(CAMUNDA_IN_EXTENSION_ELEMENT),

    getExtensionElements: function getExtensionElements(element) {
      return getVariableMappings(element, CAMUNDA_IN_EXTENSION_ELEMENT);
    },

    onSelectionChange: function onSelectionChange(element, node, event, scope) {
      outEntry && outEntry.deselect(element, node.parentNode);
    },

    setOptionLabelValue: setOptionLabelValue(CAMUNDA_IN_EXTENSION_ELEMENT)
  });
  group.entries.push(inEntry);

  // out mapping for source and sourceExpression ///////////////////////////////////////////////////////

  var outEntry = extensionElementsEntry(element, bpmnFactory, {
    id: 'variableMapping-out',
    label: translate('Out Mapping'),
    modelProperty: 'source',
    prefix: 'Out',
    idGeneration: false,
    resizable: true,

    createExtensionElement: newElement(CAMUNDA_OUT_EXTENSION_ELEMENT),
    removeExtensionElement: removeElement(CAMUNDA_OUT_EXTENSION_ELEMENT),

    getExtensionElements: function getExtensionElements(element) {
      return getVariableMappings(element, CAMUNDA_OUT_EXTENSION_ELEMENT);
    },

    onSelectionChange: function onSelectionChange(element, node, event, scope) {
      inEntry.deselect(element, node.parentNode);
    },

    setOptionLabelValue: setOptionLabelValue(CAMUNDA_OUT_EXTENSION_ELEMENT)
  });
  group.entries.push(outEntry);

  // label for selected mapping ///////////////////////////////////////////////////////

  group.entries.push(entryFactory.label({
    id: 'variableMapping-typeLabel',
    get: function get(element, node) {
      var mapping = getSelected(element, node);

      var value = '';
      if (is(mapping, CAMUNDA_IN_EXTENSION_ELEMENT)) {
        value = translate('In Mapping');
      } else if (is(mapping, CAMUNDA_OUT_EXTENSION_ELEMENT)) {
        value = translate('Out Mapping');
      }

      return {
        label: value
      };
    },

    showLabel: function showLabel(element, node) {
      return isSelected(element, node);
    }
  }));

  group.entries.push(entryFactory.selectBox({
    id: 'variableMapping-inOutType',
    label: translate('Type'),
    selectOptions: inOutTypeOptions,
    modelProperty: 'inOutType',
    get: function get(element, node) {
      var mapping = getSelected(element, node) || {};
      return {
        inOutType: getInOutType(mapping)
      };
    },
    set: function set(element, values, node) {
      var inOutType = values.inOutType;

      var props = {
        'source': undefined,
        'sourceExpression': undefined,
        'variables': undefined
      };

      if (inOutType === 'source') {
        props.source = '';
      } else if (inOutType === 'sourceExpression') {
        props.sourceExpression = '';
      } else if (inOutType === 'variables') {
        props.variables = 'all';
      }

      var mapping = getSelected(element, node);
      return cmdHelper.updateBusinessObject(element, mapping, props);
    },
    hidden: function hidden(element, node) {
      return !isSelected(element, node);
    }

  }));

  group.entries.push(entryFactory.textField({
    id: 'variableMapping-source',
    dataValueLabel: 'sourceLabel',
    modelProperty: 'source',
    get: function get(element, node) {
      var mapping = getSelected(element, node) || {};

      var label = '';
      var inOutType = getInOutType(mapping);
      if (inOutType === 'source') {
        label = 'Source';
      } else if (inOutType === 'sourceExpression') {
        label = 'Source Expression';
      }

      return {
        source: mapping[inOutType],
        sourceLabel: label
      };
    },
    set: function set(element, values, node) {
      values.source = values.source || undefined;

      var mapping = getSelected(element, node);
      var inOutType = getInOutType(mapping);

      var props = {};
      props[inOutType] = values.source || '';

      return cmdHelper.updateBusinessObject(element, mapping, props);
    },
    // one of both (source or sourceExpression) must have a value to make
    // the configuration easier and more understandable
    // it is not engine conform
    validate: function validate(element, values, node) {
      var mapping = getSelected(element, node);

      var validation = {};
      if (mapping) {
        if (!values.source) {
          validation.source = 'Mapping must have a ' + values.sourceLabel.toLowerCase() || 'value';
        }
      }

      return validation;
    },
    hidden: function hidden(element, node) {
      var selectedMapping = getSelected(element, node);
      return !selectedMapping || selectedMapping && selectedMapping.variables;
    }
  }));

  group.entries.push(entryFactory.textField({
    id: 'variableMapping-target',
    label: translate('Target'),
    modelProperty: 'target',
    get: function get(element, node) {
      return {
        target: (getSelected(element, node) || {}).target
      };
    },
    set: function set(element, values, node) {
      values.target = values.target || undefined;
      var mapping = getSelected(element, node);
      return cmdHelper.updateBusinessObject(element, mapping, values);
    },
    validate: function validate(element, values, node) {
      var mapping = getSelected(element, node);

      var validation = {};
      if (mapping) {
        var mappingType = getInOutType(mapping);
        if (!values.target && mappingType !== 'variables') {
          validation.target = 'Mapping must have a target';
        }
      }

      return validation;
    },
    hidden: function hidden(element, node) {
      var selectedMapping = getSelected(element, node);
      return !selectedMapping || selectedMapping && selectedMapping.variables;
    }
  }));

  group.entries.push(entryFactory.checkbox({
    id: 'variableMapping-local',
    label: translate('Local'),
    modelProperty: 'local',
    get: function get(element, node) {
      return {
        local: (getSelected(element, node) || {}).local
      };
    },
    set: function set(element, values, node) {
      values.local = values.local || false;
      var mapping = getSelected(element, node);
      return cmdHelper.updateBusinessObject(element, mapping, values);
    },
    hidden: function hidden(element, node) {
      return !isSelected(element, node);
    }
  }));
};

},{"../../../factory/EntryFactory":14,"../../../helper/CmdHelper":24,"../../../helper/ElementHelper":25,"../../../helper/ExtensionElementsHelper":27,"./implementation/ExtensionElements":90,"bpmn-js/lib/util/ModelUtil":216,"lodash/collection/filter":420}],86:[function(require,module,exports){
'use strict';

var entryFactory = require('../../../factory/EntryFactory'),
    cmdHelper = require('../../../helper/CmdHelper'),
    is = require('bpmn-js/lib/util/ModelUtil').is,
    getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject;

module.exports = function (group, element, translate) {

  var bo = getBusinessObject(element);

  if (!bo) {
    return;
  }

  if (is(element, 'bpmn:Process') || is(element, 'bpmn:Participant') && bo.get('processRef')) {
    var versionTagEntry = entryFactory.textField({
      id: 'versionTag',
      label: translate('Version Tag'),
      modelProperty: 'versionTag'
    });

    // in participants we have to change the default behavior of set and get
    if (is(element, 'bpmn:Participant')) {
      versionTagEntry.get = function (element) {
        var processBo = bo.get('processRef');

        return {
          versionTag: processBo.get('camunda:versionTag')
        };
      };

      versionTagEntry.set = function (element, values) {
        var processBo = bo.get('processRef');

        return cmdHelper.updateBusinessObject(element, processBo, {
          'camunda:versionTag': values.versionTag || undefined
        });
      };
    }

    group.entries.push(versionTagEntry);
  }
};

},{"../../../factory/EntryFactory":14,"../../../helper/CmdHelper":24,"bpmn-js/lib/util/ModelUtil":216}],87:[function(require,module,exports){
'use strict';

var assign = require('lodash/object/assign');

var entryFactory = require('../../../../factory/EntryFactory');

var asyncCapableHelper = require('../../../../helper/AsyncCapableHelper'),
    eventDefinitionHelper = require('../../../../helper/EventDefinitionHelper'),
    cmdHelper = require('../../../../helper/CmdHelper');

function isAsyncBefore(bo) {
  return asyncCapableHelper.isAsyncBefore(bo);
}

function isAsyncAfter(bo) {
  return asyncCapableHelper.isAsyncAfter(bo);
}

function isExclusive(bo) {
  return asyncCapableHelper.isExclusive(bo);
}

function removeFailedJobRetryTimeCycle(bo, element) {
  return asyncCapableHelper.removeFailedJobRetryTimeCycle(bo, element);
}

function canRemoveFailedJobRetryTimeCycle(element) {
  return !eventDefinitionHelper.getTimerEventDefinition(element);
}

module.exports = function (element, bpmnFactory, options, translate) {

  var getBusinessObject = options.getBusinessObject;

  var idPrefix = options.idPrefix || '',
      labelPrefix = options.labelPrefix || '';

  var asyncBeforeEntry = entryFactory.checkbox({
    id: idPrefix + 'asyncBefore',
    label: labelPrefix + translate('Asynchronous Before'),
    modelProperty: 'asyncBefore',

    get: function get(element, node) {
      var bo = getBusinessObject(element);
      return {
        asyncBefore: isAsyncBefore(bo)
      };
    },

    set: function set(element, values) {
      var bo = getBusinessObject(element);
      var asyncBefore = !!values.asyncBefore;

      var props = {
        'camunda:asyncBefore': asyncBefore,
        'camunda:async': false
      };

      var commands = [];
      if (!isAsyncAfter(bo) && !asyncBefore) {
        props = assign({ 'camunda:exclusive': true }, props);
        if (canRemoveFailedJobRetryTimeCycle(element)) {
          commands.push(removeFailedJobRetryTimeCycle(bo, element));
        }
      }

      commands.push(cmdHelper.updateBusinessObject(element, bo, props));
      return commands;
    }
  });

  var asyncAfterEntry = entryFactory.checkbox({
    id: idPrefix + 'asyncAfter',
    label: labelPrefix + translate('Asynchronous After'),
    modelProperty: 'asyncAfter',

    get: function get(element, node) {
      var bo = getBusinessObject(element);
      return {
        asyncAfter: isAsyncAfter(bo)
      };
    },

    set: function set(element, values) {
      var bo = getBusinessObject(element);
      var asyncAfter = !!values.asyncAfter;

      var props = {
        'camunda:asyncAfter': asyncAfter
      };

      var commands = [];
      if (!isAsyncBefore(bo) && !asyncAfter) {
        props = assign({ 'camunda:exclusive': true }, props);
        if (canRemoveFailedJobRetryTimeCycle(element)) {
          commands.push(removeFailedJobRetryTimeCycle(bo, element));
        }
      }

      commands.push(cmdHelper.updateBusinessObject(element, bo, props));
      return commands;
    }
  });

  var exclusiveEntry = entryFactory.checkbox({
    id: idPrefix + 'exclusive',
    label: labelPrefix + translate('Exclusive'),
    modelProperty: 'exclusive',

    get: function get(element, node) {
      var bo = getBusinessObject(element);
      return { exclusive: isExclusive(bo) };
    },

    set: function set(element, values) {
      var bo = getBusinessObject(element);
      return cmdHelper.updateBusinessObject(element, bo, { 'camunda:exclusive': !!values.exclusive });
    },

    hidden: function hidden(element) {
      var bo = getBusinessObject(element);
      return bo && !isAsyncAfter(bo) && !isAsyncBefore(bo);
    }
  });

  return [asyncBeforeEntry, asyncAfterEntry, exclusiveEntry];
};

},{"../../../../factory/EntryFactory":14,"../../../../helper/AsyncCapableHelper":23,"../../../../helper/CmdHelper":24,"../../../../helper/EventDefinitionHelper":26,"lodash/object/assign":496}],88:[function(require,module,exports){
'use strict';

var cmdHelper = require('../../../../helper/CmdHelper'),
    entryFactory = require('../../../../factory/EntryFactory'),
    elementHelper = require('../../../../helper/ElementHelper'),
    extensionElementsHelper = require('../../../../helper/ExtensionElementsHelper');

var resultVariable = require('./ResultVariable');

var getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject;
var is = require('bpmn-js/lib/util/ModelUtil').is;

var forEach = require('lodash/collection/forEach');

var attributeInfo = {
  bpmn: {
    element: 'calledElement',
    binding: 'camunda:calledElementBinding',
    version: 'camunda:calledElementVersion',
    tenantId: 'camunda:calledElementTenantId'
  },

  cmmn: {
    element: 'camunda:caseRef',
    binding: 'camunda:caseBinding',
    version: 'camunda:caseVersion',
    tenantId: 'camunda:caseTenantId'
  },

  dmn: {
    element: 'camunda:decisionRef',
    binding: 'camunda:decisionRefBinding',
    version: 'camunda:decisionRefVersion',
    tenantId: 'camunda:decisionRefTenantId'
  }
};

var bindingOptions = [{
  name: 'latest',
  value: 'latest'
}, {
  name: 'deployment',
  value: 'deployment'
}, {
  name: 'version',
  value: 'version'
}];

var mapDecisionResultOptions = [{
  name: 'singleEntry',
  value: 'singleEntry'
}, {
  name: 'singleResult',
  value: 'singleResult'
}, {
  name: 'collectEntries',
  value: 'collectEntries'
}, {
  name: 'resultList',
  value: 'resultList'
}];

var delegateVariableMappingOptions = [{
  name: 'variableMappingClass',
  value: 'variableMappingClass'
}, {
  name: 'variableMappingDelegateExpression',
  value: 'variableMappingDelegateExpression'
}];

function getCamundaInWithBusinessKey(element) {
  var camundaIn = [],
      bo = getBusinessObject(element);

  var camundaInParams = extensionElementsHelper.getExtensionElements(bo, 'camunda:In');
  if (camundaInParams) {
    forEach(camundaInParams, function (param) {
      if (param.businessKey) {
        camundaIn.push(param);
      }
    });
  }
  return camundaIn;
}

function setBusinessKey(element, bpmnFactory) {
  var bo = getBusinessObject(element);
  var commands = [];

  var extensionElements = bo.extensionElements;
  if (!extensionElements) {
    extensionElements = elementHelper.createElement('bpmn:ExtensionElements', { values: [] }, bo, bpmnFactory);
    commands.push(cmdHelper.updateProperties(element, { extensionElements: extensionElements }));
  }

  var camundaIn = elementHelper.createElement('camunda:In', { 'businessKey': '#{execution.processBusinessKey}' }, extensionElements, bpmnFactory);

  commands.push(cmdHelper.addAndRemoveElementsFromList(element, extensionElements, 'values', 'extensionElements', [camundaIn], []));

  return commands;
}

function deleteBusinessKey(element) {
  var camundaInExtensions = getCamundaInWithBusinessKey(element);
  var commands = [];
  forEach(camundaInExtensions, function (elem) {
    commands.push(extensionElementsHelper.removeEntry(getBusinessObject(element), element, elem));
  });
  return commands;
}

function isSupportedCallableType(type) {
  return ['bpmn', 'cmmn', 'dmn'].indexOf(type) !== -1;
}

module.exports = function (element, bpmnFactory, options, translate) {

  var getCallableType = options.getCallableType;

  var entries = [];

  function getAttribute(element, prop) {
    var type = getCallableType(element);
    return (attributeInfo[type] || {})[prop];
  }

  function getCallActivityBindingValue(element) {
    var type = getCallableType(element);
    var bo = getBusinessObject(element);
    var attr = (attributeInfo[type] || {}).binding;
    return bo.get(attr);
  }

  function getDelegateVariableMappingType(element) {
    var bo = getBusinessObject(element);

    var boVariableMappingClass = bo.get('camunda:variableMappingClass'),
        boVariableMappingDelegateExpression = bo.get('camunda:variableMappingDelegateExpression');

    var delegateVariableMappingType = '';
    if (typeof boVariableMappingClass !== 'undefined') {
      delegateVariableMappingType = 'variableMappingClass';
    } else if (typeof boVariableMappingDelegateExpression !== 'undefined') {
      delegateVariableMappingType = 'variableMappingDelegateExpression';
    }

    return delegateVariableMappingType;
  }

  entries.push(entryFactory.textField({
    id: 'callable-element-ref',
    dataValueLabel: 'callableElementLabel',
    modelProperty: 'callableElementRef',

    get: function get(element, node) {
      var callableElementRef;

      var attr = getAttribute(element, 'element');
      if (attr) {
        var bo = getBusinessObject(element);
        callableElementRef = bo.get(attr);
      }

      var label = '';
      var type = getCallableType(element);
      if (type === 'bpmn') {
        label = translate('Called Element');
      } else if (type === 'cmmn') {
        label = translate('Case Ref');
      } else if (type === 'dmn') {
        label = translate('Decision Ref');
      }

      return {
        callableElementRef: callableElementRef,
        callableElementLabel: label
      };
    },

    set: function set(element, values, node) {
      var newCallableElementRef = values.callableElementRef;
      var attr = getAttribute(element, 'element');

      var props = {};
      props[attr] = newCallableElementRef || '';

      return cmdHelper.updateProperties(element, props);
    },

    validate: function validate(element, values, node) {
      var elementRef = values.callableElementRef;
      var type = getCallableType(element);
      return isSupportedCallableType(type) && !elementRef ? { callableElementRef: 'Value must provide a value.' } : {};
    },

    hidden: function hidden(element, node) {
      return !isSupportedCallableType(getCallableType(element));
    }

  }));

  entries.push(entryFactory.selectBox({
    id: 'callable-binding',
    label: translate('Binding'),
    selectOptions: bindingOptions,
    modelProperty: 'callableBinding',

    get: function get(element, node) {
      var callableBinding;

      var attr = getAttribute(element, 'binding');
      if (attr) {
        var bo = getBusinessObject(element);
        callableBinding = bo.get(attr) || 'latest';
      }

      return {
        callableBinding: callableBinding
      };
    },

    set: function set(element, values, node) {
      var binding = values.callableBinding;
      var attr = getAttribute(element, 'binding'),
          attrVer = getAttribute(element, 'version');

      var props = {};
      props[attr] = binding;
      // set version value always on undefined to delete the existing value
      props[attrVer] = undefined;

      return cmdHelper.updateProperties(element, props);
    },

    hidden: function hidden(element, node) {
      return !isSupportedCallableType(getCallableType(element));
    }

  }));

  entries.push(entryFactory.textField({
    id: 'callable-version',
    label: translate('Version'),
    modelProperty: 'callableVersion',

    get: function get(element, node) {
      var callableVersion;

      var attr = getAttribute(element, 'version');
      if (attr) {
        var bo = getBusinessObject(element);
        callableVersion = bo.get(attr);
      }

      return {
        callableVersion: callableVersion
      };
    },

    set: function set(element, values, node) {
      var version = values.callableVersion;
      var attr = getAttribute(element, 'version');

      var props = {};
      props[attr] = version || undefined;

      return cmdHelper.updateProperties(element, props);
    },

    validate: function validate(element, values, node) {
      var version = values.callableVersion;

      var type = getCallableType(element);
      return isSupportedCallableType(type) && getCallActivityBindingValue(element) === 'version' && !version ? { callableVersion: translate('Value must provide a value.') } : {};
    },

    hidden: function hidden(element, node) {
      var type = getCallableType(element);
      return !isSupportedCallableType(type) || getCallActivityBindingValue(element) !== 'version';
    }

  }));

  entries.push(entryFactory.textField({
    id: 'tenant-id',
    label: translate('Tenant Id'),
    modelProperty: 'tenantId',

    get: function get(element, node) {
      var tenantId;

      var attr = getAttribute(element, 'tenantId');
      if (attr) {
        var bo = getBusinessObject(element);
        tenantId = bo.get(attr);
      }

      return {
        tenantId: tenantId
      };
    },

    set: function set(element, values, node) {
      var tenantId = values.tenantId;
      var attr = getAttribute(element, 'tenantId');

      var props = {};
      props[attr] = tenantId || undefined;

      return cmdHelper.updateProperties(element, props);
    },

    hidden: function hidden(element, node) {
      var type = getCallableType(element);
      return !isSupportedCallableType(type);
    }

  }));

  if (is(getBusinessObject(element), 'bpmn:CallActivity')) {
    entries.push(entryFactory.checkbox({
      id: 'callable-business-key',
      label: translate('Business Key'),
      modelProperty: 'callableBusinessKey',

      get: function get(element, node) {
        var camundaIn = getCamundaInWithBusinessKey(element);
        return {
          callableBusinessKey: !!(camundaIn && camundaIn.length > 0)
        };
      },

      set: function set(element, values, node) {
        if (values.callableBusinessKey) {
          return setBusinessKey(element, bpmnFactory);
        } else {
          return deleteBusinessKey(element);
        }
      }
    }));
  }

  entries = entries.concat(resultVariable(element, bpmnFactory, {
    id: 'dmn-resultVariable',
    getBusinessObject: getBusinessObject,
    getImplementationType: getCallableType,
    hideResultVariable: function hideResultVariable(element, node) {
      return getCallableType(element) !== 'dmn';
    }
  }, translate));

  entries.push(entryFactory.selectBox({
    id: 'dmn-map-decision-result',
    label: translate('Map Decision Result'),
    selectOptions: mapDecisionResultOptions,
    modelProperty: 'mapDecisionResult',

    get: function get(element, node) {
      var bo = getBusinessObject(element);
      return {
        mapDecisionResult: bo.get('camunda:mapDecisionResult') || 'resultList'
      };
    },

    set: function set(element, values, node) {
      return cmdHelper.updateProperties(element, {
        'camunda:mapDecisionResult': values.mapDecisionResult || 'resultList'
      });
    },

    hidden: function hidden(element, node) {
      var bo = getBusinessObject(element);
      var resultVariable = bo.get('camunda:resultVariable');
      return !(getCallableType(element) === 'dmn' && typeof resultVariable !== 'undefined');
    }

  }));

  entries.push(entryFactory.selectBox({
    id: 'delegateVariableMappingType',
    label: translate('Delegate Variable Mapping'),
    selectOptions: delegateVariableMappingOptions,
    emptyParameter: true,
    modelProperty: 'delegateVariableMappingType',

    get: function get(element, node) {
      return {
        delegateVariableMappingType: getDelegateVariableMappingType(element)
      };
    },

    set: function set(element, values, node) {
      var delegateVariableMappingType = values.delegateVariableMappingType;

      var props = {
        'camunda:variableMappingClass': undefined,
        'camunda:variableMappingDelegateExpression': undefined
      };

      if (delegateVariableMappingType === 'variableMappingClass') {
        props['camunda:variableMappingClass'] = '';
      } else if (delegateVariableMappingType === 'variableMappingDelegateExpression') {
        props['camunda:variableMappingDelegateExpression'] = '';
      }

      return cmdHelper.updateProperties(element, props);
    },

    hidden: function hidden(element, node) {
      return getCallableType(element) !== 'bpmn';
    }

  }));

  entries.push(entryFactory.textField({
    id: 'delegateVariableMapping',
    dataValueLabel: 'delegateVariableMappingLabel',
    modelProperty: 'delegateVariableMapping',

    get: function get(element, node) {
      var bo = getBusinessObject(element);

      var label = '';
      var delegateVariableMapping = undefined;
      var type = getDelegateVariableMappingType(element);

      if (type === 'variableMappingClass') {
        label = translate('Class');
        delegateVariableMapping = bo.get('camunda:variableMappingClass');
      } else if (type === 'variableMappingDelegateExpression') {
        label = translate('Delegate Expression');
        delegateVariableMapping = bo.get('camunda:variableMappingDelegateExpression');
      }

      return {
        delegateVariableMapping: delegateVariableMapping,
        delegateVariableMappingLabel: label
      };
    },

    set: function set(element, values, node) {
      var delegateVariableMapping = values.delegateVariableMapping;

      var attr = 'camunda:' + getDelegateVariableMappingType(element);

      var props = {};
      props[attr] = delegateVariableMapping || undefined;

      return cmdHelper.updateProperties(element, props);
    },

    validate: function validate(element, values, node) {
      var delegateVariableMapping = values.delegateVariableMapping;
      return getCallableType(element) === 'bpmn' && !delegateVariableMapping ? { delegateVariableMapping: translate('Must provide a value.') } : {};
    },

    hidden: function hidden(element, node) {
      return !(getCallableType(element) === 'bpmn' && getDelegateVariableMappingType(element) !== '');
    }

  }));

  return entries;
};

},{"../../../../factory/EntryFactory":14,"../../../../helper/CmdHelper":24,"../../../../helper/ElementHelper":25,"../../../../helper/ExtensionElementsHelper":27,"./ResultVariable":103,"bpmn-js/lib/util/ModelUtil":216,"lodash/collection/forEach":422}],89:[function(require,module,exports){
'use strict';

var entryFactory = require('../../../../factory/EntryFactory'),
    cmdHelper = require('../../../../helper/CmdHelper');

var DELEGATE_TYPES = ['class', 'expression', 'delegateExpression'];

var PROPERTIES = {
  class: 'camunda:class',
  expression: 'camunda:expression',
  delegateExpression: 'camunda:delegateExpression'
};

function isDelegate(type) {
  return DELEGATE_TYPES.indexOf(type) !== -1;
}

function getAttribute(type) {
  return PROPERTIES[type];
}

module.exports = function (element, bpmnFactory, options, translate) {

  var getImplementationType = options.getImplementationType,
      getBusinessObject = options.getBusinessObject;

  function getDelegationLabel(type) {
    switch (type) {
      case 'class':
        return translate('Java Class');
      case 'expression':
        return translate('Expression');
      case 'delegateExpression':
        return translate('Delegate Expression');
      default:
        return '';
    }
  }

  var delegateEntry = entryFactory.textField({
    id: 'delegate',
    label: translate('Value'),
    dataValueLabel: 'delegationLabel',
    modelProperty: 'delegate',

    get: function get(element, node) {
      var bo = getBusinessObject(element);
      var type = getImplementationType(element);
      var attr = getAttribute(type);
      var label = getDelegationLabel(type);
      return {
        delegate: bo.get(attr),
        delegationLabel: label
      };
    },

    set: function set(element, values, node) {
      var bo = getBusinessObject(element);
      var type = getImplementationType(element);
      var attr = getAttribute(type);
      var prop = {};
      prop[attr] = values.delegate || '';
      return cmdHelper.updateBusinessObject(element, bo, prop);
    },

    validate: function validate(element, values, node) {
      return isDelegate(getImplementationType(element)) && !values.delegate ? { delegate: 'Must provide a value' } : {};
    },

    hidden: function hidden(element, node) {
      return !isDelegate(getImplementationType(element));
    }

  });

  return [delegateEntry];
};

},{"../../../../factory/EntryFactory":14,"../../../../helper/CmdHelper":24}],90:[function(require,module,exports){
'use strict';

var getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject;

var domQuery = require('min-dom/lib/query'),
    domClosest = require('min-dom/lib/closest'),
    domify = require('min-dom/lib/domify'),
    forEach = require('lodash/collection/forEach');

var elementHelper = require('../../../../helper/ElementHelper'),
    cmdHelper = require('../../../../helper/CmdHelper'),
    utils = require('../../../../Utils');

function getSelectBox(node, id) {
  var currentTab = domClosest(node, 'div.bpp-properties-tab');
  var query = 'select[name=selectedExtensionElement]' + (id ? '[id=cam-extensionElements-' + id + ']' : '');
  return domQuery(query, currentTab);
}

function _getSelected(node, id) {
  var selectBox = getSelectBox(node, id);
  return {
    value: (selectBox || {}).value,
    idx: (selectBox || {}).selectedIndex
  };
}

function generateElementId(prefix) {
  prefix = prefix + '_';
  return utils.nextId(prefix);
}

var CREATE_EXTENSION_ELEMENT_ACTION = 'create-extension-element',
    REMOVE_EXTENSION_ELEMENT_ACTION = 'remove-extension-element';

module.exports = function (element, bpmnFactory, options, translate) {

  var id = options.id,
      prefix = options.prefix || 'elem',
      label = options.label || id,
      idGeneration = options.idGeneration === false ? options.idGeneration : true,
      businessObject = options.businessObject || getBusinessObject(element);

  var modelProperty = options.modelProperty || 'id';

  var getElements = options.getExtensionElements;

  var createElement = options.createExtensionElement,
      canCreate = typeof createElement === 'function';

  var removeElement = options.removeExtensionElement,
      canRemove = typeof removeElement === 'function';

  var onSelectionChange = options.onSelectionChange;

  var _hideElements = options.hideExtensionElements,
      canBeHidden = typeof _hideElements === 'function';

  var setOptionLabelValue = options.setOptionLabelValue;

  var defaultSize = options.size || 5,
      resizable = options.resizable;

  var reference = options.reference || undefined;

  var selectionChanged = function selectionChanged(element, node, event, scope) {
    if (typeof onSelectionChange === 'function') {
      return onSelectionChange(element, node, event, scope);
    }
  };

  var createOption = function createOption(value) {
    return '<option value="' + value + '" data-value data-name="extensionElementValue">' + value + '</option>';
  };

  var initSelectionSize = function initSelectionSize(selectBox, optionsLength) {
    if (resizable) {
      selectBox.size = optionsLength > defaultSize ? optionsLength : defaultSize;
    }
  };

  return {
    id: id,
    html: '<div class="bpp-row bpp-element-list" ' + (canBeHidden ? 'data-show="hideElements"' : '') + '>' + '<label for="cam-extensionElements-' + id + '">' + label + '</label>' + '<div class="bpp-field-wrapper">' + '<select id="cam-extensionElements-' + id + '"' + 'name="selectedExtensionElement" ' + 'size="' + defaultSize + '" ' + 'data-list-entry-container ' + 'data-on-change="selectElement">' + '</select>' + (canCreate ? '<button class="add" ' + 'id="cam-extensionElements-create-' + id + '" ' + 'data-action="createElement">' + '<span>+</span>' + '</button>' : '') + (canRemove ? '<button class="clear" ' + 'id="cam-extensionElements-remove-' + id + '" ' + 'data-action="removeElement" ' + 'data-disable="disableRemove">' + '<span>-</span>' + '</button>' : '') + '</div>' + '</div>',

    get: function get(element, node) {
      var elements = getElements(element, node);

      var result = [];
      forEach(elements, function (elem) {
        result.push({
          extensionElementValue: elem.get(modelProperty)
        });
      });

      var selectBox = getSelectBox(node.parentNode, id);
      initSelectionSize(selectBox, result.length);

      return result;
    },

    set: function set(element, values, node) {
      var action = this.__action;
      delete this.__action;

      businessObject = businessObject || getBusinessObject(element);

      var bo = reference && businessObject.get(reference) ? businessObject.get(reference) : businessObject;

      var extensionElements = bo.get('extensionElements');

      if (action.id === CREATE_EXTENSION_ELEMENT_ACTION) {
        var commands = [];
        if (!extensionElements) {
          extensionElements = elementHelper.createElement('bpmn:ExtensionElements', { values: [] }, bo, bpmnFactory);
          commands.push(cmdHelper.updateBusinessObject(element, bo, { extensionElements: extensionElements }));
        }
        commands.push(createElement(element, extensionElements, action.value, node));
        return commands;
      } else if (action.id === REMOVE_EXTENSION_ELEMENT_ACTION) {
        return removeElement(element, extensionElements, action.value, action.idx, node);
      }
    },

    createListEntryTemplate: function createListEntryTemplate(value, index, selectBox) {
      initSelectionSize(selectBox, selectBox.options.length + 1);
      return createOption(value.extensionElementValue);
    },

    deselect: function deselect(element, node) {
      var selectBox = getSelectBox(node, id);
      selectBox.selectedIndex = -1;
    },

    getSelected: function getSelected(element, node) {
      return _getSelected(node, id);
    },

    setControlValue: function setControlValue(element, node, option, property, value, idx) {
      node.value = value;

      if (!setOptionLabelValue) {
        node.text = value;
      } else {
        setOptionLabelValue(element, node, option, property, value, idx);
      }
    },

    createElement: function createElement(element, node) {
      // create option template
      var generatedId;
      if (idGeneration) {
        generatedId = generateElementId(prefix);
      }

      var selectBox = getSelectBox(node, id);
      var template = domify(createOption(generatedId));

      // add new empty option as last child element
      selectBox.appendChild(template);

      // select last child element
      selectBox.lastChild.selected = 'selected';
      selectionChanged(element, node);

      // update select box size
      initSelectionSize(selectBox, selectBox.options.length);

      this.__action = {
        id: CREATE_EXTENSION_ELEMENT_ACTION,
        value: generatedId
      };

      return true;
    },

    removeElement: function removeElement(element, node) {
      var selection = _getSelected(node, id);

      var selectBox = getSelectBox(node, id);
      selectBox.removeChild(selectBox.options[selection.idx]);

      // update select box size
      initSelectionSize(selectBox, selectBox.options.length);

      this.__action = {
        id: REMOVE_EXTENSION_ELEMENT_ACTION,
        value: selection.value,
        idx: selection.idx
      };

      return true;
    },

    hideElements: function hideElements(element, entryNode, node, scopeNode) {
      return !_hideElements(element, entryNode, node, scopeNode);
    },

    disableRemove: function disableRemove(element, entryNode, node, scopeNode) {
      return (_getSelected(entryNode, id) || {}).idx < 0;
    },

    selectElement: selectionChanged
  };
};

},{"../../../../Utils":5,"../../../../helper/CmdHelper":24,"../../../../helper/ElementHelper":25,"bpmn-js/lib/util/ModelUtil":216,"lodash/collection/forEach":422,"min-dom/lib/closest":108,"min-dom/lib/domify":110,"min-dom/lib/query":112}],91:[function(require,module,exports){
'use strict';

var entryFactory = require('../../../../factory/EntryFactory'),
    cmdHelper = require('../../../../helper/CmdHelper');

module.exports = function (element, bpmnFactory, options, translate) {

  var getImplementationType = options.getImplementationType,
      getBusinessObject = options.getBusinessObject;

  function isExternal(element) {
    return getImplementationType(element) === 'external';
  }

  var topicEntry = entryFactory.textField({
    id: 'externalTopic',
    label: translate('Topic'),
    modelProperty: 'externalTopic',

    get: function get(element, node) {
      var bo = getBusinessObject(element);
      return { externalTopic: bo.get('camunda:topic') };
    },

    set: function set(element, values, node) {
      var bo = getBusinessObject(element);
      return cmdHelper.updateBusinessObject(element, bo, {
        'camunda:topic': values.externalTopic
      });
    },

    validate: function validate(element, values, node) {
      return isExternal(element) && !values.externalTopic ? { externalTopic: 'Must provide a value' } : {};
    },

    hidden: function hidden(element, node) {
      return !isExternal(element);
    }

  });

  return [topicEntry];
};

},{"../../../../factory/EntryFactory":14,"../../../../helper/CmdHelper":24}],92:[function(require,module,exports){
'use strict';

var entryFactory = require('../../../../factory/EntryFactory');

var cmdHelper = require('../../../../helper/CmdHelper');

module.exports = function (element, bpmnFactory, options, translate) {

  var getBusinessObject = options.getBusinessObject;

  var externalTaskPriorityEntry = entryFactory.textField({
    id: 'externalTaskPriority',
    label: translate('Task Priority'),
    modelProperty: 'taskPriority',

    get: function get(element, node) {
      var bo = getBusinessObject(element);
      return {
        taskPriority: bo.get('camunda:taskPriority')
      };
    },

    set: function set(element, values) {
      var bo = getBusinessObject(element);
      return cmdHelper.updateBusinessObject(element, bo, {
        'camunda:taskPriority': values.taskPriority || undefined
      });
    }

  });

  return [externalTaskPriorityEntry];
};

},{"../../../../factory/EntryFactory":14,"../../../../helper/CmdHelper":24}],93:[function(require,module,exports){
'use strict';

var extensionElementsHelper = require('../../../../helper/ExtensionElementsHelper'),
    elementHelper = require('../../../../helper/ElementHelper'),
    cmdHelper = require('../../../../helper/CmdHelper');

var utils = require('../../../../Utils');

var entryFactory = require('../../../../factory/EntryFactory');

var extensionElementsEntry = require('./ExtensionElements');

var ModelUtil = require('bpmn-js/lib/util/ModelUtil'),
    getBusinessObject = ModelUtil.getBusinessObject;

var assign = require('lodash/object/assign');

var DEFAULT_PROPS = {
  'stringValue': undefined,
  'string': undefined,
  'expression': undefined
};

var CAMUNDA_FIELD_EXTENSION_ELEMENT = 'camunda:Field';

module.exports = function (element, bpmnFactory, translate, options) {

  options = options || {};

  var insideListener = !!options.insideListener,
      idPrefix = options.idPrefix || '',
      getSelectedListener = options.getSelectedListener,
      businessObject = options.businessObject || getBusinessObject(element);

  var entries = [];

  var isSelected = function isSelected(element, node) {
    return getSelectedField(element, node);
  };

  function getSelectedField(element, node) {
    var selected = fieldEntry.getSelected(element, node.parentNode);

    if (selected.idx === -1) {
      return;
    }

    var fields = getCamundaFields(element, node);

    return fields[selected.idx];
  }

  function getCamundaFields(element, node) {
    if (!insideListener) {
      return businessObject && extensionElementsHelper.getExtensionElements(businessObject, CAMUNDA_FIELD_EXTENSION_ELEMENT) || [];
    }
    return getCamundaListenerFields(element, node);
  }

  function getCamundaListenerFields(element, node) {
    var selectedListener = getSelectedListener(element, node);
    return selectedListener && selectedListener.fields || [];
  }

  function getFieldType(bo) {
    var fieldType = 'string';

    var expressionValue = bo && bo.expression;
    var stringValue = bo && (bo.string || bo.stringValue);

    if (typeof stringValue !== 'undefined') {
      fieldType = 'string';
    } else if (typeof expressionValue !== 'undefined') {
      fieldType = 'expression';
    }

    return fieldType;
  }

  var setOptionLabelValue = function setOptionLabelValue() {
    return function (element, node, option, property, value, idx) {
      var camundaFields = getCamundaFields(element, node);
      var field = camundaFields[idx];

      value = field.name ? field.name : '<empty>';

      var label = idx + ' : ' + value;

      option.text = label;
    };
  };

  var newElement = function newElement() {
    return function (element, extensionElements, value, node) {

      var props = {
        name: '',
        string: ''
      };

      var newFieldElem;

      if (!insideListener) {

        newFieldElem = elementHelper.createElement(CAMUNDA_FIELD_EXTENSION_ELEMENT, props, extensionElements, bpmnFactory);
        return cmdHelper.addElementsTolist(element, extensionElements, 'values', [newFieldElem]);
      } else {

        var selectedListener = getSelectedListener(element, node);
        newFieldElem = elementHelper.createElement(CAMUNDA_FIELD_EXTENSION_ELEMENT, props, selectedListener, bpmnFactory);
        return cmdHelper.addElementsTolist(element, selectedListener, 'fields', [newFieldElem]);
      }
    };
  };

  var removeElement = function removeElement() {
    return function (element, extensionElements, value, idx, node) {
      var camundaFields = getCamundaFields(element, node);
      var field = camundaFields[idx];
      if (field) {
        if (!insideListener) {
          return extensionElementsHelper.removeEntry(businessObject, element, field);
        }
        var selectedListener = getSelectedListener(element, node);
        return cmdHelper.removeElementsFromList(element, selectedListener, 'fields', null, [field]);
      }
    };
  };

  var fieldEntry = extensionElementsEntry(element, bpmnFactory, {
    id: idPrefix + 'fields',
    label: translate('Fields'),
    modelProperty: 'fieldName',
    idGeneration: 'false',

    businessObject: businessObject,

    createExtensionElement: newElement(),
    removeExtensionElement: removeElement(),

    getExtensionElements: function getExtensionElements(element, node) {
      return getCamundaFields(element, node);
    },

    setOptionLabelValue: setOptionLabelValue()

  });
  entries.push(fieldEntry);

  entries.push(entryFactory.validationAwareTextField({
    id: idPrefix + 'field-name',
    label: translate('Name'),
    modelProperty: 'fieldName',

    getProperty: function getProperty(element, node) {
      return (getSelectedField(element, node) || {}).name;
    },

    setProperty: function setProperty(element, values, node) {
      var selectedField = getSelectedField(element, node);
      return cmdHelper.updateBusinessObject(element, selectedField, { name: values.fieldName });
    },

    validate: function validate(element, values, node) {
      var bo = getSelectedField(element, node);

      var validation = {};
      if (bo) {
        var nameValue = values.fieldName;

        if (nameValue) {
          if (utils.containsSpace(nameValue)) {
            validation.fieldName = translate('Name must not contain spaces');
          }
        } else {
          validation.fieldName = translate('Parameter must have a name');
        }
      }

      return validation;
    },

    hidden: function hidden(element, node) {
      return !isSelected(element, node);
    }

  }));

  var fieldTypeOptions = [{
    name: translate('String'),
    value: 'string'
  }, {
    name: translate('Expression'),
    value: 'expression'
  }];

  entries.push(entryFactory.selectBox({
    id: idPrefix + 'field-type',
    label: translate('Type'),
    selectOptions: fieldTypeOptions,
    modelProperty: 'fieldType',

    get: function get(element, node) {
      var bo = getSelectedField(element, node);

      var fieldType = getFieldType(bo);

      return {
        fieldType: fieldType
      };
    },

    set: function set(element, values, node) {
      var props = assign({}, DEFAULT_PROPS);

      var fieldType = values.fieldType;

      if (fieldType === 'string') {
        props.string = '';
      } else if (fieldType === 'expression') {
        props.expression = '';
      }

      return cmdHelper.updateBusinessObject(element, getSelectedField(element, node), props);
    },

    hidden: function hidden(element, node) {
      return !isSelected(element, node);
    }

  }));

  entries.push(entryFactory.textBox({
    id: idPrefix + 'field-value',
    label: translate('Value'),
    modelProperty: 'fieldValue',

    get: function get(element, node) {
      var bo = getSelectedField(element, node);
      var fieldType = getFieldType(bo);

      var fieldValue;

      if (fieldType === 'string') {
        fieldValue = bo && (bo.string || bo.stringValue);
      } else if (fieldType === 'expression') {
        fieldValue = bo && bo.expression;
      }

      return {
        fieldValue: fieldValue
      };
    },

    set: function set(element, values, node) {
      var bo = getSelectedField(element, node);
      var fieldType = getFieldType(bo);

      var props = assign({}, DEFAULT_PROPS);

      var fieldValue = values.fieldValue || undefined;

      if (fieldType === 'string') {
        props.string = fieldValue;
      } else if (fieldType === 'expression') {
        props.expression = fieldValue;
      }

      return cmdHelper.updateBusinessObject(element, bo, props);
    },

    validate: function validate(element, values, node) {
      var bo = getSelectedField(element, node);

      var validation = {};
      if (bo) {
        if (!values.fieldValue) {
          validation.fieldValue = translate('Must provide a value');
        }
      }

      return validation;
    },

    show: function show(element, node) {
      return isSelected(element, node);
    }

  }));

  return entries;
};

},{"../../../../Utils":5,"../../../../factory/EntryFactory":14,"../../../../helper/CmdHelper":24,"../../../../helper/ElementHelper":25,"../../../../helper/ExtensionElementsHelper":27,"./ExtensionElements":90,"bpmn-js/lib/util/ModelUtil":216,"lodash/object/assign":496}],94:[function(require,module,exports){
'use strict';

var entryFactory = require('../../../../factory/EntryFactory');

var cmdHelper = require('../../../../helper/CmdHelper');

module.exports = function (element, bpmnFactory, options, translate) {

  var getBusinessObject = options.getBusinessObject;

  var historyTimeToLiveEntry = entryFactory.textField({
    id: 'historyTimeToLive',
    label: translate('History Time To Live'),
    modelProperty: 'historyTimeToLive',

    get: function get(element, node) {
      var bo = getBusinessObject(element);
      var historyTimeToLive = bo.get('camunda:historyTimeToLive');

      return {
        historyTimeToLive: historyTimeToLive ? historyTimeToLive : ''
      };
    },

    set: function set(element, values) {
      var bo = getBusinessObject(element);
      return cmdHelper.updateBusinessObject(element, bo, {
        'camunda:historyTimeToLive': values.historyTimeToLive || undefined
      });
    }

  });

  return [historyTimeToLiveEntry];
};

},{"../../../../factory/EntryFactory":14,"../../../../helper/CmdHelper":24}],95:[function(require,module,exports){
'use strict';

var entryFactory = require('../../../../factory/EntryFactory'),
    cmdHelper = require('../../../../helper/CmdHelper'),
    extensionElementsHelper = require('../../../../helper/ExtensionElementsHelper'),
    elementHelper = require('../../../../helper/ElementHelper');

var assign = require('lodash/object/assign');
var map = require('lodash/collection/map');

var DEFAULT_DELEGATE_PROPS = ['class', 'expression', 'delegateExpression'];

var DELEGATE_PROPS = {
  'camunda:class': undefined,
  'camunda:expression': undefined,
  'camunda:delegateExpression': undefined,
  'camunda:resultVariable': undefined
};

var DMN_CAPABLE_PROPS = {
  'camunda:decisionRef': undefined,
  'camunda:decisionRefBinding': 'latest',
  'camunda:decisionRefVersion': undefined,
  'camunda:mapDecisionResult': 'resultList',
  'camunda:decisionRefTenantId': undefined
};

var EXTERNAL_CAPABLE_PROPS = {
  'camunda:type': undefined,
  'camunda:topic': undefined
};

module.exports = function (element, bpmnFactory, options, translate) {

  var DEFAULT_OPTIONS = [{ value: 'class', name: translate('Java Class') }, { value: 'expression', name: translate('Expression') }, { value: 'delegateExpression', name: translate('Delegate Expression') }];

  var DMN_OPTION = [{ value: 'dmn', name: translate('DMN') }];

  var EXTERNAL_OPTION = [{ value: 'external', name: translate('External') }];

  var CONNECTOR_OPTION = [{ value: 'connector', name: translate('Connector') }];

  var SCRIPT_OPTION = [{ value: 'script', name: translate('Script') }];

  var getType = options.getImplementationType,
      getBusinessObject = options.getBusinessObject;

  var hasDmnSupport = options.hasDmnSupport,
      hasExternalSupport = options.hasExternalSupport,
      hasServiceTaskLikeSupport = options.hasServiceTaskLikeSupport,
      hasScriptSupport = options.hasScriptSupport;

  var entries = [];

  var selectOptions = DEFAULT_OPTIONS.concat([]);

  if (hasDmnSupport) {
    selectOptions = selectOptions.concat(DMN_OPTION);
  }

  if (hasExternalSupport) {
    selectOptions = selectOptions.concat(EXTERNAL_OPTION);
  }

  if (hasServiceTaskLikeSupport) {
    selectOptions = selectOptions.concat(CONNECTOR_OPTION);
  }

  if (hasScriptSupport) {
    selectOptions = selectOptions.concat(SCRIPT_OPTION);
  }

  selectOptions.push({ value: '' });

  entries.push(entryFactory.selectBox({
    id: 'implementation',
    label: translate('Implementation'),
    selectOptions: selectOptions,
    modelProperty: 'implType',

    get: function get(element, node) {
      return {
        implType: getType(element) || ''
      };
    },

    set: function set(element, values, node) {
      var bo = getBusinessObject(element);
      var oldType = getType(element);
      var newType = values.implType;

      var props = assign({}, DELEGATE_PROPS);

      if (DEFAULT_DELEGATE_PROPS.indexOf(newType) !== -1) {

        var newValue = '';
        if (DEFAULT_DELEGATE_PROPS.indexOf(oldType) !== -1) {
          newValue = bo.get('camunda:' + oldType);
        }
        props['camunda:' + newType] = newValue;
      }

      if (hasDmnSupport) {
        props = assign(props, DMN_CAPABLE_PROPS);
        if (newType === 'dmn') {
          props['camunda:decisionRef'] = '';
        }
      }

      if (hasExternalSupport) {
        props = assign(props, EXTERNAL_CAPABLE_PROPS);
        if (newType === 'external') {
          props['camunda:type'] = 'external';
          props['camunda:topic'] = '';
        }
      }

      if (hasScriptSupport) {
        props['camunda:script'] = undefined;

        if (newType === 'script') {
          props['camunda:script'] = elementHelper.createElement('camunda:Script', {}, bo, bpmnFactory);
        }
      }

      var commands = [];
      commands.push(cmdHelper.updateBusinessObject(element, bo, props));

      if (hasServiceTaskLikeSupport) {
        var connectors = extensionElementsHelper.getExtensionElements(bo, 'camunda:Connector');
        commands.push(map(connectors, function (connector) {
          return extensionElementsHelper.removeEntry(bo, element, connector);
        }));

        if (newType === 'connector') {
          var extensionElements = bo.get('extensionElements');
          if (!extensionElements) {
            extensionElements = elementHelper.createElement('bpmn:ExtensionElements', { values: [] }, bo, bpmnFactory);
            commands.push(cmdHelper.updateBusinessObject(element, bo, { extensionElements: extensionElements }));
          }
          var connector = elementHelper.createElement('camunda:Connector', {}, extensionElements, bpmnFactory);
          commands.push(cmdHelper.addAndRemoveElementsFromList(element, extensionElements, 'values', 'extensionElements', [connector], []));
        }
      }

      return commands;
    }
  }));

  return entries;
};

},{"../../../../factory/EntryFactory":14,"../../../../helper/CmdHelper":24,"../../../../helper/ElementHelper":25,"../../../../helper/ExtensionElementsHelper":27,"lodash/collection/map":424,"lodash/object/assign":496}],96:[function(require,module,exports){
'use strict';

var getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject;

var elementHelper = require('../../../../helper/ElementHelper'),
    extensionElementsHelper = require('../../../../helper/ExtensionElementsHelper'),
    inputOutputHelper = require('../../../../helper/InputOutputHelper'),
    cmdHelper = require('../../../../helper/CmdHelper');

var extensionElementsEntry = require('./ExtensionElements');

function getInputOutput(element, insideConnector) {
  return inputOutputHelper.getInputOutput(element, insideConnector);
}

function getConnector(element) {
  return inputOutputHelper.getConnector(element);
}

function getInputParameters(element, insideConnector) {
  return inputOutputHelper.getInputParameters(element, insideConnector);
}

function getOutputParameters(element, insideConnector) {
  return inputOutputHelper.getOutputParameters(element, insideConnector);
}

function getInputParameter(element, insideConnector, idx) {
  return inputOutputHelper.getInputParameter(element, insideConnector, idx);
}

function getOutputParameter(element, insideConnector, idx) {
  return inputOutputHelper.getOutputParameter(element, insideConnector, idx);
}

function createElement(type, parent, factory, properties) {
  return elementHelper.createElement(type, properties, parent, factory);
}

function createInputOutput(parent, bpmnFactory, properties) {
  return createElement('camunda:InputOutput', parent, bpmnFactory, properties);
}

function createParameter(type, parent, bpmnFactory, properties) {
  return createElement(type, parent, bpmnFactory, properties);
}

function ensureInputOutputSupported(element, insideConnector) {
  return inputOutputHelper.isInputOutputSupported(element, insideConnector);
}

function ensureOutparameterSupported(element, insideConnector) {
  return inputOutputHelper.areOutputParametersSupported(element, insideConnector);
}

module.exports = function (element, bpmnFactory, options, translate) {

  var TYPE_LABEL = {
    'camunda:Map': translate('Map'),
    'camunda:List': translate('List'),
    'camunda:Script': translate('Script')
  };

  options = options || {};

  var insideConnector = !!options.insideConnector,
      idPrefix = options.idPrefix || '';

  var getSelected = function getSelected(element, node) {
    var selection = inputEntry && inputEntry.getSelected(element, node) || { idx: -1 };

    var parameter = getInputParameter(element, insideConnector, selection.idx);
    if (!parameter && outputEntry) {
      selection = outputEntry.getSelected(element, node);
      parameter = getOutputParameter(element, insideConnector, selection.idx);
    }
    return parameter;
  };

  var result = {
    getSelectedParameter: getSelected
  };

  var entries = result.entries = [];

  if (!ensureInputOutputSupported(element)) {
    return result;
  }

  var newElement = function newElement(type, prop, factory) {

    return function (element, extensionElements, value) {
      var commands = [];

      var inputOutput = getInputOutput(element, insideConnector);
      if (!inputOutput) {
        var parent = !insideConnector ? extensionElements : getConnector(element);
        inputOutput = createInputOutput(parent, bpmnFactory, {
          inputParameters: [],
          outputParameters: []
        });

        if (!insideConnector) {
          commands.push(cmdHelper.addAndRemoveElementsFromList(element, extensionElements, 'values', 'extensionElements', [inputOutput], []));
        } else {
          commands.push(cmdHelper.updateBusinessObject(element, parent, { inputOutput: inputOutput }));
        }
      }

      var newElem = createParameter(type, inputOutput, bpmnFactory, { name: value });
      commands.push(cmdHelper.addElementsTolist(element, inputOutput, prop, [newElem]));

      return commands;
    };
  };

  var removeElement = function removeElement(getter, prop, otherProp) {
    return function (element, extensionElements, value, idx) {
      var inputOutput = getInputOutput(element, insideConnector);
      var parameter = getter(element, insideConnector, idx);

      var commands = [];
      commands.push(cmdHelper.removeElementsFromList(element, inputOutput, prop, null, [parameter]));

      var firstLength = inputOutput.get(prop).length - 1;
      var secondLength = (inputOutput.get(otherProp) || []).length;

      if (!firstLength && !secondLength) {

        if (!insideConnector) {
          commands.push(extensionElementsHelper.removeEntry(getBusinessObject(element), element, inputOutput));
        } else {
          var connector = getConnector(element);
          commands.push(cmdHelper.updateBusinessObject(element, connector, { inputOutput: undefined }));
        }
      }

      return commands;
    };
  };

  var setOptionLabelValue = function setOptionLabelValue(getter) {
    return function (element, node, option, property, value, idx) {
      var parameter = getter(element, insideConnector, idx);

      var suffix = 'Text';

      var definition = parameter.get('definition');
      if (typeof definition !== 'undefined') {
        var type = definition.$type;
        suffix = TYPE_LABEL[type];
      }

      option.text = (value || '') + ' : ' + suffix;
    };
  };

  // input parameters ///////////////////////////////////////////////////////////////

  var inputEntry = extensionElementsEntry(element, bpmnFactory, {
    id: idPrefix + 'inputs',
    label: translate('Input Parameters'),
    modelProperty: 'name',
    prefix: 'Input',
    resizable: true,

    createExtensionElement: newElement('camunda:InputParameter', 'inputParameters'),
    removeExtensionElement: removeElement(getInputParameter, 'inputParameters', 'outputParameters'),

    getExtensionElements: function getExtensionElements(element) {
      return getInputParameters(element, insideConnector);
    },

    onSelectionChange: function onSelectionChange(element, node, event, scope) {
      outputEntry && outputEntry.deselect(element, node);
    },

    setOptionLabelValue: setOptionLabelValue(getInputParameter)

  });
  entries.push(inputEntry);

  // output parameters ///////////////////////////////////////////////////////

  if (ensureOutparameterSupported(element, insideConnector)) {
    var outputEntry = extensionElementsEntry(element, bpmnFactory, {
      id: idPrefix + 'outputs',
      label: translate('Output Parameters'),
      modelProperty: 'name',
      prefix: 'Output',
      resizable: true,

      createExtensionElement: newElement('camunda:OutputParameter', 'outputParameters'),
      removeExtensionElement: removeElement(getOutputParameter, 'outputParameters', 'inputParameters'),

      getExtensionElements: function getExtensionElements(element) {
        return getOutputParameters(element, insideConnector);
      },

      onSelectionChange: function onSelectionChange(element, node, event, scope) {
        inputEntry.deselect(element, node);
      },

      setOptionLabelValue: setOptionLabelValue(getOutputParameter)

    });
    entries.push(outputEntry);
  }

  return result;
};

},{"../../../../helper/CmdHelper":24,"../../../../helper/ElementHelper":25,"../../../../helper/ExtensionElementsHelper":27,"../../../../helper/InputOutputHelper":30,"./ExtensionElements":90,"bpmn-js/lib/util/ModelUtil":216}],97:[function(require,module,exports){
'use strict';

var is = require('bpmn-js/lib/util/ModelUtil').is;

var elementHelper = require('../../../../helper/ElementHelper'),
    inputOutputHelper = require('../../../../helper/InputOutputHelper'),
    cmdHelper = require('../../../../helper/CmdHelper'),
    utils = require('../../../../Utils');

var entryFactory = require('../../../../factory/EntryFactory'),
    script = require('./Script')('scriptFormat', 'value', true);

function createElement(type, parent, factory, properties) {
  return elementHelper.createElement(type, properties, parent, factory);
}

function _isScript(elem) {
  return is(elem, 'camunda:Script');
}

function isList(elem) {
  return is(elem, 'camunda:List');
}

function isMap(elem) {
  return is(elem, 'camunda:Map');
}

function ensureInputOutputSupported(element, insideConnector) {
  return inputOutputHelper.isInputOutputSupported(element, insideConnector);
}

module.exports = function (element, bpmnFactory, options, translate) {

  var typeInfo = {
    'camunda:Map': {
      value: 'map',
      label: translate('Map')
    },
    'camunda:List': {
      value: 'list',
      label: translate('List')
    },
    'camunda:Script': {
      value: 'script',
      label: translate('Script')
    }
  };

  options = options || {};

  var insideConnector = !!options.insideConnector,
      idPrefix = options.idPrefix || '';

  var getSelected = options.getSelectedParameter;

  if (!ensureInputOutputSupported(element, insideConnector)) {
    return [];
  }

  var entries = [];

  var isSelected = function isSelected(element, node) {
    return getSelected(element, node);
  };

  // parameter name ////////////////////////////////////////////////////////

  entries.push(entryFactory.validationAwareTextField({
    id: idPrefix + 'parameterName',
    label: 'Name',
    modelProperty: 'name',

    getProperty: function getProperty(element, node) {
      return (getSelected(element, node) || {}).name;
    },

    setProperty: function setProperty(element, values, node) {
      var param = getSelected(element, node);
      return cmdHelper.updateBusinessObject(element, param, values);
    },

    validate: function validate(element, values, node) {
      var bo = getSelected(element, node);

      var validation = {};
      if (bo) {
        var nameValue = values.name;

        if (nameValue) {
          if (utils.containsSpace(nameValue)) {
            validation.name = 'Name must not contain spaces';
          }
        } else {
          validation.name = 'Parameter must have a name';
        }
      }

      return validation;
    },

    hidden: function hidden(element, node) {
      return !isSelected(element, node);
    }
  }));

  // parameter type //////////////////////////////////////////////////////

  var selectOptions = [{ value: 'text', name: 'Text' }, { value: 'script', name: 'Script' }, { value: 'list', name: 'List' }, { value: 'map', name: 'Map' }];

  entries.push(entryFactory.selectBox({
    id: idPrefix + 'parameterType',
    label: 'Type',
    selectOptions: selectOptions,
    modelProperty: 'parameterType',

    get: function get(element, node) {
      var bo = getSelected(element, node);

      var parameterType = 'text';

      if (typeof bo !== 'undefined') {
        var definition = bo.get('definition');
        if (typeof definition !== 'undefined') {
          var type = definition.$type;
          parameterType = typeInfo[type].value;
        }
      }

      return {
        parameterType: parameterType
      };
    },

    set: function set(element, values, node) {
      var bo = getSelected(element, node);

      var properties = {
        value: undefined,
        definition: undefined
      };

      var createParameterTypeElem = function createParameterTypeElem(type) {
        return createElement(type, bo, bpmnFactory);
      };

      var parameterType = values.parameterType;

      if (parameterType === 'script') {
        properties.definition = createParameterTypeElem('camunda:Script');
      } else if (parameterType === 'list') {
        properties.definition = createParameterTypeElem('camunda:List');
      } else if (parameterType === 'map') {
        properties.definition = createParameterTypeElem('camunda:Map');
      }

      return cmdHelper.updateBusinessObject(element, bo, properties);
    },

    show: function show(element, node) {
      return isSelected(element, node);
    }

  }));

  // parameter value (type = text) ///////////////////////////////////////////////////////

  entries.push(entryFactory.textBox({
    id: idPrefix + 'parameterType-text',
    label: 'Value',
    modelProperty: 'value',
    get: function get(element, node) {
      return {
        value: (getSelected(element, node) || {}).value
      };
    },

    set: function set(element, values, node) {
      var param = getSelected(element, node);
      values.value = values.value || undefined;
      return cmdHelper.updateBusinessObject(element, param, values);
    },

    show: function show(element, node) {
      var bo = getSelected(element, node);
      return bo && !bo.definition;
    }

  }));

  // parameter value (type = script) ///////////////////////////////////////////////////////

  entries.push({
    id: idPrefix + 'parameterType-script',
    html: '<div data-show="isScript">' + script.template + '</div>',
    get: function get(element, node) {
      var bo = getSelected(element, node);
      return bo && _isScript(bo.definition) ? script.get(element, bo.definition) : {};
    },

    set: function set(element, values, node) {
      var bo = getSelected(element, node);
      var update = script.set(element, values);
      return cmdHelper.updateBusinessObject(element, bo.definition, update);
    },

    validate: function validate(element, values, node) {
      var bo = getSelected(element, node);
      return bo && _isScript(bo.definition) ? script.validate(element, bo.definition) : {};
    },

    isScript: function isScript(element, node) {
      var bo = getSelected(element, node);
      return bo && _isScript(bo.definition);
    },

    script: script

  });

  // parameter value (type = list) ///////////////////////////////////////////////////////

  entries.push(entryFactory.table({
    id: idPrefix + 'parameterType-list',
    modelProperties: ['value'],
    labels: ['Value'],

    getElements: function getElements(element, node) {
      var bo = getSelected(element, node);

      if (bo && isList(bo.definition)) {
        return bo.definition.items;
      }

      return [];
    },

    updateElement: function updateElement(element, values, node, idx) {
      var bo = getSelected(element, node);
      var item = bo.definition.items[idx];
      return cmdHelper.updateBusinessObject(element, item, values);
    },

    addElement: function addElement(element, node) {
      var bo = getSelected(element, node);
      var newValue = createElement('camunda:Value', bo.definition, bpmnFactory, { value: undefined });
      return cmdHelper.addElementsTolist(element, bo.definition, 'items', [newValue]);
    },

    removeElement: function removeElement(element, node, idx) {
      var bo = getSelected(element, node);
      return cmdHelper.removeElementsFromList(element, bo.definition, 'items', null, [bo.definition.items[idx]]);
    },

    editable: function editable(element, node, prop, idx) {
      var bo = getSelected(element, node);
      var item = bo.definition.items[idx];
      return !isMap(item) && !isList(item) && !_isScript(item);
    },

    setControlValue: function setControlValue(element, node, input, prop, value, idx) {
      var bo = getSelected(element, node);
      var item = bo.definition.items[idx];

      if (!isMap(item) && !isList(item) && !_isScript(item)) {
        input.value = value;
      } else {
        input.value = typeInfo[item.$type].label;
      }
    },

    show: function show(element, node) {
      var bo = getSelected(element, node);
      return bo && bo.definition && isList(bo.definition);
    }

  }));

  // parameter value (type = map) ///////////////////////////////////////////////////////

  entries.push(entryFactory.table({
    id: idPrefix + 'parameterType-map',
    modelProperties: ['key', 'value'],
    labels: ['Key', 'Value'],
    addLabel: 'Add Entry',

    getElements: function getElements(element, node) {
      var bo = getSelected(element, node);

      if (bo && isMap(bo.definition)) {
        return bo.definition.entries;
      }

      return [];
    },

    updateElement: function updateElement(element, values, node, idx) {
      var bo = getSelected(element, node);
      var entry = bo.definition.entries[idx];

      if (isMap(entry.definition) || isList(entry.definition) || _isScript(entry.definition)) {
        values = {
          key: values.key
        };
      }

      return cmdHelper.updateBusinessObject(element, entry, values);
    },

    addElement: function addElement(element, node) {
      var bo = getSelected(element, node);
      var newEntry = createElement('camunda:Entry', bo.definition, bpmnFactory, { key: undefined, value: undefined });
      return cmdHelper.addElementsTolist(element, bo.definition, 'entries', [newEntry]);
    },

    removeElement: function removeElement(element, node, idx) {
      var bo = getSelected(element, node);
      return cmdHelper.removeElementsFromList(element, bo.definition, 'entries', null, [bo.definition.entries[idx]]);
    },

    editable: function editable(element, node, prop, idx) {
      var bo = getSelected(element, node);
      var entry = bo.definition.entries[idx];
      return prop === 'key' || !isMap(entry.definition) && !isList(entry.definition) && !_isScript(entry.definition);
    },

    setControlValue: function setControlValue(element, node, input, prop, value, idx) {
      var bo = getSelected(element, node);
      var entry = bo.definition.entries[idx];

      if (prop === 'key' || !isMap(entry.definition) && !isList(entry.definition) && !_isScript(entry.definition)) {
        input.value = value;
      } else {
        input.value = typeInfo[entry.definition.$type].label;
      }
    },

    show: function show(element, node) {
      var bo = getSelected(element, node);
      return bo && bo.definition && isMap(bo.definition);
    }

  }));

  return entries;
};

},{"../../../../Utils":5,"../../../../factory/EntryFactory":14,"../../../../helper/CmdHelper":24,"../../../../helper/ElementHelper":25,"../../../../helper/InputOutputHelper":30,"./Script":104,"bpmn-js/lib/util/ModelUtil":216}],98:[function(require,module,exports){
'use strict';

var entryFactory = require('../../../../factory/EntryFactory');

var cmdHelper = require('../../../../helper/CmdHelper');

module.exports = function (element, bpmnFactory, options, translate) {

  var getBusinessObject = options.getBusinessObject;

  var jobPriorityEntry = entryFactory.textField({
    id: 'jobPriority',
    label: translate('Job Priority'),
    modelProperty: 'jobPriority',

    get: function get(element, node) {
      var bo = getBusinessObject(element);
      return {
        jobPriority: bo.get('camunda:jobPriority')
      };
    },

    set: function set(element, values) {
      var bo = getBusinessObject(element);
      return cmdHelper.updateBusinessObject(element, bo, {
        'camunda:jobPriority': values.jobPriority || undefined
      });
    }

  });

  return [jobPriorityEntry];
};

},{"../../../../factory/EntryFactory":14,"../../../../helper/CmdHelper":24}],99:[function(require,module,exports){
'use strict';

var is = require('bpmn-js/lib/util/ModelUtil').is;

var entryFactory = require('../../../../factory/EntryFactory');

var asyncCapableHelper = require('../../../../helper/AsyncCapableHelper');

var elementHelper = require('../../../../helper/ElementHelper'),
    eventDefinitionHelper = require('../../../../helper/EventDefinitionHelper'),
    cmdHelper = require('../../../../helper/CmdHelper');

function isAsyncBefore(bo) {
  return asyncCapableHelper.isAsyncBefore(bo);
}

function isAsyncAfter(bo) {
  return asyncCapableHelper.isAsyncAfter(bo);
}

function getFailedJobRetryTimeCycle(bo) {
  return asyncCapableHelper.getFailedJobRetryTimeCycle(bo);
}

function removeFailedJobRetryTimeCycle(bo, element) {
  return asyncCapableHelper.removeFailedJobRetryTimeCycle(bo, element);
}

function createExtensionElements(parent, bpmnFactory) {
  return elementHelper.createElement('bpmn:ExtensionElements', { values: [] }, parent, bpmnFactory);
}

function createFailedJobRetryTimeCycle(parent, bpmnFactory, cycle) {
  return elementHelper.createElement('camunda:FailedJobRetryTimeCycle', { body: cycle }, parent, bpmnFactory);
}

module.exports = function (element, bpmnFactory, options, translate) {

  var getBusinessObject = options.getBusinessObject;

  var idPrefix = options.idPrefix || '',
      labelPrefix = options.labelPrefix || '';

  var retryTimeCycleEntry = entryFactory.textField({
    id: idPrefix + 'retryTimeCycle',
    label: labelPrefix + translate('Retry Time Cycle'),
    modelProperty: 'cycle',

    get: function get(element, node) {
      var retryTimeCycle = getFailedJobRetryTimeCycle(getBusinessObject(element));
      var value = retryTimeCycle && retryTimeCycle.get('body');
      return {
        cycle: value
      };
    },

    set: function set(element, values, node) {
      var newCycle = values.cycle;
      var bo = getBusinessObject(element);

      if (newCycle === '' || typeof newCycle === 'undefined') {
        // remove retry time cycle element(s)
        return removeFailedJobRetryTimeCycle(bo, element);
      }

      var retryTimeCycle = getFailedJobRetryTimeCycle(bo);

      if (!retryTimeCycle) {
        // add new retry time cycle element
        var commands = [];

        var extensionElements = bo.get('extensionElements');
        if (!extensionElements) {
          extensionElements = createExtensionElements(bo, bpmnFactory);
          commands.push(cmdHelper.updateBusinessObject(element, bo, { extensionElements: extensionElements }));
        }

        retryTimeCycle = createFailedJobRetryTimeCycle(extensionElements, bpmnFactory, newCycle);
        commands.push(cmdHelper.addAndRemoveElementsFromList(element, extensionElements, 'values', 'extensionElements', [retryTimeCycle], []));

        return commands;
      }

      // update existing retry time cycle element
      return cmdHelper.updateBusinessObject(element, retryTimeCycle, { body: newCycle });
    },

    hidden: function hidden(element) {
      var bo = getBusinessObject(element);

      if (bo && (isAsyncBefore(bo) || isAsyncAfter(bo))) {
        return false;
      }

      if (is(element, 'bpmn:Event')) {
        return !eventDefinitionHelper.getTimerEventDefinition(element);
      }

      return true;
    }

  });

  return [retryTimeCycleEntry];
};

},{"../../../../factory/EntryFactory":14,"../../../../helper/AsyncCapableHelper":23,"../../../../helper/CmdHelper":24,"../../../../helper/ElementHelper":25,"../../../../helper/EventDefinitionHelper":26,"bpmn-js/lib/util/ModelUtil":216}],100:[function(require,module,exports){
'use strict';

var is = require('bpmn-js/lib/util/ModelUtil').is,
    getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject;

var extensionElementsEntry = require('./ExtensionElements'),
    extensionElementsHelper = require('../../../../helper/ExtensionElementsHelper'),
    cmdHelper = require('../../../../helper/CmdHelper'),
    elementHelper = require('../../../../helper/ElementHelper'),
    ImplementationTypeHelper = require('../../../../helper/ImplementationTypeHelper');

function getListeners(bo, type) {
  return bo && extensionElementsHelper.getExtensionElements(bo, type) || [];
}

var CAMUNDA_EXECUTION_LISTENER_ELEMENT = 'camunda:ExecutionListener';
var CAMUNDA_TASK_LISTENER_ELEMENT = 'camunda:TaskListener';

module.exports = function (element, bpmnFactory, options, translate) {

  var LISTENER_TYPE_LABEL = {
    class: translate('Java Class'),
    expression: translate('Expression'),
    delegateExpression: translate('Delegate Expression'),
    script: translate('Script')
  };

  var bo;

  var result = {
    getSelectedListener: getSelectedListener
  };

  var entries = result.entries = [];

  var isSequenceFlow = ImplementationTypeHelper.isSequenceFlow(element);

  function getSelectedListener(element, node) {
    var selection = executionListenerEntry && executionListenerEntry.getSelected(element, node) || { idx: -1 };

    var listener = getListeners(bo, CAMUNDA_EXECUTION_LISTENER_ELEMENT)[selection.idx];
    if (!listener && taskListenerEntry) {
      selection = taskListenerEntry.getSelected(element, node);
      listener = getListeners(bo, CAMUNDA_TASK_LISTENER_ELEMENT)[selection.idx];
    }
    return listener;
  }

  var setOptionLabelValue = function setOptionLabelValue(type) {
    return function (element, node, option, property, value, idx) {
      var listeners = getListeners(bo, type);
      var listener = listeners[idx];
      var listenerType = ImplementationTypeHelper.getImplementationType(listener);

      var event = listener.get('event') ? listener.get('event') : '<empty>';

      var label = (event || '*') + ' : ' + (LISTENER_TYPE_LABEL[listenerType] || '');

      option.text = label;
    };
  };

  var newElement = function newElement(element, type, initialEvent) {
    return function (element, extensionElements, value) {
      var props = {
        event: initialEvent,
        class: ''
      };

      var newElem = elementHelper.createElement(type, props, extensionElements, bpmnFactory);

      return cmdHelper.addElementsTolist(element, extensionElements, 'values', [newElem]);
    };
  };

  var removeElement = function removeElement(element, type) {
    return function (element, extensionElements, value, idx) {
      var listeners = getListeners(bo, type);
      var listener = listeners[idx];
      if (listener) {
        return extensionElementsHelper.removeEntry(bo, element, listener);
      }
    };
  };

  ////////// Execution Listener

  if (is(element, 'bpmn:FlowElement') || is(element, 'bpmn:Process') || is(element, 'bpmn:Participant')) {
    bo = getBusinessObject(element);
    if (is(element, 'bpmn:Participant')) {
      element = element.processRef;
      bo = bo.get('processRef');
    }

    if (bo) {

      var executionListenerEntry = extensionElementsEntry(element, bpmnFactory, {
        id: 'executionListeners',
        label: translate('Execution Listener'),
        modelProperty: 'name',
        idGeneration: 'false',
        reference: 'processRef',

        createExtensionElement: newElement(element, CAMUNDA_EXECUTION_LISTENER_ELEMENT, isSequenceFlow ? 'take' : 'start'),
        removeExtensionElement: removeElement(element, CAMUNDA_EXECUTION_LISTENER_ELEMENT),

        getExtensionElements: function getExtensionElements(element) {
          return getListeners(bo, CAMUNDA_EXECUTION_LISTENER_ELEMENT);
        },

        onSelectionChange: function onSelectionChange(element, node, event, scope) {
          taskListenerEntry && taskListenerEntry.deselect(element, node);
        },

        setOptionLabelValue: setOptionLabelValue(CAMUNDA_EXECUTION_LISTENER_ELEMENT)

      });
      entries.push(executionListenerEntry);
    }
  }

  ////////// Task Listener

  if (is(element, 'bpmn:UserTask')) {
    bo = getBusinessObject(element);

    var taskListenerEntry = extensionElementsEntry(element, bpmnFactory, {
      id: 'taskListeners',
      label: translate('Task Listener'),
      modelProperty: 'name',
      idGeneration: 'false',

      createExtensionElement: newElement(element, CAMUNDA_TASK_LISTENER_ELEMENT, 'create'),
      removeExtensionElement: removeElement(element, CAMUNDA_TASK_LISTENER_ELEMENT),

      getExtensionElements: function getExtensionElements(element) {
        return getListeners(bo, CAMUNDA_TASK_LISTENER_ELEMENT);
      },

      onSelectionChange: function onSelectionChange(element, node, event, scope) {
        executionListenerEntry.deselect(element, node);
      },

      setOptionLabelValue: setOptionLabelValue(CAMUNDA_TASK_LISTENER_ELEMENT)

    });
    entries.push(taskListenerEntry);
  }

  return result;
};

},{"../../../../helper/CmdHelper":24,"../../../../helper/ElementHelper":25,"../../../../helper/ExtensionElementsHelper":27,"../../../../helper/ImplementationTypeHelper":29,"./ExtensionElements":90,"bpmn-js/lib/util/ModelUtil":216}],101:[function(require,module,exports){
'use strict';

var getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject;

var entryFactory = require('../../../../factory/EntryFactory');

var elementHelper = require('../../../../helper/ElementHelper'),
    cmdHelper = require('../../../../helper/CmdHelper');

var domClasses = require('min-dom/lib/classes');

/**
 * Get a property value of the loop characteristics.
 *
 * @param {djs.model.Base} element
 * @param {string} propertyName
 *
 * @return {any} the property value
 */
function getProperty(element, propertyName) {
  var loopCharacteristics = getLoopCharacteristics(element);
  return loopCharacteristics && loopCharacteristics.get(propertyName);
}

/**
 * Get the body of a given expression.
 *
 * @param {ModdleElement<bpmn:FormalExpression>} expression
 *
 * @return {string} the body (value) of the expression
 */
function getBody(expression) {
  return expression && expression.get('body');
}

/**
 * Get the loop characteristics of an element.
 *
 * @param {djs.model.Base} element
 *
 * @return {ModdleElement<bpmn:MultiInstanceLoopCharacteristics>} the loop characteristics
 */
function getLoopCharacteristics(element) {
  var bo = getBusinessObject(element);
  return bo.loopCharacteristics;
}

/**
 * Get the loop cardinality of the loop characteristics.
 *
 * @param {djs.model.Base} element
 *
 * @return {ModdleElement<bpmn:FormalExpression>} an expression representing the loop cardinality
 */
function getLoopCardinality(element) {
  return getProperty(element, 'loopCardinality');
}

/**
 * Get the loop cardinality value of the loop characteristics.
 *
 * @param {djs.model.Base} element
 *
 * @return {string} the loop cardinality value
 */
function getLoopCardinalityValue(element) {
  var loopCardinality = getLoopCardinality(element);
  return getBody(loopCardinality);
}

/**
 * Get the completion condition of the loop characteristics.
 *
 * @param {djs.model.Base} element
 *
 * @return {ModdleElement<bpmn:FormalExpression>} an expression representing the completion condition
 */
function getCompletionCondition(element) {
  return getProperty(element, 'completionCondition');
}

/**
 * Get the completion condition value of the loop characteristics.
 *
 * @param {djs.model.Base} element
 *
 * @return {string} the completion condition value
 */
function getCompletionConditionValue(element) {
  var completionCondition = getCompletionCondition(element);
  return getBody(completionCondition);
}

/**
 * Get the 'camunda:collection' attribute value of the loop characteristics.
 *
 * @param {djs.model.Base} element
 *
 * @return {string} the 'camunda:collection' value
 */
function getCollection(element) {
  return getProperty(element, 'camunda:collection');
}

/**
 * Get the 'camunda:elementVariable' attribute value of the loop characteristics.
 *
 * @param {djs.model.Base} element
 *
 * @return {string} the 'camunda:elementVariable' value
 */
function getElementVariable(element) {
  return getProperty(element, 'camunda:elementVariable');
}

/**
 * Creates 'bpmn:FormalExpression' element.
 *
 * @param {ModdleElement} parent
 * @param {string} body
 * @param {BpmnFactory} bpmnFactory
 *
 * @result {ModdleElement<bpmn:FormalExpression>} a formal expression
 */
function createFormalExpression(parent, body, bpmnFactory) {
  return elementHelper.createElement('bpmn:FormalExpression', { body: body }, parent, bpmnFactory);
}

/**
 * Updates a specific formal expression of the loop characteristics.
 *
 * @param {djs.model.Base} element
 * @param {string} propertyName
 * @param {string} newValue
 * @param {BpmnFactory} bpmnFactory
 */
function updateFormalExpression(element, propertyName, newValue, bpmnFactory) {
  var loopCharacteristics = getLoopCharacteristics(element);

  var expressionProps = {};

  if (!newValue) {
    // remove formal expression
    expressionProps[propertyName] = undefined;
    return cmdHelper.updateBusinessObject(element, loopCharacteristics, expressionProps);
  }

  var existingExpression = loopCharacteristics.get(propertyName);

  if (!existingExpression) {
    // add formal expression
    expressionProps[propertyName] = createFormalExpression(loopCharacteristics, newValue, bpmnFactory);
    return cmdHelper.updateBusinessObject(element, loopCharacteristics, expressionProps);
  }

  // edit existing formal expression
  return cmdHelper.updateBusinessObject(element, existingExpression, {
    body: newValue
  });
}

module.exports = function (element, bpmnFactory, translate) {

  var entries = [];

  // error message /////////////////////////////////////////////////////////////////

  entries.push({
    id: 'multiInstance-errorMessage',
    html: '<div data-show="isValid">' + '<span class="bpp-icon-warning"></span> ' + translate('Must provide either loop cardinality or collection') + '</div>',

    isValid: function isValid(element, node, notification, scope) {
      var loopCharacteristics = getLoopCharacteristics(element);

      var isValid = true;
      if (loopCharacteristics) {
        var loopCardinality = getLoopCardinalityValue(element);
        var collection = getCollection(element);

        isValid = !loopCardinality && !collection;
      }

      domClasses(node).toggle('bpp-hidden', !isValid);
      domClasses(notification).toggle('bpp-error-message', isValid);

      return isValid;
    }
  });

  // loop cardinality //////////////////////////////////////////////////////////////

  entries.push(entryFactory.textField({
    id: 'multiInstance-loopCardinality',
    label: translate('Loop Cardinality'),
    modelProperty: 'loopCardinality',

    get: function get(element, node) {
      return {
        loopCardinality: getLoopCardinalityValue(element)
      };
    },

    set: function set(element, values) {
      return updateFormalExpression(element, 'loopCardinality', values.loopCardinality, bpmnFactory);
    }
  }));

  // collection //////////////////////////////////////////////////////////////////

  entries.push(entryFactory.textField({
    id: 'multiInstance-collection',
    label: translate('Collection'),
    modelProperty: 'collection',

    get: function get(element, node) {
      return {
        collection: getCollection(element)
      };
    },

    set: function set(element, values) {
      var loopCharacteristics = getLoopCharacteristics(element);
      return cmdHelper.updateBusinessObject(element, loopCharacteristics, {
        'camunda:collection': values.collection || undefined
      });
    },

    validate: function validate(element, values, node) {
      var collection = getCollection(element);
      var elementVariable = getElementVariable(element);

      if (!collection && elementVariable) {
        return { collection: 'Must provide a value' };
      }
    }
  }));

  // element variable ////////////////////////////////////////////////////////////

  entries.push(entryFactory.textField({
    id: 'multiInstance-elementVariable',
    label: translate('Element Variable'),
    modelProperty: 'elementVariable',

    get: function get(element, node) {
      return {
        elementVariable: getElementVariable(element)
      };
    },

    set: function set(element, values) {
      var loopCharacteristics = getLoopCharacteristics(element);
      return cmdHelper.updateBusinessObject(element, loopCharacteristics, {
        'camunda:elementVariable': values.elementVariable || undefined
      });
    }
  }));

  // Completion Condition //////////////////////////////////////////////////////

  entries.push(entryFactory.textField({
    id: 'multiInstance-completionCondition',
    label: translate('Completion Condition'),
    modelProperty: 'completionCondition',

    get: function get(element) {
      return {
        completionCondition: getCompletionConditionValue(element)
      };
    },

    set: function set(element, values) {
      return updateFormalExpression(element, 'completionCondition', values.completionCondition, bpmnFactory);
    }
  }));

  return entries;
};

},{"../../../../factory/EntryFactory":14,"../../../../helper/CmdHelper":24,"../../../../helper/ElementHelper":25,"bpmn-js/lib/util/ModelUtil":216,"min-dom/lib/classes":106}],102:[function(require,module,exports){
'use strict';

var getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject,
    is = require('bpmn-js/lib/util/ModelUtil').is;

var factory = require('../../../../factory/EntryFactory');

var elementHelper = require('../../../../helper/ElementHelper'),
    extensionElementsHelper = require('../../../../helper/ExtensionElementsHelper'),
    cmdHelper = require('../../../../helper/CmdHelper'),
    utils = require('../../../../Utils');

var assign = require('lodash/object/assign'),
    forEach = require('lodash/collection/forEach'),
    find = require('lodash/collection/find');

function generatePropertyId() {
  return utils.nextId('Property_');
}

/**
 * Get all camunda:property objects for a specific business object
 *
 * @param  {ModdleElement} parent
 *
 * @return {Array<ModdleElement>} a list of camunda:property objects
 */
function getPropertyValues(parent) {
  var properties = parent && getPropertiesElement(parent);
  if (properties && properties.values) {
    return properties.values;
  }
  return [];
}

/**
 * Get all camunda:Properties object for a specific business object
 *
 * @param  {ModdleElement} parent
 *
 * @return {ModdleElement} a camunda:Properties object
 */
function getPropertiesElement(element) {
  if (!isExtensionElements(element)) {
    return element.properties;
  } else {
    return getPropertiesElementInsideExtensionElements(element);
  }
}

/**
 * Get first camunda:Properties object for a specific bpmn:ExtensionElements
 * business object.
 *
 * @param {ModdleElement} extensionElements
 *
 * @return {ModdleElement} a camunda:Properties object
 */
function getPropertiesElementInsideExtensionElements(extensionElements) {
  return find(extensionElements.values, function (elem) {
    return is(elem, 'camunda:Properties');
  });
}

/**
 * Returns true, if the given business object is a bpmn:ExtensionElements.
 *
 * @param {ModdleElement} element
 *
 * @return {boolean} a boolean value
 */
function isExtensionElements(element) {
  return is(element, 'bpmn:ExtensionElements');
}

/**
 * Create a camunda:property entry using tableEntryFactory
 *
 * @param  {djs.model.Base} element
 * @param  {BpmnFactory} bpmnFactory
 * @param  {Object} options
 * @param  {string} options.id
 * @param  {Array<string>} options.modelProperties
 * @param  {Array<string>} options.labels
 * @param  {function} options.getParent Gets the parent business object
 * @param  {function} options.show Indicate when the entry will be shown, should return boolean
 */
module.exports = function (element, bpmnFactory, options, translate) {

  var getParent = options.getParent;

  var modelProperties = options.modelProperties,
      createParent = options.createParent;

  var bo = getBusinessObject(element);
  if (is(element, 'bpmn:Participant')) {
    bo = bo.get('processRef');
  }

  // build properties group only when the participant have a processRef
  if (!bo) {
    return;
  }

  assign(options, {
    addLabel: translate('Add Property'),
    getElements: function getElements(element, node) {
      var parent = getParent(element, node, bo);
      return getPropertyValues(parent);
    },
    addElement: function addElement(element, node) {
      var commands = [],
          parent = getParent(element, node, bo);

      if (!parent && typeof createParent === 'function') {
        var result = createParent(element, bo);
        parent = result.parent;
        commands.push(result.cmd);
      }

      var properties = getPropertiesElement(parent);
      if (!properties) {
        properties = elementHelper.createElement('camunda:Properties', {}, parent, bpmnFactory);

        if (!isExtensionElements(parent)) {
          commands.push(cmdHelper.updateBusinessObject(element, parent, { 'properties': properties }));
        } else {
          commands.push(cmdHelper.addAndRemoveElementsFromList(element, parent, 'values', 'extensionElements', [properties], []));
        }
      }

      var propertyProps = {};
      forEach(modelProperties, function (prop) {
        propertyProps[prop] = undefined;
      });

      // create id if necessary
      if (modelProperties.indexOf('id') >= 0) {
        propertyProps.id = generatePropertyId();
      }

      var property = elementHelper.createElement('camunda:Property', propertyProps, properties, bpmnFactory);
      commands.push(cmdHelper.addElementsTolist(element, properties, 'values', [property]));

      return commands;
    },
    updateElement: function updateElement(element, value, node, idx) {
      var parent = getParent(element, node, bo),
          property = getPropertyValues(parent)[idx];

      forEach(modelProperties, function (prop) {
        value[prop] = value[prop] || undefined;
      });

      return cmdHelper.updateBusinessObject(element, property, value);
    },
    validate: function validate(element, value, node, idx) {
      // validate id if necessary
      if (modelProperties.indexOf('id') >= 0) {

        var parent = getParent(element, node, bo),
            properties = getPropertyValues(parent),
            property = properties[idx];

        if (property) {
          // check if id is valid
          var validationError = utils.isIdValid(property, value.id);

          if (validationError) {
            return { id: validationError };
          }
        }
      }
    },
    removeElement: function removeElement(element, node, idx) {
      var commands = [],
          parent = getParent(element, node, bo),
          properties = getPropertiesElement(parent),
          propertyValues = getPropertyValues(parent),
          currentProperty = propertyValues[idx];

      commands.push(cmdHelper.removeElementsFromList(element, properties, 'values', null, [currentProperty]));

      if (propertyValues.length === 1) {
        // remove camunda:properties if the last existing property has been removed
        if (!isExtensionElements(parent)) {
          commands.push(cmdHelper.updateBusinessObject(element, parent, { properties: undefined }));
        } else {
          forEach(parent.values, function (value) {
            if (is(value, 'camunda:Properties')) {
              commands.push(extensionElementsHelper.removeEntry(bo, element, value));
            }
          });
        }
      }

      return commands;
    }
  });

  return factory.table(options);
};

},{"../../../../Utils":5,"../../../../factory/EntryFactory":14,"../../../../helper/CmdHelper":24,"../../../../helper/ElementHelper":25,"../../../../helper/ExtensionElementsHelper":27,"bpmn-js/lib/util/ModelUtil":216,"lodash/collection/find":421,"lodash/collection/forEach":422,"lodash/object/assign":496}],103:[function(require,module,exports){
'use strict';

var is = require('bpmn-js/lib/util/ModelUtil').is;

var assign = require('lodash/object/assign');

var entryFactory = require('../../../../factory/EntryFactory'),
    cmdHelper = require('../../../../helper/CmdHelper');

module.exports = function (element, bpmnFactory, options, translate) {

  var getBusinessObject = options.getBusinessObject,
      hideResultVariable = options.hideResultVariable,
      id = options.id || 'resultVariable';

  var resultVariableEntry = entryFactory.textField({
    id: id,
    label: translate('Result Variable'),
    modelProperty: 'resultVariable',

    get: function get(element, node) {
      var bo = getBusinessObject(element);
      return { resultVariable: bo.get('camunda:resultVariable') };
    },

    set: function set(element, values, node) {
      var bo = getBusinessObject(element);

      var resultVariable = values.resultVariable || undefined;

      var props = {
        'camunda:resultVariable': resultVariable
      };

      if (is(bo, 'camunda:DmnCapable') && !resultVariable) {
        props = assign({ 'camunda:mapDecisionResult': 'resultList' }, props);
      }

      return cmdHelper.updateBusinessObject(element, bo, props);
    },

    hidden: function hidden(element, node) {
      if (typeof hideResultVariable === 'function') {
        return hideResultVariable.apply(resultVariableEntry, arguments);
      }
    }

  });

  return [resultVariableEntry];
};

},{"../../../../factory/EntryFactory":14,"../../../../helper/CmdHelper":24,"bpmn-js/lib/util/ModelUtil":216,"lodash/object/assign":496}],104:[function(require,module,exports){
'use strict';

var domQuery = require('min-dom/lib/query'),
    utils = require('../../../../Utils');

function getScriptType(node) {
  return utils.selectedType('select[name=scriptType]', node.parentElement);
}

module.exports = function (scriptLanguagePropName, scriptValuePropName, isFormatRequired) {

  return {
    template: '<div class="bpp-row bpp-textfield">' + '<label for="cam-script-format">Script Format</label>' + '<div class="bpp-field-wrapper">' + '<input id="cam-script-format" type="text" name="scriptFormat" />' + '<button class="clear" data-action="script.clearScriptFormat" data-show="script.canClearScriptFormat">' + '<span>X</span>' + '</button>' + '</div>' + '</div>' + '<div class="bpp-row">' + '<label for="cam-script-type">Script Type</label>' + '<div class="bpp-field-wrapper">' + '<select id="cam-script-type" name="scriptType" data-value>' + '<option value="script" selected>Inline Script</option>' + '<option value="scriptResource">External Resource</option>' + '</select>' + '</div>' + '</div>' + '<div class="bpp-row bpp-textfield">' + '<label for="cam-script-resource-val" data-show="script.isScriptResource">Resource</label>' + '<div class="bpp-field-wrapper" data-show="script.isScriptResource">' + '<input id="cam-script-resource-val" type="text" name="scriptResourceValue" />' + '<button class="clear" data-action="script.clearScriptResource" data-show="script.canClearScriptResource">' + '<span>X</span>' + '</button>' + '</div>' + '</div>' + '<div class="bpp-row">' + '<label for="cam-script-val" data-show="script.isScript">Script</label>' + '<div class="bpp-field-wrapper" data-show="script.isScript">' + '<textarea id="cam-script-val" type="text" name="scriptValue"></textarea>' + '</div>' + '</div>',

    get: function get(element, bo) {
      var values = {};

      // read values from xml:
      var boScriptResource = bo.get('camunda:resource'),
          boScript = bo.get(scriptValuePropName),
          boScriptFormat = bo.get(scriptLanguagePropName);

      if (typeof boScriptResource !== 'undefined') {
        values.scriptResourceValue = boScriptResource;
        values.scriptType = 'scriptResource';
      } else {
        values.scriptValue = boScript;
        values.scriptType = 'script';
      }

      values.scriptFormat = boScriptFormat;

      return values;
    },

    set: function set(element, values, containerElement) {
      var scriptFormat = values.scriptFormat,
          scriptType = values.scriptType,
          scriptResourceValue = values.scriptResourceValue,
          scriptValue = values.scriptValue;

      // init update
      var update = {
        'camunda:resource': undefined
      };
      update[scriptValuePropName] = undefined;
      update[scriptLanguagePropName] = undefined;

      if (isFormatRequired) {
        // always set language
        update[scriptLanguagePropName] = scriptFormat || '';
      } else
        // set language only when scriptFormat has a value
        if (scriptFormat !== '') {
          update[scriptLanguagePropName] = scriptFormat;
        }

      // set either inline script or resource
      if ('scriptResource' === scriptType) {
        update['camunda:resource'] = scriptResourceValue || '';
      } else {
        update[scriptValuePropName] = scriptValue || '';
      }

      return update;
    },

    validate: function validate(element, values) {
      var validationResult = {};

      if (values.scriptType === 'script' && !values.scriptValue) {
        validationResult.scriptValue = 'Must provide a value';
      }

      if (values.scriptType === 'scriptResource' && !values.scriptResourceValue) {
        validationResult.scriptResourceValue = 'Must provide a value';
      }

      if (isFormatRequired && (!values.scriptFormat || values.scriptFormat.length === 0)) {
        validationResult.scriptFormat = 'Must provide a value';
      }

      return validationResult;
    },

    clearScriptFormat: function clearScriptFormat(element, inputNode, btnNode, scopeNode) {
      domQuery('input[name=scriptFormat]', scopeNode).value = '';

      return true;
    },

    canClearScriptFormat: function canClearScriptFormat(element, inputNode, btnNode, scopeNode) {
      var input = domQuery('input[name=scriptFormat]', scopeNode);

      return input.value !== '';
    },

    clearScriptResource: function clearScriptResource(element, inputNode, btnNode, scopeNode) {
      domQuery('input[name=scriptResourceValue]', scopeNode).value = '';

      return true;
    },

    canClearScriptResource: function canClearScriptResource(element, inputNode, btnNode, scopeNode) {
      var input = domQuery('input[name=scriptResourceValue]', scopeNode);

      return input.value !== '';
    },

    clearScript: function clearScript(element, inputNode, btnNode, scopeNode) {
      domQuery('textarea[name=scriptValue]', scopeNode).value = '';

      return true;
    },

    canClearScript: function canClearScript(element, inputNode, btnNode, scopeNode) {
      var input = domQuery('textarea[name=scriptValue]', scopeNode);

      return input.value !== '';
    },

    isScriptResource: function isScriptResource(element, inputNode, btnNode, scopeNode) {
      var scriptType = getScriptType(scopeNode);
      return scriptType === 'scriptResource';
    },

    isScript: function isScript(element, inputNode, btnNode, scopeNode) {
      var scriptType = getScriptType(scopeNode);
      return scriptType === 'script';
    }

  };
};

},{"../../../../Utils":5,"min-dom/lib/query":112}],105:[function(require,module,exports){
"use strict";

/**
 * Set attribute `name` to `val`, or get attr `name`.
 *
 * @param {Element} el
 * @param {String} name
 * @param {String} [val]
 * @api public
 */

module.exports = function (el, name, val) {
  // get
  if (arguments.length == 2) {
    return el.getAttribute(name);
  }

  // remove
  if (val === null) {
    return el.removeAttribute(name);
  }

  // set
  el.setAttribute(name, val);

  return el;
};

},{}],106:[function(require,module,exports){
'use strict';

module.exports = require('component-classes');

},{"component-classes":230}],107:[function(require,module,exports){
"use strict";

module.exports = function (el) {

  var c;

  while (el.childNodes.length) {
    c = el.childNodes[0];
    el.removeChild(c);
  }

  return el;
};

},{}],108:[function(require,module,exports){
'use strict';

module.exports = require('component-closest');

},{"component-closest":231}],109:[function(require,module,exports){
'use strict';

module.exports = require('component-delegate');

},{"component-delegate":232}],110:[function(require,module,exports){
'use strict';

module.exports = require('domify');

},{"domify":411}],111:[function(require,module,exports){
'use strict';

module.exports = require('component-matches-selector');

},{"component-matches-selector":235}],112:[function(require,module,exports){
'use strict';

module.exports = require('component-query');

},{"component-query":236}],113:[function(require,module,exports){
"use strict";

module.exports = function (el) {
  el.parentNode && el.parentNode.removeChild(el);
};

},{}],114:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = Modeler;

var _inherits = require('inherits');

var _inherits2 = _interopRequireDefault(_inherits);

var _ids = require('ids');

var _ids2 = _interopRequireDefault(_ids);

var _Viewer = require('./Viewer');

var _Viewer2 = _interopRequireDefault(_Viewer);

var _NavigatedViewer = require('./NavigatedViewer');

var _NavigatedViewer2 = _interopRequireDefault(_NavigatedViewer);

var _keyboardMove = require('diagram-js/lib/navigation/keyboard-move');

var _keyboardMove2 = _interopRequireDefault(_keyboardMove);

var _movecanvas = require('diagram-js/lib/navigation/movecanvas');

var _movecanvas2 = _interopRequireDefault(_movecanvas);

var _touch = require('diagram-js/lib/navigation/touch');

var _touch2 = _interopRequireDefault(_touch);

var _zoomscroll = require('diagram-js/lib/navigation/zoomscroll');

var _zoomscroll2 = _interopRequireDefault(_zoomscroll);

var _alignElements = require('diagram-js/lib/features/align-elements');

var _alignElements2 = _interopRequireDefault(_alignElements);

var _autoPlace = require('./features/auto-place');

var _autoPlace2 = _interopRequireDefault(_autoPlace);

var _autoResize = require('./features/auto-resize');

var _autoResize2 = _interopRequireDefault(_autoResize);

var _autoScroll = require('diagram-js/lib/features/auto-scroll');

var _autoScroll2 = _interopRequireDefault(_autoScroll);

var _bendpoints = require('diagram-js/lib/features/bendpoints');

var _bendpoints2 = _interopRequireDefault(_bendpoints);

var _contextPad = require('./features/context-pad');

var _contextPad2 = _interopRequireDefault(_contextPad);

var _copyPaste = require('./features/copy-paste');

var _copyPaste2 = _interopRequireDefault(_copyPaste);

var _distributeElements = require('./features/distribute-elements');

var _distributeElements2 = _interopRequireDefault(_distributeElements);

var _editorActions = require('./features/editor-actions');

var _editorActions2 = _interopRequireDefault(_editorActions);

var _keyboard = require('./features/keyboard');

var _keyboard2 = _interopRequireDefault(_keyboard);

var _keyboardMoveSelection = require('diagram-js/lib/features/keyboard-move-selection');

var _keyboardMoveSelection2 = _interopRequireDefault(_keyboardMoveSelection);

var _labelEditing = require('./features/label-editing');

var _labelEditing2 = _interopRequireDefault(_labelEditing);

var _modeling = require('./features/modeling');

var _modeling2 = _interopRequireDefault(_modeling);

var _move = require('diagram-js/lib/features/move');

var _move2 = _interopRequireDefault(_move);

var _palette = require('./features/palette');

var _palette2 = _interopRequireDefault(_palette);

var _replacePreview = require('./features/replace-preview');

var _replacePreview2 = _interopRequireDefault(_replacePreview);

var _resize = require('diagram-js/lib/features/resize');

var _resize2 = _interopRequireDefault(_resize);

var _snapping = require('./features/snapping');

var _snapping2 = _interopRequireDefault(_snapping);

var _search = require('./features/search');

var _search2 = _interopRequireDefault(_search);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

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>';

/**
 * 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) {
  _Viewer2.default.call(this, options);

  // hook ID collection into the modeler
  this.on('import.parse.complete', function (event) {
    if (!event.error) {
      this._collectIds(event.definitions, event.context);
    }
  }, this);

  this.on('diagram.destroy', function () {
    this.get('moddle').ids.clear();
  }, this);
}

(0, _inherits2.default)(Modeler, _Viewer2.default);

Modeler.Viewer = _Viewer2.default;
Modeler.NavigatedViewer = _NavigatedViewer2.default;

/**
 * Create a new diagram to start modeling.
 *
 * @param {Function} [done]
 */
Modeler.prototype.createDiagram = function (done) {
  return this.importXML(initialDiagram, done);
};

/**
 * Create a moddle instance, attaching ids to it.
 *
 * @param {Object} options
 */
Modeler.prototype._createModdle = function (options) {
  var moddle = _Viewer2.default.prototype._createModdle.call(this, options);

  // attach ids to moddle to be able to track
  // and validated ids in the BPMN 2.0 XML document
  // tree
  moddle.ids = new _ids2.default([32, 36, 1]);

  return moddle;
};

/**
 * Collect ids processed during parsing of the
 * definitions object.
 *
 * @param {ModdleElement} definitions
 * @param {Context} context
 */
Modeler.prototype._collectIds = function (definitions, context) {

  var moddle = definitions.$model,
      ids = moddle.ids,
      id;

  // remove references from previous import
  ids.clear();

  for (id in context.elementsById) {
    ids.claim(id, context.elementsById[id]);
  }
};

Modeler.prototype._interactionModules = [
// non-modeling components
_keyboardMove2.default, _movecanvas2.default, _touch2.default, _zoomscroll2.default];

Modeler.prototype._modelingModules = [
// modeling components
_alignElements2.default, _autoPlace2.default, _autoScroll2.default, _autoResize2.default, _bendpoints2.default, _contextPad2.default, _copyPaste2.default, _distributeElements2.default, _editorActions2.default, _keyboard2.default, _keyboardMoveSelection2.default, _labelEditing2.default, _modeling2.default, _move2.default, _palette2.default, _replacePreview2.default, _resize2.default, _snapping2.default, _search2.default];

// modules the modeler is composed of
//
// - viewer modules
// - interaction modules
// - modeling modules

Modeler.prototype._modules = [].concat(Modeler.prototype._modules, Modeler.prototype._interactionModules, Modeler.prototype._modelingModules);

},{"./NavigatedViewer":115,"./Viewer":116,"./features/auto-place":126,"./features/auto-resize":129,"./features/context-pad":131,"./features/copy-paste":133,"./features/distribute-elements":135,"./features/editor-actions":137,"./features/keyboard":139,"./features/label-editing":144,"./features/modeling":187,"./features/palette":193,"./features/replace-preview":198,"./features/search":205,"./features/snapping":208,"diagram-js/lib/features/align-elements":257,"diagram-js/lib/features/auto-scroll":263,"diagram-js/lib/features/bendpoints":269,"diagram-js/lib/features/keyboard-move-selection":296,"diagram-js/lib/features/move":334,"diagram-js/lib/features/resize":352,"diagram-js/lib/navigation/keyboard-move":384,"diagram-js/lib/navigation/movecanvas":386,"diagram-js/lib/navigation/touch":387,"diagram-js/lib/navigation/zoomscroll":390,"ids":414,"inherits":415}],115:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = NavigatedViewer;

var _inherits = require('inherits');

var _inherits2 = _interopRequireDefault(_inherits);

var _Viewer = require('./Viewer');

var _Viewer2 = _interopRequireDefault(_Viewer);

var _keyboardMove = require('diagram-js/lib/navigation/keyboard-move');

var _keyboardMove2 = _interopRequireDefault(_keyboardMove);

var _movecanvas = require('diagram-js/lib/navigation/movecanvas');

var _movecanvas2 = _interopRequireDefault(_movecanvas);

var _zoomscroll = require('diagram-js/lib/navigation/zoomscroll');

var _zoomscroll2 = _interopRequireDefault(_zoomscroll);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * A viewer that includes mouse navigation facilities
 *
 * @param {Object} options
 */
function NavigatedViewer(options) {
  _Viewer2.default.call(this, options);
}

(0, _inherits2.default)(NavigatedViewer, _Viewer2.default);

NavigatedViewer.prototype._navigationModules = [_keyboardMove2.default, _movecanvas2.default, _zoomscroll2.default];

NavigatedViewer.prototype._modules = [].concat(NavigatedViewer.prototype._modules, NavigatedViewer.prototype._navigationModules);

},{"./Viewer":116,"diagram-js/lib/navigation/keyboard-move":384,"diagram-js/lib/navigation/movecanvas":386,"diagram-js/lib/navigation/zoomscroll":390,"inherits":415}],116:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = Viewer;

var _minDash = require('min-dash');

var _minDom = require('min-dom');

var _tinySvg = require('tiny-svg');

var _diagramJs = require('diagram-js');

var _diagramJs2 = _interopRequireDefault(_diagramJs);

var _bpmnModdle = require('bpmn-moddle');

var _bpmnModdle2 = _interopRequireDefault(_bpmnModdle);

var _inherits = require('inherits');

var _inherits2 = _interopRequireDefault(_inherits);

var _Importer = require('./import/Importer');

var _core = require('./core');

var _core2 = _interopRequireDefault(_core);

var _translate = require('diagram-js/lib/i18n/translate');

var _translate2 = _interopRequireDefault(_translate);

var _selection = require('diagram-js/lib/features/selection');

var _selection2 = _interopRequireDefault(_selection);

var _overlays = require('diagram-js/lib/features/overlays');

var _overlays2 = _interopRequireDefault(_overlays);

var _PoweredByUtil = require('./util/PoweredByUtil');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function checkValidationError(err) {

  // 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)

  var pattern = /unparsable content <([^>]+)> detected([\s\S]*)$/;
  var match = pattern.exec(err.message);

  if (match) {
    err.message = 'unparsable content <' + match[1] + '> detected; ' + 'this may indicate an invalid BPMN 2.0 diagram file' + match[2];
  }

  return err;
} /**
   * The code in the <project-logo></project-logo> area
   * must not be changed.
   *
   * @see http://bpmn.io/license for more information.
   */


var DEFAULT_OPTIONS = {
  width: '100%',
  height: '100%',
  position: 'relative'
};

/**
 * Ensure the passed argument is a proper unit (defaulting to px)
 */
function ensureUnit(val) {
  return val + ((0, _minDash.isNumber)(val) ? 'px' : '');
}

/**
 * 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) {

  options = (0, _minDash.assign)({}, DEFAULT_OPTIONS, options);

  this._moddle = this._createModdle(options);

  this._container = this._createContainer(options);

  /* <project-logo> */

  addProjectLogo(this._container);

  /* </project-logo> */

  this._init(this._container, this._moddle, options);
}

(0, _inherits2.default)(Viewer, _diagramJs2.default);

/**
 * 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 {Function} [done] invoked with (err, warnings=[])
 */
Viewer.prototype.importXML = function (xml, done) {

  // done is optional
  done = done || function () {};

  var self = this;

  // hook in pre-parse listeners +
  // allow xml manipulation
  xml = this._emit('import.parse.start', { xml: xml }) || xml;

  this._moddle.fromXML(xml, 'bpmn:Definitions', function (err, definitions, context) {

    // hook in post parse listeners +
    // allow definitions manipulation
    definitions = self._emit('import.parse.complete', {
      error: err,
      definitions: definitions,
      context: context
    }) || definitions;

    var parseWarnings = context.warnings;

    if (err) {
      err = checkValidationError(err);

      self._emit('import.done', { error: err, warnings: parseWarnings });

      return done(err, parseWarnings);
    }

    self.importDefinitions(definitions, function (err, importWarnings) {
      var allWarnings = [].concat(parseWarnings, importWarnings || []);

      self._emit('import.done', { error: err, warnings: allWarnings });

      done(err, allWarnings);
    });
  });
};

/**
 * 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 formated XML
 * @param {Boolean} [options.preamble=true] output preamble
 *
 * @param {Function} done invoked with (err, xml)
 */
Viewer.prototype.saveXML = function (options, done) {

  if (!done) {
    done = options;
    options = {};
  }

  var self = this;

  var definitions = this._definitions;

  if (!definitions) {
    return done(new Error('no definitions loaded'));
  }

  // allow to fiddle around with definitions
  definitions = this._emit('saveXML.start', {
    definitions: definitions
  }) || definitions;

  this._moddle.toXML(definitions, options, function (err, xml) {

    try {
      xml = self._emit('saveXML.serialized', {
        error: err,
        xml: xml
      }) || xml;

      self._emit('saveXML.done', {
        error: err,
        xml: xml
      });
    } catch (e) {
      console.error('error in saveXML life-cycle listener', e);
    }

    done(err, xml);
  });
};

/**
 * 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]
 * @param {Function} done invoked with (err, svgStr)
 */
Viewer.prototype.saveSVG = function (options, done) {

  if (!done) {
    done = options;
    options = {};
  }

  this._emit('saveSVG.start');

  var svg, err;

  try {
    var canvas = this.get('canvas');

    var contentNode = canvas.getDefaultLayer(),
        defsNode = (0, _minDom.query)('defs', canvas._svg);

    var contents = (0, _tinySvg.innerSVG)(contentNode),
        defs = defsNode ? '<defs>' + (0, _tinySvg.innerSVG)(defsNode) + '</defs>' : '';

    var bbox = contentNode.getBBox();

    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;
  }

  this._emit('saveSVG.done', {
    error: err,
    svg: svg
  });

  done(err, svg);
};

/**
 * 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 Viewer#get
 */

/**
 * 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 Viewer#invoke
 */

/**
 * Remove all drawn elements from the viewer.
 *
 * After calling this method the viewer can still
 * be reused for opening another diagram.
 *
 * @method Viewer#clear
 */

Viewer.prototype.importDefinitions = function (definitions, done) {

  // catch synchronous exceptions during #clear()
  try {
    if (this._definitions) {
      // clear existing rendered diagram
      this.clear();
    }

    // update definitions
    this._definitions = definitions;
  } catch (e) {
    return done(e);
  }

  // perform graphical import
  return (0, _Importer.importBpmnDiagram)(this, definitions, done);
};

Viewer.prototype.getModules = function () {
  return this._modules;
};

/**
 * Destroy the viewer instance and remove all its
 * remainders from the document tree.
 */
Viewer.prototype.destroy = function () {

  // diagram destroy
  _diagramJs2.default.prototype.destroy.call(this);

  // dom detach
  (0, _minDom.remove)(this._container);
};

/**
 * 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]
 */
Viewer.prototype.on = function (event, priority, callback, target) {
  return this.get('eventBus').on(event, priority, callback, target);
};

/**
 * De-register an event listener
 *
 * @param {String} event
 * @param {Function} callback
 */
Viewer.prototype.off = function (event, callback) {
  this.get('eventBus').off(event, callback);
};

Viewer.prototype.attachTo = function (parentNode) {

  if (!parentNode) {
    throw new Error('parentNode required');
  }

  // ensure we detach from the
  // previous, old parent
  this.detach();

  // unwrap jQuery if provided
  if (parentNode.get && parentNode.constructor.prototype.jquery) {
    parentNode = parentNode.get(0);
  }

  if (typeof parentNode === 'string') {
    parentNode = (0, _minDom.query)(parentNode);
  }

  parentNode.appendChild(this._container);

  this._emit('attach', {});

  this.get('canvas').resized();
};

Viewer.prototype.getDefinitions = function () {
  return this._definitions;
};

Viewer.prototype.detach = function () {

  var container = this._container,
      parentNode = container.parentNode;

  if (!parentNode) {
    return;
  }

  this._emit('detach', {});

  parentNode.removeChild(container);
};

Viewer.prototype._init = function (container, moddle, options) {

  var baseModules = options.modules || this.getModules(),
      additionalModules = options.additionalModules || [],
      staticModules = [{
    bpmnjs: ['value', this],
    moddle: ['value', moddle]
  }];

  var diagramModules = [].concat(staticModules, baseModules, additionalModules);

  var diagramOptions = (0, _minDash.assign)((0, _minDash.omit)(options, ['additionalModules']), {
    canvas: (0, _minDash.assign)({}, options.canvas, { container: container }),
    modules: diagramModules
  });

  // invoke diagram constructor
  _diagramJs2.default.call(this, diagramOptions);

  if (options && options.container) {
    this.attachTo(options.container);
  }
};

/**
 * Emit an event on the underlying {@link EventBus}
 *
 * @param  {String} type
 * @param  {Object} event
 *
 * @return {Object} event processing result (if any)
 */
Viewer.prototype._emit = function (type, event) {
  return this.get('eventBus').fire(type, event);
};

Viewer.prototype._createContainer = function (options) {

  var container = (0, _minDom.domify)('<div class="bjs-container"></div>');

  (0, _minDash.assign)(container.style, {
    width: ensureUnit(options.width),
    height: ensureUnit(options.height),
    position: options.position
  });

  return container;
};

Viewer.prototype._createModdle = function (options) {
  var moddleOptions = (0, _minDash.assign)({}, this._moddleExtensions, options.moddleExtensions);

  return new _bpmnModdle2.default(moddleOptions);
};

// modules the viewer is composed of
Viewer.prototype._modules = [_core2.default, _translate2.default, _selection2.default, _overlays2.default];

// default moddle extensions the viewer is composed of
Viewer.prototype._moddleExtensions = {};

/* <project-logo> */

/**
 * 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 = _PoweredByUtil.BPMNIO_IMG;

  var linkMarkup = '<a href="http://bpmn.io" ' + 'target="_blank" ' + 'class="bjs-powered-by" ' + 'title="Powered by bpmn.io" ' + 'style="position: absolute; bottom: 15px; right: 15px; z-index: 100">' + img + '</a>';

  var linkElement = (0, _minDom.domify)(linkMarkup);

  container.appendChild(linkElement);

  _minDom.event.bind(linkElement, 'click', function (event) {
    (0, _PoweredByUtil.open)();

    event.preventDefault();
  });
}

/* </project-logo> */

},{"./core":117,"./import/Importer":211,"./util/PoweredByUtil":217,"bpmn-moddle":220,"diagram-js":241,"diagram-js/lib/features/overlays":339,"diagram-js/lib/features/selection":361,"diagram-js/lib/i18n/translate":376,"inherits":415,"min-dash":505,"min-dom":506,"tiny-svg":535}],117:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _draw = require('../draw');

var _draw2 = _interopRequireDefault(_draw);

var _import = require('../import');

var _import2 = _interopRequireDefault(_import);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __depends__: [_draw2.default, _import2.default]
};

},{"../draw":122,"../import":213}],118:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.isTypedEvent = isTypedEvent;
exports.isThrowEvent = isThrowEvent;
exports.isCollection = isCollection;
exports.getDi = getDi;
exports.getSemantic = getSemantic;
exports.getFillColor = getFillColor;
exports.getStrokeColor = getStrokeColor;
exports.getCirclePath = getCirclePath;
exports.getRoundRectPath = getRoundRectPath;
exports.getDiamondPath = getDiamondPath;
exports.getRectPath = getRectPath;

var _minDash = require('min-dash');

var _RenderUtil = require('diagram-js/lib/util/RenderUtil');

// element utils //////////////////////

/**
 * 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) {

  function matches(definition, filter) {
    return (0, _minDash.every)(filter, function (val, key) {

      // we want a == conversion here, to be able to catch
      // undefined == false and friends
      /* jshint -W116 */
      return definition[key] == val;
    });
  }

  return (0, _minDash.some)(event.eventDefinitions, function (definition) {
    return definition.$type === eventDefinitionType && matches(event, filter);
  });
}

function isThrowEvent(event) {
  return event.$type === 'bpmn:IntermediateThrowEvent' || event.$type === 'bpmn:EndEvent';
}

function isCollection(element) {
  var dataObject = element.dataObjectRef;

  return element.isCollection || dataObject && dataObject.isCollection;
}

function getDi(element) {
  return element.businessObject.di;
}

function getSemantic(element) {
  return element.businessObject;
}

// color access //////////////////////

function getFillColor(element, defaultColor) {
  return getDi(element).get('bioc:fill') || defaultColor || 'white';
}

function getStrokeColor(element, defaultColor) {
  return getDi(element).get('bioc:stroke') || defaultColor || 'black';
}

// cropping path customizations //////////////////////

function getCirclePath(shape) {

  var cx = shape.x + shape.width / 2,
      cy = shape.y + shape.height / 2,
      radius = shape.width / 2;

  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']];

  return (0, _RenderUtil.componentsToPath)(circlePath);
}

function getRoundRectPath(shape, borderRadius) {

  var x = shape.x,
      y = shape.y,
      width = shape.width,
      height = shape.height;

  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']];

  return (0, _RenderUtil.componentsToPath)(roundRectPath);
}

function getDiamondPath(shape) {

  var width = shape.width,
      height = shape.height,
      x = shape.x,
      y = shape.y,
      halfWidth = width / 2,
      halfHeight = height / 2;

  var diamondPath = [['M', x + halfWidth, y], ['l', halfWidth, halfHeight], ['l', -halfWidth, halfHeight], ['l', -halfWidth, -halfHeight], ['z']];

  return (0, _RenderUtil.componentsToPath)(diamondPath);
}

function getRectPath(shape) {
  var x = shape.x,
      y = shape.y,
      width = shape.width,
      height = shape.height;

  var rectPath = [['M', x, y], ['l', width, 0], ['l', 0, height], ['l', -width, 0], ['z']];

  return (0, _RenderUtil.componentsToPath)(rectPath);
}

},{"diagram-js/lib/util/RenderUtil":407,"min-dash":505}],119:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = BpmnRenderer;

var _inherits = require('inherits');

var _inherits2 = _interopRequireDefault(_inherits);

var _minDash = require('min-dash');

var _BaseRenderer = require('diagram-js/lib/draw/BaseRenderer');

var _BaseRenderer2 = _interopRequireDefault(_BaseRenderer);

var _DiUtil = require('../util/DiUtil');

var _ModelUtil = require('../util/ModelUtil');

var _RenderUtil = require('diagram-js/lib/util/RenderUtil');

var _BpmnRenderUtil = require('./BpmnRenderUtil');

var _minDom = require('min-dom');

var _tinySvg = require('tiny-svg');

var _SvgTransformUtil = require('diagram-js/lib/util/SvgTransformUtil');

var _ids = require('ids');

var _ids2 = _interopRequireDefault(_ids);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var RENDERER_IDS = new _ids2.default();

var TASK_BORDER_RADIUS = 10;
var INNER_OUTER_DIST = 3;

var DEFAULT_FILL_OPACITY = .95,
    HIGH_FILL_OPACITY = .35;

function BpmnRenderer(config, eventBus, styles, pathMap, canvas, textRenderer, priority) {

  _BaseRenderer2.default.call(this, eventBus, priority);

  var defaultFillColor = config && config.defaultFillColor,
      defaultStrokeColor = config && config.defaultStrokeColor;

  var rendererId = RENDERER_IDS.next();

  var markers = {};

  var computeStyle = styles.computeStyle;

  function addMarker(id, options) {
    var attrs = (0, _minDash.assign)({
      fill: 'black',
      strokeWidth: 1,
      strokeLinecap: 'round',
      strokeDasharray: 'none'
    }, options.attrs);

    var ref = options.ref || { x: 0, y: 0 };

    var scale = options.scale || 1;

    // fix for safari / chrome / firefox bug not correctly
    // resetting stroke dash array
    if (attrs.strokeDasharray === 'none') {
      attrs.strokeDasharray = [10000, 1];
    }

    var marker = (0, _tinySvg.create)('marker');

    (0, _tinySvg.attr)(options.element, attrs);

    (0, _tinySvg.append)(marker, options.element);

    (0, _tinySvg.attr)(marker, {
      id: id,
      viewBox: '0 0 20 20',
      refX: ref.x,
      refY: ref.y,
      markerWidth: 20 * scale,
      markerHeight: 20 * scale,
      orient: 'auto'
    });

    var defs = (0, _minDom.query)('defs', canvas._svg);

    if (!defs) {
      defs = (0, _tinySvg.create)('defs');

      (0, _tinySvg.append)(canvas._svg, defs);
    }

    (0, _tinySvg.append)(defs, marker);

    markers[id] = marker;
  }

  function marker(type, fill, stroke) {
    var id = type + '-' + fill + '-' + stroke + '-' + rendererId;

    if (!markers[id]) {
      createMarker(type, fill, stroke);
    }

    return 'url(#' + id + ')';
  }

  function createMarker(type, fill, stroke) {
    var id = type + '-' + fill + '-' + stroke + '-' + rendererId;

    if (type === 'sequenceflow-end') {
      var sequenceflowEnd = (0, _tinySvg.create)('path');
      (0, _tinySvg.attr)(sequenceflowEnd, { d: 'M 1 5 L 11 10 L 1 15 Z' });

      addMarker(id, {
        element: sequenceflowEnd,
        ref: { x: 11, y: 10 },
        scale: 0.5,
        attrs: {
          fill: stroke,
          stroke: stroke
        }
      });
    }

    if (type === 'messageflow-start') {
      var messageflowStart = (0, _tinySvg.create)('circle');
      (0, _tinySvg.attr)(messageflowStart, { cx: 6, cy: 6, r: 3.5 });

      addMarker(id, {
        element: messageflowStart,
        attrs: {
          fill: fill,
          stroke: stroke
        },
        ref: { x: 6, y: 6 }
      });
    }

    if (type === 'messageflow-end') {
      var messageflowEnd = (0, _tinySvg.create)('path');
      (0, _tinySvg.attr)(messageflowEnd, { d: 'm 1 5 l 0 -3 l 7 3 l -7 3 z' });

      addMarker(id, {
        element: messageflowEnd,
        attrs: {
          fill: fill,
          stroke: stroke,
          strokeLinecap: 'butt'
        },
        ref: { x: 8.5, y: 5 }
      });
    }

    if (type === 'association-start') {
      var associationStart = (0, _tinySvg.create)('path');
      (0, _tinySvg.attr)(associationStart, { d: 'M 11 5 L 1 10 L 11 15' });

      addMarker(id, {
        element: associationStart,
        attrs: {
          fill: 'none',
          stroke: stroke,
          strokeWidth: 1.5
        },
        ref: { x: 1, y: 10 },
        scale: 0.5
      });
    }

    if (type === 'association-end') {
      var associationEnd = (0, _tinySvg.create)('path');
      (0, _tinySvg.attr)(associationEnd, { d: 'M 1 5 L 11 10 L 1 15' });

      addMarker(id, {
        element: associationEnd,
        attrs: {
          fill: 'none',
          stroke: stroke,
          strokeWidth: 1.5
        },
        ref: { x: 12, y: 10 },
        scale: 0.5
      });
    }

    if (type === 'conditional-flow-marker') {
      var conditionalflowMarker = (0, _tinySvg.create)('path');
      (0, _tinySvg.attr)(conditionalflowMarker, { d: 'M 0 10 L 8 6 L 16 10 L 8 14 Z' });

      addMarker(id, {
        element: conditionalflowMarker,
        attrs: {
          fill: fill,
          stroke: stroke
        },
        ref: { x: -1, y: 10 },
        scale: 0.5
      });
    }

    if (type === 'conditional-default-flow-marker') {
      var conditionaldefaultflowMarker = (0, _tinySvg.create)('path');
      (0, _tinySvg.attr)(conditionaldefaultflowMarker, { d: 'M 6 4 L 10 16' });

      addMarker(id, {
        element: conditionaldefaultflowMarker,
        attrs: {
          stroke: stroke
        },
        ref: { x: 0, y: 10 },
        scale: 0.5
      });
    }
  }

  function drawCircle(parentGfx, width, height, offset, attrs) {

    if ((0, _minDash.isObject)(offset)) {
      attrs = offset;
      offset = 0;
    }

    offset = offset || 0;

    attrs = computeStyle(attrs, {
      stroke: 'black',
      strokeWidth: 2,
      fill: 'white'
    });

    if (attrs.fill === 'none') {
      delete attrs.fillOpacity;
    }

    var cx = width / 2,
        cy = height / 2;

    var circle = (0, _tinySvg.create)('circle');
    (0, _tinySvg.attr)(circle, {
      cx: cx,
      cy: cy,
      r: Math.round((width + height) / 4 - offset)
    });
    (0, _tinySvg.attr)(circle, attrs);

    (0, _tinySvg.append)(parentGfx, circle);

    return circle;
  }

  function drawRect(parentGfx, width, height, r, offset, attrs) {

    if ((0, _minDash.isObject)(offset)) {
      attrs = offset;
      offset = 0;
    }

    offset = offset || 0;

    attrs = computeStyle(attrs, {
      stroke: 'black',
      strokeWidth: 2,
      fill: 'white'
    });

    var rect = (0, _tinySvg.create)('rect');
    (0, _tinySvg.attr)(rect, {
      x: offset,
      y: offset,
      width: width - offset * 2,
      height: height - offset * 2,
      rx: r,
      ry: r
    });
    (0, _tinySvg.attr)(rect, attrs);

    (0, _tinySvg.append)(parentGfx, rect);

    return rect;
  }

  function drawDiamond(parentGfx, width, height, attrs) {

    var x_2 = width / 2;
    var y_2 = height / 2;

    var points = [{ x: x_2, y: 0 }, { x: width, y: y_2 }, { x: x_2, y: height }, { x: 0, y: y_2 }];

    var pointsString = points.map(function (point) {
      return point.x + ',' + point.y;
    }).join(' ');

    attrs = computeStyle(attrs, {
      stroke: 'black',
      strokeWidth: 2,
      fill: 'white'
    });

    var polygon = (0, _tinySvg.create)('polygon');
    (0, _tinySvg.attr)(polygon, {
      points: pointsString
    });
    (0, _tinySvg.attr)(polygon, attrs);

    (0, _tinySvg.append)(parentGfx, polygon);

    return polygon;
  }

  function drawLine(parentGfx, waypoints, attrs) {
    attrs = computeStyle(attrs, ['no-fill'], {
      stroke: 'black',
      strokeWidth: 2,
      fill: 'none'
    });

    var line = (0, _RenderUtil.createLine)(waypoints, attrs);

    (0, _tinySvg.append)(parentGfx, line);

    return line;
  }

  function drawPath(parentGfx, d, attrs) {

    attrs = computeStyle(attrs, ['no-fill'], {
      strokeWidth: 2,
      stroke: 'black'
    });

    var path = (0, _tinySvg.create)('path');
    (0, _tinySvg.attr)(path, { d: d });
    (0, _tinySvg.attr)(path, attrs);

    (0, _tinySvg.append)(parentGfx, path);

    return path;
  }

  function drawMarker(type, parentGfx, path, attrs) {
    return drawPath(parentGfx, path, (0, _minDash.assign)({ 'data-marker': type }, attrs));
  }

  function as(type) {
    return function (parentGfx, element) {
      return handlers[type](parentGfx, element);
    };
  }

  function renderer(type) {
    return handlers[type];
  }

  function renderEventContent(element, parentGfx) {

    var event = (0, _BpmnRenderUtil.getSemantic)(element);
    var isThrowing = (0, _BpmnRenderUtil.isThrowEvent)(event);

    if ((0, _BpmnRenderUtil.isTypedEvent)(event, 'bpmn:MessageEventDefinition')) {
      return renderer('bpmn:MessageEventDefinition')(parentGfx, element, isThrowing);
    }

    if ((0, _BpmnRenderUtil.isTypedEvent)(event, 'bpmn:TimerEventDefinition')) {
      return renderer('bpmn:TimerEventDefinition')(parentGfx, element, isThrowing);
    }

    if ((0, _BpmnRenderUtil.isTypedEvent)(event, 'bpmn:ConditionalEventDefinition')) {
      return renderer('bpmn:ConditionalEventDefinition')(parentGfx, element);
    }

    if ((0, _BpmnRenderUtil.isTypedEvent)(event, 'bpmn:SignalEventDefinition')) {
      return renderer('bpmn:SignalEventDefinition')(parentGfx, element, isThrowing);
    }

    if ((0, _BpmnRenderUtil.isTypedEvent)(event, 'bpmn:CancelEventDefinition') && (0, _BpmnRenderUtil.isTypedEvent)(event, 'bpmn:TerminateEventDefinition', { parallelMultiple: false })) {
      return renderer('bpmn:MultipleEventDefinition')(parentGfx, element, isThrowing);
    }

    if ((0, _BpmnRenderUtil.isTypedEvent)(event, 'bpmn:CancelEventDefinition') && (0, _BpmnRenderUtil.isTypedEvent)(event, 'bpmn:TerminateEventDefinition', { parallelMultiple: true })) {
      return renderer('bpmn:ParallelMultipleEventDefinition')(parentGfx, element, isThrowing);
    }

    if ((0, _BpmnRenderUtil.isTypedEvent)(event, 'bpmn:EscalationEventDefinition')) {
      return renderer('bpmn:EscalationEventDefinition')(parentGfx, element, isThrowing);
    }

    if ((0, _BpmnRenderUtil.isTypedEvent)(event, 'bpmn:LinkEventDefinition')) {
      return renderer('bpmn:LinkEventDefinition')(parentGfx, element, isThrowing);
    }

    if ((0, _BpmnRenderUtil.isTypedEvent)(event, 'bpmn:ErrorEventDefinition')) {
      return renderer('bpmn:ErrorEventDefinition')(parentGfx, element, isThrowing);
    }

    if ((0, _BpmnRenderUtil.isTypedEvent)(event, 'bpmn:CancelEventDefinition')) {
      return renderer('bpmn:CancelEventDefinition')(parentGfx, element, isThrowing);
    }

    if ((0, _BpmnRenderUtil.isTypedEvent)(event, 'bpmn:CompensateEventDefinition')) {
      return renderer('bpmn:CompensateEventDefinition')(parentGfx, element, isThrowing);
    }

    if ((0, _BpmnRenderUtil.isTypedEvent)(event, 'bpmn:TerminateEventDefinition')) {
      return renderer('bpmn:TerminateEventDefinition')(parentGfx, element, isThrowing);
    }

    return null;
  }

  function renderLabel(parentGfx, label, options) {

    options = (0, _minDash.assign)({
      size: {
        width: 100
      }
    }, options);

    var text = textRenderer.createText(label || '', options);

    (0, _tinySvg.classes)(text).add('djs-label');

    (0, _tinySvg.append)(parentGfx, text);

    return text;
  }

  function renderEmbeddedLabel(parentGfx, element, align) {
    var semantic = (0, _BpmnRenderUtil.getSemantic)(element);

    return renderLabel(parentGfx, semantic.name, {
      box: element,
      align: align,
      padding: 5,
      style: {
        fill: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
      }
    });
  }

  function renderExternalLabel(parentGfx, element) {
    var semantic = (0, _BpmnRenderUtil.getSemantic)(element);
    var box = {
      width: 90,
      height: 30,
      x: element.width / 2 + element.x,
      y: element.height / 2 + element.y
    };

    return renderLabel(parentGfx, semantic.name, {
      box: box,
      fitBox: true,
      style: (0, _minDash.assign)({}, textRenderer.getExternalStyle(), {
        fill: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
      })
    });
  }

  function renderLaneLabel(parentGfx, text, element) {
    var textBox = renderLabel(parentGfx, text, {
      box: {
        height: 30,
        width: element.height
      },
      align: 'center-middle',
      style: {
        fill: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
      }
    });

    var top = -1 * element.height;

    (0, _SvgTransformUtil.transform)(textBox, 0, -top, 270);
  }

  function createPathFromConnection(connection) {
    var waypoints = connection.waypoints;

    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;
  }

  var handlers = this.handlers = {
    'bpmn:Event': function bpmnEvent(parentGfx, element, attrs) {

      if (!('fillOpacity' in attrs)) {
        attrs.fillOpacity = DEFAULT_FILL_OPACITY;
      }

      return drawCircle(parentGfx, element.width, element.height, attrs);
    },
    'bpmn:StartEvent': function bpmnStartEvent(parentGfx, element) {
      var attrs = {
        fill: (0, _BpmnRenderUtil.getFillColor)(element, defaultFillColor),
        stroke: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
      };

      var semantic = (0, _BpmnRenderUtil.getSemantic)(element);

      if (!semantic.isInterrupting) {
        attrs = {
          strokeDasharray: '6',
          strokeLinecap: 'round',
          fill: (0, _BpmnRenderUtil.getFillColor)(element, defaultFillColor),
          stroke: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
        };
      }

      var circle = renderer('bpmn:Event')(parentGfx, element, attrs);

      renderEventContent(element, parentGfx);

      return circle;
    },
    'bpmn:MessageEventDefinition': function bpmnMessageEventDefinition(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
        }
      });

      var fill = isThrowing ? (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor) : (0, _BpmnRenderUtil.getFillColor)(element, defaultFillColor);
      var stroke = isThrowing ? (0, _BpmnRenderUtil.getFillColor)(element, defaultFillColor) : (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor);

      var messagePath = drawPath(parentGfx, pathData, {
        strokeWidth: 1,
        fill: fill,
        stroke: stroke
      });

      return messagePath;
    },
    'bpmn:TimerEventDefinition': function bpmnTimerEventDefinition(parentGfx, element) {
      var circle = drawCircle(parentGfx, element.width, element.height, 0.2 * element.height, {
        strokeWidth: 2,
        fill: (0, _BpmnRenderUtil.getFillColor)(element, defaultFillColor),
        stroke: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
      });

      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
        }
      });

      drawPath(parentGfx, pathData, {
        strokeWidth: 2,
        strokeLinecap: 'square',
        stroke: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
      });

      for (var i = 0; i < 12; i++) {

        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
          }
        });

        var width = element.width / 2;
        var height = element.height / 2;

        drawPath(parentGfx, linePathData, {
          strokeWidth: 1,
          strokeLinecap: 'square',
          transform: 'rotate(' + i * 30 + ',' + height + ',' + width + ')',
          stroke: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
        });
      }

      return circle;
    },
    'bpmn:EscalationEventDefinition': function bpmnEscalationEventDefinition(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
        }
      });

      var fill = isThrowing ? (0, _BpmnRenderUtil.getStrokeColor)(event, defaultStrokeColor) : 'none';

      return drawPath(parentGfx, pathData, {
        strokeWidth: 1,
        fill: fill,
        stroke: (0, _BpmnRenderUtil.getStrokeColor)(event, defaultStrokeColor)
      });
    },
    'bpmn:ConditionalEventDefinition': function bpmnConditionalEventDefinition(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
        }
      });

      return drawPath(parentGfx, pathData, {
        strokeWidth: 1,
        stroke: (0, _BpmnRenderUtil.getStrokeColor)(event, defaultStrokeColor)
      });
    },
    'bpmn:LinkEventDefinition': function bpmnLinkEventDefinition(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
        }
      });

      var fill = isThrowing ? (0, _BpmnRenderUtil.getStrokeColor)(event, defaultStrokeColor) : 'none';

      return drawPath(parentGfx, pathData, {
        strokeWidth: 1,
        fill: fill,
        stroke: (0, _BpmnRenderUtil.getStrokeColor)(event, defaultStrokeColor)
      });
    },
    'bpmn:ErrorEventDefinition': function bpmnErrorEventDefinition(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
        }
      });

      var fill = isThrowing ? (0, _BpmnRenderUtil.getStrokeColor)(event, defaultStrokeColor) : 'none';

      return drawPath(parentGfx, pathData, {
        strokeWidth: 1,
        fill: fill,
        stroke: (0, _BpmnRenderUtil.getStrokeColor)(event, defaultStrokeColor)
      });
    },
    'bpmn:CancelEventDefinition': function bpmnCancelEventDefinition(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
        }
      });

      var fill = isThrowing ? (0, _BpmnRenderUtil.getStrokeColor)(event, defaultStrokeColor) : 'none';

      var path = drawPath(parentGfx, pathData, {
        strokeWidth: 1,
        fill: fill,
        stroke: (0, _BpmnRenderUtil.getStrokeColor)(event, defaultStrokeColor)
      });

      (0, _SvgTransformUtil.rotate)(path, 45);

      return path;
    },
    'bpmn:CompensateEventDefinition': function bpmnCompensateEventDefinition(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
        }
      });

      var fill = isThrowing ? (0, _BpmnRenderUtil.getStrokeColor)(event, defaultStrokeColor) : 'none';

      return drawPath(parentGfx, pathData, {
        strokeWidth: 1,
        fill: fill,
        stroke: (0, _BpmnRenderUtil.getStrokeColor)(event, defaultStrokeColor)
      });
    },
    'bpmn:SignalEventDefinition': function bpmnSignalEventDefinition(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
        }
      });

      var fill = isThrowing ? (0, _BpmnRenderUtil.getStrokeColor)(event, defaultStrokeColor) : 'none';

      return drawPath(parentGfx, pathData, {
        strokeWidth: 1,
        fill: fill,
        stroke: (0, _BpmnRenderUtil.getStrokeColor)(event, defaultStrokeColor)
      });
    },
    'bpmn:MultipleEventDefinition': function bpmnMultipleEventDefinition(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
        }
      });

      var fill = isThrowing ? (0, _BpmnRenderUtil.getStrokeColor)(event, defaultStrokeColor) : 'none';

      return drawPath(parentGfx, pathData, {
        strokeWidth: 1,
        fill: fill
      });
    },
    'bpmn:ParallelMultipleEventDefinition': function bpmnParallelMultipleEventDefinition(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
        }
      });

      return drawPath(parentGfx, pathData, {
        strokeWidth: 1,
        fill: (0, _BpmnRenderUtil.getStrokeColor)(event, defaultStrokeColor),
        stroke: (0, _BpmnRenderUtil.getStrokeColor)(event, defaultStrokeColor)
      });
    },
    'bpmn:EndEvent': function bpmnEndEvent(parentGfx, element) {
      var circle = renderer('bpmn:Event')(parentGfx, element, {
        strokeWidth: 4,
        fill: (0, _BpmnRenderUtil.getFillColor)(element, defaultFillColor),
        stroke: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
      });

      renderEventContent(element, parentGfx, true);

      return circle;
    },
    'bpmn:TerminateEventDefinition': function bpmnTerminateEventDefinition(parentGfx, element) {
      var circle = drawCircle(parentGfx, element.width, element.height, 8, {
        strokeWidth: 4,
        fill: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor),
        stroke: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
      });

      return circle;
    },
    'bpmn:IntermediateEvent': function bpmnIntermediateEvent(parentGfx, element) {
      var outer = renderer('bpmn:Event')(parentGfx, element, {
        strokeWidth: 1,
        fill: (0, _BpmnRenderUtil.getFillColor)(element, defaultFillColor),
        stroke: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
      });

      /* inner */
      drawCircle(parentGfx, element.width, element.height, INNER_OUTER_DIST, {
        strokeWidth: 1,
        fill: (0, _BpmnRenderUtil.getFillColor)(element, 'none'),
        stroke: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
      });

      renderEventContent(element, parentGfx);

      return outer;
    },
    'bpmn:IntermediateCatchEvent': as('bpmn:IntermediateEvent'),
    'bpmn:IntermediateThrowEvent': as('bpmn:IntermediateEvent'),

    'bpmn:Activity': function bpmnActivity(parentGfx, element, attrs) {

      attrs = attrs || {};

      if (!('fillOpacity' in attrs)) {
        attrs.fillOpacity = DEFAULT_FILL_OPACITY;
      }

      return drawRect(parentGfx, element.width, element.height, TASK_BORDER_RADIUS, attrs);
    },

    'bpmn:Task': function bpmnTask(parentGfx, element) {
      var attrs = {
        fill: (0, _BpmnRenderUtil.getFillColor)(element, defaultFillColor),
        stroke: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
      };

      var rect = renderer('bpmn:Activity')(parentGfx, element, attrs);

      renderEmbeddedLabel(parentGfx, element, 'center-middle');
      attachTaskMarkers(parentGfx, element);

      return rect;
    },
    'bpmn:ServiceTask': function bpmnServiceTask(parentGfx, element) {
      var task = renderer('bpmn:Task')(parentGfx, element);

      var pathDataBG = pathMap.getScaledPath('TASK_TYPE_SERVICE', {
        abspos: {
          x: 12,
          y: 18
        }
      });

      /* service bg */drawPath(parentGfx, pathDataBG, {
        strokeWidth: 1,
        fill: (0, _BpmnRenderUtil.getFillColor)(element, defaultFillColor),
        stroke: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
      });

      var fillPathData = pathMap.getScaledPath('TASK_TYPE_SERVICE_FILL', {
        abspos: {
          x: 17.2,
          y: 18
        }
      });

      /* service fill */drawPath(parentGfx, fillPathData, {
        strokeWidth: 0,
        fill: (0, _BpmnRenderUtil.getFillColor)(element, defaultFillColor)
      });

      var pathData = pathMap.getScaledPath('TASK_TYPE_SERVICE', {
        abspos: {
          x: 17,
          y: 22
        }
      });

      /* service */drawPath(parentGfx, pathData, {
        strokeWidth: 1,
        fill: (0, _BpmnRenderUtil.getFillColor)(element, defaultFillColor),
        stroke: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
      });

      return task;
    },
    'bpmn:UserTask': function bpmnUserTask(parentGfx, element) {
      var task = renderer('bpmn:Task')(parentGfx, element);

      var x = 15;
      var y = 12;

      var pathData = pathMap.getScaledPath('TASK_TYPE_USER_1', {
        abspos: {
          x: x,
          y: y
        }
      });

      /* user path */drawPath(parentGfx, pathData, {
        strokeWidth: 0.5,
        fill: (0, _BpmnRenderUtil.getFillColor)(element, defaultFillColor),
        stroke: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
      });

      var pathData2 = pathMap.getScaledPath('TASK_TYPE_USER_2', {
        abspos: {
          x: x,
          y: y
        }
      });

      /* user2 path */drawPath(parentGfx, pathData2, {
        strokeWidth: 0.5,
        fill: (0, _BpmnRenderUtil.getFillColor)(element, defaultFillColor),
        stroke: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
      });

      var pathData3 = pathMap.getScaledPath('TASK_TYPE_USER_3', {
        abspos: {
          x: x,
          y: y
        }
      });

      /* user3 path */drawPath(parentGfx, pathData3, {
        strokeWidth: 0.5,
        fill: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor),
        stroke: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
      });

      return task;
    },
    'bpmn:ManualTask': function bpmnManualTask(parentGfx, element) {
      var task = renderer('bpmn:Task')(parentGfx, element);

      var pathData = pathMap.getScaledPath('TASK_TYPE_MANUAL', {
        abspos: {
          x: 17,
          y: 15
        }
      });

      /* manual path */drawPath(parentGfx, pathData, {
        strokeWidth: 0.5, // 0.25,
        fill: (0, _BpmnRenderUtil.getFillColor)(element, defaultFillColor),
        stroke: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
      });

      return task;
    },
    'bpmn:SendTask': function bpmnSendTask(parentGfx, element) {
      var task = renderer('bpmn:Task')(parentGfx, element);

      var pathData = pathMap.getScaledPath('TASK_TYPE_SEND', {
        xScaleFactor: 1,
        yScaleFactor: 1,
        containerWidth: 21,
        containerHeight: 14,
        position: {
          mx: 0.285,
          my: 0.357
        }
      });

      /* send path */drawPath(parentGfx, pathData, {
        strokeWidth: 1,
        fill: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor),
        stroke: (0, _BpmnRenderUtil.getFillColor)(element, defaultFillColor)
      });

      return task;
    },
    'bpmn:ReceiveTask': function bpmnReceiveTask(parentGfx, element) {
      var semantic = (0, _BpmnRenderUtil.getSemantic)(element);

      var task = renderer('bpmn:Task')(parentGfx, element);
      var pathData;

      if (semantic.instantiate) {
        drawCircle(parentGfx, 28, 28, 20 * 0.22, { strokeWidth: 1 });

        pathData = pathMap.getScaledPath('TASK_TYPE_INSTANTIATING_SEND', {
          abspos: {
            x: 7.77,
            y: 9.52
          }
        });
      } else {

        pathData = pathMap.getScaledPath('TASK_TYPE_SEND', {
          xScaleFactor: 0.9,
          yScaleFactor: 0.9,
          containerWidth: 21,
          containerHeight: 14,
          position: {
            mx: 0.3,
            my: 0.4
          }
        });
      }

      /* receive path */drawPath(parentGfx, pathData, {
        strokeWidth: 1,
        fill: (0, _BpmnRenderUtil.getFillColor)(element, defaultFillColor),
        stroke: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
      });

      return task;
    },
    'bpmn:ScriptTask': function bpmnScriptTask(parentGfx, element) {
      var task = renderer('bpmn:Task')(parentGfx, element);

      var pathData = pathMap.getScaledPath('TASK_TYPE_SCRIPT', {
        abspos: {
          x: 15,
          y: 20
        }
      });

      /* script path */drawPath(parentGfx, pathData, {
        strokeWidth: 1,
        stroke: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
      });

      return task;
    },
    'bpmn:BusinessRuleTask': function bpmnBusinessRuleTask(parentGfx, element) {
      var task = renderer('bpmn:Task')(parentGfx, element);

      var headerPathData = pathMap.getScaledPath('TASK_TYPE_BUSINESS_RULE_HEADER', {
        abspos: {
          x: 8,
          y: 8
        }
      });

      var businessHeaderPath = drawPath(parentGfx, headerPathData);
      (0, _tinySvg.attr)(businessHeaderPath, {
        strokeWidth: 1,
        fill: (0, _BpmnRenderUtil.getFillColor)(element, '#aaaaaa'),
        stroke: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
      });

      var headerData = pathMap.getScaledPath('TASK_TYPE_BUSINESS_RULE_MAIN', {
        abspos: {
          x: 8,
          y: 8
        }
      });

      var businessPath = drawPath(parentGfx, headerData);
      (0, _tinySvg.attr)(businessPath, {
        strokeWidth: 1,
        stroke: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
      });

      return task;
    },
    'bpmn:SubProcess': function bpmnSubProcess(parentGfx, element, attrs) {
      attrs = (0, _minDash.assign)({
        fill: (0, _BpmnRenderUtil.getFillColor)(element, defaultFillColor),
        stroke: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
      }, attrs);

      var rect = renderer('bpmn:Activity')(parentGfx, element, attrs);

      var expanded = (0, _DiUtil.isExpanded)(element);

      if ((0, _DiUtil.isEventSubProcess)(element)) {
        (0, _tinySvg.attr)(rect, {
          strokeDasharray: '1,2'
        });
      }

      renderEmbeddedLabel(parentGfx, element, expanded ? 'center-top' : 'center-middle');

      if (expanded) {
        attachTaskMarkers(parentGfx, element);
      } else {
        attachTaskMarkers(parentGfx, element, ['SubProcessMarker']);
      }

      return rect;
    },
    'bpmn:AdHocSubProcess': function bpmnAdHocSubProcess(parentGfx, element) {
      return renderer('bpmn:SubProcess')(parentGfx, element);
    },
    'bpmn:Transaction': function bpmnTransaction(parentGfx, element) {
      var outer = renderer('bpmn:SubProcess')(parentGfx, element);

      var innerAttrs = styles.style(['no-fill', 'no-events'], {
        stroke: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
      });

      /* inner path */drawRect(parentGfx, element.width, element.height, TASK_BORDER_RADIUS - 2, INNER_OUTER_DIST, innerAttrs);

      return outer;
    },
    'bpmn:CallActivity': function bpmnCallActivity(parentGfx, element) {
      return renderer('bpmn:SubProcess')(parentGfx, element, {
        strokeWidth: 5
      });
    },
    'bpmn:Participant': function bpmnParticipant(parentGfx, element) {

      var attrs = {
        fillOpacity: DEFAULT_FILL_OPACITY,
        fill: (0, _BpmnRenderUtil.getFillColor)(element, defaultFillColor),
        stroke: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
      };

      var lane = renderer('bpmn:Lane')(parentGfx, element, attrs);

      var expandedPool = (0, _DiUtil.isExpanded)(element);

      if (expandedPool) {
        drawLine(parentGfx, [{ x: 30, y: 0 }, { x: 30, y: element.height }], {
          stroke: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
        });
        var text = (0, _BpmnRenderUtil.getSemantic)(element).name;
        renderLaneLabel(parentGfx, text, element);
      } else {
        // Collapsed pool draw text inline
        var text2 = (0, _BpmnRenderUtil.getSemantic)(element).name;
        renderLabel(parentGfx, text2, {
          box: element, align: 'center-middle',
          style: {
            fill: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
          }
        });
      }

      var participantMultiplicity = !!(0, _BpmnRenderUtil.getSemantic)(element).participantMultiplicity;

      if (participantMultiplicity) {
        renderer('ParticipantMultiplicityMarker')(parentGfx, element);
      }

      return lane;
    },
    'bpmn:Lane': function bpmnLane(parentGfx, element, attrs) {
      var rect = drawRect(parentGfx, element.width, element.height, 0, (0, _minDash.assign)({
        fill: (0, _BpmnRenderUtil.getFillColor)(element, defaultFillColor),
        fillOpacity: HIGH_FILL_OPACITY,
        stroke: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
      }, attrs));

      var semantic = (0, _BpmnRenderUtil.getSemantic)(element);

      if (semantic.$type === 'bpmn:Lane') {
        var text = semantic.name;
        renderLaneLabel(parentGfx, text, element);
      }

      return rect;
    },
    'bpmn:InclusiveGateway': function bpmnInclusiveGateway(parentGfx, element) {
      var diamond = renderer('bpmn:Gateway')(parentGfx, element);

      /* circle path */
      drawCircle(parentGfx, element.width, element.height, element.height * 0.24, {
        strokeWidth: 2.5,
        fill: (0, _BpmnRenderUtil.getFillColor)(element, defaultFillColor),
        stroke: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
      });

      return diamond;
    },
    'bpmn:ExclusiveGateway': function bpmnExclusiveGateway(parentGfx, element) {
      var diamond = renderer('bpmn:Gateway')(parentGfx, element);

      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
        }
      });

      if ((0, _BpmnRenderUtil.getDi)(element).isMarkerVisible) {
        drawPath(parentGfx, pathData, {
          strokeWidth: 1,
          fill: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor),
          stroke: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
        });
      }

      return diamond;
    },
    'bpmn:ComplexGateway': function bpmnComplexGateway(parentGfx, element) {
      var diamond = renderer('bpmn:Gateway')(parentGfx, element);

      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
        }
      });

      /* complex path */drawPath(parentGfx, pathData, {
        strokeWidth: 1,
        fill: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor),
        stroke: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
      });

      return diamond;
    },
    'bpmn:ParallelGateway': function bpmnParallelGateway(parentGfx, element) {
      var diamond = renderer('bpmn:Gateway')(parentGfx, element);

      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
        }
      });

      /* parallel path */drawPath(parentGfx, pathData, {
        strokeWidth: 1,
        fill: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor),
        stroke: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
      });

      return diamond;
    },
    'bpmn:EventBasedGateway': function bpmnEventBasedGateway(parentGfx, element) {

      var semantic = (0, _BpmnRenderUtil.getSemantic)(element);

      var diamond = renderer('bpmn:Gateway')(parentGfx, element);

      /* outer circle path */drawCircle(parentGfx, element.width, element.height, element.height * 0.20, {
        strokeWidth: 1,
        fill: 'none',
        stroke: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
      });

      var type = semantic.eventGatewayType;
      var instantiate = !!semantic.instantiate;

      function drawEvent() {

        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
          }
        });

        var attrs = {
          strokeWidth: 2,
          fill: (0, _BpmnRenderUtil.getFillColor)(element, 'none'),
          stroke: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
        };

        /* event path */drawPath(parentGfx, pathData, attrs);
      }

      if (type === 'Parallel') {

        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
          }
        });

        var parallelPath = drawPath(parentGfx, pathData);
        (0, _tinySvg.attr)(parallelPath, {
          strokeWidth: 1,
          fill: 'none'
        });
      } else if (type === 'Exclusive') {

        if (!instantiate) {
          var innerCircle = drawCircle(parentGfx, element.width, element.height, element.height * 0.26);
          (0, _tinySvg.attr)(innerCircle, {
            strokeWidth: 1,
            fill: 'none',
            stroke: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
          });
        }

        drawEvent();
      }

      return diamond;
    },
    'bpmn:Gateway': function bpmnGateway(parentGfx, element) {
      var attrs = {
        fill: (0, _BpmnRenderUtil.getFillColor)(element, defaultFillColor),
        fillOpacity: DEFAULT_FILL_OPACITY,
        stroke: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
      };

      return drawDiamond(parentGfx, element.width, element.height, attrs);
    },
    'bpmn:SequenceFlow': function bpmnSequenceFlow(parentGfx, element) {
      var pathData = createPathFromConnection(element);

      var fill = (0, _BpmnRenderUtil.getFillColor)(element, defaultFillColor),
          stroke = (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor);

      var attrs = {
        strokeLinejoin: 'round',
        markerEnd: marker('sequenceflow-end', fill, stroke),
        stroke: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
      };

      var path = drawPath(parentGfx, pathData, attrs);

      var sequenceFlow = (0, _BpmnRenderUtil.getSemantic)(element);

      var source;

      if (element.source) {
        source = element.source.businessObject;

        // conditional flow marker
        if (sequenceFlow.conditionExpression && source.$instanceOf('bpmn:Activity')) {
          (0, _tinySvg.attr)(path, {
            markerStart: marker('conditional-flow-marker', fill, stroke)
          });
        }

        // default marker
        if (source.default && (source.$instanceOf('bpmn:Gateway') || source.$instanceOf('bpmn:Activity')) && source.default === sequenceFlow) {
          (0, _tinySvg.attr)(path, {
            markerStart: marker('conditional-default-flow-marker', fill, stroke)
          });
        }
      }

      return path;
    },
    'bpmn:Association': function bpmnAssociation(parentGfx, element, attrs) {

      var semantic = (0, _BpmnRenderUtil.getSemantic)(element);

      var fill = (0, _BpmnRenderUtil.getFillColor)(element, defaultFillColor),
          stroke = (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor);

      attrs = (0, _minDash.assign)({
        strokeDasharray: '0.5, 5',
        strokeLinecap: 'round',
        strokeLinejoin: 'round',
        stroke: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
      }, attrs || {});

      if (semantic.associationDirection === 'One' || semantic.associationDirection === 'Both') {
        attrs.markerEnd = marker('association-end', fill, stroke);
      }

      if (semantic.associationDirection === 'Both') {
        attrs.markerStart = marker('association-start', fill, stroke);
      }

      return drawLine(parentGfx, element.waypoints, attrs);
    },
    'bpmn:DataInputAssociation': function bpmnDataInputAssociation(parentGfx, element) {
      var fill = (0, _BpmnRenderUtil.getFillColor)(element, defaultFillColor),
          stroke = (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor);

      return renderer('bpmn:Association')(parentGfx, element, {
        markerEnd: marker('association-end', fill, stroke)
      });
    },
    'bpmn:DataOutputAssociation': function bpmnDataOutputAssociation(parentGfx, element) {
      var fill = (0, _BpmnRenderUtil.getFillColor)(element, defaultFillColor),
          stroke = (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor);

      return renderer('bpmn:Association')(parentGfx, element, {
        markerEnd: marker('association-end', fill, stroke)
      });
    },
    'bpmn:MessageFlow': function bpmnMessageFlow(parentGfx, element) {

      var semantic = (0, _BpmnRenderUtil.getSemantic)(element),
          di = (0, _BpmnRenderUtil.getDi)(element);

      var fill = (0, _BpmnRenderUtil.getFillColor)(element, defaultFillColor),
          stroke = (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor);

      var pathData = createPathFromConnection(element);

      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: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
      };

      var path = drawPath(parentGfx, pathData, attrs);

      if (semantic.messageRef) {
        var midPoint = path.getPointAtLength(path.getTotalLength() / 2);

        var markerPathData = pathMap.getScaledPath('MESSAGE_FLOW_MARKER', {
          abspos: {
            x: midPoint.x,
            y: midPoint.y
          }
        });

        var messageAttrs = { strokeWidth: 1 };

        if (di.messageVisibleKind === 'initiating') {
          messageAttrs.fill = 'white';
          messageAttrs.stroke = 'black';
        } else {
          messageAttrs.fill = '#888';
          messageAttrs.stroke = 'white';
        }

        drawPath(parentGfx, markerPathData, messageAttrs);
      }

      return path;
    },
    'bpmn:DataObject': function bpmnDataObject(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
        }
      });

      var elementObject = drawPath(parentGfx, pathData, {
        fill: (0, _BpmnRenderUtil.getFillColor)(element, defaultFillColor),
        fillOpacity: DEFAULT_FILL_OPACITY,
        stroke: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
      });

      var semantic = (0, _BpmnRenderUtil.getSemantic)(element);

      if ((0, _BpmnRenderUtil.isCollection)(semantic)) {
        renderDataItemCollection(parentGfx, element);
      }

      return elementObject;
    },
    'bpmn:DataObjectReference': as('bpmn:DataObject'),
    'bpmn:DataInput': function bpmnDataInput(parentGfx, element) {

      var arrowPathData = pathMap.getRawPath('DATA_ARROW');

      // page
      var elementObject = renderer('bpmn:DataObject')(parentGfx, element);

      /* input arrow path */drawPath(parentGfx, arrowPathData, { strokeWidth: 1 });

      return elementObject;
    },
    'bpmn:DataOutput': function bpmnDataOutput(parentGfx, element) {
      var arrowPathData = pathMap.getRawPath('DATA_ARROW');

      // page
      var elementObject = renderer('bpmn:DataObject')(parentGfx, element);

      /* output arrow path */drawPath(parentGfx, arrowPathData, {
        strokeWidth: 1,
        fill: 'black'
      });

      return elementObject;
    },
    'bpmn:DataStoreReference': function bpmnDataStoreReference(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
        }
      });

      var elementStore = drawPath(parentGfx, DATA_STORE_PATH, {
        strokeWidth: 2,
        fill: (0, _BpmnRenderUtil.getFillColor)(element, defaultFillColor),
        fillOpacity: DEFAULT_FILL_OPACITY,
        stroke: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
      });

      return elementStore;
    },
    'bpmn:BoundaryEvent': function bpmnBoundaryEvent(parentGfx, element) {

      var semantic = (0, _BpmnRenderUtil.getSemantic)(element),
          cancel = semantic.cancelActivity;

      var attrs = {
        strokeWidth: 1,
        fill: (0, _BpmnRenderUtil.getFillColor)(element, defaultFillColor),
        stroke: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
      };

      if (!cancel) {
        attrs.strokeDasharray = '6';
        attrs.strokeLinecap = 'round';
      }

      // apply fillOpacity
      var outerAttrs = (0, _minDash.assign)({}, attrs, {
        fillOpacity: 1
      });

      // apply no-fill
      var innerAttrs = (0, _minDash.assign)({}, attrs, {
        fill: 'none'
      });

      var outer = renderer('bpmn:Event')(parentGfx, element, outerAttrs);

      /* inner path */drawCircle(parentGfx, element.width, element.height, INNER_OUTER_DIST, innerAttrs);

      renderEventContent(element, parentGfx);

      return outer;
    },
    'bpmn:Group': function bpmnGroup(parentGfx, element) {
      var semantic = (0, _BpmnRenderUtil.getSemantic)(element),
          di = (0, _BpmnRenderUtil.getDi)(element);

      var group = drawRect(parentGfx, element.width, element.height, TASK_BORDER_RADIUS, {
        strokeWidth: 1,
        strokeDasharray: '8,3,1,3',
        fill: 'none',
        pointerEvents: 'none'
      });

      var categoryValueRef = semantic.categoryValueRef || {};

      if (categoryValueRef.value) {
        var box = di.label ? di.label.bounds : element;

        renderLabel(parentGfx, categoryValueRef.value, {
          box: box,
          style: {
            fill: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
          }
        });
      }

      return group;
    },
    'label': function label(parentGfx, element) {
      return renderExternalLabel(parentGfx, element);
    },
    'bpmn:TextAnnotation': function bpmnTextAnnotation(parentGfx, element) {
      var style = {
        'fill': 'none',
        'stroke': 'none'
      };

      var textElement = drawRect(parentGfx, element.width, element.height, 0, 0, style);

      var textPathData = pathMap.getScaledPath('TEXT_ANNOTATION', {
        xScaleFactor: 1,
        yScaleFactor: 1,
        containerWidth: element.width,
        containerHeight: element.height,
        position: {
          mx: 0.0,
          my: 0.0
        }
      });

      drawPath(parentGfx, textPathData, {
        stroke: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
      });

      var text = (0, _BpmnRenderUtil.getSemantic)(element).text || '';
      renderLabel(parentGfx, text, {
        box: element,
        align: 'left-top',
        padding: 5,
        style: {
          fill: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
        }
      });

      return textElement;
    },
    'ParticipantMultiplicityMarker': function ParticipantMultiplicityMarker(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
        }
      });

      drawMarker('participant-multiplicity', parentGfx, markerPath, {
        strokeWidth: 1,
        fill: (0, _BpmnRenderUtil.getFillColor)(element, defaultFillColor),
        stroke: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
      });
    },
    'SubProcessMarker': function SubProcessMarker(parentGfx, element) {
      var markerRect = drawRect(parentGfx, 14, 14, 0, {
        strokeWidth: 1,
        fill: (0, _BpmnRenderUtil.getFillColor)(element, defaultFillColor),
        stroke: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
      });

      // Process marker is placed in the middle of the box
      // therefore fixed values can be used here
      (0, _SvgTransformUtil.translate)(markerRect, element.width / 2 - 7.5, element.height - 20);

      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
        }
      });

      drawMarker('sub-process', parentGfx, markerPath, {
        fill: (0, _BpmnRenderUtil.getFillColor)(element, defaultFillColor),
        stroke: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
      });
    },
    'ParallelMarker': function ParallelMarker(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
        }
      });

      drawMarker('parallel', parentGfx, markerPath, {
        fill: (0, _BpmnRenderUtil.getFillColor)(element, defaultFillColor),
        stroke: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
      });
    },
    'SequentialMarker': function SequentialMarker(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
        }
      });

      drawMarker('sequential', parentGfx, markerPath, {
        fill: (0, _BpmnRenderUtil.getFillColor)(element, defaultFillColor),
        stroke: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
      });
    },
    'CompensationMarker': function CompensationMarker(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
        }
      });

      drawMarker('compensation', parentGfx, markerMath, {
        strokeWidth: 1,
        fill: (0, _BpmnRenderUtil.getFillColor)(element, defaultFillColor),
        stroke: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
      });
    },
    'LoopMarker': function LoopMarker(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
        }
      });

      drawMarker('loop', parentGfx, markerPath, {
        strokeWidth: 1,
        fill: (0, _BpmnRenderUtil.getFillColor)(element, defaultFillColor),
        stroke: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor),
        strokeLinecap: 'round',
        strokeMiterlimit: 0.5
      });
    },
    'AdhocMarker': function AdhocMarker(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
        }
      });

      drawMarker('adhoc', parentGfx, markerPath, {
        strokeWidth: 1,
        fill: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor),
        stroke: (0, _BpmnRenderUtil.getStrokeColor)(element, defaultStrokeColor)
      });
    }
  };

  function attachTaskMarkers(parentGfx, element, taskMarkers) {
    var obj = (0, _BpmnRenderUtil.getSemantic)(element);

    var subprocess = taskMarkers && taskMarkers.indexOf('SubProcessMarker') !== -1;
    var position;

    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
      };
    }

    (0, _minDash.forEach)(taskMarkers, function (marker) {
      renderer(marker)(parentGfx, element, position);
    });

    if (obj.isForCompensation) {
      renderer('CompensationMarker')(parentGfx, element, position);
    }

    if (obj.$type === 'bpmn:AdHocSubProcess') {
      renderer('AdhocMarker')(parentGfx, element, position);
    }

    var loopCharacteristics = obj.loopCharacteristics,
        isSequential = loopCharacteristics && loopCharacteristics.isSequential;

    if (loopCharacteristics) {

      if (isSequential === undefined) {
        renderer('LoopMarker')(parentGfx, element, position);
      }

      if (isSequential === false) {
        renderer('ParallelMarker')(parentGfx, element, position);
      }

      if (isSequential === true) {
        renderer('SequentialMarker')(parentGfx, element, position);
      }
    }
  }

  function renderDataItemCollection(parentGfx, element) {

    var yPosition = (element.height - 16) / element.height;

    var pathData = pathMap.getScaledPath('DATA_OBJECT_COLLECTION_PATH', {
      xScaleFactor: 1,
      yScaleFactor: 1,
      containerWidth: element.width,
      containerHeight: element.height,
      position: {
        mx: 0.451,
        my: yPosition
      }
    });

    /* collection path */drawPath(parentGfx, pathData, {
      strokeWidth: 2
    });
  }

  // extension API, use at your own risk
  this._drawPath = drawPath;
}

(0, _inherits2.default)(BpmnRenderer, _BaseRenderer2.default);

BpmnRenderer.$inject = ['config.bpmnRenderer', 'eventBus', 'styles', 'pathMap', 'canvas', 'textRenderer'];

BpmnRenderer.prototype.canRender = function (element) {
  return (0, _ModelUtil.is)(element, 'bpmn:BaseElement');
};

BpmnRenderer.prototype.drawShape = function (parentGfx, element) {
  var type = element.type;
  var h = this.handlers[type];

  /* jshint -W040 */
  return h(parentGfx, element);
};

BpmnRenderer.prototype.drawConnection = function (parentGfx, element) {
  var type = element.type;
  var h = this.handlers[type];

  /* jshint -W040 */
  return h(parentGfx, element);
};

BpmnRenderer.prototype.getShapePath = function (element) {

  if ((0, _ModelUtil.is)(element, 'bpmn:Event')) {
    return (0, _BpmnRenderUtil.getCirclePath)(element);
  }

  if ((0, _ModelUtil.is)(element, 'bpmn:Activity')) {
    return (0, _BpmnRenderUtil.getRoundRectPath)(element, TASK_BORDER_RADIUS);
  }

  if ((0, _ModelUtil.is)(element, 'bpmn:Gateway')) {
    return (0, _BpmnRenderUtil.getDiamondPath)(element);
  }

  return (0, _BpmnRenderUtil.getRectPath)(element);
};

},{"../util/DiUtil":214,"../util/ModelUtil":216,"./BpmnRenderUtil":118,"diagram-js/lib/draw/BaseRenderer":252,"diagram-js/lib/util/RenderUtil":407,"diagram-js/lib/util/SvgTransformUtil":408,"ids":414,"inherits":415,"min-dash":505,"min-dom":506,"tiny-svg":535}],120:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = PathMap;
/**
 * Map containing SVG paths needed by BpmnRenderer.
 */

function PathMap() {

  /**
   * 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  0 15  l 0 -15 ' + 'm  4 15  l 0 -15 ' + 'm  4 15  l 0 -15 ',
      height: 61,
      width: 51,
      heightElements: [12],
      widthElements: [1, 6, 12, 15]
    },
    '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'
    }
  };

  this.getRawPath = function getRawPath(pathId) {
    return this.pathMap[pathId].d;
  };

  /**
   * 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];

    // positioning
    // compute the start point of the path
    var mx, my;

    if (param.abspos) {
      mx = param.abspos.x;
      my = param.abspos.y;
    } else {
      mx = param.containerWidth * param.position.mx;
      my = param.containerHeight * param.position.my;
    }

    var coordinates = {}; // map for the scaled coordinates
    if (param.position) {

      // path
      var heightRatio = param.containerHeight / rawPath.height * param.yScaleFactor;
      var widthRatio = param.containerWidth / rawPath.width * param.xScaleFactor;

      // Apply height ratio
      for (var heightIndex = 0; heightIndex < rawPath.heightElements.length; heightIndex++) {
        coordinates['y' + heightIndex] = rawPath.heightElements[heightIndex] * heightRatio;
      }

      // Apply width ratio
      for (var widthIndex = 0; widthIndex < rawPath.widthElements.length; widthIndex++) {
        coordinates['x' + widthIndex] = rawPath.widthElements[widthIndex] * widthRatio;
      }
    }

    // Apply value to raw path
    var path = format(rawPath.d, {
      mx: mx,
      my: my,
      e: coordinates
    });
    return path;
  };
}

// helpers //////////////////////

// copied 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

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) + '';

  return res;
}

function format(str, obj) {
  return String(str).replace(tokenRegex, function (all, key) {
    return replacer(all, key, obj);
  });
}

},{}],121:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = TextRenderer;

var _minDash = require('min-dash');

var _Text = require('diagram-js/lib/util/Text');

var _Text2 = _interopRequireDefault(_Text);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var DEFAULT_FONT_SIZE = 12;
var LINE_HEIGHT_RATIO = 1.2;

var MIN_TEXT_ANNOTATION_HEIGHT = 30;

function TextRenderer(config) {

  var defaultStyle = (0, _minDash.assign)({
    fontFamily: 'Arial, sans-serif',
    fontSize: DEFAULT_FONT_SIZE,
    fontWeight: 'normal',
    lineHeight: LINE_HEIGHT_RATIO
  }, config && config.defaultStyle || {});

  var fontSize = parseInt(defaultStyle.fontSize, 10) - 1;

  var externalStyle = (0, _minDash.assign)({}, defaultStyle, {
    fontSize: fontSize
  }, config && config.externalStyle || {});

  var textUtil = new _Text2.default({
    style: defaultStyle
  });

  /**
   * Get the new bounds of an externally rendered,
   * layouted label.
   *
   * @param  {Bounds} bounds
   * @param  {String} text
   *
   * @return {Bounds}
   */
  this.getExternalLabelBounds = function (bounds, text) {

    var layoutedDimensions = textUtil.getDimensions(text, {
      box: {
        width: 90,
        height: 30,
        x: bounds.width / 2 + bounds.x,
        y: bounds.height / 2 + bounds.y
      },
      style: externalStyle
    });

    // 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)
    };
  };

  /**
   * Get the new bounds of text annotation.
   *
   * @param  {Bounds} bounds
   * @param  {String} text
   *
   * @return {Bounds}
   */
  this.getTextAnnotationBounds = function (bounds, text) {

    var layoutedDimensions = textUtil.getDimensions(text, {
      box: bounds,
      style: defaultStyle,
      align: 'left-top',
      padding: 5
    });

    return {
      x: bounds.x,
      y: bounds.y,
      width: bounds.width,
      height: Math.max(MIN_TEXT_ANNOTATION_HEIGHT, Math.round(layoutedDimensions.height))
    };
  };

  /**
   * 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 || {});
  };

  /**
   * Get default text style.
   */
  this.getDefaultStyle = function () {
    return defaultStyle;
  };

  /**
   * Get the external text style.
   */
  this.getExternalStyle = function () {
    return externalStyle;
  };
}

TextRenderer.$inject = ['config.textRenderer'];

},{"diagram-js/lib/util/Text":409,"min-dash":505}],122:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _BpmnRenderer = require('./BpmnRenderer');

var _BpmnRenderer2 = _interopRequireDefault(_BpmnRenderer);

var _TextRenderer = require('./TextRenderer');

var _TextRenderer2 = _interopRequireDefault(_TextRenderer);

var _PathMap = require('./PathMap');

var _PathMap2 = _interopRequireDefault(_PathMap);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __init__: ['bpmnRenderer'],
  bpmnRenderer: ['type', _BpmnRenderer2.default],
  textRenderer: ['type', _TextRenderer2.default],
  pathMap: ['type', _PathMap2.default]
};

},{"./BpmnRenderer":119,"./PathMap":120,"./TextRenderer":121}],123:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = AutoPlace;

var _ModelUtil = require('../../util/ModelUtil');

var _ModelingUtil = require('../modeling/util/ModelingUtil');

var _AutoPlaceUtil = require('./AutoPlaceUtil');

/**
 * 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(eventBus, modeling) {

  function emit(event, payload) {
    return eventBus.fire(event, payload);
  }

  /**
   * 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) {

    // allow others to provide the position
    var position = emit('autoPlace', {
      source: source,
      shape: shape
    });

    if (!position) {
      position = getNewShapePosition(source, shape);
    }

    var newShape = modeling.appendShape(source, shape, position, source.parent);

    // notify interested parties on new shape placed
    emit('autoPlace.end', {
      shape: newShape
    });

    return newShape;
  };
}

AutoPlace.$inject = ['eventBus', 'modeling'];

// helpers //////////////////////

/**
 * 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) {

  if ((0, _ModelUtil.is)(element, 'bpmn:TextAnnotation')) {
    return (0, _AutoPlaceUtil.getTextAnnotationPosition)(source, element);
  }

  if ((0, _ModelingUtil.isAny)(element, ['bpmn:DataObjectReference', 'bpmn:DataStoreReference'])) {
    return (0, _AutoPlaceUtil.getDataElementPosition)(source, element);
  }

  if ((0, _ModelUtil.is)(element, 'bpmn:FlowNode')) {
    return (0, _AutoPlaceUtil.getFlowNodePosition)(source, element);
  }

  return (0, _AutoPlaceUtil.getDefaultPosition)(source, element);
}

},{"../../util/ModelUtil":216,"../modeling/util/ModelingUtil":189,"./AutoPlaceUtil":125}],124:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = AutoPlaceSelectionBehavior;
/**
 * Select element after auto placement.
 *
 * @param {EventBus} eventBus
 * @param {Selection} selection
 */
function AutoPlaceSelectionBehavior(eventBus, selection) {

  eventBus.on('autoPlace.end', 500, function (e) {
    selection.select(e.shape);
  });
}

AutoPlaceSelectionBehavior.$inject = ['eventBus', 'selection'];

},{}],125:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.getFlowNodePosition = getFlowNodePosition;
exports.getFlowNodeDistance = getFlowNodeDistance;
exports.getTextAnnotationPosition = getTextAnnotationPosition;
exports.getDataElementPosition = getDataElementPosition;
exports.getDefaultPosition = getDefaultPosition;
exports.getConnectedAtPosition = getConnectedAtPosition;
exports.deconflictPosition = deconflictPosition;

var _ModelUtil = require('../../util/ModelUtil');

var _LayoutUtil = require('diagram-js/lib/layout/LayoutUtil');

var _minDash = require('min-dash');

var DEFAULT_HORIZONTAL_DISTANCE = 50;

var MAX_HORIZONTAL_DISTANCE = 250;

// padding to detect element placement
var PLACEMENT_DETECTION_PAD = 10;

/**
 * Always try to place element right of source;
 * compute actual distance from previous nodes in flow.
 */
function getFlowNodePosition(source, element) {

  var sourceTrbl = (0, _LayoutUtil.asTRBL)(source);
  var sourceMid = (0, _LayoutUtil.getMid)(source);

  var horizontalDistance = getFlowNodeDistance(source, element);

  var orientation = 'left',
      rowSize = 80,
      margin = 30;

  if ((0, _ModelUtil.is)(source, 'bpmn:BoundaryEvent')) {
    orientation = (0, _LayoutUtil.getOrientation)(source, source.host, -25);

    if (orientation.indexOf('top') !== -1) {
      margin *= -1;
    }
  }

  function getVerticalDistance(orient) {
    if (orient.indexOf('top') != -1) {
      return -1 * rowSize;
    } else if (orient.indexOf('bottom') != -1) {
      return rowSize;
    } else {
      return 0;
    }
  }

  var position = {
    x: sourceTrbl.right + horizontalDistance + element.width / 2,
    y: sourceMid.y + getVerticalDistance(orientation)
  };

  var escapeDirection = {
    y: {
      margin: margin,
      rowSize: rowSize
    }
  };

  return deconflictPosition(source, element, position, escapeDirection);
}

/**
 * Compute best distance between source and target,
 * based on existing connections to and from source.
 *
 * @param {djs.model.Shape} source
 * @param {djs.model.Shape} element
 *
 * @return {Number} distance
 */
function getFlowNodeDistance(source, element) {

  var sourceTrbl = (0, _LayoutUtil.asTRBL)(source);

  // is connection a reference to consider?
  function isReference(c) {
    return (0, _ModelUtil.is)(c, 'bpmn:SequenceFlow');
  }

  function toTargetNode(weight) {

    return function (shape) {
      return {
        shape: shape,
        weight: weight,
        distanceTo: function distanceTo(shape) {
          var shapeTrbl = (0, _LayoutUtil.asTRBL)(shape);

          return shapeTrbl.left - sourceTrbl.right;
        }
      };
    };
  }

  function toSourceNode(weight) {
    return function (shape) {
      return {
        shape: shape,
        weight: weight,
        distanceTo: function distanceTo(shape) {
          var shapeTrbl = (0, _LayoutUtil.asTRBL)(shape);

          return sourceTrbl.left - shapeTrbl.right;
        }
      };
    };
  }

  // we create a list of nodes to take into consideration
  // for calculating the optimal flow node distance
  //
  //   * weight existing target nodes higher than source nodes
  //   * only take into account individual nodes once
  //
  var nodes = (0, _minDash.reduce)([].concat(getTargets(source, isReference).map(toTargetNode(5)), getSources(source, isReference).map(toSourceNode(1))), function (nodes, node) {
    // filter out shapes connected twice via source or target
    nodes[node.shape.id + '__weight_' + node.weight] = node;

    return nodes;
  }, {});

  // compute distances between source and incoming nodes;
  // group at the same time by distance and expose the
  // favourite distance as { fav: { count, value } }.
  var distancesGrouped = (0, _minDash.reduce)(nodes, function (result, node) {

    var shape = node.shape,
        weight = node.weight,
        distanceTo = node.distanceTo;

    var fav = result.fav,
        currentDistance,
        currentDistanceCount,
        currentDistanceEntry;

    currentDistance = distanceTo(shape);

    // ignore too far away peers
    // or non-left to right modeled nodes
    if (currentDistance < 0 || currentDistance > MAX_HORIZONTAL_DISTANCE) {
      return result;
    }

    currentDistanceEntry = result[String(currentDistance)] = result[String(currentDistance)] || {
      value: currentDistance,
      count: 0
    };

    // inc diff count
    currentDistanceCount = currentDistanceEntry.count += 1 * weight;

    if (!fav || fav.count < currentDistanceCount) {
      result.fav = currentDistanceEntry;
    }

    return result;
  }, {});

  if (distancesGrouped.fav) {
    return distancesGrouped.fav.value;
  } else {
    return DEFAULT_HORIZONTAL_DISTANCE;
  }
}

/**
 * Always try to place text annotations top right of source.
 */
function getTextAnnotationPosition(source, element) {

  var sourceTrbl = (0, _LayoutUtil.asTRBL)(source);

  var position = {
    x: sourceTrbl.right + element.width / 2,
    y: sourceTrbl.top - 50 - element.height / 2
  };

  var escapeDirection = {
    y: {
      margin: -30,
      rowSize: 20
    }
  };

  return deconflictPosition(source, element, position, escapeDirection);
}

/**
 * Always put element bottom right of source.
 */
function getDataElementPosition(source, element) {

  var sourceTrbl = (0, _LayoutUtil.asTRBL)(source);

  var position = {
    x: sourceTrbl.right - 10 + element.width / 2,
    y: sourceTrbl.bottom + 40 + element.width / 2
  };

  var escapeDirection = {
    x: {
      margin: 30,
      rowSize: 30
    }
  };

  return deconflictPosition(source, element, position, escapeDirection);
}

/**
 * Always put element right of source per default.
 */
function getDefaultPosition(source, element) {

  var sourceTrbl = (0, _LayoutUtil.asTRBL)(source);

  var sourceMid = (0, _LayoutUtil.getMid)(source);

  // simply put element right next to source
  return {
    x: sourceTrbl.right + DEFAULT_HORIZONTAL_DISTANCE + element.width / 2,
    y: sourceMid.y
  };
}

/**
 * Returns all connected elements around the given source.
 *
 * This includes:
 *
 *   - connected elements
 *   - host connected elements
 *   - attachers connected elements
 *
 * @param  {djs.model.Shape} source
 * @param  {djs.model.Shape} element
 *
 * @return {Array<djs.model.Shape>}
 */
function getAutoPlaceClosure(source, element) {

  var allConnected = getConnected(source);

  if (source.host) {
    allConnected = allConnected.concat(getConnected(source.host));
  }

  if (source.attachers) {
    allConnected = allConnected.concat(source.attachers.reduce(function (shapes, attacher) {
      return shapes.concat(getConnected(attacher));
    }, []));
  }

  return allConnected;
}

/**
 * Return target at given position, if defined.
 *
 * This takes connected elements from host and attachers
 * into account, too.
 */
function getConnectedAtPosition(source, position, element) {

  var bounds = {
    x: position.x - element.width / 2,
    y: position.y - element.height / 2,
    width: element.width,
    height: element.height
  };

  var closure = getAutoPlaceClosure(source, element);

  return (0, _minDash.find)(closure, function (target) {

    if (target === element) {
      return false;
    }

    var orientation = (0, _LayoutUtil.getOrientation)(target, bounds, PLACEMENT_DETECTION_PAD);

    return orientation === 'intersect';
  });
}

/**
 * Returns a new, position for the given element
 * based on the given element that is not occupied
 * by some element connected to source.
 *
 * Take into account the escapeDirection (where to move
 * on positining clashes) in the computation.
 *
 * @param {djs.model.Shape} source
 * @param {djs.model.Shape} element
 * @param {Point} position
 * @param {Object} escapeDelta
 *
 * @return {Point}
 */
function deconflictPosition(source, element, position, escapeDelta) {

  function nextPosition(existingElement) {

    var newPosition = {
      x: position.x,
      y: position.y
    };

    ['x', 'y'].forEach(function (axis) {

      var axisDelta = escapeDelta[axis];

      if (!axisDelta) {
        return;
      }

      var dimension = axis === 'x' ? 'width' : 'height';

      var margin = axisDelta.margin,
          rowSize = axisDelta.rowSize;

      if (margin < 0) {
        newPosition[axis] = Math.min(existingElement[axis] + margin - element[dimension] / 2, position[axis] - rowSize + margin);
      } else {
        newPosition[axis] = Math.max(existingTarget[axis] + existingTarget[dimension] + margin + element[dimension] / 2, position[axis] + rowSize + margin);
      }
    });

    return newPosition;
  }

  var existingTarget;

  // deconflict position until free slot is found
  while (existingTarget = getConnectedAtPosition(source, position, element)) {
    position = nextPosition(existingTarget);
  }

  return position;
}

// helpers //////////////////////

function noneFilter() {
  return true;
}

function getConnected(element, connectionFilter) {
  return [].concat(getTargets(element, connectionFilter), getSources(element, connectionFilter));
}

function getSources(shape, connectionFilter) {

  if (!connectionFilter) {
    connectionFilter = noneFilter;
  }

  return shape.incoming.filter(connectionFilter).map(function (c) {
    return c.source;
  });
}

function getTargets(shape, connectionFilter) {

  if (!connectionFilter) {
    connectionFilter = noneFilter;
  }

  return shape.outgoing.filter(connectionFilter).map(function (c) {
    return c.target;
  });
}

},{"../../util/ModelUtil":216,"diagram-js/lib/layout/LayoutUtil":380,"min-dash":505}],126:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _AutoPlace = require('./AutoPlace');

var _AutoPlace2 = _interopRequireDefault(_AutoPlace);

var _AutoPlaceSelectionBehavior = require('./AutoPlaceSelectionBehavior');

var _AutoPlaceSelectionBehavior2 = _interopRequireDefault(_AutoPlaceSelectionBehavior);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __init__: ['autoPlaceSelectionBehavior'],
  autoPlace: ['type', _AutoPlace2.default],
  autoPlaceSelectionBehavior: ['type', _AutoPlaceSelectionBehavior2.default]
};

},{"./AutoPlace":123,"./AutoPlaceSelectionBehavior":124}],127:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = BpmnAutoResize;

var _AutoResize = require('diagram-js/lib/features/auto-resize/AutoResize');

var _AutoResize2 = _interopRequireDefault(_AutoResize);

var _inherits = require('inherits');

var _inherits2 = _interopRequireDefault(_inherits);

var _ModelUtil = require('../../util/ModelUtil');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * Sub class of the AutoResize module which implements a BPMN
 * specific resize function.
 */
function BpmnAutoResize(injector) {

  injector.invoke(_AutoResize2.default, this);
}

BpmnAutoResize.$inject = ['injector'];

(0, _inherits2.default)(BpmnAutoResize, _AutoResize2.default);

/**
 * Resize shapes and lanes
 *
 * @param  {djs.model.Shape} target
 * @param  {Object} newBounds
 */
BpmnAutoResize.prototype.resize = function (target, newBounds) {

  if ((0, _ModelUtil.is)(target, 'bpmn:Participant')) {
    this._modeling.resizeLane(target, newBounds);
  } else {
    this._modeling.resizeShape(target, newBounds);
  }
};

},{"../../util/ModelUtil":216,"diagram-js/lib/features/auto-resize/AutoResize":260,"inherits":415}],128:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = BpmnAutoResizeProvider;

var _ModelUtil = require('../../util/ModelUtil');

var _inherits = require('inherits');

var _inherits2 = _interopRequireDefault(_inherits);

var _minDash = require('min-dash');

var _AutoResizeProvider = require('diagram-js/lib/features/auto-resize/AutoResizeProvider');

var _AutoResizeProvider2 = _interopRequireDefault(_AutoResizeProvider);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * This module is a provider for automatically resizing parent BPMN elements
 */
function BpmnAutoResizeProvider(eventBus, modeling) {
  _AutoResizeProvider2.default.call(this, eventBus);

  this._modeling = modeling;
}

(0, _inherits2.default)(BpmnAutoResizeProvider, _AutoResizeProvider2.default);

BpmnAutoResizeProvider.$inject = ['eventBus', 'modeling'];

/**
 * Check if the given target can be expanded
 *
 * @param  {djs.model.Shape} target
 *
 * @return {boolean}
 */
BpmnAutoResizeProvider.prototype.canResize = function (elements, target) {

  if (!(0, _ModelUtil.is)(target, 'bpmn:Participant') && !(0, _ModelUtil.is)(target, 'bpmn:Lane') && !(0, _ModelUtil.is)(target, 'bpmn:SubProcess')) {
    return false;
  }

  var canResize = true;

  (0, _minDash.forEach)(elements, function (element) {

    if ((0, _ModelUtil.is)(element, 'bpmn:Lane') || element.labelTarget) {
      canResize = false;
      return;
    }
  });

  return canResize;
};

},{"../../util/ModelUtil":216,"diagram-js/lib/features/auto-resize/AutoResizeProvider":261,"inherits":415,"min-dash":505}],129:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _BpmnAutoResize = require('./BpmnAutoResize');

var _BpmnAutoResize2 = _interopRequireDefault(_BpmnAutoResize);

var _BpmnAutoResizeProvider = require('./BpmnAutoResizeProvider');

var _BpmnAutoResizeProvider2 = _interopRequireDefault(_BpmnAutoResizeProvider);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __init__: ['bpmnAutoResize', 'bpmnAutoResizeProvider'],
  bpmnAutoResize: ['type', _BpmnAutoResize2.default],
  bpmnAutoResizeProvider: ['type', _BpmnAutoResizeProvider2.default]
};

},{"./BpmnAutoResize":127,"./BpmnAutoResizeProvider":128}],130:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = ContextPadProvider;

var _minDash = require('min-dash');

var _ModelUtil = require('../../util/ModelUtil');

var _DiUtil = require('../../util/DiUtil');

var _ModelingUtil = require('../modeling/util/ModelingUtil');

var _LaneUtil = require('../modeling/util/LaneUtil');

var _Mouse = require('diagram-js/lib/util/Mouse');

/**
 * A provider for BPMN 2.0 elements context pad
 */
function ContextPadProvider(config, injector, eventBus, contextPad, modeling, elementFactory, connect, create, popupMenu, canvas, rules, translate) {

  config = config || {};

  contextPad.registerProvider(this);

  this._contextPad = contextPad;

  this._modeling = modeling;

  this._elementFactory = elementFactory;
  this._connect = connect;
  this._create = create;
  this._popupMenu = popupMenu;
  this._canvas = canvas;
  this._rules = rules;
  this._translate = translate;

  if (config.autoPlace !== false) {
    this._autoPlace = injector.get('autoPlace', false);
  }

  eventBus.on('create.end', 250, function (event) {
    var shape = event.context.shape;

    if (!(0, _Mouse.hasPrimaryModifier)(event)) {
      return;
    }

    var entries = contextPad.getEntries(shape);

    if (entries.replace) {
      entries.replace.action.click(event, shape);
    }
  });
}

ContextPadProvider.$inject = ['config.contextPad', 'injector', 'eventBus', 'contextPad', 'modeling', 'elementFactory', 'connect', 'create', 'popupMenu', 'canvas', 'rules', 'translate'];

ContextPadProvider.prototype.getContextPadEntries = function (element) {

  var contextPad = this._contextPad,
      modeling = this._modeling,
      elementFactory = this._elementFactory,
      connect = this._connect,
      create = this._create,
      popupMenu = this._popupMenu,
      canvas = this._canvas,
      rules = this._rules,
      autoPlace = this._autoPlace,
      translate = this._translate;

  var actions = {};

  if (element.type === 'label') {
    return actions;
  }

  var businessObject = element.businessObject;

  function startConnect(event, element) {
    connect.start(event, element);
  }

  function removeElement(e) {
    modeling.removeElements([element]);
  }

  function getReplaceMenuPosition(element) {

    var Y_OFFSET = 5;

    var diagramContainer = canvas.getContainer(),
        pad = contextPad.getPad(element).html;

    var diagramRect = diagramContainer.getBoundingClientRect(),
        padRect = pad.getBoundingClientRect();

    var top = padRect.top - diagramRect.top;
    var left = padRect.left - diagramRect.left;

    var pos = {
      x: left,
      y: top + padRect.height + Y_OFFSET
    };

    return pos;
  }

  /**
   * 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) {

    if (typeof title !== 'string') {
      options = title;
      title = translate('Append {type}', { type: type.replace(/^bpmn:/, '') });
    }

    function appendStart(event, element) {

      var shape = elementFactory.createShape((0, _minDash.assign)({ type: type }, options));
      create.start(event, shape, element);
    }

    var append = autoPlace ? function (event, element) {
      var shape = elementFactory.createShape((0, _minDash.assign)({ type: type }, options));

      autoPlace.append(element, shape);
    } : appendStart;

    return {
      group: 'model',
      className: className,
      title: title,
      action: {
        dragstart: appendStart,
        click: append
      }
    };
  }

  function splitLaneHandler(count) {

    return function (event, element) {
      // actual split
      modeling.splitLane(element, count);

      // refresh context pad after split to
      // get rid of split icons
      contextPad.open(element, true);
    };
  }

  if ((0, _ModelingUtil.isAny)(businessObject, ['bpmn:Lane', 'bpmn:Participant']) && (0, _DiUtil.isExpanded)(businessObject)) {

    var childLanes = (0, _LaneUtil.getChildLanes)(element);

    (0, _minDash.assign)(actions, {
      'lane-insert-above': {
        group: 'lane-insert-above',
        className: 'bpmn-icon-lane-insert-above',
        title: translate('Add Lane above'),
        action: {
          click: function click(event, element) {
            modeling.addLane(element, 'top');
          }
        }
      }
    });

    if (childLanes.length < 2) {

      if (element.height >= 120) {
        (0, _minDash.assign)(actions, {
          'lane-divide-two': {
            group: 'lane-divide',
            className: 'bpmn-icon-lane-divide-two',
            title: translate('Divide into two Lanes'),
            action: {
              click: splitLaneHandler(2)
            }
          }
        });
      }

      if (element.height >= 180) {
        (0, _minDash.assign)(actions, {
          'lane-divide-three': {
            group: 'lane-divide',
            className: 'bpmn-icon-lane-divide-three',
            title: translate('Divide into three Lanes'),
            action: {
              click: splitLaneHandler(3)
            }
          }
        });
      }
    }

    (0, _minDash.assign)(actions, {
      'lane-insert-below': {
        group: 'lane-insert-below',
        className: 'bpmn-icon-lane-insert-below',
        title: translate('Add Lane below'),
        action: {
          click: function click(event, element) {
            modeling.addLane(element, 'bottom');
          }
        }
      }
    });
  }

  if ((0, _ModelUtil.is)(businessObject, 'bpmn:FlowNode')) {

    if ((0, _ModelUtil.is)(businessObject, 'bpmn:EventBasedGateway')) {

      (0, _minDash.assign)(actions, {
        'append.receive-task': appendAction('bpmn:ReceiveTask', 'bpmn-icon-receive-task'),
        '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.condtion-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 if (isEventType(businessObject, 'bpmn:BoundaryEvent', 'bpmn:CompensateEventDefinition')) {

      (0, _minDash.assign)(actions, {
        'append.compensation-activity': appendAction('bpmn:Task', 'bpmn-icon-task', translate('Append compensation activity'), {
          isForCompensation: true
        })
      });
    } else if (!(0, _ModelUtil.is)(businessObject, 'bpmn:EndEvent') && !businessObject.isForCompensation && !isEventType(businessObject, 'bpmn:IntermediateThrowEvent', 'bpmn:LinkEventDefinition') && !(0, _DiUtil.isEventSubProcess)(businessObject)) {

      (0, _minDash.assign)(actions, {
        'append.end-event': appendAction('bpmn:EndEvent', 'bpmn-icon-end-event-none'),
        'append.gateway': appendAction('bpmn:ExclusiveGateway', 'bpmn-icon-gateway-none', translate('Append Gateway')),
        'append.append-task': appendAction('bpmn:Task', 'bpmn-icon-task'),
        'append.intermediate-event': appendAction('bpmn:IntermediateThrowEvent', 'bpmn-icon-intermediate-event-none', translate('Append Intermediate/Boundary Event'))
      });
    }
  }

  if (!popupMenu.isEmpty(element, 'bpmn-replace')) {
    // Replace menu entry
    (0, _minDash.assign)(actions, {
      'replace': {
        group: 'edit',
        className: 'bpmn-icon-screw-wrench',
        title: translate('Change type'),
        action: {
          click: function click(event, element) {

            var position = (0, _minDash.assign)(getReplaceMenuPosition(element), {
              cursor: { x: event.x, y: event.y }
            });

            popupMenu.open(element, 'bpmn-replace', position);
          }
        }
      }
    });
  }

  if ((0, _ModelingUtil.isAny)(businessObject, ['bpmn:FlowNode', 'bpmn:InteractionNode', 'bpmn:DataObjectReference', 'bpmn:DataStoreReference'])) {

    (0, _minDash.assign)(actions, {
      'append.text-annotation': appendAction('bpmn:TextAnnotation', 'bpmn-icon-text-annotation'),

      'connect': {
        group: 'connect',
        className: 'bpmn-icon-connection-multi',
        title: translate('Connect using ' + (businessObject.isForCompensation ? '' : 'Sequence/MessageFlow or ') + 'Association'),
        action: {
          click: startConnect,
          dragstart: startConnect
        }
      }
    });
  }

  if ((0, _ModelingUtil.isAny)(businessObject, ['bpmn:DataObjectReference', 'bpmn:DataStoreReference'])) {
    (0, _minDash.assign)(actions, {
      'connect': {
        group: 'connect',
        className: 'bpmn-icon-connection-multi',
        title: translate('Connect using DataInputAssociation'),
        action: {
          click: startConnect,
          dragstart: startConnect
        }
      }
    });
  }

  // delete element entry, only show if allowed by rules
  var deleteAllowed = rules.allowed('elements.delete', { elements: [element] });

  if ((0, _minDash.isArray)(deleteAllowed)) {
    // was the element returned as a deletion candidate?
    deleteAllowed = deleteAllowed[0] === element;
  }

  if (deleteAllowed) {
    (0, _minDash.assign)(actions, {
      'delete': {
        group: 'edit',
        className: 'bpmn-icon-trash',
        title: translate('Remove'),
        action: {
          click: removeElement
        }
      }
    });
  }

  return actions;
};

function isEventType(eventBo, type, definition) {

  var isType = eventBo.$instanceOf(type);
  var isDefinition = false;

  var definitions = eventBo.eventDefinitions || [];
  (0, _minDash.forEach)(definitions, function (def) {
    if (def.$type === definition) {
      isDefinition = true;
    }
  });

  return isType && isDefinition;
}

},{"../../util/DiUtil":214,"../../util/ModelUtil":216,"../modeling/util/LaneUtil":188,"../modeling/util/ModelingUtil":189,"diagram-js/lib/util/Mouse":403,"min-dash":505}],131:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _diagramJsDirectEditing = require('diagram-js-direct-editing');

var _diagramJsDirectEditing2 = _interopRequireDefault(_diagramJsDirectEditing);

var _contextPad = require('diagram-js/lib/features/context-pad');

var _contextPad2 = _interopRequireDefault(_contextPad);

var _selection = require('diagram-js/lib/features/selection');

var _selection2 = _interopRequireDefault(_selection);

var _connect = require('diagram-js/lib/features/connect');

var _connect2 = _interopRequireDefault(_connect);

var _create = require('diagram-js/lib/features/create');

var _create2 = _interopRequireDefault(_create);

var _popupMenu = require('../popup-menu');

var _popupMenu2 = _interopRequireDefault(_popupMenu);

var _ContextPadProvider = require('./ContextPadProvider');

var _ContextPadProvider2 = _interopRequireDefault(_ContextPadProvider);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __depends__: [_diagramJsDirectEditing2.default, _contextPad2.default, _selection2.default, _connect2.default, _create2.default, _popupMenu2.default],
  __init__: ['contextPadProvider'],
  contextPadProvider: ['type', _ContextPadProvider2.default]
};

},{"../popup-menu":195,"./ContextPadProvider":130,"diagram-js-direct-editing":238,"diagram-js/lib/features/connect":275,"diagram-js/lib/features/context-pad":277,"diagram-js/lib/features/create":281,"diagram-js/lib/features/selection":361}],132:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = BpmnCopyPaste;

var _ModelUtil = require('../../util/ModelUtil');

var _ModelCloneHelper = require('../../util/model/ModelCloneHelper');

var _ModelCloneHelper2 = _interopRequireDefault(_ModelCloneHelper);

var _ModelCloneUtils = require('../../util/model/ModelCloneUtils');

var _minDash = require('min-dash');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function setProperties(descriptor, data, properties) {
  (0, _minDash.forEach)(properties, function (property) {
    if (data[property] !== undefined) {
      descriptor[property] = data[property];
    }
  });
}

function removeProperties(element, properties) {
  (0, _minDash.forEach)(properties, function (prop) {
    if (element[prop]) {
      delete element[prop];
    }
  });
}

function BpmnCopyPaste(bpmnFactory, eventBus, copyPaste, clipboard, canvas, bpmnRules) {

  var helper = new _ModelCloneHelper2.default(eventBus, bpmnFactory);

  copyPaste.registerDescriptor(function (element, descriptor) {
    var businessObject = descriptor.oldBusinessObject = (0, _ModelUtil.getBusinessObject)(element);

    var colors = {};

    descriptor.type = element.type;

    setProperties(descriptor, businessObject.di, ['isExpanded']);

    setProperties(colors, businessObject.di, ['fill', 'stroke']);

    descriptor.colors = colors;

    if (element.type === 'label') {
      return descriptor;
    }

    setProperties(descriptor, businessObject, ['processRef', 'triggeredByEvent']);

    if (businessObject.default) {
      descriptor.default = businessObject.default.id;
    }

    return descriptor;
  });

  eventBus.on('element.paste', function (context) {
    var descriptor = context.descriptor,
        createdElements = context.createdElements,
        parent = descriptor.parent,
        rootElement = canvas.getRootElement(),
        oldBusinessObject = descriptor.oldBusinessObject,
        newBusinessObject,
        source,
        target,
        canConnect;

    newBusinessObject = bpmnFactory.create(oldBusinessObject.$type);

    var properties = (0, _ModelCloneUtils.getProperties)(oldBusinessObject.$descriptor);

    properties = (0, _minDash.filter)(properties, function (property) {
      return _ModelCloneUtils.IGNORED_PROPERTIES.indexOf(property.replace(/bpmn:/, '')) === -1;
    });

    descriptor.businessObject = helper.clone(oldBusinessObject, newBusinessObject, properties);

    if (descriptor.type === 'label') {
      return;
    }

    if ((0, _ModelUtil.is)(parent, 'bpmn:Process')) {
      descriptor.parent = (0, _ModelUtil.is)(rootElement, 'bpmn:Collaboration') ? rootElement : parent;
    }

    if (descriptor.type === 'bpmn:DataOutputAssociation' || descriptor.type === 'bpmn:DataInputAssociation' || descriptor.type === 'bpmn:MessageFlow') {
      descriptor.parent = rootElement;
    }

    if ((0, _ModelUtil.is)(parent, 'bpmn:Lane')) {
      descriptor.parent = parent.parent;
    }

    // make sure that the correct type of connection is created
    if (descriptor.waypoints) {
      source = createdElements[descriptor.source];
      target = createdElements[descriptor.target];

      if (source && target) {
        source = source.element;
        target = target.element;
      }

      canConnect = bpmnRules.canConnect(source, target);

      if (canConnect) {
        descriptor.type = canConnect.type;
      }
    }

    // remove the id or else we cannot paste multiple times
    delete newBusinessObject.id;

    // assign an ID
    bpmnFactory._ensureId(newBusinessObject);

    if (descriptor.type === 'bpmn:Participant' && descriptor.processRef) {
      descriptor.processRef = newBusinessObject.processRef = bpmnFactory.create('bpmn:Process');
    }

    setProperties(newBusinessObject, descriptor, ['isExpanded', 'triggeredByEvent']);

    removeProperties(descriptor, ['triggeredByEvent']);
  });
}

BpmnCopyPaste.$inject = ['bpmnFactory', 'eventBus', 'copyPaste', 'clipboard', 'canvas', 'bpmnRules'];

},{"../../util/ModelUtil":216,"../../util/model/ModelCloneHelper":218,"../../util/model/ModelCloneUtils":219,"min-dash":505}],133:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _copyPaste = require('diagram-js/lib/features/copy-paste');

var _copyPaste2 = _interopRequireDefault(_copyPaste);

var _BpmnCopyPaste = require('./BpmnCopyPaste');

var _BpmnCopyPaste2 = _interopRequireDefault(_BpmnCopyPaste);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __depends__: [_copyPaste2.default],
  __init__: ['bpmnCopyPaste'],
  bpmnCopyPaste: ['type', _BpmnCopyPaste2.default]
};

},{"./BpmnCopyPaste":132,"diagram-js/lib/features/copy-paste":279}],134:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = BpmnDistributeElements;

var _minDash = require('min-dash');

var _ModelingUtil = require('../modeling/util/ModelingUtil');

/**
 * Registers element exclude filters for elements that
 * currently do not support distribution.
 */
function BpmnDistributeElements(distributeElements) {

  distributeElements.registerFilter(function (elements) {
    return (0, _minDash.filter)(elements, function (element) {
      var cannotDistribute = (0, _ModelingUtil.isAny)(element, ['bpmn:Association', 'bpmn:BoundaryEvent', 'bpmn:DataInputAssociation', 'bpmn:DataOutputAssociation', 'bpmn:Lane', 'bpmn:MessageFlow', 'bpmn:Participant', 'bpmn:SequenceFlow', 'bpmn:TextAnnotation']);

      return !(element.labelTarget || cannotDistribute);
    });
  });
}

BpmnDistributeElements.$inject = ['distributeElements'];

},{"../modeling/util/ModelingUtil":189,"min-dash":505}],135:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _distributeElements = require('diagram-js/lib/features/distribute-elements');

var _distributeElements2 = _interopRequireDefault(_distributeElements);

var _BpmnDistributeElements = require('./BpmnDistributeElements');

var _BpmnDistributeElements2 = _interopRequireDefault(_BpmnDistributeElements);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __depends__: [_distributeElements2.default],
  __init__: ['bpmnDistributeElements'],
  bpmnDistributeElements: ['type', _BpmnDistributeElements2.default]
};

},{"./BpmnDistributeElements":134,"diagram-js/lib/features/distribute-elements":283}],136:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = BpmnEditorActions;

var _inherits = require('inherits');

var _inherits2 = _interopRequireDefault(_inherits);

var _EditorActions = require('diagram-js/lib/features/editor-actions/EditorActions');

var _EditorActions2 = _interopRequireDefault(_EditorActions);

var _minDash = require('min-dash');

var _ModelUtil = require('../../util/ModelUtil');

var _Elements = require('diagram-js/lib/util/Elements');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * Registers and executes BPMN specific editor actions.
 *
 * @param {Injector} injector
 */
function BpmnEditorActions(injector) {
  injector.invoke(_EditorActions2.default, this);
}

(0, _inherits2.default)(BpmnEditorActions, _EditorActions2.default);

BpmnEditorActions.$inject = ['injector'];

/**
 * Register default actions.
 *
 * @param {Injector} injector
 */
BpmnEditorActions.prototype._registerDefaultActions = function (injector) {

  // (0) invoke super method

  _EditorActions2.default.prototype._registerDefaultActions.call(this, injector);

  // (1) retrieve optional components to integrate with

  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);

  // (2) check components and register actions

  if (canvas && elementRegistry && selection) {
    this._registerAction('selectElements', function () {
      // select all elements except for the invisible
      // root element
      var rootElement = canvas.getRootElement();

      var elements = elementRegistry.filter(function (element) {
        return element !== rootElement;
      });

      selection.select(elements);

      return elements;
    });
  }

  if (spaceTool) {
    this._registerAction('spaceTool', function () {
      spaceTool.toggle();
    });
  }

  if (lassoTool) {
    this._registerAction('lassoTool', function () {
      lassoTool.toggle();
    });
  }

  if (handTool) {
    this._registerAction('handTool', function () {
      handTool.toggle();
    });
  }

  if (globalConnect) {
    this._registerAction('globalConnectTool', function () {
      globalConnect.toggle();
    });
  }

  if (selection && distributeElements) {
    this._registerAction('distributeElements', function (opts) {
      var currentSelection = selection.get(),
          type = opts.type;

      if (currentSelection.length) {
        distributeElements.trigger(currentSelection, type);
      }
    });
  }

  if (selection && alignElements) {
    this._registerAction('alignElements', function (opts) {
      var currentSelection = selection.get(),
          aligneableElements = [],
          type = opts.type;

      if (currentSelection.length) {
        aligneableElements = (0, _minDash.filter)(currentSelection, function (element) {
          return !(0, _ModelUtil.is)(element, 'bpmn:Lane');
        });

        alignElements.trigger(aligneableElements, type);
      }
    });
  }

  if (selection && modeling) {
    this._registerAction('setColor', function (opts) {
      var currentSelection = selection.get();

      if (currentSelection.length) {
        modeling.setColor(currentSelection, opts);
      }
    });
  }

  if (selection && directEditing) {
    this._registerAction('directEditing', function () {
      var currentSelection = selection.get();

      if (currentSelection.length) {
        directEditing.activate(currentSelection[0]);
      }
    });
  }

  if (searchPad) {
    this._registerAction('find', function () {
      searchPad.toggle();
    });
  }

  if (canvas && modeling) {
    this._registerAction('moveToOrigin', function () {
      var rootElement = canvas.getRootElement(),
          boundingBox,
          elements;

      if ((0, _ModelUtil.is)(rootElement, 'bpmn:Collaboration')) {
        elements = elementRegistry.filter(function (element) {
          return (0, _ModelUtil.is)(element.parent, 'bpmn:Collaboration');
        });
      } else {
        elements = elementRegistry.filter(function (element) {
          return element !== rootElement && !(0, _ModelUtil.is)(element.parent, 'bpmn:SubProcess');
        });
      }

      boundingBox = (0, _Elements.getBBox)(elements);

      modeling.moveElements(elements, { x: -boundingBox.x, y: -boundingBox.y }, rootElement);
    });
  }
};

},{"../../util/ModelUtil":216,"diagram-js/lib/features/editor-actions/EditorActions":287,"diagram-js/lib/util/Elements":396,"inherits":415,"min-dash":505}],137:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _editorActions = require('diagram-js/lib/features/editor-actions');

var _editorActions2 = _interopRequireDefault(_editorActions);

var _BpmnEditorActions = require('./BpmnEditorActions');

var _BpmnEditorActions2 = _interopRequireDefault(_BpmnEditorActions);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __depends__: [_editorActions2.default],
  editorActions: ['type', _BpmnEditorActions2.default]
};

},{"./BpmnEditorActions":136,"diagram-js/lib/features/editor-actions":288}],138:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = BpmnKeyboardBindings;

var _inherits = require('inherits');

var _inherits2 = _interopRequireDefault(_inherits);

var _KeyboardBindings = require('diagram-js/lib/features/keyboard/KeyboardBindings');

var _KeyboardBindings2 = _interopRequireDefault(_KeyboardBindings);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * BPMN 2.0 specific keyboard bindings.
 *
 * @param {Injector} injector
 */
function BpmnKeyboardBindings(injector) {
  injector.invoke(_KeyboardBindings2.default, this);
}

(0, _inherits2.default)(BpmnKeyboardBindings, _KeyboardBindings2.default);

BpmnKeyboardBindings.$inject = ['injector'];

/**
 * Register available keyboard bindings.
 *
 * @param {Keyboard} keyboard
 * @param {EditorActions} editorActions
 */
BpmnKeyboardBindings.prototype.registerBindings = function (keyboard, editorActions) {

  // inherit default bindings
  _KeyboardBindings2.default.prototype.registerBindings.call(this, keyboard, editorActions);

  /**
   * 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) {

    if (editorActions.isRegistered(action)) {
      keyboard.addListener(fn);
    }
  }

  // select all elements
  // CTRL + A
  addListener('selectElements', function (context) {

    var event = context.keyEvent;

    if (keyboard.isKey(['a', 'A'], event) && keyboard.isCmd(event)) {
      editorActions.trigger('selectElements');

      return true;
    }
  });

  // search labels
  // CTRL + F
  addListener('find', function (context) {

    var event = context.keyEvent;

    if (keyboard.isKey(['f', 'F'], event) && keyboard.isCmd(event)) {
      editorActions.trigger('find');

      return true;
    }
  });

  // activate space tool
  // S
  addListener('spaceTool', function (context) {

    var event = context.keyEvent;

    if (keyboard.hasModifier(event)) {
      return;
    }

    if (keyboard.isKey(['s', 'S'], event)) {
      editorActions.trigger('spaceTool');

      return true;
    }
  });

  // activate lasso tool
  // L
  addListener('lassoTool', function (context) {

    var event = context.keyEvent;

    if (keyboard.hasModifier(event)) {
      return;
    }

    if (keyboard.isKey(['l', 'L'], event)) {
      editorActions.trigger('lassoTool');

      return true;
    }
  });

  // activate hand tool
  // H
  addListener('handTool', function (context) {

    var event = context.keyEvent;

    if (keyboard.hasModifier(event)) {
      return;
    }

    if (keyboard.isKey(['h', 'H'], event)) {
      editorActions.trigger('handTool');

      return true;
    }
  });

  // activate global connect tool
  // C
  addListener('globalConnectTool', function (context) {

    var event = context.keyEvent;

    if (keyboard.hasModifier(event)) {
      return;
    }

    if (keyboard.isKey(['c', 'C'], event)) {
      editorActions.trigger('globalConnectTool');

      return true;
    }
  });

  // activate direct editing
  // E
  addListener('directEditing', function (context) {

    var event = context.keyEvent;

    if (keyboard.hasModifier(event)) {
      return;
    }

    if (keyboard.isKey(['e', 'E'], event)) {
      editorActions.trigger('directEditing');

      return true;
    }
  });
};

},{"diagram-js/lib/features/keyboard/KeyboardBindings":298,"inherits":415}],139:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _keyboard = require('diagram-js/lib/features/keyboard');

var _keyboard2 = _interopRequireDefault(_keyboard);

var _BpmnKeyboardBindings = require('./BpmnKeyboardBindings');

var _BpmnKeyboardBindings2 = _interopRequireDefault(_BpmnKeyboardBindings);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __depends__: [_keyboard2.default],
  __init__: ['keyboardBindings'],
  keyboardBindings: ['type', _BpmnKeyboardBindings2.default]
};

},{"./BpmnKeyboardBindings":138,"diagram-js/lib/features/keyboard":300}],140:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = LabelEditingPreview;

var _tinySvg = require('tiny-svg');

var _ModelUtil = require('../../util/ModelUtil');

var _SvgTransformUtil = require('diagram-js/lib/util/SvgTransformUtil');

var MARKER_HIDDEN = 'djs-element-hidden',
    MARKER_LABEL_HIDDEN = 'djs-label-hidden';

function LabelEditingPreview(eventBus, canvas, elementRegistry, pathMap) {

  var self = this;

  var defaultLayer = canvas.getDefaultLayer();

  var element, absoluteElementBBox, gfx;

  eventBus.on('directEditing.activate', function (context) {
    var activeProvider = context.active;

    element = activeProvider.element.label || activeProvider.element;

    // text annotation
    if ((0, _ModelUtil.is)(element, 'bpmn:TextAnnotation')) {
      absoluteElementBBox = canvas.getAbsoluteBBox(element);

      gfx = (0, _tinySvg.create)('g');

      var textPathData = pathMap.getScaledPath('TEXT_ANNOTATION', {
        xScaleFactor: 1,
        yScaleFactor: 1,
        containerWidth: element.width,
        containerHeight: element.height,
        position: {
          mx: 0.0,
          my: 0.0
        }
      });

      var path = self.path = (0, _tinySvg.create)('path');

      (0, _tinySvg.attr)(path, {
        d: textPathData,
        strokeWidth: 2,
        stroke: getStrokeColor(element)
      });

      (0, _tinySvg.append)(gfx, path);

      (0, _tinySvg.append)(defaultLayer, gfx);

      (0, _SvgTransformUtil.translate)(gfx, element.x, element.y);
    }

    if ((0, _ModelUtil.is)(element, 'bpmn:TextAnnotation') || element.labelTarget) {
      canvas.addMarker(element, MARKER_HIDDEN);
    } else if ((0, _ModelUtil.is)(element, 'bpmn:Task') || (0, _ModelUtil.is)(element, 'bpmn:CallActivity') || (0, _ModelUtil.is)(element, 'bpmn:SubProcess') || (0, _ModelUtil.is)(element, 'bpmn:Participant')) {
      canvas.addMarker(element, MARKER_LABEL_HIDDEN);
    }
  });

  eventBus.on('directEditing.resize', function (context) {

    // text annotation
    if ((0, _ModelUtil.is)(element, 'bpmn:TextAnnotation')) {
      var height = context.height,
          dy = context.dy;

      var newElementHeight = Math.max(element.height / absoluteElementBBox.height * (height + dy), 0);

      var textPathData = pathMap.getScaledPath('TEXT_ANNOTATION', {
        xScaleFactor: 1,
        yScaleFactor: 1,
        containerWidth: element.width,
        containerHeight: newElementHeight,
        position: {
          mx: 0.0,
          my: 0.0
        }
      });

      (0, _tinySvg.attr)(self.path, {
        d: textPathData
      });
    }
  });

  eventBus.on(['directEditing.complete', 'directEditing.cancel'], function (context) {
    var activeProvider = context.active;

    if (activeProvider) {
      canvas.removeMarker(activeProvider.element.label || activeProvider.element, MARKER_HIDDEN);
      canvas.removeMarker(element, MARKER_LABEL_HIDDEN);
    }

    element = undefined;
    absoluteElementBBox = undefined;

    if (gfx) {
      (0, _tinySvg.remove)(gfx);

      gfx = undefined;
    }
  });
}

LabelEditingPreview.$inject = ['eventBus', 'canvas', 'elementRegistry', 'pathMap'];

// helpers ///////////////////

function getStrokeColor(element, defaultColor) {
  var bo = (0, _ModelUtil.getBusinessObject)(element);

  return bo.di.get('stroke') || defaultColor || 'black';
}

},{"../../util/ModelUtil":216,"diagram-js/lib/util/SvgTransformUtil":408,"tiny-svg":535}],141:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = LabelEditingProvider;

var _minDash = require('min-dash');

var _LabelUtil = require('./LabelUtil');

var _ModelUtil = require('../../util/ModelUtil');

var _ModelingUtil = require('../modeling/util/ModelingUtil');

var _DiUtil = require('../../util/DiUtil');

var _LabelUtil2 = require('../../util/LabelUtil');

function LabelEditingProvider(eventBus, canvas, directEditing, modeling, resizeHandles, textRenderer) {

  this._canvas = canvas;
  this._modeling = modeling;
  this._textRenderer = textRenderer;

  directEditing.registerProvider(this);

  // listen to dblclick on non-root elements
  eventBus.on('element.dblclick', function (event) {
    activateDirectEdit(event.element, true);
  });

  // complete on followup canvas operation
  eventBus.on(['element.mousedown', 'drag.init', 'canvas.viewbox.changing', 'autoPlace', 'popupMenu.open'], function (event) {

    if (directEditing.isActive()) {
      directEditing.complete();
    }
  });

  // cancel on command stack changes
  eventBus.on(['commandStack.changed'], function (e) {
    if (directEditing.isActive()) {
      directEditing.cancel();
    }
  });

  eventBus.on('directEditing.activate', function (event) {
    resizeHandles.removeResizers();
  });

  eventBus.on('create.end', 500, function (event) {

    var element = event.shape,
        canExecute = event.context.canExecute,
        isTouch = event.isTouch;

    // 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

    // 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;
    }

    if (!canExecute) {
      return;
    }

    activateDirectEdit(element);
  });

  eventBus.on('autoPlace.end', 500, function (event) {
    activateDirectEdit(event.shape);
  });

  function activateDirectEdit(element, force) {
    if (force || (0, _ModelingUtil.isAny)(element, ['bpmn:Task', 'bpmn:TextAnnotation']) || isCollapsedSubProcess(element)) {

      directEditing.activate(element);
    }
  }
}

LabelEditingProvider.$inject = ['eventBus', 'canvas', 'directEditing', 'modeling', 'resizeHandles', 'textRenderer'];

/**
 * 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) {

  // text
  var text = (0, _LabelUtil.getLabel)(element);

  if (text === undefined) {
    return;
  }

  var context = {
    text: text
  };

  // bounds
  var bounds = this.getEditingBBox(element);

  (0, _minDash.assign)(context, bounds);

  var options = {};

  // tasks
  if ((0, _ModelingUtil.isAny)(element, ['bpmn:Task', 'bpmn:Participant', 'bpmn:Lane', 'bpmn:CallActivity']) || isCollapsedSubProcess(element)) {
    (0, _minDash.assign)(options, {
      centerVertically: true
    });
  }

  // external labels
  if ((0, _LabelUtil2.isLabelExternal)(element)) {
    (0, _minDash.assign)(options, {
      autoResize: true
    });
  }

  // text annotations
  if ((0, _ModelUtil.is)(element, 'bpmn:TextAnnotation')) {
    (0, _minDash.assign)(options, {
      resizable: true,
      autoResize: true
    });
  }

  (0, _minDash.assign)(context, {
    options: options
  });

  return context;
};

/**
 * 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;

  var target = element.label || element;

  var bbox = canvas.getAbsoluteBBox(target);

  var mid = {
    x: bbox.x + bbox.width / 2,
    y: bbox.y + bbox.height / 2
  };

  // default position
  var bounds = { x: bbox.x, y: bbox.y };

  var zoom = canvas.zoom();

  var defaultStyle = this._textRenderer.getDefaultStyle(),
      externalStyle = this._textRenderer.getExternalStyle();

  // take zoom into account
  var externalFontSize = externalStyle.fontSize * zoom,
      externalLineHeight = externalStyle.lineHeight,
      defaultFontSize = defaultStyle.fontSize * zoom,
      defaultLineHeight = defaultStyle.lineHeight;

  var style = {
    fontFamily: this._textRenderer.getDefaultStyle().fontFamily,
    fontWeight: this._textRenderer.getDefaultStyle().fontWeight
  };

  // adjust for expanded pools AND lanes
  if ((0, _ModelUtil.is)(element, 'bpmn:Lane') || isExpandedPool(element)) {

    (0, _minDash.assign)(bounds, {
      width: bbox.height,
      height: 30 * zoom,
      x: bbox.x - bbox.height / 2 + 15 * zoom,
      y: mid.y - 30 * zoom / 2
    });

    (0, _minDash.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)'
    });
  }

  // internal labels for tasks and collapsed call activities,
  // sub processes and participants
  if ((0, _ModelingUtil.isAny)(element, ['bpmn:Task', 'bpmn:CallActivity']) || isCollapsedPool(element) || isCollapsedSubProcess(element)) {

    (0, _minDash.assign)(bounds, {
      width: bbox.width,
      height: bbox.height
    });

    (0, _minDash.assign)(style, {
      fontSize: defaultFontSize + 'px',
      lineHeight: defaultLineHeight,
      paddingTop: 7 * zoom + 'px',
      paddingBottom: 7 * zoom + 'px',
      paddingLeft: 5 * zoom + 'px',
      paddingRight: 5 * zoom + 'px'
    });
  }

  // internal labels for expanded sub processes
  if (isExpandedSubProcess(element)) {
    (0, _minDash.assign)(bounds, {
      width: bbox.width,
      x: bbox.x
    });

    (0, _minDash.assign)(style, {
      fontSize: defaultFontSize + 'px',
      lineHeight: defaultLineHeight,
      paddingTop: 7 * zoom + 'px',
      paddingBottom: 7 * zoom + 'px',
      paddingLeft: 5 * zoom + 'px',
      paddingRight: 5 * zoom + 'px'
    });
  }

  var width = 90 * zoom,
      paddingTop = 7 * zoom,
      paddingBottom = 4 * zoom;

  // external labels for events, data elements, gateways and connections
  if (target.labelTarget) {
    (0, _minDash.assign)(bounds, {
      width: width,
      height: bbox.height + paddingTop + paddingBottom,
      x: mid.x - width / 2,
      y: bbox.y - paddingTop
    });

    (0, _minDash.assign)(style, {
      fontSize: externalFontSize + 'px',
      lineHeight: externalLineHeight,
      paddingTop: paddingTop + 'px',
      paddingBottom: paddingBottom + 'px'
    });
  }

  // external label not yet created
  if ((0, _LabelUtil2.isLabelExternal)(target) && !(0, _LabelUtil2.hasExternalLabel)(target) && !(0, _LabelUtil2.isLabel)(target)) {

    var externalLabelMid = (0, _LabelUtil2.getExternalLabelMid)(element);

    var absoluteBBox = canvas.getAbsoluteBBox({
      x: externalLabelMid.x,
      y: externalLabelMid.y,
      width: 0,
      height: 0
    });

    var height = externalFontSize + paddingTop + paddingBottom;

    (0, _minDash.assign)(bounds, {
      width: width,
      height: height,
      x: absoluteBBox.x - width / 2,
      y: absoluteBBox.y - height / 2
    });

    (0, _minDash.assign)(style, {
      fontSize: externalFontSize + 'px',
      lineHeight: externalLineHeight,
      paddingTop: paddingTop + 'px',
      paddingBottom: paddingBottom + 'px'
    });
  }

  // text annotations
  if ((0, _ModelUtil.is)(element, 'bpmn:TextAnnotation')) {
    (0, _minDash.assign)(bounds, {
      width: bbox.width,
      height: bbox.height,
      minWidth: 30 * zoom,
      minHeight: 10 * zoom
    });

    (0, _minDash.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
    });
  }

  return { bounds: bounds, style: style };
};

LabelEditingProvider.prototype.update = function (element, newLabel, activeContextText, bounds) {

  var newBounds, bbox;

  if ((0, _ModelUtil.is)(element, 'bpmn:TextAnnotation')) {

    bbox = this._canvas.getAbsoluteBBox(element);

    newBounds = {
      x: element.x,
      y: element.y,
      width: element.width / bbox.width * bounds.width,
      height: element.height / bbox.height * bounds.height
    };
  }

  if (isEmptyText(newLabel)) {
    newLabel = null;
  }

  this._modeling.updateLabel(element, newLabel, newBounds);
};

// helpers //////////////////////

function isCollapsedSubProcess(element) {
  return (0, _ModelUtil.is)(element, 'bpmn:SubProcess') && !(0, _DiUtil.isExpanded)(element);
}

function isExpandedSubProcess(element) {
  return (0, _ModelUtil.is)(element, 'bpmn:SubProcess') && (0, _DiUtil.isExpanded)(element);
}

function isCollapsedPool(element) {
  return (0, _ModelUtil.is)(element, 'bpmn:Participant') && !(0, _DiUtil.isExpanded)(element);
}

function isExpandedPool(element) {
  return (0, _ModelUtil.is)(element, 'bpmn:Participant') && (0, _DiUtil.isExpanded)(element);
}

function isEmptyText(label) {
  return !label || !label.trim();
}

},{"../../util/DiUtil":214,"../../util/LabelUtil":215,"../../util/ModelUtil":216,"../modeling/util/ModelingUtil":189,"./LabelUtil":142,"min-dash":505}],142:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.getLabel = getLabel;
exports.setLabel = setLabel;

var _ModelUtil = require('../../util/ModelUtil');

function getLabelAttr(semantic) {
  if ((0, _ModelUtil.is)(semantic, 'bpmn:FlowElement') || (0, _ModelUtil.is)(semantic, 'bpmn:Participant') || (0, _ModelUtil.is)(semantic, 'bpmn:Lane') || (0, _ModelUtil.is)(semantic, 'bpmn:SequenceFlow') || (0, _ModelUtil.is)(semantic, 'bpmn:MessageFlow')) {

    return 'name';
  }

  if ((0, _ModelUtil.is)(semantic, 'bpmn:TextAnnotation')) {
    return 'text';
  }
}

function getLabel(element) {
  var semantic = element.businessObject,
      attr = getLabelAttr(semantic);

  if (attr) {
    return semantic[attr] || '';
  }
}

function setLabel(element, text, isExternal) {
  var semantic = element.businessObject,
      attr = getLabelAttr(semantic);

  if (attr) {
    semantic[attr] = text;
  }

  return element;
}

},{"../../util/ModelUtil":216}],143:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = UpdateLabelHandler;

var _LabelUtil = require('../LabelUtil');

var _LabelUtil2 = require('../../../util/LabelUtil');

var _ModelUtil = require('../../../util/ModelUtil');

var NULL_DIMENSIONS = {
  width: 0,
  height: 0
};

/**
 * A handler that updates the text of a BPMN element.
 */
function UpdateLabelHandler(modeling, textRenderer) {

  /**
   * 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) {

    // external label if present
    var label = element.label || element;

    var labelTarget = element.labelTarget || element;

    (0, _LabelUtil.setLabel)(label, text, labelTarget !== label);

    return [label, labelTarget];
  }

  function preExecute(ctx) {
    var element = ctx.element,
        businessObject = element.businessObject,
        newLabel = ctx.newLabel;

    if (!(0, _LabelUtil2.isLabel)(element) && (0, _LabelUtil2.isLabelExternal)(element) && !(0, _LabelUtil2.hasExternalLabel)(element) && !isEmptyText(newLabel)) {

      // create label
      var paddingTop = 7;

      var labelCenter = (0, _LabelUtil2.getExternalLabelMid)(element);

      labelCenter = {
        x: labelCenter.x,
        y: labelCenter.y + paddingTop
      };

      modeling.createLabel(element, labelCenter, {
        id: businessObject.id + '_label',
        businessObject: businessObject
      });
    }
  }

  function execute(ctx) {
    ctx.oldLabel = (0, _LabelUtil.getLabel)(ctx.element);
    return setText(ctx.element, ctx.newLabel);
  }

  function revert(ctx) {
    return setText(ctx.element, ctx.oldLabel);
  }

  function postExecute(ctx) {
    var element = ctx.element,
        label = element.label || element,
        newLabel = ctx.newLabel,
        newBounds = ctx.newBounds,
        hints = ctx.hints || {};

    if ((0, _LabelUtil2.isLabel)(label) && isEmptyText(newLabel)) {

      if (hints.removeShape !== false) {
        modeling.removeShape(label, { unsetLabel: false });
      }

      return;
    }

    // ignore internal labels for elements except text annotations
    if (!(0, _LabelUtil2.isLabelExternal)(element) && !(0, _ModelUtil.is)(element, 'bpmn:TextAnnotation')) {
      return;
    }

    var bo = (0, _ModelUtil.getBusinessObject)(label);

    var text = bo.name || bo.text;

    // don't resize without text
    if (!text) {
      return;
    }

    // resize element based on label _or_ pre-defined bounds
    if (typeof newBounds === 'undefined') {
      newBounds = textRenderer.getExternalLabelBounds(label, text);
    }

    // setting newBounds to false or _null_ will
    // disable the postExecute resize operation
    if (newBounds) {
      modeling.resizeShape(label, newBounds, NULL_DIMENSIONS);
    }
  }

  // API

  this.preExecute = preExecute;
  this.execute = execute;
  this.revert = revert;
  this.postExecute = postExecute;
}

UpdateLabelHandler.$inject = ['modeling', 'textRenderer'];

// helpers ///////////////////////

function isEmptyText(label) {
  return !label || !label.trim();
}

},{"../../../util/LabelUtil":215,"../../../util/ModelUtil":216,"../LabelUtil":142}],144:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _changeSupport = require('diagram-js/lib/features/change-support');

var _changeSupport2 = _interopRequireDefault(_changeSupport);

var _resize = require('diagram-js/lib/features/resize');

var _resize2 = _interopRequireDefault(_resize);

var _diagramJsDirectEditing = require('diagram-js-direct-editing');

var _diagramJsDirectEditing2 = _interopRequireDefault(_diagramJsDirectEditing);

var _LabelEditingProvider = require('./LabelEditingProvider');

var _LabelEditingProvider2 = _interopRequireDefault(_LabelEditingProvider);

var _LabelEditingPreview = require('./LabelEditingPreview');

var _LabelEditingPreview2 = _interopRequireDefault(_LabelEditingPreview);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __depends__: [_changeSupport2.default, _resize2.default, _diagramJsDirectEditing2.default],
  __init__: ['labelEditingProvider', 'labelEditingPreview'],
  labelEditingProvider: ['type', _LabelEditingProvider2.default],
  labelEditingPreview: ['type', _LabelEditingPreview2.default]
};

},{"./LabelEditingPreview":140,"./LabelEditingProvider":141,"diagram-js-direct-editing":238,"diagram-js/lib/features/change-support":271,"diagram-js/lib/features/resize":352}],145:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = BpmnFactory;

var _minDash = require('min-dash');

var _ModelingUtil = require('./util/ModelingUtil');

function BpmnFactory(moddle) {
  this._model = moddle;
}

BpmnFactory.$inject = ['moddle'];

BpmnFactory.prototype._needsId = function (element) {
  return (0, _ModelingUtil.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']);
};

BpmnFactory.prototype._ensureId = function (element) {

  // generate semantic ids for elements
  // bpmn:SequenceFlow -> SequenceFlow_ID
  var prefix = (element.$type || '').replace(/^[^:]*:/g, '') + '_';

  if (!element.id && this._needsId(element)) {
    element.id = this._model.ids.nextPrefixed(prefix, element);
  }
};

BpmnFactory.prototype.create = function (type, attrs) {
  var element = this._model.create(type, attrs || {});

  this._ensureId(element);

  return element;
};

BpmnFactory.prototype.createDiLabel = function () {
  return this.create('bpmndi:BPMNLabel', {
    bounds: this.createDiBounds()
  });
};

BpmnFactory.prototype.createDiShape = function (semantic, bounds, attrs) {

  return this.create('bpmndi:BPMNShape', (0, _minDash.assign)({
    bpmnElement: semantic,
    bounds: this.createDiBounds(bounds)
  }, attrs));
};

BpmnFactory.prototype.createDiBounds = function (bounds) {
  return this.create('dc:Bounds', bounds);
};

BpmnFactory.prototype.createDiWaypoints = function (waypoints) {
  var self = this;

  return (0, _minDash.map)(waypoints, function (pos) {
    return self.createDiWaypoint(pos);
  });
};

BpmnFactory.prototype.createDiWaypoint = function (point) {
  return this.create('dc:Point', (0, _minDash.pick)(point, ['x', 'y']));
};

BpmnFactory.prototype.createDiEdge = function (semantic, waypoints, attrs) {
  return this.create('bpmndi:BPMNEdge', (0, _minDash.assign)({
    bpmnElement: semantic
  }, attrs));
};

BpmnFactory.prototype.createDiPlane = function (semantic) {
  return this.create('bpmndi:BPMNPlane', {
    bpmnElement: semantic
  });
};

},{"./util/ModelingUtil":189,"min-dash":505}],146:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = BpmnLayouter;

var _inherits = require('inherits');

var _inherits2 = _interopRequireDefault(_inherits);

var _minDash = require('min-dash');

var _BaseLayouter = require('diagram-js/lib/layout/BaseLayouter');

var _BaseLayouter2 = _interopRequireDefault(_BaseLayouter);

var _ManhattanLayout = require('diagram-js/lib/layout/ManhattanLayout');

var _LayoutUtil = require('diagram-js/lib/layout/LayoutUtil');

var _DiUtil = require('../../util/DiUtil');

var _ModelUtil = require('../../util/ModelUtil');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function BpmnLayouter() {}

(0, _inherits2.default)(BpmnLayouter, _BaseLayouter2.default);

BpmnLayouter.prototype.layoutConnection = function (connection, hints) {
  hints = hints || {};

  var source = connection.source,
      target = connection.target,
      waypoints = connection.waypoints,
      start = hints.connectionStart,
      end = hints.connectionEnd;

  var manhattanOptions, updatedWaypoints;

  if (!start) {
    start = getConnectionDocking(waypoints && waypoints[0], source);
  }

  if (!end) {
    end = getConnectionDocking(waypoints && waypoints[waypoints.length - 1], target);
  }

  // TODO(nikku): support vertical modeling
  // and invert preferredLayouts accordingly

  if ((0, _ModelUtil.is)(connection, 'bpmn:Association') || (0, _ModelUtil.is)(connection, 'bpmn:DataAssociation')) {

    if (waypoints && !isCompensationAssociation(connection)) {
      return [].concat([start], waypoints.slice(1, -1), [end]);
    }
  }

  // manhattan layout sequence / message flows
  if ((0, _ModelUtil.is)(connection, 'bpmn:MessageFlow')) {
    manhattanOptions = getMessageFlowManhattanOptions(source, target);
  } else

    // layout all connection between flow elements h:h,
    //
    // except for
    //
    // (1) outgoing of BoundaryEvents -> layout based on attach orientation and target orientation
    // (2) incoming / outgoing of Gateway -> v:h (outgoing), h:v (incoming)
    // (3) loops from / to the same element
    //
    if ((0, _ModelUtil.is)(connection, 'bpmn:SequenceFlow') || isCompensationAssociation(connection)) {

      if (source === target) {
        manhattanOptions = {
          preferredLayouts: ['b:l']
        };
      } else if ((0, _ModelUtil.is)(source, 'bpmn:BoundaryEvent')) {

        manhattanOptions = {
          preferredLayouts: getBoundaryEventPreferredLayouts(source, target)
        };
      } else if ((0, _ModelUtil.is)(source, 'bpmn:Gateway')) {

        manhattanOptions = {
          preferredLayouts: ['v:h']
        };
      } else if ((0, _ModelUtil.is)(target, 'bpmn:Gateway')) {

        manhattanOptions = {
          preferredLayouts: ['h:v']
        };
      } else {
        manhattanOptions = {
          preferredLayouts: ['h:h']
        };
      }
    }

  if (manhattanOptions) {

    manhattanOptions = (0, _minDash.assign)(manhattanOptions, hints);

    updatedWaypoints = (0, _ManhattanLayout.withoutRedundantPoints)((0, _ManhattanLayout.repairConnection)(source, target, start, end, waypoints, manhattanOptions));
  }

  return updatedWaypoints || [start, end];
};

function getAttachOrientation(attachedElement) {

  var hostElement = attachedElement.host,
      padding = -10;

  return (0, _LayoutUtil.getOrientation)((0, _LayoutUtil.getMid)(attachedElement), hostElement, padding);
}

function getMessageFlowManhattanOptions(source, target) {
  return {
    preferredLayouts: ['straight', 'v:v'],
    preserveDocking: getMessageFlowPreserveDocking(source, target)
  };
}

function getMessageFlowPreserveDocking(source, target) {

  // (1) docking element connected to participant has precedence

  if ((0, _ModelUtil.is)(target, 'bpmn:Participant')) {
    return 'source';
  }

  if ((0, _ModelUtil.is)(source, 'bpmn:Participant')) {
    return 'target';
  }

  // (2) docking element connected to expanded sub-process has precedence

  if (isExpandedSubProcess(target)) {
    return 'source';
  }

  if (isExpandedSubProcess(source)) {
    return 'target';
  }

  // (3) docking event has precedence

  if ((0, _ModelUtil.is)(target, 'bpmn:Event')) {
    return 'target';
  }

  if ((0, _ModelUtil.is)(source, 'bpmn:Event')) {
    return 'source';
  }

  return null;
}

function getConnectionDocking(point, shape) {
  return point ? point.original || point : (0, _LayoutUtil.getMid)(shape);
}

function isCompensationAssociation(connection) {

  var source = connection.source,
      target = connection.target;

  return (0, _ModelUtil.is)(target, 'bpmn:Activity') && (0, _ModelUtil.is)(source, 'bpmn:BoundaryEvent') && target.businessObject.isForCompensation;
}

function isExpandedSubProcess(element) {
  return (0, _ModelUtil.is)(element, 'bpmn:SubProcess') && (0, _DiUtil.isExpanded)(element);
}

function isSame(a, b) {
  return a === b;
}

function isAnyOrientation(orientation, orientations) {
  return orientations.indexOf(orientation) !== -1;
}

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'
};

var orientationDirectionMapping = {
  top: 't',
  right: 'r',
  bottom: 'b',
  left: 'l'
};

function getHorizontalOrientation(orientation) {
  var matches = /right|left/.exec(orientation);

  return matches && matches[0];
}

function getVerticalOrientation(orientation) {
  var matches = /top|bottom/.exec(orientation);

  return matches && matches[0];
}

function isOppositeOrientation(a, b) {
  return oppositeOrientationMapping[a] === b;
}

function isOppositeHorizontalOrientation(a, b) {
  var horizontalOrientation = getHorizontalOrientation(a);

  var oppositeHorizontalOrientation = oppositeOrientationMapping[horizontalOrientation];

  return b.indexOf(oppositeHorizontalOrientation) !== -1;
}

function isOppositeVerticalOrientation(a, b) {
  var verticalOrientation = getVerticalOrientation(a);

  var oppositeVerticalOrientation = oppositeOrientationMapping[verticalOrientation];

  return b.indexOf(oppositeVerticalOrientation) !== -1;
}

function isHorizontalOrientation(orientation) {
  return orientation === 'right' || orientation === 'left';
}

function getBoundaryEventPreferredLayouts(source, target) {
  var sourceMid = (0, _LayoutUtil.getMid)(source),
      targetMid = (0, _LayoutUtil.getMid)(target),
      attachOrientation = getAttachOrientation(source),
      sourceLayout,
      targetlayout;

  var isLoop = isSame(source.host, target);

  var attachedToSide = isAnyOrientation(attachOrientation, ['top', 'right', 'bottom', 'left']);

  var isHorizontalAttachOrientation = isHorizontalOrientation(attachOrientation);

  var targetOrientation = (0, _LayoutUtil.getOrientation)(targetMid, sourceMid, {
    x: source.width / 2 + target.width / 2,
    y: source.height / 2 + target.height / 2
  });

  // source layout

  // attached to either top, right, bottom or left side
  if (attachedToSide) {

    sourceLayout = orientationDirectionMapping[isHorizontalAttachOrientation ? getHorizontalOrientation(attachOrientation) : getVerticalOrientation(attachOrientation)];
  } else

    // attached to either top-right, top-left, bottom-right or bottom-left corner
    {

      // loop, same vertical or opposite horizontal orientation
      if (isLoop || isSame(getVerticalOrientation(attachOrientation), getVerticalOrientation(targetOrientation)) || isOppositeOrientation(getHorizontalOrientation(attachOrientation), getHorizontalOrientation(targetOrientation))) {
        sourceLayout = orientationDirectionMapping[getVerticalOrientation(attachOrientation)];
      } else {
        sourceLayout = orientationDirectionMapping[getHorizontalOrientation(attachOrientation)];
      }
    }

  // target layout

  // attached to either top, right, bottom or left side
  if (attachedToSide) {

    // loop or opposite horizontal/vertical orientation
    if (isLoop || (isHorizontalAttachOrientation ? isOppositeHorizontalOrientation(attachOrientation, targetOrientation) : isOppositeVerticalOrientation(attachOrientation, targetOrientation))) {
      targetlayout = isHorizontalAttachOrientation ? 'h' : 'v';
    } else {
      targetlayout = isHorizontalAttachOrientation ? 'v' : 'h';
    }
  } else

    // attached to either top-right, top-left, bottom-right or bottom-left corner
    {

      // orientation is 'right', 'left'
      // or same vertical orientation but also 'right' or 'left'
      if (isHorizontalOrientation(targetOrientation) || isSame(getVerticalOrientation(attachOrientation), getVerticalOrientation(targetOrientation)) && getHorizontalOrientation(targetOrientation)) {
        targetlayout = 'h';
      } else {
        targetlayout = 'v';
      }
    }

  return [sourceLayout + ':' + targetlayout];
}

},{"../../util/DiUtil":214,"../../util/ModelUtil":216,"diagram-js/lib/layout/BaseLayouter":378,"diagram-js/lib/layout/LayoutUtil":380,"diagram-js/lib/layout/ManhattanLayout":381,"inherits":415,"min-dash":505}],147:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = BpmnUpdater;

var _minDash = require('min-dash');

var _inherits = require('inherits');

var _inherits2 = _interopRequireDefault(_inherits);

var _Collections = require('diagram-js/lib/util/Collections');

var _model = require('diagram-js/lib/model');

var _ModelUtil = require('../../util/ModelUtil');

var _CommandInterceptor = require('diagram-js/lib/command/CommandInterceptor');

var _CommandInterceptor2 = _interopRequireDefault(_CommandInterceptor);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * A handler responsible for updating the underlying BPMN 2.0 XML + DI
 * once changes on the diagram happen
 */
function BpmnUpdater(eventBus, bpmnFactory, connectionDocking, translate) {

  _CommandInterceptor2.default.call(this, eventBus);

  this._bpmnFactory = bpmnFactory;
  this._translate = translate;

  var self = this;

  // connection cropping //////////////////////

  // crop connection ends during create/update
  function cropConnection(e) {
    var context = e.context,
        connection;

    if (!context.cropped) {
      connection = context.connection;
      connection.waypoints = connectionDocking.getCroppedWaypoints(connection);
      context.cropped = true;
    }
  }

  this.executed(['connection.layout', 'connection.create', 'connection.reconnectEnd', 'connection.reconnectStart'], cropConnection);

  this.reverted(['connection.layout'], function (e) {
    delete e.context.cropped;
  });

  // BPMN + DI update //////////////////////


  // update parent
  function updateParent(e) {
    var context = e.context;

    self.updateParent(context.shape || context.connection, context.oldParent);
  }

  function reverseUpdateParent(e) {
    var context = e.context;

    var element = context.shape || context.connection,

    // oldParent is the (old) new parent, because we are undoing
    oldParent = context.parent || context.newParent;

    self.updateParent(element, oldParent);
  }

  this.executed(['shape.move', 'shape.create', 'shape.delete', 'connection.create', 'connection.move', 'connection.delete'], ifBpmn(updateParent));

  this.reverted(['shape.move', 'shape.create', 'shape.delete', 'connection.create', 'connection.move', 'connection.delete'], ifBpmn(reverseUpdateParent));

  /*
   * ## 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;

    (0, _minDash.forEach)(children, function (child) {
      if ((0, _ModelUtil.is)(child, 'bpmn:BaseElement')) {
        self.updateParent(child);
      }
    });
  }

  this.executed(['canvas.updateRoot'], updateRoot);
  this.reverted(['canvas.updateRoot'], updateRoot);

  // update bounds
  function updateBounds(e) {
    var shape = e.context.shape;

    if (!(0, _ModelUtil.is)(shape, 'bpmn:BaseElement')) {
      return;
    }

    self.updateBounds(shape);
  }

  this.executed(['shape.move', 'shape.create', 'shape.resize'], ifBpmn(function (event) {

    // exclude labels because they're handled separately during shape.changed
    if (event.context.shape.type === 'label') {
      return;
    }

    updateBounds(event);
  }));

  this.reverted(['shape.move', 'shape.create', 'shape.resize'], ifBpmn(function (event) {

    // exclude labels because they're handled separately during shape.changed
    if (event.context.shape.type === 'label') {
      return;
    }

    updateBounds(event);
  }));

  // 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 } });
    }
  });

  // attach / detach connection
  function updateConnection(e) {
    self.updateConnection(e.context);
  }

  this.executed(['connection.create', 'connection.move', 'connection.delete', 'connection.reconnectEnd', 'connection.reconnectStart'], ifBpmn(updateConnection));

  this.reverted(['connection.create', 'connection.move', 'connection.delete', 'connection.reconnectEnd', 'connection.reconnectStart'], ifBpmn(updateConnection));

  // update waypoints
  function updateConnectionWaypoints(e) {
    self.updateConnectionWaypoints(e.context.connection);
  }

  this.executed(['connection.layout', 'connection.move', 'connection.updateWaypoints', 'connection.reconnectEnd', 'connection.reconnectStart'], ifBpmn(updateConnectionWaypoints));

  this.reverted(['connection.layout', 'connection.move', 'connection.updateWaypoints', 'connection.reconnectEnd', 'connection.reconnectStart'], ifBpmn(updateConnectionWaypoints));

  // update Default & Conditional flows
  this.executed(['connection.reconnectEnd', 'connection.reconnectStart'], ifBpmn(function (e) {
    var context = e.context,
        connection = context.connection,
        businessObject = (0, _ModelUtil.getBusinessObject)(connection),
        oldSource = (0, _ModelUtil.getBusinessObject)(context.oldSource),
        oldTarget = (0, _ModelUtil.getBusinessObject)(context.oldTarget),
        newSource = (0, _ModelUtil.getBusinessObject)(connection.source),
        newTarget = (0, _ModelUtil.getBusinessObject)(connection.target);

    if (oldSource === newSource || oldTarget === newTarget) {
      return;
    }

    // on reconnectStart -> default flow
    if (oldSource && oldSource.default === businessObject) {
      context.default = oldSource.default;
      oldSource.default = undefined;
    }

    // on reconnectEnd -> default flow
    if (businessObject.sourceRef && businessObject.sourceRef.default && !((0, _ModelUtil.is)(newTarget, 'bpmn:Activity') || (0, _ModelUtil.is)(newTarget, 'bpmn:EndEvent') || (0, _ModelUtil.is)(newTarget, 'bpmn:Gateway') || (0, _ModelUtil.is)(newTarget, 'bpmn:IntermediateThrowEvent'))) {
      context.default = businessObject.sourceRef.default;
      businessObject.sourceRef.default = undefined;
    }

    // on reconnectStart -> conditional flow
    if (oldSource && businessObject.conditionExpression && !((0, _ModelUtil.is)(newSource, 'bpmn:Activity') || (0, _ModelUtil.is)(newSource, 'bpmn:Gateway'))) {
      context.conditionExpression = businessObject.conditionExpression;
      businessObject.conditionExpression = undefined;
    }

    // on reconnectEnd -> conditional flow
    if (oldTarget && businessObject.conditionExpression && !((0, _ModelUtil.is)(newTarget, 'bpmn:Activity') || (0, _ModelUtil.is)(newTarget, 'bpmn:EndEvent') || (0, _ModelUtil.is)(newTarget, 'bpmn:Gateway') || (0, _ModelUtil.is)(newTarget, 'bpmn:IntermediateThrowEvent'))) {
      context.conditionExpression = businessObject.conditionExpression;
      businessObject.conditionExpression = undefined;
    }
  }));

  this.reverted(['connection.reconnectEnd', 'connection.reconnectStart'], ifBpmn(function (e) {
    var context = e.context,
        connection = context.connection,
        businessObject = (0, _ModelUtil.getBusinessObject)(connection),
        newSource = (0, _ModelUtil.getBusinessObject)(connection.source);

    // default flow
    if (context.default) {
      if ((0, _ModelUtil.is)(newSource, 'bpmn:ExclusiveGateway') || (0, _ModelUtil.is)(newSource, 'bpmn:InclusiveGateway') || (0, _ModelUtil.is)(newSource, 'bpmn:Activity')) {
        newSource.default = context.default;
      }
    }

    // conditional flow
    if (context.conditionExpression && (0, _ModelUtil.is)(newSource, 'bpmn:Activity')) {
      businessObject.conditionExpression = context.conditionExpression;
    }
  }));

  // update attachments
  function updateAttachment(e) {
    self.updateAttachment(e.context);
  }

  this.executed(['element.updateAttachment'], ifBpmn(updateAttachment));
  this.reverted(['element.updateAttachment'], ifBpmn(updateAttachment));
}

(0, _inherits2.default)(BpmnUpdater, _CommandInterceptor2.default);

BpmnUpdater.$inject = ['eventBus', 'bpmnFactory', 'connectionDocking', 'translate'];

// implementation //////////////////////

BpmnUpdater.prototype.updateAttachment = function (context) {

  var shape = context.shape,
      businessObject = shape.businessObject,
      host = shape.host;

  businessObject.attachedToRef = host && host.businessObject;
};

BpmnUpdater.prototype.updateParent = function (element, oldParent) {
  // do not update BPMN 2.0 label parent
  if (element instanceof _model.Label) {
    return;
  }

  // data stores in collaborations are handled seperately by DataStoreBehavior
  if ((0, _ModelUtil.is)(element, 'bpmn:DataStoreReference') && element.parent && (0, _ModelUtil.is)(element.parent, 'bpmn:Collaboration')) {
    return;
  }

  var parentShape = element.parent;

  var businessObject = element.businessObject,
      parentBusinessObject = parentShape && parentShape.businessObject,
      parentDi = parentBusinessObject && parentBusinessObject.di;

  if ((0, _ModelUtil.is)(element, 'bpmn:FlowNode')) {
    this.updateFlowNodeRefs(businessObject, parentBusinessObject, oldParent && oldParent.businessObject);
  }

  if ((0, _ModelUtil.is)(element, 'bpmn:DataOutputAssociation')) {
    if (element.source) {
      parentBusinessObject = element.source.businessObject;
    } else {
      parentBusinessObject = null;
    }
  }

  if ((0, _ModelUtil.is)(element, 'bpmn:DataInputAssociation')) {
    if (element.target) {
      parentBusinessObject = element.target.businessObject;
    } else {
      parentBusinessObject = null;
    }
  }

  this.updateSemanticParent(businessObject, parentBusinessObject);

  if ((0, _ModelUtil.is)(element, 'bpmn:DataObjectReference') && businessObject.dataObjectRef) {
    this.updateSemanticParent(businessObject.dataObjectRef, parentBusinessObject);
  }

  this.updateDiParent(businessObject.di, parentDi);
};

BpmnUpdater.prototype.updateBounds = function (shape) {

  var di = shape.businessObject.di;

  var target = shape instanceof _model.Label ? this._getLabel(di) : di;

  var bounds = target.bounds;

  if (!bounds) {
    bounds = this._bpmnFactory.createDiBounds();
    target.set('bounds', bounds);
  }

  (0, _minDash.assign)(bounds, {
    x: shape.x,
    y: shape.y,
    width: shape.width,
    height: shape.height
  });
};

BpmnUpdater.prototype.updateFlowNodeRefs = function (businessObject, newContainment, oldContainment) {

  if (oldContainment === newContainment) {
    return;
  }

  var oldRefs, newRefs;

  if ((0, _ModelUtil.is)(oldContainment, 'bpmn:Lane')) {
    oldRefs = oldContainment.get('flowNodeRef');
    (0, _Collections.remove)(oldRefs, businessObject);
  }

  if ((0, _ModelUtil.is)(newContainment, 'bpmn:Lane')) {
    newRefs = newContainment.get('flowNodeRef');
    (0, _Collections.add)(newRefs, businessObject);
  }
};

// update existing sourceElement and targetElement di information
BpmnUpdater.prototype.updateDiConnection = function (di, newSource, newTarget) {

  if (di.sourceElement && di.sourceElement.bpmnElement !== newSource) {
    di.sourceElement = newSource && newSource.di;
  }

  if (di.targetElement && di.targetElement.bpmnElement !== newTarget) {
    di.targetElement = newTarget && newTarget.di;
  }
};

BpmnUpdater.prototype.updateDiParent = function (di, parentDi) {

  if (parentDi && !(0, _ModelUtil.is)(parentDi, 'bpmndi:BPMNPlane')) {
    parentDi = parentDi.$parent;
  }

  if (di.$parent === parentDi) {
    return;
  }

  var planeElements = (parentDi || di.$parent).get('planeElement');

  if (parentDi) {
    planeElements.push(di);
    di.$parent = parentDi;
  } else {
    (0, _Collections.remove)(planeElements, di);
    di.$parent = null;
  }
};

function getDefinitions(element) {
  while (element && !(0, _ModelUtil.is)(element, 'bpmn:Definitions')) {
    element = element.$parent;
  }

  return element;
}

BpmnUpdater.prototype.getLaneSet = function (container) {

  var laneSet, laneSets;

  // bpmn:Lane
  if ((0, _ModelUtil.is)(container, 'bpmn:Lane')) {
    laneSet = container.childLaneSet;

    if (!laneSet) {
      laneSet = this._bpmnFactory.create('bpmn:LaneSet');
      container.childLaneSet = laneSet;
      laneSet.$parent = container;
    }

    return laneSet;
  }

  // bpmn:Participant
  if ((0, _ModelUtil.is)(container, 'bpmn:Participant')) {
    container = container.processRef;
  }

  // bpmn:FlowElementsContainer
  laneSets = container.get('laneSets');
  laneSet = laneSets[0];

  if (!laneSet) {
    laneSet = this._bpmnFactory.create('bpmn:LaneSet');
    laneSet.$parent = container;
    laneSets.push(laneSet);
  }

  return laneSet;
};

BpmnUpdater.prototype.updateSemanticParent = function (businessObject, newParent, visualParent) {

  var containment,
      translate = this._translate;

  if (businessObject.$parent === newParent) {
    return;
  }

  if ((0, _ModelUtil.is)(businessObject, 'bpmn:Lane')) {

    if (newParent) {
      newParent = this.getLaneSet(newParent);
    }

    containment = 'lanes';
  } else if ((0, _ModelUtil.is)(businessObject, 'bpmn:FlowElement')) {

    if (newParent) {

      if ((0, _ModelUtil.is)(newParent, 'bpmn:Participant')) {
        newParent = newParent.processRef;
      } else if ((0, _ModelUtil.is)(newParent, 'bpmn:Lane')) {
        do {
          // unwrap Lane -> LaneSet -> (Lane | FlowElementsContainer)
          newParent = newParent.$parent.$parent;
        } while ((0, _ModelUtil.is)(newParent, 'bpmn:Lane'));
      }
    }

    containment = 'flowElements';
  } else if ((0, _ModelUtil.is)(businessObject, 'bpmn:Artifact')) {

    while (newParent && !(0, _ModelUtil.is)(newParent, 'bpmn:Process') && !(0, _ModelUtil.is)(newParent, 'bpmn:SubProcess') && !(0, _ModelUtil.is)(newParent, 'bpmn:Collaboration')) {

      if ((0, _ModelUtil.is)(newParent, 'bpmn:Participant')) {
        newParent = newParent.processRef;
        break;
      } else {
        newParent = newParent.$parent;
      }
    }

    containment = 'artifacts';
  } else if ((0, _ModelUtil.is)(businessObject, 'bpmn:MessageFlow')) {
    containment = 'messageFlows';
  } else if ((0, _ModelUtil.is)(businessObject, 'bpmn:Participant')) {
    containment = 'participants';

    // make sure the participants process is properly attached / detached
    // from the XML document

    var process = businessObject.processRef,
        definitions;

    if (process) {
      definitions = getDefinitions(businessObject.$parent || newParent);

      if (businessObject.$parent) {
        (0, _Collections.remove)(definitions.get('rootElements'), process);
        process.$parent = null;
      }

      if (newParent) {
        (0, _Collections.add)(definitions.get('rootElements'), process);
        process.$parent = definitions;
      }
    }
  } else if ((0, _ModelUtil.is)(businessObject, 'bpmn:DataOutputAssociation')) {
    containment = 'dataOutputAssociations';
  } else if ((0, _ModelUtil.is)(businessObject, 'bpmn:DataInputAssociation')) {
    containment = 'dataInputAssociations';
  }

  if (!containment) {
    throw new Error(translate('no parent for {element} in {parent}', {
      element: businessObject.id,
      parent: newParent.id
    }));
  }

  var children;

  if (businessObject.$parent) {
    // remove from old parent
    children = businessObject.$parent.get(containment);
    (0, _Collections.remove)(children, businessObject);
  }

  if (!newParent) {
    businessObject.$parent = null;
  } else {
    // add to new parent
    children = newParent.get(containment);
    children.push(businessObject);
    businessObject.$parent = newParent;
  }

  if (visualParent) {
    var diChildren = visualParent.get(containment);

    (0, _Collections.remove)(children, businessObject);

    if (newParent) {

      if (!diChildren) {
        diChildren = [];
        newParent.set(containment, diChildren);
      }

      diChildren.push(businessObject);
    }
  }
};

BpmnUpdater.prototype.updateConnectionWaypoints = function (connection) {
  connection.businessObject.di.set('waypoint', this._bpmnFactory.createDiWaypoints(connection.waypoints));
};

BpmnUpdater.prototype.updateConnection = function (context) {

  var connection = context.connection,
      businessObject = (0, _ModelUtil.getBusinessObject)(connection),
      newSource = (0, _ModelUtil.getBusinessObject)(connection.source),
      newTarget = (0, _ModelUtil.getBusinessObject)(connection.target),
      visualParent;

  if (!(0, _ModelUtil.is)(businessObject, 'bpmn:DataAssociation')) {

    var inverseSet = (0, _ModelUtil.is)(businessObject, 'bpmn:SequenceFlow');

    if (businessObject.sourceRef !== newSource) {
      if (inverseSet) {
        (0, _Collections.remove)(businessObject.sourceRef && businessObject.sourceRef.get('outgoing'), businessObject);

        if (newSource && newSource.get('outgoing')) {
          newSource.get('outgoing').push(businessObject);
        }
      }

      businessObject.sourceRef = newSource;
    }

    if (businessObject.targetRef !== newTarget) {
      if (inverseSet) {
        (0, _Collections.remove)(businessObject.targetRef && businessObject.targetRef.get('incoming'), businessObject);

        if (newTarget && newTarget.get('incoming')) {
          newTarget.get('incoming').push(businessObject);
        }
      }

      businessObject.targetRef = newTarget;
    }
  } else if ((0, _ModelUtil.is)(businessObject, 'bpmn:DataInputAssociation')) {
    // handle obnoxious isMsome sourceRef
    businessObject.get('sourceRef')[0] = newSource;

    visualParent = context.parent || context.newParent || newTarget;

    this.updateSemanticParent(businessObject, newTarget, parent.businessObject);
  } else if ((0, _ModelUtil.is)(businessObject, 'bpmn:DataOutputAssociation')) {
    visualParent = context.parent || context.newParent || newSource;

    this.updateSemanticParent(businessObject, newSource, visualParent);

    // targetRef = new target
    businessObject.targetRef = newTarget;
  }

  this.updateConnectionWaypoints(connection);

  this.updateDiConnection(businessObject.di, newSource, newTarget);
};

// helpers //////////////////////

BpmnUpdater.prototype._getLabel = function (di) {
  if (!di.label) {
    di.label = this._bpmnFactory.createDiLabel();
  }

  return di.label;
};

/**
 * 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) {

  return function (event) {

    var context = event.context,
        element = context.shape || context.connection;

    if ((0, _ModelUtil.is)(element, 'bpmn:BaseElement')) {
      fn(event);
    }
  };
}

},{"../../util/ModelUtil":216,"diagram-js/lib/command/CommandInterceptor":243,"diagram-js/lib/model":382,"diagram-js/lib/util/Collections":393,"inherits":415,"min-dash":505}],148:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = ElementFactory;

var _minDash = require('min-dash');

var _inherits = require('inherits');

var _inherits2 = _interopRequireDefault(_inherits);

var _ModelUtil = require('../../util/ModelUtil');

var _DiUtil = require('../../util/DiUtil');

var _ElementFactory = require('diagram-js/lib/core/ElementFactory');

var _ElementFactory2 = _interopRequireDefault(_ElementFactory);

var _LabelUtil = require('../../util/LabelUtil');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * A bpmn-aware factory for diagram-js shapes
 */
function ElementFactory(bpmnFactory, moddle, translate) {
  _ElementFactory2.default.call(this);

  this._bpmnFactory = bpmnFactory;
  this._moddle = moddle;
  this._translate = translate;
}

(0, _inherits2.default)(ElementFactory, _ElementFactory2.default);

ElementFactory.$inject = ['bpmnFactory', 'moddle', 'translate'];

ElementFactory.prototype.baseCreate = _ElementFactory2.default.prototype.create;

ElementFactory.prototype.create = function (elementType, attrs) {
  // no special magic for labels,
  // we assume their businessObjects have already been created
  // and wired via attrs
  if (elementType === 'label') {
    return this.baseCreate(elementType, (0, _minDash.assign)({ type: 'label' }, _LabelUtil.DEFAULT_LABEL_SIZE, attrs));
  }

  return this.createBpmnElement(elementType, attrs);
};

ElementFactory.prototype.createBpmnElement = function (elementType, attrs) {
  var size,
      translate = this._translate;

  attrs = attrs || {};

  var businessObject = attrs.businessObject;

  if (!businessObject) {
    if (!attrs.type) {
      throw new Error(translate('no shape type specified'));
    }

    businessObject = this._bpmnFactory.create(attrs.type);
  }

  if (!businessObject.di) {
    if (elementType === 'root') {
      businessObject.di = this._bpmnFactory.createDiPlane(businessObject, [], {
        id: businessObject.id + '_di'
      });
    } else if (elementType === 'connection') {
      businessObject.di = this._bpmnFactory.createDiEdge(businessObject, [], {
        id: businessObject.id + '_di'
      });
    } else {
      businessObject.di = this._bpmnFactory.createDiShape(businessObject, {}, {
        id: businessObject.id + '_di'
      });
    }
  }

  if (attrs.colors) {
    (0, _minDash.assign)(businessObject.di, attrs.colors);

    delete attrs.colors;
  }

  applyAttributes(businessObject, attrs, ['processRef', 'isInterrupting', 'associationDirection', 'isForCompensation']);

  if (attrs.isExpanded) {
    applyAttribute(businessObject.di, attrs, 'isExpanded');
  }

  if ((0, _ModelUtil.is)(businessObject, 'bpmn:ExclusiveGateway')) {
    businessObject.di.isMarkerVisible = true;
  }

  var eventDefinitions, newEventDefinition;

  if (attrs.eventDefinitionType) {
    eventDefinitions = businessObject.get('eventDefinitions') || [];
    newEventDefinition = this._moddle.create(attrs.eventDefinitionType);

    if (attrs.eventDefinitionType === 'bpmn:ConditionalEventDefinition') {
      newEventDefinition.condition = this._moddle.create('bpmn:FormalExpression');
    }

    eventDefinitions.push(newEventDefinition);

    newEventDefinition.$parent = businessObject;
    businessObject.eventDefinitions = eventDefinitions;

    delete attrs.eventDefinitionType;
  }

  size = this._getDefaultSize(businessObject);

  attrs = (0, _minDash.assign)({
    businessObject: businessObject,
    id: businessObject.id
  }, size, attrs);

  return this.baseCreate(elementType, attrs);
};

ElementFactory.prototype._getDefaultSize = function (semantic) {

  if ((0, _ModelUtil.is)(semantic, 'bpmn:SubProcess')) {

    if ((0, _DiUtil.isExpanded)(semantic)) {
      return { width: 350, height: 200 };
    } else {
      return { width: 100, height: 80 };
    }
  }

  if ((0, _ModelUtil.is)(semantic, 'bpmn:Task')) {
    return { width: 100, height: 80 };
  }

  if ((0, _ModelUtil.is)(semantic, 'bpmn:Gateway')) {
    return { width: 50, height: 50 };
  }

  if ((0, _ModelUtil.is)(semantic, 'bpmn:Event')) {
    return { width: 36, height: 36 };
  }

  if ((0, _ModelUtil.is)(semantic, 'bpmn:Participant')) {
    if (!(0, _DiUtil.isExpanded)(semantic)) {
      return { width: 400, height: 100 };
    } else {
      return { width: 600, height: 250 };
    }
  }

  if ((0, _ModelUtil.is)(semantic, 'bpmn:Lane')) {
    return { width: 400, height: 100 };
  }

  if ((0, _ModelUtil.is)(semantic, 'bpmn:DataObjectReference')) {
    return { width: 36, height: 50 };
  }

  if ((0, _ModelUtil.is)(semantic, 'bpmn:DataStoreReference')) {
    return { width: 50, height: 50 };
  }

  if ((0, _ModelUtil.is)(semantic, 'bpmn:TextAnnotation')) {
    return { width: 100, height: 30 };
  }

  return { width: 100, height: 80 };
};

ElementFactory.prototype.createParticipantShape = function (collapsed) {

  var attrs = { type: 'bpmn:Participant' };

  if (!collapsed) {
    attrs.processRef = this._bpmnFactory.create('bpmn:Process');
  }

  return this.createShape(attrs);
};

// helpers //////////////////////

/**
 * 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) {

  (0, _minDash.forEach)(attributeNames, function (property) {
    if (attrs[property] !== undefined) {
      applyAttribute(element, attrs, property);
    }
  });
}

/**
 * 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];

  delete attrs[attributeName];
}

},{"../../util/DiUtil":214,"../../util/LabelUtil":215,"../../util/ModelUtil":216,"diagram-js/lib/core/ElementFactory":247,"inherits":415,"min-dash":505}],149:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = Modeling;

var _inherits = require('inherits');

var _inherits2 = _interopRequireDefault(_inherits);

var _Modeling = require('diagram-js/lib/features/modeling/Modeling');

var _Modeling2 = _interopRequireDefault(_Modeling);

var _UpdatePropertiesHandler = require('./cmd/UpdatePropertiesHandler');

var _UpdatePropertiesHandler2 = _interopRequireDefault(_UpdatePropertiesHandler);

var _UpdateCanvasRootHandler = require('./cmd/UpdateCanvasRootHandler');

var _UpdateCanvasRootHandler2 = _interopRequireDefault(_UpdateCanvasRootHandler);

var _AddLaneHandler = require('./cmd/AddLaneHandler');

var _AddLaneHandler2 = _interopRequireDefault(_AddLaneHandler);

var _SplitLaneHandler = require('./cmd/SplitLaneHandler');

var _SplitLaneHandler2 = _interopRequireDefault(_SplitLaneHandler);

var _ResizeLaneHandler = require('./cmd/ResizeLaneHandler');

var _ResizeLaneHandler2 = _interopRequireDefault(_ResizeLaneHandler);

var _UpdateFlowNodeRefsHandler = require('./cmd/UpdateFlowNodeRefsHandler');

var _UpdateFlowNodeRefsHandler2 = _interopRequireDefault(_UpdateFlowNodeRefsHandler);

var _IdClaimHandler = require('./cmd/IdClaimHandler');

var _IdClaimHandler2 = _interopRequireDefault(_IdClaimHandler);

var _SetColorHandler = require('./cmd/SetColorHandler');

var _SetColorHandler2 = _interopRequireDefault(_SetColorHandler);

var _UpdateLabelHandler = require('../label-editing/cmd/UpdateLabelHandler');

var _UpdateLabelHandler2 = _interopRequireDefault(_UpdateLabelHandler);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * BPMN 2.0 modeling features activator
 *
 * @param {EventBus} eventBus
 * @param {ElementFactory} elementFactory
 * @param {CommandStack} commandStack
 * @param {BpmnRules} bpmnRules
 */
function Modeling(eventBus, elementFactory, commandStack, bpmnRules) {

  _Modeling2.default.call(this, eventBus, elementFactory, commandStack);

  this._bpmnRules = bpmnRules;
}

(0, _inherits2.default)(Modeling, _Modeling2.default);

Modeling.$inject = ['eventBus', 'elementFactory', 'commandStack', 'bpmnRules'];

Modeling.prototype.getHandlers = function () {
  var handlers = _Modeling2.default.prototype.getHandlers.call(this);

  handlers['element.updateProperties'] = _UpdatePropertiesHandler2.default;
  handlers['canvas.updateRoot'] = _UpdateCanvasRootHandler2.default;
  handlers['lane.add'] = _AddLaneHandler2.default;
  handlers['lane.resize'] = _ResizeLaneHandler2.default;
  handlers['lane.split'] = _SplitLaneHandler2.default;
  handlers['lane.updateRefs'] = _UpdateFlowNodeRefsHandler2.default;
  handlers['id.updateClaim'] = _IdClaimHandler2.default;
  handlers['element.setColor'] = _SetColorHandler2.default;
  handlers['element.updateLabel'] = _UpdateLabelHandler2.default;

  return handlers;
};

Modeling.prototype.updateLabel = function (element, newLabel, newBounds, hints) {
  this._commandStack.execute('element.updateLabel', {
    element: element,
    newLabel: newLabel,
    newBounds: newBounds,
    hints: hints || {}
  });
};

Modeling.prototype.connect = function (source, target, attrs, hints) {

  var bpmnRules = this._bpmnRules;

  if (!attrs) {
    attrs = bpmnRules.canConnect(source, target);
  }

  if (!attrs) {
    return;
  }

  return this.createConnection(source, target, attrs, source.parent, hints);
};

Modeling.prototype.updateProperties = function (element, properties) {
  this._commandStack.execute('element.updateProperties', {
    element: element,
    properties: properties
  });
};

Modeling.prototype.resizeLane = function (laneShape, newBounds, balanced) {
  this._commandStack.execute('lane.resize', {
    shape: laneShape,
    newBounds: newBounds,
    balanced: balanced
  });
};

Modeling.prototype.addLane = function (targetLaneShape, location) {
  var context = {
    shape: targetLaneShape,
    location: location
  };

  this._commandStack.execute('lane.add', context);

  return context.newLane;
};

Modeling.prototype.splitLane = function (targetLane, count) {
  this._commandStack.execute('lane.split', {
    shape: targetLane,
    count: count
  });
};

/**
 * Transform the current diagram into a collaboration.
 *
 * @return {djs.model.Root} the new root element
 */
Modeling.prototype.makeCollaboration = function () {

  var collaborationElement = this._create('root', {
    type: 'bpmn:Collaboration'
  });

  var context = {
    newRoot: collaborationElement
  };

  this._commandStack.execute('canvas.updateRoot', context);

  return collaborationElement;
};

Modeling.prototype.updateLaneRefs = function (flowNodeShapes, laneShapes) {

  this._commandStack.execute('lane.updateRefs', {
    flowNodeShapes: flowNodeShapes,
    laneShapes: laneShapes
  });
};

/**
 * Transform the current diagram into a process.
 *
 * @return {djs.model.Root} the new root element
 */
Modeling.prototype.makeProcess = function () {

  var processElement = this._create('root', {
    type: 'bpmn:Process'
  });

  var context = {
    newRoot: processElement
  };

  this._commandStack.execute('canvas.updateRoot', context);
};

Modeling.prototype.claimId = function (id, moddleElement) {
  this._commandStack.execute('id.updateClaim', {
    id: id,
    element: moddleElement,
    claiming: true
  });
};

Modeling.prototype.unclaimId = function (id, moddleElement) {
  this._commandStack.execute('id.updateClaim', {
    id: id,
    element: moddleElement
  });
};

Modeling.prototype.setColor = function (elements, colors) {
  if (!elements.length) {
    elements = [elements];
  }

  this._commandStack.execute('element.setColor', {
    elements: elements,
    colors: colors
  });
};

},{"../label-editing/cmd/UpdateLabelHandler":143,"./cmd/AddLaneHandler":178,"./cmd/IdClaimHandler":179,"./cmd/ResizeLaneHandler":180,"./cmd/SetColorHandler":181,"./cmd/SplitLaneHandler":182,"./cmd/UpdateCanvasRootHandler":183,"./cmd/UpdateFlowNodeRefsHandler":184,"./cmd/UpdatePropertiesHandler":185,"diagram-js/lib/features/modeling/Modeling":305,"inherits":415}],150:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = AdaptiveLabelPositioningBehavior;

var _inherits = require('inherits');

var _inherits2 = _interopRequireDefault(_inherits);

var _LayoutUtil = require('diagram-js/lib/layout/LayoutUtil');

var _Math = require('diagram-js/lib/util/Math');

var _LabelUtil = require('../../../util/LabelUtil');

var _CommandInterceptor = require('diagram-js/lib/command/CommandInterceptor');

var _CommandInterceptor2 = _interopRequireDefault(_CommandInterceptor);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * 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) {

  _CommandInterceptor2.default.call(this, eventBus);

  this.postExecuted(['connection.create', 'connection.layout', 'connection.reconnectEnd', 'connection.reconnectStart', 'connection.updateWaypoints'], function (event) {

    var context = event.context,
        connection = context.connection;

    var source = connection.source,
        target = connection.target;

    checkLabelAdjustment(source);
    checkLabelAdjustment(target);
  });

  this.postExecuted(['label.create'], function (event) {
    checkLabelAdjustment(event.context.shape.labelTarget);
  });

  function checkLabelAdjustment(element) {

    // skip non-existing labels
    if (!(0, _LabelUtil.hasExternalLabel)(element)) {
      return;
    }

    var optimalPosition = getOptimalPosition(element);

    // no optimal position found
    if (!optimalPosition) {
      return;
    }

    adjustLabelPosition(element, optimalPosition);
  }

  var ELEMENT_LABEL_DISTANCE = 10;

  function adjustLabelPosition(element, orientation) {

    var elementMid = (0, _LayoutUtil.getMid)(element),
        label = element.label,
        labelMid = (0, _LayoutUtil.getMid)(label);

    var elementTrbl = (0, _LayoutUtil.asTRBL)(element);

    var newLabelMid;

    switch (orientation) {
      case 'top':
        newLabelMid = {
          x: elementMid.x,
          y: elementTrbl.top - ELEMENT_LABEL_DISTANCE - label.height / 2
        };

        break;

      case 'left':

        newLabelMid = {
          x: elementTrbl.left - ELEMENT_LABEL_DISTANCE - label.width / 2,
          y: elementMid.y
        };

        break;

      case 'bottom':

        newLabelMid = {
          x: elementMid.x,
          y: elementTrbl.bottom + ELEMENT_LABEL_DISTANCE + label.height / 2
        };

        break;

      case 'right':

        newLabelMid = {
          x: elementTrbl.right + ELEMENT_LABEL_DISTANCE + label.width / 2,
          y: elementMid.y
        };

        break;
    }

    var delta = (0, _Math.substract)(newLabelMid, labelMid);

    modeling.moveShape(label, delta);
  }
}

(0, _inherits2.default)(AdaptiveLabelPositioningBehavior, _CommandInterceptor2.default);

AdaptiveLabelPositioningBehavior.$inject = ['eventBus', 'modeling'];

/**
 * Return the optimal label position around an element
 * or _undefined_, if none was found.
 *
 * @param  {Shape} element
 *
 * @return {String} positioning identifier
 */
function getOptimalPosition(element) {

  var labelMid = (0, _LayoutUtil.getMid)(element.label);

  var elementMid = (0, _LayoutUtil.getMid)(element);

  var labelOrientation = getApproximateOrientation(elementMid, labelMid);

  if (!isAligned(labelOrientation)) {
    return;
  }

  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);
  });

  var freeAlignments = ALIGNMENTS.filter(function (alignment) {

    return takenAlignments.indexOf(alignment) === -1;
  });

  // NOTHING TO DO; label already aligned a.O.K.
  if (freeAlignments.indexOf(labelOrientation) !== -1) {
    return;
  }

  return freeAlignments[0];
}

var ALIGNMENTS = ['top', 'bottom', 'left', 'right'];

function getApproximateOrientation(p0, p1) {
  return (0, _LayoutUtil.getOrientation)(p1, p0, 5);
}

function isAligned(orientation) {
  return ALIGNMENTS.indexOf(orientation) !== -1;
}

},{"../../../util/LabelUtil":215,"diagram-js/lib/command/CommandInterceptor":243,"diagram-js/lib/layout/LayoutUtil":380,"diagram-js/lib/util/Math":402,"inherits":415}],151:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = AppendBehavior;

var _inherits = require('inherits');

var _inherits2 = _interopRequireDefault(_inherits);

var _ModelUtil = require('../../../util/ModelUtil');

var _CommandInterceptor = require('diagram-js/lib/command/CommandInterceptor');

var _CommandInterceptor2 = _interopRequireDefault(_CommandInterceptor);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function AppendBehavior(eventBus, elementFactory, bpmnRules) {

  _CommandInterceptor2.default.call(this, eventBus);

  // assign correct shape position unless already set

  this.preExecute('shape.append', function (context) {

    var source = context.source,
        shape = context.shape;

    if (!context.position) {

      if ((0, _ModelUtil.is)(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);
}

(0, _inherits2.default)(AppendBehavior, _CommandInterceptor2.default);

AppendBehavior.$inject = ['eventBus', 'elementFactory', 'bpmnRules'];

},{"../../../util/ModelUtil":216,"diagram-js/lib/command/CommandInterceptor":243,"inherits":415}],152:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = BoundaryEventBehavior;

var _inherits = require('inherits');

var _inherits2 = _interopRequireDefault(_inherits);

var _CommandInterceptor = require('diagram-js/lib/command/CommandInterceptor');

var _CommandInterceptor2 = _interopRequireDefault(_CommandInterceptor);

var _ModelUtil = require('../../../util/ModelUtil');

var _minDash = require('min-dash');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * BPMN specific boundary event behavior
 */
function BoundaryEventBehavior(eventBus, modeling) {

  _CommandInterceptor2.default.call(this, eventBus);

  function getBoundaryEvents(element) {
    return (0, _minDash.filter)(element.attachers, function (attacher) {
      return (0, _ModelUtil.is)(attacher, 'bpmn:BoundaryEvent');
    });
  }

  // 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);

    if ((0, _ModelUtil.is)(source, 'bpmn:EventBasedGateway') && (0, _ModelUtil.is)(target, 'bpmn:ReceiveTask') && boundaryEvents.length > 0) {
      modeling.removeElements(boundaryEvents);
    }
  });

  // remove after replacing connected gateway with event-based gateway
  this.postExecute('connection.reconnectStart', function (event) {
    var oldSource = event.context.oldSource,
        newSource = event.context.newSource;

    if ((0, _ModelUtil.is)(oldSource, 'bpmn:Gateway') && (0, _ModelUtil.is)(newSource, 'bpmn:EventBasedGateway')) {
      (0, _minDash.forEach)(newSource.outgoing, function (connection) {
        var target = connection.target,
            attachedboundaryEvents = getBoundaryEvents(target);

        if ((0, _ModelUtil.is)(target, 'bpmn:ReceiveTask') && attachedboundaryEvents.length > 0) {
          modeling.removeElements(attachedboundaryEvents);
        }
      });
    }
  });
}

BoundaryEventBehavior.$inject = ['eventBus', 'modeling'];

(0, _inherits2.default)(BoundaryEventBehavior, _CommandInterceptor2.default);

},{"../../../util/ModelUtil":216,"diagram-js/lib/command/CommandInterceptor":243,"inherits":415,"min-dash":505}],153:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = CopyPasteBehavior;

var _inherits = require('inherits');

var _inherits2 = _interopRequireDefault(_inherits);

var _minDash = require('min-dash');

var _ModelUtil = require('../../../util/ModelUtil');

var _CommandInterceptor = require('diagram-js/lib/command/CommandInterceptor');

var _CommandInterceptor2 = _interopRequireDefault(_CommandInterceptor);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function CopyPasteBehavior(eventBus, modeling, canvas) {

  _CommandInterceptor2.default.call(this, eventBus);

  this.preExecute('elements.paste', 1500, function (context) {
    var topParent = context.topParent;

    // always grab the latest root
    if (!topParent.parent) {
      context.topParent = canvas.getRootElement();
    }

    if ((0, _ModelUtil.is)(topParent, 'bpmn:Lane')) {
      do {
        // unwrap Lane -> LaneSet -> (Lane | FlowElementsContainer)
        topParent = context.topParent = topParent.parent;
      } while ((0, _ModelUtil.is)(topParent, 'bpmn:Lane') || !(0, _ModelUtil.is)(topParent, 'bpmn:Participant'));
    }
  }, true);

  this.postExecute('elements.paste', function (context) {

    var tree = context.tree,
        createdElements = tree.createdElements;

    (0, _minDash.forEach)(createdElements, function (data) {
      var element = data.element,
          businessObject = element.businessObject,
          descriptor = data.descriptor,
          defaultFlow;

      if (((0, _ModelUtil.is)(businessObject, 'bpmn:ExclusiveGateway') || (0, _ModelUtil.is)(businessObject, 'bpmn:InclusiveGateway') || (0, _ModelUtil.is)(businessObject, 'bpmn:Activity')) && descriptor.default) {

        defaultFlow = createdElements[descriptor.default];

        // if the default flow wasn't created, means that it wasn't copied
        if (defaultFlow) {
          defaultFlow = defaultFlow.element;
        } else {
          defaultFlow = undefined;
        }

        delete element.default;

        modeling.updateProperties(element, { default: defaultFlow });
      }
    });
  }, true);
}

CopyPasteBehavior.$inject = ['eventBus', 'modeling', 'canvas'];

(0, _inherits2.default)(CopyPasteBehavior, _CommandInterceptor2.default);

},{"../../../util/ModelUtil":216,"diagram-js/lib/command/CommandInterceptor":243,"inherits":415,"min-dash":505}],154:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = CreateBoundaryEventBehavior;

var _inherits = require('inherits');

var _inherits2 = _interopRequireDefault(_inherits);

var _CommandInterceptor = require('diagram-js/lib/command/CommandInterceptor');

var _CommandInterceptor2 = _interopRequireDefault(_CommandInterceptor);

var _ModelUtil = require('../../../util/ModelUtil');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * BPMN specific create boundary event behavior
 */
function CreateBoundaryEventBehavior(eventBus, modeling, elementFactory, bpmnFactory) {

  _CommandInterceptor2.default.call(this, eventBus);

  /**
   * replace intermediate event with boundary event when
   * attaching it to a shape
   */

  this.preExecute('shape.create', function (context) {
    var shape = context.shape,
        host = context.host,
        businessObject,
        boundaryEvent;

    var attrs = {
      cancelActivity: true
    };

    if (host && (0, _ModelUtil.is)(shape, 'bpmn:IntermediateThrowEvent')) {
      attrs.attachedToRef = host.businessObject;

      businessObject = bpmnFactory.create('bpmn:BoundaryEvent', attrs);

      boundaryEvent = {
        type: 'bpmn:BoundaryEvent',
        businessObject: businessObject
      };

      context.shape = elementFactory.createShape(boundaryEvent);
    }
  }, true);
}

CreateBoundaryEventBehavior.$inject = ['eventBus', 'modeling', 'elementFactory', 'bpmnFactory'];

(0, _inherits2.default)(CreateBoundaryEventBehavior, _CommandInterceptor2.default);

},{"../../../util/ModelUtil":216,"diagram-js/lib/command/CommandInterceptor":243,"inherits":415}],155:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = CreateDataObjectBehavior;

var _inherits = require('inherits');

var _inherits2 = _interopRequireDefault(_inherits);

var _CommandInterceptor = require('diagram-js/lib/command/CommandInterceptor');

var _CommandInterceptor2 = _interopRequireDefault(_CommandInterceptor);

var _ModelUtil = require('../../../util/ModelUtil');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * BPMN specific create data object behavior
 */
function CreateDataObjectBehavior(eventBus, bpmnFactory, moddle) {

  _CommandInterceptor2.default.call(this, eventBus);

  this.preExecute('shape.create', function (event) {

    var context = event.context,
        shape = context.shape;

    if ((0, _ModelUtil.is)(shape, 'bpmn:DataObjectReference') && shape.type !== 'label') {

      // create a DataObject every time a DataObjectReference is created
      var dataObject = bpmnFactory.create('bpmn:DataObject');

      // set the reference to the DataObject
      shape.businessObject.dataObjectRef = dataObject;
    }
  });
}

CreateDataObjectBehavior.$inject = ['eventBus', 'bpmnFactory', 'moddle'];

(0, _inherits2.default)(CreateDataObjectBehavior, _CommandInterceptor2.default);

},{"../../../util/ModelUtil":216,"diagram-js/lib/command/CommandInterceptor":243,"inherits":415}],156:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = CreateParticipantBehavior;

var _inherits = require('inherits');

var _inherits2 = _interopRequireDefault(_inherits);

var _CommandInterceptor = require('diagram-js/lib/command/CommandInterceptor');

var _CommandInterceptor2 = _interopRequireDefault(_CommandInterceptor);

var _ModelUtil = require('../../../util/ModelUtil');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * BPMN specific create participant behavior
 */
function CreateParticipantBehavior(eventBus, modeling, elementFactory, bpmnFactory, canvas) {

  _CommandInterceptor2.default.call(this, eventBus);

  /**
   * morph process into collaboration before adding
   * participant onto collaboration
   */

  this.preExecute('shape.create', function (context) {

    var parent = context.parent,
        shape = context.shape,
        position = context.position;

    var rootElement = canvas.getRootElement();

    if ((0, _ModelUtil.is)(parent, 'bpmn:Process') && (0, _ModelUtil.is)(shape, 'bpmn:Participant') && !(0, _ModelUtil.is)(rootElement, 'bpmn:Collaboration')) {

      // this is going to detach the process root
      // and set the returned collaboration element
      // as the new root element
      var collaborationElement = modeling.makeCollaboration();

      // monkey patch the create context
      // so that the participant is being dropped
      // onto the new collaboration root instead
      context.position = position;
      context.parent = collaborationElement;

      context.processRoot = parent;
    }
  }, true);

  this.execute('shape.create', function (context) {

    var processRoot = context.processRoot,
        shape = context.shape;

    if (processRoot) {
      context.oldProcessRef = shape.businessObject.processRef;

      // assign the participant processRef
      shape.businessObject.processRef = processRoot.businessObject;
    }
  }, true);

  this.revert('shape.create', function (context) {
    var processRoot = context.processRoot,
        shape = context.shape;

    if (processRoot) {
      // assign the participant processRef
      shape.businessObject.processRef = context.oldProcessRef;
    }
  }, true);

  this.postExecute('shape.create', function (context) {

    var processRoot = context.processRoot,
        shape = context.shape;

    if (processRoot) {
      // process root is already detached at this point
      var processChildren = processRoot.children.slice();
      modeling.moveElements(processChildren, { x: 0, y: 0 }, shape);
    }
  }, true);
}

CreateParticipantBehavior.$inject = ['eventBus', 'modeling', 'elementFactory', 'bpmnFactory', 'canvas'];

(0, _inherits2.default)(CreateParticipantBehavior, _CommandInterceptor2.default);

},{"../../../util/ModelUtil":216,"diagram-js/lib/command/CommandInterceptor":243,"inherits":415}],157:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = DataInputAssociationBehavior;

var _inherits = require('inherits');

var _inherits2 = _interopRequireDefault(_inherits);

var _CommandInterceptor = require('diagram-js/lib/command/CommandInterceptor');

var _CommandInterceptor2 = _interopRequireDefault(_CommandInterceptor);

var _Collections = require('diagram-js/lib/util/Collections');

var _minDash = require('min-dash');

var _ModelUtil = require('../../../util/ModelUtil');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var TARGET_REF_PLACEHOLDER_NAME = '__targetRef_placeholder';

/**
 * 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) {

  _CommandInterceptor2.default.call(this, eventBus);

  this.executed(['connection.create', 'connection.delete', 'connection.move', 'connection.reconnectEnd'], ifDataInputAssociation(fixTargetRef));

  this.reverted(['connection.create', 'connection.delete', 'connection.move', 'connection.reconnectEnd'], ifDataInputAssociation(fixTargetRef));

  function usesTargetRef(element, targetRef, removedConnection) {

    var inputAssociations = element.get('dataInputAssociations');

    return (0, _minDash.find)(inputAssociations, function (association) {
      return association !== removedConnection && association.targetRef === targetRef;
    });
  }

  function getTargetRef(element, create) {

    var properties = element.get('properties');

    var targetRefProp = (0, _minDash.find)(properties, function (p) {
      return p.name === TARGET_REF_PLACEHOLDER_NAME;
    });

    if (!targetRefProp && create) {
      targetRefProp = bpmnFactory.create('bpmn:Property', {
        name: TARGET_REF_PLACEHOLDER_NAME
      });

      (0, _Collections.add)(properties, targetRefProp);
    }

    return targetRefProp;
  }

  function cleanupTargetRef(element, connection) {

    var targetRefProp = getTargetRef(element);

    if (!targetRefProp) {
      return;
    }

    if (!usesTargetRef(element, targetRefProp, connection)) {
      (0, _Collections.remove)(element.get('properties'), targetRefProp);
    }
  }

  /**
   * Make sure targetRef is set to a valid property or
   * `null` if the connection is detached.
   *
   * @param {Event} event
   */
  function fixTargetRef(event) {

    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;

    var dataAssociation = connection.businessObject,
        targetRefProp;

    if (oldTargetBo && oldTargetBo !== targetBo) {
      cleanupTargetRef(oldTargetBo, connectionBo);
    }

    if (newTargetBo && newTargetBo !== targetBo) {
      cleanupTargetRef(newTargetBo, connectionBo);
    }

    if (targetBo) {
      targetRefProp = getTargetRef(targetBo, true);
      dataAssociation.targetRef = targetRefProp;
    } else {
      dataAssociation.targetRef = null;
    }
  }
}

DataInputAssociationBehavior.$inject = ['eventBus', 'bpmnFactory'];

(0, _inherits2.default)(DataInputAssociationBehavior, _CommandInterceptor2.default);

/**
 * Only call the given function when the event
 * touches a bpmn:DataInputAssociation.
 *
 * @param {Function} fn
 * @return {Function}
 */
function ifDataInputAssociation(fn) {

  return function (event) {
    var context = event.context,
        connection = context.connection;

    if ((0, _ModelUtil.is)(connection, 'bpmn:DataInputAssociation')) {
      return fn(event);
    }
  };
}

},{"../../../util/ModelUtil":216,"diagram-js/lib/command/CommandInterceptor":243,"diagram-js/lib/util/Collections":393,"inherits":415,"min-dash":505}],158:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = DataStoreBehavior;

var _inherits = require('inherits');

var _inherits2 = _interopRequireDefault(_inherits);

var _CommandInterceptor = require('diagram-js/lib/command/CommandInterceptor');

var _CommandInterceptor2 = _interopRequireDefault(_CommandInterceptor);

var _ModelUtil = require('../../../util/ModelUtil');

var _ModelingUtil = require('../util/ModelingUtil');

var _UpdateSemanticParentHandler = require('../cmd/UpdateSemanticParentHandler');

var _UpdateSemanticParentHandler2 = _interopRequireDefault(_UpdateSemanticParentHandler);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * BPMN specific data store behavior
 */
function DataStoreBehavior(canvas, commandStack, elementRegistry, eventBus) {

  _CommandInterceptor2.default.call(this, eventBus);

  commandStack.registerHandler('dataStore.updateContainment', _UpdateSemanticParentHandler2.default);

  function getFirstParticipant() {
    return elementRegistry.filter(function (element) {
      return (0, _ModelUtil.is)(element, 'bpmn:Participant');
    })[0];
  }

  function getDataStores(element) {
    return element.children.filter(function (child) {
      return (0, _ModelUtil.is)(child, 'bpmn:DataStoreReference') && !child.labelTarget;
    });
  }

  function updateDataStoreParent(dataStore, newDataStoreParent) {
    var dataStoreBo = dataStore.businessObject || dataStore;

    newDataStoreParent = newDataStoreParent || getFirstParticipant();

    if (newDataStoreParent) {
      var newDataStoreParentBo = newDataStoreParent.businessObject || newDataStoreParent;

      commandStack.execute('dataStore.updateContainment', {
        dataStoreBo: dataStoreBo,
        newSemanticParent: newDataStoreParentBo.processRef || newDataStoreParentBo,
        newDiParent: newDataStoreParentBo.di
      });
    }
  }

  // disable auto-resize for data stores
  this.preExecute('shape.create', function (event) {

    var context = event.context,
        shape = context.shape;

    if ((0, _ModelUtil.is)(shape, 'bpmn:DataStoreReference') && shape.type !== 'label') {

      if (!context.hints) {
        context.hints = {};
      }

      // prevent auto resizing
      context.hints.autoResize = false;
    }
  });

  // disable auto-resize for data stores
  this.preExecute('elements.move', function (event) {
    var context = event.context,
        shapes = context.shapes;

    var dataStoreReferences = shapes.filter(function (shape) {
      return (0, _ModelUtil.is)(shape, 'bpmn:DataStoreReference');
    });

    if (dataStoreReferences.length) {
      if (!context.hints) {
        context.hints = {};
      }

      // prevent auto resizing for data store references
      context.hints.autoResize = shapes.filter(function (shape) {
        return !(0, _ModelUtil.is)(shape, 'bpmn:DataStoreReference');
      });
    }
  });

  // update parent on data store created
  this.postExecute('shape.create', function (event) {
    var context = event.context,
        shape = context.shape,
        parent = shape.parent;

    if ((0, _ModelUtil.is)(shape, 'bpmn:DataStoreReference') && shape.type !== 'label' && (0, _ModelUtil.is)(parent, 'bpmn:Collaboration')) {

      updateDataStoreParent(shape);
    }
  });

  // 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;

    if ((0, _ModelUtil.is)(oldParent, 'bpmn:Collaboration')) {

      // do nothing if not necessary
      return;
    }

    if ((0, _ModelUtil.is)(shape, 'bpmn:DataStoreReference') && shape.type !== 'label' && (0, _ModelUtil.is)(parent, 'bpmn:Collaboration')) {

      var participant = (0, _ModelUtil.is)(oldParent, 'bpmn:Participant') ? oldParent : getAncestor(oldParent, 'bpmn:Participant');

      updateDataStoreParent(shape, participant);
    }
  });

  // 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();

    if ((0, _ModelingUtil.isAny)(shape, ['bpmn:Participant', 'bpmn:SubProcess']) && (0, _ModelUtil.is)(rootElement, 'bpmn:Collaboration')) {
      getDataStores(rootElement).filter(function (dataStore) {
        return isDescendant(dataStore, shape);
      }).forEach(function (dataStore) {
        updateDataStoreParent(dataStore);
      });
    }
  });

  // update data store parents on collaboration -> process
  this.postExecute('canvas.updateRoot', function (event) {
    var context = event.context,
        oldRoot = context.oldRoot,
        newRoot = context.newRoot;

    var dataStores = getDataStores(oldRoot);

    dataStores.forEach(function (dataStore) {

      if ((0, _ModelUtil.is)(newRoot, 'bpmn:Process')) {
        updateDataStoreParent(dataStore, newRoot);
      }
    });
  });
}

DataStoreBehavior.$inject = ['canvas', 'commandStack', 'elementRegistry', 'eventBus'];

(0, _inherits2.default)(DataStoreBehavior, _CommandInterceptor2.default);

// helpers //////////

function isDescendant(descendant, ancestor) {
  var descendantBo = descendant.businessObject || descendant,
      ancestorBo = ancestor.businessObject || ancestor;

  while (descendantBo.$parent) {
    if (descendantBo.$parent === ancestorBo.processRef || ancestorBo) {
      return true;
    }

    descendantBo = descendantBo.$parent;
  }

  return false;
}

function getAncestor(element, type) {

  while (element.parent) {
    if ((0, _ModelUtil.is)(element.parent, type)) {
      return element.parent;
    }

    element = element.parent;
  }
}

},{"../../../util/ModelUtil":216,"../cmd/UpdateSemanticParentHandler":186,"../util/ModelingUtil":189,"diagram-js/lib/command/CommandInterceptor":243,"inherits":415}],159:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = DeleteLaneBehavior;

var _inherits = require('inherits');

var _inherits2 = _interopRequireDefault(_inherits);

var _CommandInterceptor = require('diagram-js/lib/command/CommandInterceptor');

var _CommandInterceptor2 = _interopRequireDefault(_CommandInterceptor);

var _ModelUtil = require('../../../util/ModelUtil');

var _LaneUtil = require('../util/LaneUtil');

var _Elements = require('diagram-js/lib/util/Elements');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var LOW_PRIORITY = 500;

/**
 * BPMN specific delete lane behavior
 */
function DeleteLaneBehavior(eventBus, modeling, spaceTool) {

  _CommandInterceptor2.default.call(this, eventBus);

  function compensateLaneDelete(shape, oldParent) {

    var siblings = (0, _LaneUtil.getChildLanes)(oldParent);

    var topAffected = [];
    var bottomAffected = [];

    (0, _Elements.eachElement)(siblings, function (element) {

      if (element.y > shape.y) {
        bottomAffected.push(element);
      } else {
        topAffected.push(element);
      }

      return element.children;
    });

    if (!siblings.length) {
      return;
    }

    var offset;

    if (bottomAffected.length && topAffected.length) {
      offset = shape.height / 2;
    } else {
      offset = shape.height;
    }

    var topAdjustments, bottomAdjustments;

    if (topAffected.length) {
      topAdjustments = spaceTool.calculateAdjustments(topAffected, 'y', offset, shape.y - 10);

      spaceTool.makeSpace(topAdjustments.movingShapes, topAdjustments.resizingShapes, { x: 0, y: offset }, 's');
    }

    if (bottomAffected.length) {
      bottomAdjustments = spaceTool.calculateAdjustments(bottomAffected, 'y', -offset, shape.y + shape.height + 10);

      spaceTool.makeSpace(bottomAdjustments.movingShapes, bottomAdjustments.resizingShapes, { x: 0, y: -offset }, 'n');
    }
  }

  /**
   * Adjust sizes of other lanes after lane deletion
   */
  this.postExecuted('shape.delete', LOW_PRIORITY, function (event) {

    var context = event.context,
        hints = context.hints,
        shape = context.shape,
        oldParent = context.oldParent;

    // only compensate lane deletes
    if (!(0, _ModelUtil.is)(shape, 'bpmn:Lane')) {
      return;
    }

    // compensate root deletes only
    if (hints && hints.nested) {
      return;
    }

    compensateLaneDelete(shape, oldParent);
  });
}

DeleteLaneBehavior.$inject = ['eventBus', 'modeling', 'spaceTool'];

(0, _inherits2.default)(DeleteLaneBehavior, _CommandInterceptor2.default);

},{"../../../util/ModelUtil":216,"../util/LaneUtil":188,"diagram-js/lib/command/CommandInterceptor":243,"diagram-js/lib/util/Elements":396,"inherits":415}],160:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = DropOnFlowBehavior;

var _inherits = require('inherits');

var _inherits2 = _interopRequireDefault(_inherits);

var _minDash = require('min-dash');

var _CommandInterceptor = require('diagram-js/lib/command/CommandInterceptor');

var _CommandInterceptor2 = _interopRequireDefault(_CommandInterceptor);

var _LineIntersection = require('diagram-js/lib/util/LineIntersection');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function DropOnFlowBehavior(eventBus, bpmnRules, modeling) {

  _CommandInterceptor2.default.call(this, eventBus);

  /**
   * Reconnect start / end of a connection after
   * dropping an element on a flow.
   */

  function insertShape(shape, targetFlow, position) {
    var waypoints = targetFlow.waypoints,
        waypointsBefore,
        waypointsAfter,
        dockingPoint,
        source,
        target,
        incomingConnection,
        outgoingConnection,
        oldOutgoing = shape.outgoing.slice(),
        oldIncoming = shape.incoming.slice();

    var intersection = (0, _LineIntersection.getApproxIntersection)(waypoints, position);

    if (intersection) {
      waypointsBefore = waypoints.slice(0, intersection.index);
      waypointsAfter = waypoints.slice(intersection.index + (intersection.bendpoint ? 1 : 0));

      // due to inaccuracy intersection might have been found
      if (!waypointsBefore.length || !waypointsAfter.length) {
        return;
      }

      dockingPoint = intersection.bendpoint ? waypoints[intersection.index] : position;

      // if last waypointBefore is inside shape's bounds, ignore docking point
      if (!isPointInsideBBox(shape, waypointsBefore[waypointsBefore.length - 1])) {
        waypointsBefore.push(copy(dockingPoint));
      }

      // if first waypointAfter is inside shape's bounds, ignore docking point
      if (!isPointInsideBBox(shape, waypointsAfter[0])) {
        waypointsAfter.unshift(copy(dockingPoint));
      }
    }

    source = targetFlow.source;
    target = targetFlow.target;

    if (bpmnRules.canConnect(source, shape, targetFlow)) {
      // reconnect source -> inserted shape
      modeling.reconnectEnd(targetFlow, shape, waypointsBefore || position);

      incomingConnection = targetFlow;
    }

    if (bpmnRules.canConnect(shape, target, targetFlow)) {

      if (!incomingConnection) {
        // reconnect inserted shape -> end
        modeling.reconnectStart(targetFlow, shape, waypointsAfter || position);

        outgoingConnection = targetFlow;
      } else {
        outgoingConnection = modeling.connect(shape, target, { type: targetFlow.type, waypoints: waypointsAfter });
      }
    }

    var duplicateConnections = [].concat(incomingConnection && (0, _minDash.filter)(oldIncoming, function (connection) {
      return connection.source === incomingConnection.source;
    }) || [], outgoingConnection && (0, _minDash.filter)(oldOutgoing, function (connection) {
      return connection.source === outgoingConnection.source;
    }) || []);

    if (duplicateConnections.length) {
      modeling.removeElements(duplicateConnections);
    }
  }

  this.preExecute('elements.move', function (context) {

    var newParent = context.newParent,
        shapes = context.shapes,
        delta = context.delta,
        shape = shapes[0];

    if (!shape || !newParent) {
      return;
    }

    // if the new parent is a connection,
    // change it to the new parent's parent
    if (newParent && newParent.waypoints) {
      context.newParent = newParent = newParent.parent;
    }

    var shapeMid = getMid(shape);
    var newShapeMid = {
      x: shapeMid.x + delta.x,
      y: shapeMid.y + delta.y
    };

    // find a connection which intersects with the
    // element's mid point
    var connection = (0, _minDash.find)(newParent.children, function (element) {
      var canInsert = bpmnRules.canInsert(shapes, element);

      return canInsert && (0, _LineIntersection.getApproxIntersection)(element.waypoints, newShapeMid);
    });

    if (connection) {
      context.targetFlow = connection;
      context.position = newShapeMid;
    }
  }, true);

  this.postExecuted('elements.move', function (context) {

    var shapes = context.shapes,
        targetFlow = context.targetFlow,
        position = context.position;

    if (targetFlow) {
      insertShape(shapes[0], targetFlow, position);
    }
  }, true);

  this.preExecute('shape.create', function (context) {

    var parent = context.parent,
        shape = context.shape;

    if (bpmnRules.canInsert(shape, parent)) {
      context.targetFlow = parent;
      context.parent = parent.parent;
    }
  }, true);

  this.postExecuted('shape.create', function (context) {

    var shape = context.shape,
        targetFlow = context.targetFlow,
        position = context.position;

    if (targetFlow) {
      insertShape(shape, targetFlow, position);
    }
  }, true);
}

(0, _inherits2.default)(DropOnFlowBehavior, _CommandInterceptor2.default);

DropOnFlowBehavior.$inject = ['eventBus', 'bpmnRules', 'modeling'];

// helpers /////////////////////

function isPointInsideBBox(bbox, point) {
  var x = point.x,
      y = point.y;

  return x >= bbox.x && x <= bbox.x + bbox.width && y >= bbox.y && y <= bbox.y + bbox.height;
}

function copy(obj) {
  return (0, _minDash.assign)({}, obj);
}

function getMid(bounds) {

  return {
    x: Math.round(bounds.x + bounds.width / 2),
    y: Math.round(bounds.y + bounds.height / 2)
  };
}

},{"diagram-js/lib/command/CommandInterceptor":243,"diagram-js/lib/util/LineIntersection":401,"inherits":415,"min-dash":505}],161:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = ImportDockingFix;

var _LayoutUtil = require('diagram-js/lib/layout/LayoutUtil');

var _LineIntersect = require('./util/LineIntersect');

var _LineIntersect2 = _interopRequireDefault(_LineIntersect);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * Fix broken dockings after DI imports.
 *
 * @param {EventBus} eventBus
 */
function ImportDockingFix(eventBus) {

  function adjustDocking(startPoint, nextPoint, elementMid) {

    var elementTop = {
      x: elementMid.x,
      y: elementMid.y - 50
    };

    var elementLeft = {
      x: elementMid.x - 50,
      y: elementMid.y
    };

    var verticalIntersect = (0, _LineIntersect2.default)(startPoint, nextPoint, elementMid, elementTop),
        horizontalIntersect = (0, _LineIntersect2.default)(startPoint, nextPoint, elementMid, elementLeft);

    // original is horizontal or vertical center cross intersection
    var centerIntersect;

    if (verticalIntersect && horizontalIntersect) {
      if (getDistance(verticalIntersect, elementMid) > getDistance(horizontalIntersect, elementMid)) {
        centerIntersect = horizontalIntersect;
      } else {
        centerIntersect = verticalIntersect;
      }
    } else {
      centerIntersect = verticalIntersect || horizontalIntersect;
    }

    startPoint.original = centerIntersect;
  }

  function fixDockings(connection) {
    var waypoints = connection.waypoints;

    adjustDocking(waypoints[0], waypoints[1], (0, _LayoutUtil.getMid)(connection.source));

    adjustDocking(waypoints[waypoints.length - 1], waypoints[waypoints.length - 2], (0, _LayoutUtil.getMid)(connection.target));
  }

  eventBus.on('bpmnElement.added', function (e) {

    var element = e.element;

    if (element.waypoints) {
      fixDockings(element);
    }
  });
}

ImportDockingFix.$inject = ['eventBus'];

// helpers //////////////////////

function getDistance(p1, p2) {
  return Math.sqrt(Math.pow(p1.x - p2.x, 2) + Math.pow(p1.y - p2.y, 2));
}

},{"./util/LineIntersect":177,"diagram-js/lib/layout/LayoutUtil":380}],162:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = LabelBehavior;

var _minDash = require('min-dash');

var _inherits = require('inherits');

var _inherits2 = _interopRequireDefault(_inherits);

var _ModelUtil = require('../../../util/ModelUtil');

var _LabelUtil = require('../../../util/LabelUtil');

var _LabelLayoutUtil = require('./util/LabelLayoutUtil');

var _CommandInterceptor = require('diagram-js/lib/command/CommandInterceptor');

var _CommandInterceptor2 = _interopRequireDefault(_CommandInterceptor);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var DEFAULT_LABEL_DIMENSIONS = {
  width: 90,
  height: 20
};

var NAME_PROPERTY = 'name';
var TEXT_PROPERTY = 'text';

/**
 * 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) {

  _CommandInterceptor2.default.call(this, eventBus);

  // update label if name property was updated
  this.postExecute('element.updateProperties', function (e) {
    var context = e.context,
        element = context.element,
        properties = context.properties;

    if (NAME_PROPERTY in properties) {
      modeling.updateLabel(element, properties[NAME_PROPERTY]);
    }

    if (TEXT_PROPERTY in properties && (0, _ModelUtil.is)(element, 'bpmn:TextAnnotation')) {

      var newBounds = textRenderer.getTextAnnotationBounds({
        x: element.x,
        y: element.y,
        width: element.width,
        height: element.height
      }, properties[TEXT_PROPERTY] || '');

      modeling.updateLabel(element, properties.text, newBounds);
    }
  });

  // create label shape after shape/connection was created
  this.postExecute(['shape.create', 'connection.create'], function (e) {
    var context = e.context;

    var element = context.shape || context.connection,
        businessObject = element.businessObject;

    if (!(0, _LabelUtil.isLabelExternal)(element)) {
      return;
    }

    // only create label if name
    if (!businessObject.name) {
      return;
    }

    var labelCenter = (0, _LabelUtil.getExternalLabelMid)(element);

    // we don't care about x and y
    var labelDimensions = textRenderer.getExternalLabelBounds(DEFAULT_LABEL_DIMENSIONS, businessObject.name || '');

    modeling.createLabel(element, labelCenter, {
      id: businessObject.id + '_label',
      businessObject: businessObject,
      width: labelDimensions.width,
      height: labelDimensions.height
    });
  });

  // update label after label shape was deleted
  this.postExecute('shape.delete', function (event) {
    var context = event.context,
        labelTarget = context.labelTarget,
        hints = context.hints || {};

    // check if label
    if (labelTarget && hints.unsetLabel !== false) {
      modeling.updateLabel(labelTarget, null, null, { removeShape: false });
    }
  });

  // update di information on label creation
  this.postExecute(['label.create'], function (event) {

    var context = event.context,
        element = context.shape,
        businessObject,
        di;

    // we want to trigger on real labels only
    if (!element.labelTarget) {
      return;
    }

    // we want to trigger on BPMN elements only
    if (!(0, _ModelUtil.is)(element.labelTarget || element, 'bpmn:BaseElement')) {
      return;
    }

    businessObject = element.businessObject, di = businessObject.di;

    if (!di.label) {
      di.label = bpmnFactory.create('bpmndi:BPMNLabel', {
        bounds: bpmnFactory.create('dc:Bounds')
      });
    }

    (0, _minDash.assign)(di.label.bounds, {
      x: element.x,
      y: element.y,
      width: element.width,
      height: element.height
    });
  });

  function getVisibleLabelAdjustment(event) {

    var command = event.command,
        context = event.context,
        connection = context.connection,
        label = connection.label,
        hints = (0, _minDash.assign)({}, context.hints),
        newWaypoints = context.newWaypoints || connection.waypoints,
        oldWaypoints = context.oldWaypoints;

    if (typeof hints.startChanged === 'undefined') {
      hints.startChanged = command === 'connection.reconnectStart';
    }

    if (typeof hints.endChanged === 'undefined') {
      hints.endChanged = command === 'connection.reconnectEnd';
    }

    return (0, _LabelLayoutUtil.getLabelAdjustment)(label, newWaypoints, oldWaypoints, hints);
  }

  this.postExecute(['connection.layout', 'connection.reconnectEnd', 'connection.reconnectStart', 'connection.updateWaypoints'], function (event) {

    var label = event.context.connection.label,
        labelAdjustment;

    if (!label) {
      return;
    }

    labelAdjustment = getVisibleLabelAdjustment(event);

    modeling.moveShape(label, labelAdjustment);
  });

  // keep label position on shape replace
  this.postExecute(['shape.replace'], function (event) {
    var context = event.context,
        newShape = context.newShape,
        oldShape = context.oldShape;

    var businessObject = (0, _ModelUtil.getBusinessObject)(newShape);

    if (businessObject && (0, _LabelUtil.isLabelExternal)(businessObject) && oldShape.label && newShape.label) {
      newShape.label.x = oldShape.label.x;
      newShape.label.y = oldShape.label.y;
    }
  });
}

(0, _inherits2.default)(LabelBehavior, _CommandInterceptor2.default);

LabelBehavior.$inject = ['eventBus', 'modeling', 'bpmnFactory', 'textRenderer'];

},{"../../../util/LabelUtil":215,"../../../util/ModelUtil":216,"./util/LabelLayoutUtil":175,"diagram-js/lib/command/CommandInterceptor":243,"inherits":415,"min-dash":505}],163:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = ModelingFeedback;

var _ModelUtil = require('../../../util/ModelUtil');

var COLLAB_ERR_MSG = 'flow elements must be children of pools/participants',
    PROCESS_ERR_MSG = 'participants cannot be pasted onto a non-empty process diagram';

function ModelingFeedback(eventBus, tooltips, translate) {

  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>'
    });
  }

  eventBus.on(['shape.move.rejected', 'create.rejected'], function (event) {
    var context = event.context,
        shape = context.shape,
        target = context.target;

    if ((0, _ModelUtil.is)(target, 'bpmn:Collaboration') && (0, _ModelUtil.is)(shape, 'bpmn:FlowNode')) {
      showError(event, translate(COLLAB_ERR_MSG));
    }
  });

  eventBus.on(['elements.paste.rejected'], function (event) {
    var context = event.context,
        position = context.position,
        target = context.target;

    if ((0, _ModelUtil.is)(target, 'bpmn:Collaboration')) {
      showError(position, translate(COLLAB_ERR_MSG));
    }

    if ((0, _ModelUtil.is)(target, 'bpmn:Process')) {
      showError(position, translate(PROCESS_ERR_MSG), 3000);
    }
  });
}

ModelingFeedback.$inject = ['eventBus', 'tooltips', 'translate'];

},{"../../../util/ModelUtil":216}],164:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = RemoveElementBehavior;

var _inherits = require('inherits');

var _inherits2 = _interopRequireDefault(_inherits);

var _ModelUtil = require('../../../util/ModelUtil');

var _CommandInterceptor = require('diagram-js/lib/command/CommandInterceptor');

var _CommandInterceptor2 = _interopRequireDefault(_CommandInterceptor);

var _LineIntersect = require('./util/LineIntersect');

var _LineIntersect2 = _interopRequireDefault(_LineIntersect);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function RemoveElementBehavior(eventBus, bpmnRules, modeling) {

  _CommandInterceptor2.default.call(this, eventBus);

  /**
   * Combine sequence flows when deleting an element
   * if there is one incoming and one outgoing
   * sequence flow
   */
  this.preExecute('shape.delete', function (e) {

    var shape = e.context.shape;

    // only handle [a] -> [shape] -> [b] patterns
    if (shape.incoming.length !== 1 || shape.outgoing.length !== 1) {
      return;
    }

    var inConnection = shape.incoming[0],
        outConnection = shape.outgoing[0];

    // only handle sequence flows
    if (!(0, _ModelUtil.is)(inConnection, 'bpmn:SequenceFlow') || !(0, _ModelUtil.is)(outConnection, 'bpmn:SequenceFlow')) {
      return;
    }

    if (bpmnRules.canConnect(inConnection.source, outConnection.target, inConnection)) {

      // compute new, combined waypoints
      var newWaypoints = getNewWaypoints(inConnection.waypoints, outConnection.waypoints);

      modeling.reconnectEnd(inConnection, outConnection.target, newWaypoints);
    }
  });
}

(0, _inherits2.default)(RemoveElementBehavior, _CommandInterceptor2.default);

RemoveElementBehavior.$inject = ['eventBus', 'bpmnRules', 'modeling'];

// helpers //////////////////////

function getDocking(point) {
  return point.original || point;
}

function getNewWaypoints(inWaypoints, outWaypoints) {

  var intersection = (0, _LineIntersect2.default)(getDocking(inWaypoints[inWaypoints.length - 2]), getDocking(inWaypoints[inWaypoints.length - 1]), getDocking(outWaypoints[1]), getDocking(outWaypoints[0]));

  if (intersection) {
    return [].concat(inWaypoints.slice(0, inWaypoints.length - 1), [intersection], outWaypoints.slice(1));
  } else {
    return [getDocking(inWaypoints[0]), getDocking(outWaypoints[outWaypoints.length - 1])];
  }
}

},{"../../../util/ModelUtil":216,"./util/LineIntersect":177,"diagram-js/lib/command/CommandInterceptor":243,"inherits":415}],165:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = RemoveParticipantBehavior;

var _inherits = require('inherits');

var _inherits2 = _interopRequireDefault(_inherits);

var _CommandInterceptor = require('diagram-js/lib/command/CommandInterceptor');

var _CommandInterceptor2 = _interopRequireDefault(_CommandInterceptor);

var _ModelUtil = require('../../../util/ModelUtil');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * BPMN specific remove behavior
 */
function RemoveParticipantBehavior(eventBus, modeling) {

  _CommandInterceptor2.default.call(this, eventBus);

  /**
   * morph collaboration diagram into process diagram
   * after the last participant has been removed
   */

  this.preExecute('shape.delete', function (context) {

    var shape = context.shape,
        parent = shape.parent;

    // activate the behavior if the shape to be removed
    // is a participant
    if ((0, _ModelUtil.is)(shape, 'bpmn:Participant')) {
      context.collaborationRoot = parent;
    }
  }, true);

  this.postExecute('shape.delete', function (context) {

    var collaborationRoot = context.collaborationRoot;

    if (collaborationRoot && !collaborationRoot.businessObject.participants.length) {
      // replace empty collaboration with process diagram
      modeling.makeProcess();
    }
  }, true);
}

RemoveParticipantBehavior.$inject = ['eventBus', 'modeling'];

(0, _inherits2.default)(RemoveParticipantBehavior, _CommandInterceptor2.default);

},{"../../../util/ModelUtil":216,"diagram-js/lib/command/CommandInterceptor":243,"inherits":415}],166:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = ReplaceConnectionBehavior;

var _minDash = require('min-dash');

var _inherits = require('inherits');

var _inherits2 = _interopRequireDefault(_inherits);

var _CommandInterceptor = require('diagram-js/lib/command/CommandInterceptor');

var _CommandInterceptor2 = _interopRequireDefault(_CommandInterceptor);

var _ModelUtil = require('../../../util/ModelUtil');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function ReplaceConnectionBehavior(eventBus, modeling, bpmnRules) {

  _CommandInterceptor2.default.call(this, eventBus);

  function fixConnection(connection) {

    var source = connection.source,
        target = connection.target,
        parent = connection.parent;

    // do not do anything if connection
    // is already deleted (may happen due to other
    // behaviors plugged-in before)
    if (!parent) {
      return;
    }

    var replacementType, remove;

    /**
     * Check if incoming or outgoing connections
     * can stay or could be substituted with an
     * appropriate replacement.
     *
     * This holds true for SequenceFlow <> MessageFlow.
     */

    if ((0, _ModelUtil.is)(connection, 'bpmn:SequenceFlow')) {
      if (!bpmnRules.canConnectSequenceFlow(source, target)) {
        remove = true;
      }

      if (bpmnRules.canConnectMessageFlow(source, target)) {
        replacementType = 'bpmn:MessageFlow';
      }
    }

    // transform message flows into sequence flows, if possible

    if ((0, _ModelUtil.is)(connection, 'bpmn:MessageFlow')) {

      if (!bpmnRules.canConnectMessageFlow(source, target)) {
        remove = true;
      }

      if (bpmnRules.canConnectSequenceFlow(source, target)) {
        replacementType = 'bpmn:SequenceFlow';
      }
    }

    if ((0, _ModelUtil.is)(connection, 'bpmn:Association') && !bpmnRules.canConnectAssociation(source, target)) {
      remove = true;
    }

    // remove invalid connection,
    // unless it has been removed already
    if (remove) {
      modeling.removeConnection(connection);
    }

    // replace SequenceFlow <> MessageFlow

    if (replacementType) {
      modeling.connect(source, target, {
        type: replacementType,
        waypoints: connection.waypoints.slice()
      });
    }
  }

  this.postExecuted('elements.move', function (context) {

    var closure = context.closure,
        allConnections = closure.allConnections;

    (0, _minDash.forEach)(allConnections, fixConnection);
  }, true);

  this.postExecuted(['connection.reconnectStart', 'connection.reconnectEnd'], function (event) {

    var connection = event.context.connection;

    fixConnection(connection);
  });

  this.postExecuted('element.updateProperties', function (event) {
    var context = event.context,
        properties = context.properties,
        element = context.element,
        businessObject = element.businessObject,
        connection;

    // remove condition expression when morphing to default flow
    if (properties.default) {
      connection = (0, _minDash.find)(element.outgoing, (0, _minDash.matchPattern)({ id: element.businessObject.default.id }));

      if (connection) {
        modeling.updateProperties(connection, { conditionExpression: undefined });
      }
    }

    // remove default property from source when morphing to conditional flow
    if (properties.conditionExpression && businessObject.sourceRef.default === businessObject) {
      modeling.updateProperties(element.source, { default: undefined });
    }
  });
}

(0, _inherits2.default)(ReplaceConnectionBehavior, _CommandInterceptor2.default);

ReplaceConnectionBehavior.$inject = ['eventBus', 'modeling', 'bpmnRules'];

},{"../../../util/ModelUtil":216,"diagram-js/lib/command/CommandInterceptor":243,"inherits":415,"min-dash":505}],167:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = ReplaceElementBehaviour;

var _inherits = require('inherits');

var _inherits2 = _interopRequireDefault(_inherits);

var _CommandInterceptor = require('diagram-js/lib/command/CommandInterceptor');

var _CommandInterceptor2 = _interopRequireDefault(_CommandInterceptor);

var _minDash = require('min-dash');

var _DiUtil = require('../../../util/DiUtil');

var _ModelUtil = require('../../../util/ModelUtil');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * Defines the behaviour of what happens to the elements inside a container
 * that morphs into another BPMN element
 */
function ReplaceElementBehaviour(eventBus, bpmnReplace, bpmnRules, elementRegistry, selection, modeling) {

  _CommandInterceptor2.default.call(this, eventBus);

  this._bpmnReplace = bpmnReplace;
  this._elementRegistry = elementRegistry;
  this._selection = selection;
  this._modeling = modeling;

  this.postExecuted(['elements.move'], 500, function (event) {

    var context = event.context,
        target = context.newParent,
        newHost = context.newHost,
        elements = [];

    (0, _minDash.forEach)(context.closure.topLevel, function (topLevelElements) {
      if ((0, _DiUtil.isEventSubProcess)(topLevelElements)) {
        elements = elements.concat(topLevelElements.children);
      } else {
        elements = elements.concat(topLevelElements);
      }
    });

    // Change target to host when the moving element is a `bpmn:BoundaryEvent`
    if (elements.length === 1 && newHost) {
      target = newHost;
    }

    var canReplace = bpmnRules.canReplace(elements, target);

    if (canReplace) {
      this.replaceElements(elements, canReplace.replacements, newHost);
    }
  }, this);

  // update attachments if the host is replaced
  this.postExecute(['shape.replace'], 1500, function (e) {

    var context = e.context,
        oldShape = context.oldShape,
        newShape = context.newShape,
        attachers = oldShape.attachers,
        canReplace;

    if (attachers && attachers.length) {
      canReplace = bpmnRules.canReplace(attachers, newShape);

      this.replaceElements(attachers, canReplace.replacements);
    }
  }, this);

  this.postExecuted(['shape.replace'], 1500, function (e) {
    var context = e.context,
        oldShape = context.oldShape,
        newShape = context.newShape;

    modeling.unclaimId(oldShape.businessObject.id, oldShape.businessObject);
    modeling.updateProperties(newShape, { id: oldShape.id });
  });
}

(0, _inherits2.default)(ReplaceElementBehaviour, _CommandInterceptor2.default);

ReplaceElementBehaviour.prototype.replaceElements = function (elements, newElements, newHost) {
  var elementRegistry = this._elementRegistry,
      bpmnReplace = this._bpmnReplace,
      selection = this._selection,
      modeling = this._modeling;

  (0, _minDash.forEach)(newElements, function (replacement) {

    var newElement = {
      type: replacement.newElementType
    };

    var oldElement = elementRegistry.get(replacement.oldElementId);

    if (newHost && (0, _ModelUtil.is)(oldElement, 'bpmn:BoundaryEvent')) {
      modeling.updateAttachment(oldElement, null);
    }

    var idx = elements.indexOf(oldElement);

    elements[idx] = bpmnReplace.replaceElement(oldElement, newElement, { select: false });

    if (newHost && (0, _ModelUtil.is)(elements[idx], 'bpmn:BoundaryEvent')) {
      modeling.updateAttachment(elements[idx], newHost);
    }
  });

  if (newElements) {
    selection.select(elements);
  }
};

ReplaceElementBehaviour.$inject = ['eventBus', 'bpmnReplace', 'bpmnRules', 'elementRegistry', 'selection', 'modeling'];

},{"../../../util/DiUtil":214,"../../../util/ModelUtil":216,"diagram-js/lib/command/CommandInterceptor":243,"inherits":415,"min-dash":505}],168:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = ResizeLaneBehavior;

var _ModelUtil = require('../../../util/ModelUtil');

var _LayoutUtil = require('diagram-js/lib/layout/LayoutUtil');

var _Mouse = require('diagram-js/lib/util/Mouse');

var SLIGHTLY_HIGHER_PRIORITY = 1001;

/**
 * Invoke {@link Modeling#resizeLane} instead of
 * {@link Modeling#resizeShape} when resizing a Lane
 * or Participant shape.
 */
function ResizeLaneBehavior(eventBus, modeling) {

  eventBus.on('resize.start', SLIGHTLY_HIGHER_PRIORITY + 500, function (event) {
    var context = event.context,
        shape = context.shape;

    if ((0, _ModelUtil.is)(shape, 'bpmn:Lane') || (0, _ModelUtil.is)(shape, 'bpmn:Participant')) {

      // should we resize the opposite lane(s) in
      // order to compensate for the resize operation?
      context.balanced = !(0, _Mouse.hasPrimaryModifier)(event);
    }
  });

  /**
   * 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;

    if ((0, _ModelUtil.is)(shape, 'bpmn:Lane') || (0, _ModelUtil.is)(shape, 'bpmn:Participant')) {

      if (canExecute) {
        // ensure we have actual pixel values for new bounds
        // (important when zoom level was > 1 during move)
        newBounds = (0, _LayoutUtil.roundBounds)(newBounds);

        // perform the actual resize
        modeling.resizeLane(shape, newBounds, context.balanced);
      }

      // stop propagation
      return false;
    }
  });
}

ResizeLaneBehavior.$inject = ['eventBus', 'modeling'];

},{"../../../util/ModelUtil":216,"diagram-js/lib/layout/LayoutUtil":380,"diagram-js/lib/util/Mouse":403}],169:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = ToggleElementCollapseBehaviour;

var _inherits = require('inherits');

var _inherits2 = _interopRequireDefault(_inherits);

var _CommandInterceptor = require('diagram-js/lib/command/CommandInterceptor');

var _CommandInterceptor2 = _interopRequireDefault(_CommandInterceptor);

var _ModelUtil = require('../../../util/ModelUtil');

var _ResizeUtil = require('diagram-js/lib/features/resize/ResizeUtil');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var LOW_PRIORITY = 500;

function ToggleElementCollapseBehaviour(eventBus, elementFactory, modeling, resize) {

  _CommandInterceptor2.default.call(this, eventBus);

  function hideEmptyLables(children) {
    if (children.length) {
      children.forEach(function (child) {
        if (child.type === 'label' && !child.businessObject.name) {
          child.hidden = true;
        }
      });
    }
  }

  function expandedBounds(shape, defaultSize) {
    var children = shape.children,
        newBounds = defaultSize,
        visibleElements,
        visibleBBox;

    visibleElements = filterVisible(children).concat([shape]);

    visibleBBox = (0, _ResizeUtil.computeChildrenBBox)(visibleElements);

    if (visibleBBox) {
      // center to visibleBBox with max(defaultSize, childrenBounds)
      newBounds.width = Math.max(visibleBBox.width, newBounds.width);
      newBounds.height = Math.max(visibleBBox.height, newBounds.height);

      newBounds.x = visibleBBox.x + (visibleBBox.width - newBounds.width) / 2;
      newBounds.y = visibleBBox.y + (visibleBBox.height - newBounds.height) / 2;
    } else {
      // center to collapsed shape with defaultSize
      newBounds.x = shape.x + (shape.width - newBounds.width) / 2;
      newBounds.y = shape.y + (shape.height - newBounds.height) / 2;
    }

    return newBounds;
  }

  function collapsedBounds(shape, defaultSize) {

    return {
      x: shape.x + (shape.width - defaultSize.width) / 2,
      y: shape.y + (shape.height - defaultSize.height) / 2,
      width: defaultSize.width,
      height: defaultSize.height
    };
  }

  this.executed(['shape.toggleCollapse'], LOW_PRIORITY, function (e) {

    var context = e.context,
        shape = context.shape;

    if (!(0, _ModelUtil.is)(shape, 'bpmn:SubProcess')) {
      return;
    }

    if (!shape.collapsed) {
      // all children got made visible through djs, hide empty labels
      hideEmptyLables(shape.children);

      // remove collapsed marker
      (0, _ModelUtil.getBusinessObject)(shape).di.isExpanded = true;
    } else {
      // place collapsed marker
      (0, _ModelUtil.getBusinessObject)(shape).di.isExpanded = false;
    }
  });

  this.reverted(['shape.toggleCollapse'], LOW_PRIORITY, function (e) {

    var context = e.context;
    var shape = context.shape;

    // revert removing/placing collapsed marker
    if (!shape.collapsed) {
      (0, _ModelUtil.getBusinessObject)(shape).di.isExpanded = true;
    } else {
      (0, _ModelUtil.getBusinessObject)(shape).di.isExpanded = false;
    }
  });

  this.postExecuted(['shape.toggleCollapse'], LOW_PRIORITY, function (e) {
    var shape = e.context.shape,
        defaultSize = elementFactory._getDefaultSize(shape),
        newBounds;

    if (shape.collapsed) {

      // resize to default size of collapsed shapes
      newBounds = collapsedBounds(shape, defaultSize);
    } else {

      // resize to bounds of max(visible children, defaultSize)
      newBounds = expandedBounds(shape, defaultSize);
    }

    modeling.resizeShape(shape, newBounds);
  });
}

(0, _inherits2.default)(ToggleElementCollapseBehaviour, _CommandInterceptor2.default);

ToggleElementCollapseBehaviour.$inject = ['eventBus', 'elementFactory', 'modeling'];

// helpers //////////////////////

function filterVisible(elements) {
  return elements.filter(function (e) {
    return !e.hidden;
  });
}

},{"../../../util/ModelUtil":216,"diagram-js/lib/command/CommandInterceptor":243,"diagram-js/lib/features/resize/ResizeUtil":351,"inherits":415}],170:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = UnclaimIdBehavior;

var _minDash = require('min-dash');

var _inherits = require('inherits');

var _inherits2 = _interopRequireDefault(_inherits);

var _CommandInterceptor = require('diagram-js/lib/command/CommandInterceptor');

var _CommandInterceptor2 = _interopRequireDefault(_CommandInterceptor);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * Unclaims model IDs on element deletion.
 *
 * @param {EventBus} eventBus
 * @param {Modeling} modeling
 */
function UnclaimIdBehavior(eventBus, modeling) {

  _CommandInterceptor2.default.call(this, eventBus);

  this.preExecute('elements.delete', function (event) {
    var context = event.context,
        elements = context.elements;

    (0, _minDash.forEach)(elements, function (element) {
      modeling.unclaimId(element.businessObject.id, element.businessObject);
    });
  });
}

(0, _inherits2.default)(UnclaimIdBehavior, _CommandInterceptor2.default);

UnclaimIdBehavior.$inject = ['eventBus', 'modeling'];

},{"diagram-js/lib/command/CommandInterceptor":243,"inherits":415,"min-dash":505}],171:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = DeleteSequenceFlowBehavior;

var _inherits = require('inherits');

var _inherits2 = _interopRequireDefault(_inherits);

var _CommandInterceptor = require('diagram-js/lib/command/CommandInterceptor');

var _CommandInterceptor2 = _interopRequireDefault(_CommandInterceptor);

var _ModelUtil = require('../../../util/ModelUtil');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * 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) {

  _CommandInterceptor2.default.call(this, eventBus);

  this.preExecute('connection.delete', function (event) {
    var context = event.context,
        connection = context.connection,
        source = connection.source;

    if (isDefaultFlow(connection, source)) {
      modeling.updateProperties(source, {
        'default': null
      });
    }
  });
}

(0, _inherits2.default)(DeleteSequenceFlowBehavior, _CommandInterceptor2.default);

DeleteSequenceFlowBehavior.$inject = ['eventBus', 'modeling'];

// helpers //////////////////////

function isDefaultFlow(connection, source) {

  if (!(0, _ModelUtil.is)(connection, 'bpmn:SequenceFlow')) {
    return false;
  }

  var sourceBo = (0, _ModelUtil.getBusinessObject)(source),
      sequenceFlow = (0, _ModelUtil.getBusinessObject)(connection);

  return sourceBo.get('default') === sequenceFlow;
}

},{"../../../util/ModelUtil":216,"diagram-js/lib/command/CommandInterceptor":243,"inherits":415}],172:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = UpdateFlowNodeRefsBehavior;

var _inherits = require('inherits');

var _inherits2 = _interopRequireDefault(_inherits);

var _CommandInterceptor = require('diagram-js/lib/command/CommandInterceptor');

var _CommandInterceptor2 = _interopRequireDefault(_CommandInterceptor);

var _ModelUtil = require('../../../util/ModelUtil');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var LOW_PRIORITY = 500,
    HIGH_PRIORITY = 5000;

/**
 * BPMN specific delete lane behavior
 */
function UpdateFlowNodeRefsBehavior(eventBus, modeling, translate) {

  _CommandInterceptor2.default.call(this, eventBus);

  /**
   * 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!
   */

  // the update context
  var context;

  function initContext() {
    context = context || new UpdateContext();
    context.enter();

    return context;
  }

  function getContext() {
    if (!context) {
      throw new Error(translate('out of bounds release'));
    }

    return context;
  }

  function releaseContext() {

    if (!context) {
      throw new Error(translate('out of bounds release'));
    }

    var triggerUpdate = context.leave();

    if (triggerUpdate) {
      modeling.updateLaneRefs(context.flowNodes, context.lanes);

      context = null;
    }

    return triggerUpdate;
  }

  var laneRefUpdateEvents = ['spaceTool', 'lane.add', 'lane.resize', 'lane.split', 'elements.move', 'elements.delete', 'shape.create', 'shape.delete', 'shape.move', 'shape.resize'];

  // listen to a lot of stuff to group lane updates

  this.preExecute(laneRefUpdateEvents, HIGH_PRIORITY, function (event) {
    initContext();
  });

  this.postExecuted(laneRefUpdateEvents, LOW_PRIORITY, function (event) {
    releaseContext();
  });

  // Mark flow nodes + lanes that need an update

  this.preExecute(['shape.create', 'shape.move', 'shape.delete', 'shape.resize'], function (event) {

    var context = event.context,
        shape = context.shape;

    var updateContext = getContext();

    // no need to update labels
    if (shape.labelTarget) {
      return;
    }

    if ((0, _ModelUtil.is)(shape, 'bpmn:Lane')) {
      updateContext.addLane(shape);
    }

    if ((0, _ModelUtil.is)(shape, 'bpmn:FlowNode')) {
      updateContext.addFlowNode(shape);
    }
  });
}

UpdateFlowNodeRefsBehavior.$inject = ['eventBus', 'modeling', 'translate'];

(0, _inherits2.default)(UpdateFlowNodeRefsBehavior, _CommandInterceptor2.default);

function UpdateContext() {

  this.flowNodes = [];
  this.lanes = [];

  this.counter = 0;

  this.addLane = function (lane) {
    this.lanes.push(lane);
  };

  this.addFlowNode = function (flowNode) {
    this.flowNodes.push(flowNode);
  };

  this.enter = function () {
    this.counter++;
  };

  this.leave = function () {
    this.counter--;

    return !this.counter;
  };
}

},{"../../../util/ModelUtil":216,"diagram-js/lib/command/CommandInterceptor":243,"inherits":415}],173:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _AdaptiveLabelPositioningBehavior = require('./AdaptiveLabelPositioningBehavior');

var _AdaptiveLabelPositioningBehavior2 = _interopRequireDefault(_AdaptiveLabelPositioningBehavior);

var _AppendBehavior = require('./AppendBehavior');

var _AppendBehavior2 = _interopRequireDefault(_AppendBehavior);

var _BoundaryEventBehavior = require('./BoundaryEventBehavior');

var _BoundaryEventBehavior2 = _interopRequireDefault(_BoundaryEventBehavior);

var _CopyPasteBehavior = require('./CopyPasteBehavior');

var _CopyPasteBehavior2 = _interopRequireDefault(_CopyPasteBehavior);

var _CreateBoundaryEventBehavior = require('./CreateBoundaryEventBehavior');

var _CreateBoundaryEventBehavior2 = _interopRequireDefault(_CreateBoundaryEventBehavior);

var _CreateDataObjectBehavior = require('./CreateDataObjectBehavior');

var _CreateDataObjectBehavior2 = _interopRequireDefault(_CreateDataObjectBehavior);

var _CreateParticipantBehavior = require('./CreateParticipantBehavior');

var _CreateParticipantBehavior2 = _interopRequireDefault(_CreateParticipantBehavior);

var _DataInputAssociationBehavior = require('./DataInputAssociationBehavior');

var _DataInputAssociationBehavior2 = _interopRequireDefault(_DataInputAssociationBehavior);

var _DataStoreBehavior = require('./DataStoreBehavior');

var _DataStoreBehavior2 = _interopRequireDefault(_DataStoreBehavior);

var _DeleteLaneBehavior = require('./DeleteLaneBehavior');

var _DeleteLaneBehavior2 = _interopRequireDefault(_DeleteLaneBehavior);

var _DropOnFlowBehavior = require('./DropOnFlowBehavior');

var _DropOnFlowBehavior2 = _interopRequireDefault(_DropOnFlowBehavior);

var _ImportDockingFix = require('./ImportDockingFix');

var _ImportDockingFix2 = _interopRequireDefault(_ImportDockingFix);

var _LabelBehavior = require('./LabelBehavior');

var _LabelBehavior2 = _interopRequireDefault(_LabelBehavior);

var _ModelingFeedback = require('./ModelingFeedback');

var _ModelingFeedback2 = _interopRequireDefault(_ModelingFeedback);

var _ReplaceConnectionBehavior = require('./ReplaceConnectionBehavior');

var _ReplaceConnectionBehavior2 = _interopRequireDefault(_ReplaceConnectionBehavior);

var _RemoveParticipantBehavior = require('./RemoveParticipantBehavior');

var _RemoveParticipantBehavior2 = _interopRequireDefault(_RemoveParticipantBehavior);

var _ReplaceElementBehaviour = require('./ReplaceElementBehaviour');

var _ReplaceElementBehaviour2 = _interopRequireDefault(_ReplaceElementBehaviour);

var _ResizeLaneBehavior = require('./ResizeLaneBehavior');

var _ResizeLaneBehavior2 = _interopRequireDefault(_ResizeLaneBehavior);

var _RemoveElementBehavior = require('./RemoveElementBehavior');

var _RemoveElementBehavior2 = _interopRequireDefault(_RemoveElementBehavior);

var _ToggleElementCollapseBehaviour = require('./ToggleElementCollapseBehaviour');

var _ToggleElementCollapseBehaviour2 = _interopRequireDefault(_ToggleElementCollapseBehaviour);

var _UnclaimIdBehavior = require('./UnclaimIdBehavior');

var _UnclaimIdBehavior2 = _interopRequireDefault(_UnclaimIdBehavior);

var _UpdateFlowNodeRefsBehavior = require('./UpdateFlowNodeRefsBehavior');

var _UpdateFlowNodeRefsBehavior2 = _interopRequireDefault(_UpdateFlowNodeRefsBehavior);

var _UnsetDefaultFlowBehavior = require('./UnsetDefaultFlowBehavior');

var _UnsetDefaultFlowBehavior2 = _interopRequireDefault(_UnsetDefaultFlowBehavior);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __init__: ['adaptiveLabelPositioningBehavior', 'appendBehavior', 'boundaryEventBehavior', 'copyPasteBehavior', 'createBoundaryEventBehavior', 'createDataObjectBehavior', 'dataStoreBehavior', 'createParticipantBehavior', 'dataInputAssociationBehavior', 'deleteLaneBehavior', 'dropOnFlowBehavior', 'importDockingFix', 'labelBehavior', 'modelingFeedback', 'removeElementBehavior', 'removeParticipantBehavior', 'replaceConnectionBehavior', 'replaceElementBehaviour', 'resizeLaneBehavior', 'toggleElementCollapseBehaviour', 'unclaimIdBehavior', 'unsetDefaultFlowBehavior', 'updateFlowNodeRefsBehavior'],
  adaptiveLabelPositioningBehavior: ['type', _AdaptiveLabelPositioningBehavior2.default],
  appendBehavior: ['type', _AppendBehavior2.default],
  boundaryEventBehavior: ['type', _BoundaryEventBehavior2.default],
  copyPasteBehavior: ['type', _CopyPasteBehavior2.default],
  createBoundaryEventBehavior: ['type', _CreateBoundaryEventBehavior2.default],
  createDataObjectBehavior: ['type', _CreateDataObjectBehavior2.default],
  createParticipantBehavior: ['type', _CreateParticipantBehavior2.default],
  dataInputAssociationBehavior: ['type', _DataInputAssociationBehavior2.default],
  dataStoreBehavior: ['type', _DataStoreBehavior2.default],
  deleteLaneBehavior: ['type', _DeleteLaneBehavior2.default],
  dropOnFlowBehavior: ['type', _DropOnFlowBehavior2.default],
  importDockingFix: ['type', _ImportDockingFix2.default],
  labelBehavior: ['type', _LabelBehavior2.default],
  modelingFeedback: ['type', _ModelingFeedback2.default],
  replaceConnectionBehavior: ['type', _ReplaceConnectionBehavior2.default],
  removeParticipantBehavior: ['type', _RemoveParticipantBehavior2.default],
  replaceElementBehaviour: ['type', _ReplaceElementBehaviour2.default],
  resizeLaneBehavior: ['type', _ResizeLaneBehavior2.default],
  removeElementBehavior: ['type', _RemoveElementBehavior2.default],
  toggleElementCollapseBehaviour: ['type', _ToggleElementCollapseBehaviour2.default],
  unclaimIdBehavior: ['type', _UnclaimIdBehavior2.default],
  updateFlowNodeRefsBehavior: ['type', _UpdateFlowNodeRefsBehavior2.default],
  unsetDefaultFlowBehavior: ['type', _UnsetDefaultFlowBehavior2.default]
};

},{"./AdaptiveLabelPositioningBehavior":150,"./AppendBehavior":151,"./BoundaryEventBehavior":152,"./CopyPasteBehavior":153,"./CreateBoundaryEventBehavior":154,"./CreateDataObjectBehavior":155,"./CreateParticipantBehavior":156,"./DataInputAssociationBehavior":157,"./DataStoreBehavior":158,"./DeleteLaneBehavior":159,"./DropOnFlowBehavior":160,"./ImportDockingFix":161,"./LabelBehavior":162,"./ModelingFeedback":163,"./RemoveElementBehavior":164,"./RemoveParticipantBehavior":165,"./ReplaceConnectionBehavior":166,"./ReplaceElementBehaviour":167,"./ResizeLaneBehavior":168,"./ToggleElementCollapseBehaviour":169,"./UnclaimIdBehavior":170,"./UnsetDefaultFlowBehavior":171,"./UpdateFlowNodeRefsBehavior":172}],174:[function(require,module,exports){
"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.vectorLength = vectorLength;
exports.getAngle = getAngle;
exports.rotateVector = rotateVector;
exports.perpendicularFoot = perpendicularFoot;
exports.getDistancePointLine = getDistancePointLine;
exports.getDistancePointPoint = getDistancePointPoint;
/**
 * 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));
}

/**
 * Calculates the angle between a line a the yAxis
 *
 * @param {Array}
 * @return {Float}
 */
function getAngle(line) {
  // 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));
}

/**
 * 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
  };
}

/**
 * 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) {

  // the 2d system
  var system = [{ n: a[0] - c[0], lambda: b[0] }, { n: a[1] - c[1], lambda: b[1] }];

  // solve
  var n = system[0].n * b[0] + system[1].n * b[1],
      l = system[0].lambda * b[0] + system[1].lambda * b[1];

  return -n / l;
}

/**
 * Position of perpendicular foot
 *
 * @param {Point}
 * @param [ {Point}, {Point} ] line defined throug two points
 * @return {Point} the perpendicular foot position
 */
function perpendicularFoot(point, line) {

  var a = line[0],
      b = line[1];

  // relative position of b from a
  var bd = { x: b.x - a.x, y: b.y - a.y };

  // 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]);

  return { x: a.x + r * bd.x, y: a.y + r * bd.y };
}

/**
 * Calculates the distance between a point and a line
 *
 * @param {Point}
 * @param [ {Point}, {Point} ] line defined throug two points
 * @return {Float} distance
 */
function getDistancePointLine(point, line) {

  var pfPoint = perpendicularFoot(point, line);

  // distance vector
  var connectionVector = {
    x: pfPoint.x - point.x,
    y: pfPoint.y - point.y
  };

  return vectorLength(connectionVector);
}

/**
 * Calculates the distance between two points
 *
 * @param {Point}
 * @param {Point}
 * @return {Float} distance
 */
function getDistancePointPoint(point1, point2) {

  return vectorLength({
    x: point1.x - point2.x,
    y: point1.y - point2.y
  });
}

},{}],175:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.findNewLabelLineStartIndex = findNewLabelLineStartIndex;
exports.getLabelAdjustment = getLabelAdjustment;

var _GeometricUtil = require('./GeometricUtil');

var _LineAttachmentUtil = require('./LineAttachmentUtil');

var _LayoutUtil = require('diagram-js/lib/layout/LayoutUtil');

function findNewLabelLineStartIndex(oldWaypoints, newWaypoints, attachment, hints) {

  var index = attachment.segmentIndex;

  var offset = newWaypoints.length - oldWaypoints.length;

  // segmentMove happend
  if (hints.segmentMove) {

    var oldSegmentStartIndex = hints.segmentMove.segmentStartIndex,
        newSegmentStartIndex = hints.segmentMove.newSegmentStartIndex;

    // if label was on moved segment return new segment index
    if (index === oldSegmentStartIndex) {
      return newSegmentStartIndex;
    }

    // label is after new segment index
    if (index >= newSegmentStartIndex) {
      return index + offset < newSegmentStartIndex ? newSegmentStartIndex : index + offset;
    }

    // if label is before new segment index
    return index;
  }

  // bendpointMove happend
  if (hints.bendpointMove) {

    var insert = hints.bendpointMove.insert,
        bendpointIndex = hints.bendpointMove.bendpointIndex,
        newIndex;

    // waypoints length didnt change
    if (offset === 0) {
      return index;
    }

    // label behind new/removed bendpoint
    if (index >= bendpointIndex) {
      newIndex = insert ? index + 1 : index - 1;
    }

    // label before new/removed bendpoint
    if (index < bendpointIndex) {

      newIndex = index;

      // decide label should take right or left segment
      if (insert && attachment.type !== 'bendpoint' && bendpointIndex - 1 === index) {

        var rel = relativePositionMidWaypoint(newWaypoints, bendpointIndex);

        if (rel < attachment.relativeLocation) {
          newIndex++;
        }
      }
    }

    return newIndex;
  }

  // start/end changed
  if (offset === 0) {
    return index;
  }

  if (hints.connectionStart) {
    return index === 0 ? 0 : null;
  }

  if (hints.connectionEnd) {
    return index === oldWaypoints.length - 2 ? newWaypoints.length - 2 : null;
  }

  // if nothing fits, return null
  return null;
}

/**
 * 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) {

  var x = 0,
      y = 0;

  var labelPosition = getLabelMid(label);

  // get closest attachment
  var attachment = (0, _LineAttachmentUtil.getAttachment)(labelPosition, oldWaypoints),
      oldLabelLineIndex = attachment.segmentIndex,
      newLabelLineIndex = findNewLabelLineStartIndex(oldWaypoints, newWaypoints, attachment, hints);

  if (newLabelLineIndex === null) {
    return { x: x, y: y };
  }

  // 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 };
  }

  var oldLabelLine = getLine(oldWaypoints, oldLabelLineIndex),
      newLabelLine = getLine(newWaypoints, newLabelLineIndex),
      oldFoot = attachment.position;

  var relativeFootPosition = getRelativeFootPosition(oldLabelLine, oldFoot),
      angleDelta = getAngleDelta(oldLabelLine, newLabelLine);

  // special rule if label on bendpoint
  if (attachment.type === 'bendpoint') {

    var offset = newWaypoints.length - oldWaypoints.length,
        oldBendpointIndex = attachment.bendpointIndex,
        oldBendpoint = oldWaypoints[oldBendpointIndex];

    // bendpoint position hasnt changed, return same position
    if (newWaypoints.indexOf(oldBendpoint) !== -1) {
      return { x: x, y: y };
    }

    // new bendpoint and old bendpoint have same index, then just return the offset
    if (offset === 0) {
      var newBendpoint = newWaypoints[oldBendpointIndex];

      return {
        x: newBendpoint.x - attachment.position.x,
        y: newBendpoint.y - attachment.position.y
      };
    }

    // if bendpoints get removed
    if (offset < 0 && oldBendpointIndex !== 0 && oldBendpointIndex < oldWaypoints.length - 1) {
      relativeFootPosition = relativePositionMidWaypoint(oldWaypoints, oldBendpointIndex);
    }
  }

  var newFoot = {
    x: (newLabelLine[1].x - newLabelLine[0].x) * relativeFootPosition + newLabelLine[0].x,
    y: (newLabelLine[1].y - newLabelLine[0].y) * relativeFootPosition + newLabelLine[0].y
  };

  // the rotated vector to label
  var newLabelVector = (0, _GeometricUtil.rotateVector)({
    x: labelPosition.x - oldFoot.x,
    y: labelPosition.y - oldFoot.y
  }, angleDelta);

  // the new relative position
  x = newFoot.x + newLabelVector.x - labelPosition.x;
  y = newFoot.y + newLabelVector.y - labelPosition.y;

  return (0, _LayoutUtil.roundPoint)({
    x: x,
    y: y
  });
}

// HELPERS //////////////////////

function relativePositionMidWaypoint(waypoints, idx) {

  var distanceSegment1 = (0, _GeometricUtil.getDistancePointPoint)(waypoints[idx - 1], waypoints[idx]),
      distanceSegment2 = (0, _GeometricUtil.getDistancePointPoint)(waypoints[idx], waypoints[idx + 1]);

  var relativePosition = distanceSegment1 / (distanceSegment1 + distanceSegment2);

  return relativePosition;
}

function getLabelMid(label) {
  return {
    x: label.x + label.width / 2,
    y: label.y + label.height / 2
  };
}

function getAngleDelta(l1, l2) {
  var a1 = (0, _GeometricUtil.getAngle)(l1),
      a2 = (0, _GeometricUtil.getAngle)(l2);
  return a2 - a1;
}

function getLine(waypoints, idx) {
  return [waypoints[idx], waypoints[idx + 1]];
}

function getRelativeFootPosition(line, foot) {

  var length = (0, _GeometricUtil.getDistancePointPoint)(line[0], line[1]),
      lengthToFoot = (0, _GeometricUtil.getDistancePointPoint)(line[0], foot);

  return length === 0 ? 0 : lengthToFoot / length;
}

},{"./GeometricUtil":174,"./LineAttachmentUtil":176,"diagram-js/lib/layout/LayoutUtil":380}],176:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.getAttachment = getAttachment;
var sqrt = Math.sqrt,
    min = Math.min,
    max = Math.max,
    abs = Math.abs;

/**
 * Calculate the square (power to two) of a number.
 *
 * @param {Number} n
 *
 * @return {Number}
 */
function sq(n) {
  return Math.pow(n, 2);
}

/**
 * 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));
}

/**
 * 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) {

  var idx = 0,
      segmentStart,
      segmentEnd,
      segmentStartDistance,
      segmentEndDistance,
      attachmentPosition,
      minDistance,
      intersections,
      attachment,
      attachmentDistance,
      closestAttachmentDistance,
      closestAttachment;

  for (idx = 0; idx < line.length - 1; idx++) {

    segmentStart = line[idx];
    segmentEnd = line[idx + 1];

    if (pointsEqual(segmentStart, segmentEnd)) {
      intersections = [segmentStart];
    } else {
      segmentStartDistance = getDistance(point, segmentStart);
      segmentEndDistance = getDistance(point, segmentEnd);

      minDistance = min(segmentStartDistance, segmentEndDistance);

      intersections = getCircleSegmentIntersections(segmentStart, segmentEnd, point, minDistance);
    }

    if (intersections.length < 1) {
      throw new Error('expected between [1, 2] circle -> line intersections');
    }

    // one intersection -> bendpoint attachment
    if (intersections.length === 1) {
      attachment = {
        type: 'bendpoint',
        position: intersections[0],
        segmentIndex: idx,
        bendpointIndex: pointsEqual(segmentStart, intersections[0]) ? idx : idx + 1
      };
    }

    // two intersections -> segment attachment
    if (intersections.length === 2) {

      attachmentPosition = mid(intersections[0], intersections[1]);

      attachment = {
        type: 'segment',
        position: attachmentPosition,
        segmentIndex: idx,
        relativeLocation: getDistance(segmentStart, attachmentPosition) / getDistance(segmentStart, segmentEnd)
      };
    }

    attachmentDistance = getDistance(attachment.position, point);

    if (!closestAttachment || closestAttachmentDistance > attachmentDistance) {
      closestAttachment = attachment;
      closestAttachmentDistance = attachmentDistance;
    }
  }

  return closestAttachment;
}

/**
 * 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) {

  var baX = s2.x - s1.x;
  var baY = s2.y - s1.y;
  var caX = cc.x - s1.x;
  var caY = cc.y - s1.y;

  var a = baX * baX + baY * baY;
  var bBy2 = baX * caX + baY * caY;
  var c = caX * caX + caY * caY - cr * cr;

  var pBy2 = bBy2 / a;
  var q = c / a;

  var disc = pBy2 * pBy2 - q;

  // 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;
  }

  if (disc < 0) {
    return [];
  }

  // if disc == 0 ... dealt with later
  var tmpSqrt = sqrt(disc);
  var abScalingFactor1 = -pBy2 + tmpSqrt;
  var abScalingFactor2 = -pBy2 - tmpSqrt;

  var i1 = {
    x: s1.x - baX * abScalingFactor1,
    y: s1.y - baY * abScalingFactor1
  };

  if (disc === 0) {
    // abScalingFactor1 == abScalingFactor2
    return [i1];
  }

  var i2 = {
    x: s1.x - baX * abScalingFactor2,
    y: s1.y - baY * abScalingFactor2
  };

  // return only points on line segment
  return [i1, i2].filter(function (p) {
    return isPointInSegment(p, s1, s2);
  });
}

function isPointInSegment(p, segmentStart, segmentEnd) {
  return fenced(p.x, segmentStart.x, segmentEnd.x) && fenced(p.y, segmentStart.y, segmentEnd.y);
}

function fenced(n, rangeStart, rangeEnd) {

  // use matching threshold to work around
  // precisison errors in intersection computation

  return n >= min(rangeStart, rangeEnd) - EQUAL_THRESHOLD && n <= max(rangeStart, rangeEnd) + EQUAL_THRESHOLD;
}

/**
 * Calculate mid of two points.
 *
 * @param {Point} p1
 * @param {Point} p2
 *
 * @return {Point}
 */
function mid(p1, p2) {

  return {
    x: (p1.x + p2.x) / 2,
    y: (p1.y + p2.y) / 2
  };
}

var EQUAL_THRESHOLD = 0.1;

function pointsEqual(p1, p2) {

  return abs(p1.x - p2.x) <= EQUAL_THRESHOLD && abs(p1.y - p2.y) <= EQUAL_THRESHOLD;
}

},{}],177:[function(require,module,exports){
"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = lineIntersect;
/**
 * 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) {
  // 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;

  denominator = (l2e.y - l2s.y) * (l1e.x - l1s.x) - (l2e.x - l2s.x) * (l1e.y - l1s.y);

  if (denominator == 0) {
    return null;
  }

  a = l1s.y - l2s.y;
  b = l1s.x - l2s.x;
  numerator = (l2e.x - l2s.x) * a - (l2e.y - l2s.y) * b;

  c = numerator / denominator;

  // 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))
  };
}

},{}],178:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = AddLaneHandler;

var _minDash = require('min-dash');

var _Elements = require('diagram-js/lib/util/Elements');

var _LaneUtil = require('../util/LaneUtil');

/**
 * A handler that allows us to add a new lane
 * above or below an existing one.
 *
 * @param {Modeling} modeling
 */
function AddLaneHandler(modeling, spaceTool) {
  this._modeling = modeling;
  this._spaceTool = spaceTool;
}

AddLaneHandler.$inject = ['modeling', 'spaceTool'];

AddLaneHandler.prototype.preExecute = function (context) {

  var spaceTool = this._spaceTool,
      modeling = this._modeling;

  var shape = context.shape,
      location = context.location;

  var lanesRoot = (0, _LaneUtil.getLanesRoot)(shape);

  var isRoot = lanesRoot === shape,
      laneParent = isRoot ? shape : shape.parent;

  var existingChildLanes = (0, _LaneUtil.getChildLanes)(laneParent);

  // (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 + _LaneUtil.LANE_INDENTATION,
      y: shape.y,
      width: shape.width - _LaneUtil.LANE_INDENTATION,
      height: shape.height
    }, laneParent);
  }

  // (1) collect affected elements to create necessary space
  var allAffected = [];

  (0, _Elements.eachElement)(lanesRoot, function (element) {
    allAffected.push(element);

    if (element === shape) {
      return [];
    }

    return (0, _minDash.filter)(element.children, function (c) {
      return c !== shape;
    });
  });

  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';

  var adjustments = spaceTool.calculateAdjustments(allAffected, 'y', offset, spacePos);

  spaceTool.makeSpace(adjustments.movingShapes, adjustments.resizingShapes, { x: 0, y: offset }, direction);

  // (2) create new lane at open space
  context.newLane = modeling.createShape({ type: 'bpmn:Lane' }, {
    x: shape.x + (isRoot ? _LaneUtil.LANE_INDENTATION : 0),
    y: lanePosition - (location === 'top' ? 120 : 0),
    width: shape.width - (isRoot ? _LaneUtil.LANE_INDENTATION : 0),
    height: 120
  }, laneParent);
};

},{"../util/LaneUtil":188,"diagram-js/lib/util/Elements":396,"min-dash":505}],179:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = IdClaimHandler;
function IdClaimHandler(moddle) {
  this._moddle = moddle;
}

IdClaimHandler.$inject = ['moddle'];

IdClaimHandler.prototype.execute = function (context) {
  var ids = this._moddle.ids,
      id = context.id,
      element = context.element,
      claiming = context.claiming;

  if (claiming) {
    ids.claim(id, element);
  } else {
    ids.unclaim(id);
  }
};

/**
 * Command revert implementation.
 */
IdClaimHandler.prototype.revert = function (context) {
  var ids = this._moddle.ids,
      id = context.id,
      element = context.element,
      claiming = context.claiming;

  if (claiming) {
    ids.unclaim(id);
  } else {
    ids.claim(id, element);
  }
};

},{}],180:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = ResizeLaneHandler;

var _ModelUtil = require('../../../util/ModelUtil');

var _LaneUtil = require('../util/LaneUtil');

var _Elements = require('diagram-js/lib/util/Elements');

var _LayoutUtil = require('diagram-js/lib/layout/LayoutUtil');

var _ResizeUtil = require('diagram-js/lib/features/resize/ResizeUtil');

/**
 * A handler that resizes a lane.
 *
 * @param {Modeling} modeling
 */
function ResizeLaneHandler(modeling, spaceTool) {
  this._modeling = modeling;
  this._spaceTool = spaceTool;
}

ResizeLaneHandler.$inject = ['modeling', 'spaceTool'];

ResizeLaneHandler.prototype.preExecute = function (context) {

  var shape = context.shape,
      newBounds = context.newBounds,
      balanced = context.balanced;

  if (balanced !== false) {
    this.resizeBalanced(shape, newBounds);
  } else {
    this.resizeSpace(shape, newBounds);
  }
};

/**
 * Resize balanced, adjusting next / previous lane sizes.
 *
 * @param {djs.model.Shape} shape
 * @param {Bounds} newBounds
 */
ResizeLaneHandler.prototype.resizeBalanced = function (shape, newBounds) {

  var modeling = this._modeling;

  var resizeNeeded = (0, _LaneUtil.computeLanesResize)(shape, newBounds);

  // resize the lane
  modeling.resizeShape(shape, newBounds);

  // resize other lanes as needed
  resizeNeeded.forEach(function (r) {
    modeling.resizeShape(r.shape, r.newBounds);
  });
};

/**
 * 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;

  var shapeTrbl = (0, _LayoutUtil.asTRBL)(shape),
      newTrbl = (0, _LayoutUtil.asTRBL)(newBounds);

  var trblDiff = (0, _ResizeUtil.substractTRBL)(newTrbl, shapeTrbl);

  var lanesRoot = (0, _LaneUtil.getLanesRoot)(shape);

  var allAffected = [],
      allLanes = [];

  (0, _Elements.eachElement)(lanesRoot, function (element) {
    allAffected.push(element);

    if ((0, _ModelUtil.is)(element, 'bpmn:Lane') || (0, _ModelUtil.is)(element, 'bpmn:Participant')) {
      allLanes.push(element);
    }

    return element.children;
  });

  var change, spacePos, direction, offset, adjustments;

  if (trblDiff.bottom || trblDiff.top) {

    change = trblDiff.bottom || trblDiff.top;
    spacePos = shape.y + (trblDiff.bottom ? shape.height : 0) + (trblDiff.bottom ? -10 : 10);
    direction = trblDiff.bottom ? 's' : 'n';

    offset = trblDiff.top > 0 || trblDiff.bottom < 0 ? -change : change;

    adjustments = spaceTool.calculateAdjustments(allAffected, 'y', offset, spacePos);

    spaceTool.makeSpace(adjustments.movingShapes, adjustments.resizingShapes, { x: 0, y: change }, direction);
  }

  if (trblDiff.left || trblDiff.right) {

    change = trblDiff.right || trblDiff.left;
    spacePos = shape.x + (trblDiff.right ? shape.width : 0) + (trblDiff.right ? -10 : 100);
    direction = trblDiff.right ? 'e' : 'w';

    offset = trblDiff.left > 0 || trblDiff.right < 0 ? -change : change;

    adjustments = spaceTool.calculateAdjustments(allLanes, 'x', offset, spacePos);

    spaceTool.makeSpace(adjustments.movingShapes, adjustments.resizingShapes, { x: change, y: 0 }, direction);
  }
};

},{"../../../util/ModelUtil":216,"../util/LaneUtil":188,"diagram-js/lib/features/resize/ResizeUtil":351,"diagram-js/lib/layout/LayoutUtil":380,"diagram-js/lib/util/Elements":396}],181:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = SetColorHandler;

var _minDash = require('min-dash');

var DEFAULT_COLORS = {
  fill: undefined,
  stroke: undefined
};

function SetColorHandler(commandStack) {
  this._commandStack = commandStack;
}

SetColorHandler.$inject = ['commandStack'];

SetColorHandler.prototype.postExecute = function (context) {
  var elements = context.elements,
      colors = context.colors || DEFAULT_COLORS;

  var self = this;

  var di = {};

  if ('fill' in colors) {
    (0, _minDash.assign)(di, { fill: colors.fill });
  }

  if ('stroke' in colors) {
    (0, _minDash.assign)(di, { stroke: colors.stroke });
  }

  (0, _minDash.forEach)(elements, function (element) {

    self._commandStack.execute('element.updateProperties', {
      element: element,
      properties: {
        di: di
      }
    });
  });
};

},{"min-dash":505}],182:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = SplitLaneHandler;

var _LaneUtil = require('../util/LaneUtil');

/**
 * A handler that splits a lane into a number of sub-lanes,
 * creating new sub lanes, if neccessary.
 *
 * @param {Modeling} modeling
 */
function SplitLaneHandler(modeling, translate) {
  this._modeling = modeling;
  this._translate = translate;
}

SplitLaneHandler.$inject = ['modeling', 'translate'];

SplitLaneHandler.prototype.preExecute = function (context) {

  var modeling = this._modeling,
      translate = this._translate;

  var shape = context.shape,
      newLanesCount = context.count;

  var childLanes = (0, _LaneUtil.getChildLanes)(shape),
      existingLanesCount = childLanes.length;

  if (existingLanesCount > newLanesCount) {
    throw new Error(translate('more than {count} child lanes', { count: newLanesCount }));
  }

  var newLanesHeight = Math.round(shape.height / newLanesCount);

  // 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;

  for (idx = 0; idx < newLanesCount; idx++) {

    laneY = shape.y + idx * newLanesHeight;

    // if bottom lane
    if (idx === newLanesCount - 1) {
      laneHeight = shape.height - newLanesHeight * idx;
    } else {
      laneHeight = newLanesHeight;
    }

    laneBounds = {
      x: shape.x + _LaneUtil.LANE_INDENTATION,
      y: laneY,
      width: shape.width - _LaneUtil.LANE_INDENTATION,
      height: laneHeight
    };

    if (idx < existingLanesCount) {
      // resize existing lane
      modeling.resizeShape(childLanes[idx], laneBounds);
    } else {
      // create a new lane at position
      newLaneAttrs = {
        type: 'bpmn:Lane'
      };

      modeling.createShape(newLaneAttrs, laneBounds, shape);
    }
  }
};

},{"../util/LaneUtil":188}],183:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = UpdateCanvasRootHandler;

var _Collections = require('diagram-js/lib/util/Collections');

function UpdateCanvasRootHandler(canvas, modeling) {
  this._canvas = canvas;
  this._modeling = modeling;
}

UpdateCanvasRootHandler.$inject = ['canvas', 'modeling'];

UpdateCanvasRootHandler.prototype.execute = function (context) {

  var canvas = this._canvas;

  var newRoot = context.newRoot,
      newRootBusinessObject = newRoot.businessObject,
      oldRoot = canvas.getRootElement(),
      oldRootBusinessObject = oldRoot.businessObject,
      bpmnDefinitions = oldRootBusinessObject.$parent,
      diPlane = oldRootBusinessObject.di;

  // (1) replace process old <> new root
  canvas.setRootElement(newRoot, true);

  // (2) update root elements
  (0, _Collections.add)(bpmnDefinitions.rootElements, newRootBusinessObject);
  newRootBusinessObject.$parent = bpmnDefinitions;

  (0, _Collections.remove)(bpmnDefinitions.rootElements, oldRootBusinessObject);
  oldRootBusinessObject.$parent = null;

  // (3) wire di
  oldRootBusinessObject.di = null;

  diPlane.bpmnElement = newRootBusinessObject;
  newRootBusinessObject.di = diPlane;

  context.oldRoot = oldRoot;

  // TODO(nikku): return changed elements?
  // return [ newRoot, oldRoot ];
};

UpdateCanvasRootHandler.prototype.revert = function (context) {

  var canvas = this._canvas;

  var newRoot = context.newRoot,
      newRootBusinessObject = newRoot.businessObject,
      oldRoot = context.oldRoot,
      oldRootBusinessObject = oldRoot.businessObject,
      bpmnDefinitions = newRootBusinessObject.$parent,
      diPlane = newRootBusinessObject.di;

  // (1) replace process old <> new root
  canvas.setRootElement(oldRoot, true);

  // (2) update root elements
  (0, _Collections.remove)(bpmnDefinitions.rootElements, newRootBusinessObject);
  newRootBusinessObject.$parent = null;

  (0, _Collections.add)(bpmnDefinitions.rootElements, oldRootBusinessObject);
  oldRootBusinessObject.$parent = bpmnDefinitions;

  // (3) wire di
  newRootBusinessObject.di = null;

  diPlane.bpmnElement = oldRootBusinessObject;
  oldRootBusinessObject.di = diPlane;

  // TODO(nikku): return changed elements?
  // return [ newRoot, oldRoot ];
};

},{"diagram-js/lib/util/Collections":393}],184:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = UpdateFlowNodeRefsHandler;

var _LaneUtil = require('../util/LaneUtil');

var _ModelUtil = require('../../../util/ModelUtil');

var _Collections = require('diagram-js/lib/util/Collections');

var _LayoutUtil = require('diagram-js/lib/layout/LayoutUtil');

var FLOW_NODE_REFS_ATTR = 'flowNodeRef',
    LANES_ATTR = 'lanes';

/**
 * A handler that updates lane refs on changed elements
 */
function UpdateFlowNodeRefsHandler(elementRegistry) {
  this._elementRegistry = elementRegistry;
}

UpdateFlowNodeRefsHandler.$inject = ['elementRegistry'];

UpdateFlowNodeRefsHandler.prototype.computeUpdates = function (flowNodeShapes, laneShapes) {

  var handledNodes = {};

  var updates = [];

  var participantCache = {};

  var allFlowNodeShapes = [];

  function isInLaneShape(element, laneShape) {

    var laneTrbl = (0, _LayoutUtil.asTRBL)(laneShape);

    var elementMid = {
      x: element.x + element.width / 2,
      y: element.y + element.height / 2
    };

    return elementMid.x > laneTrbl.left && elementMid.x < laneTrbl.right && elementMid.y > laneTrbl.top && elementMid.y < laneTrbl.bottom;
  }

  function addFlowNodeShape(flowNodeShape) {
    if (!handledNodes[flowNodeShape.id]) {
      allFlowNodeShapes.push(flowNodeShape);
      handledNodes[flowNodeShape.id] = flowNodeShape;
    }
  }

  function getAllLaneShapes(flowNodeShape) {

    var root = (0, _LaneUtil.getLanesRoot)(flowNodeShape);

    if (!participantCache[root.id]) {
      participantCache[root.id] = (0, _LaneUtil.collectLanes)(root);
    }

    return participantCache[root.id];
  }

  function getNewLanes(flowNodeShape) {
    if (!flowNodeShape.parent) {
      return [];
    }

    var allLaneShapes = getAllLaneShapes(flowNodeShape);

    return allLaneShapes.filter(function (l) {
      return isInLaneShape(flowNodeShape, l);
    }).map(function (shape) {
      return shape.businessObject;
    });
  }

  laneShapes.forEach(function (laneShape) {
    var root = (0, _LaneUtil.getLanesRoot)(laneShape);

    if (!root || handledNodes[root.id]) {
      return;
    }

    var children = root.children.filter(function (c) {
      return (0, _ModelUtil.is)(c, 'bpmn:FlowNode');
    });

    children.forEach(addFlowNodeShape);

    handledNodes[root.id] = root;
  });

  flowNodeShapes.forEach(addFlowNodeShape);

  allFlowNodeShapes.forEach(function (flowNodeShape) {

    var flowNode = flowNodeShape.businessObject;

    var lanes = flowNode.get(LANES_ATTR),
        remove = lanes.slice(),
        add = getNewLanes(flowNodeShape);

    updates.push({ flowNode: flowNode, remove: remove, add: add });
  });

  laneShapes.forEach(function (laneShape) {

    var lane = laneShape.businessObject;

    // lane got removed XX-)
    if (!laneShape.parent) {
      lane.get(FLOW_NODE_REFS_ATTR).forEach(function (flowNode) {
        updates.push({ flowNode: flowNode, remove: [lane], add: [] });
      });
    }
  });

  return updates;
};

UpdateFlowNodeRefsHandler.prototype.execute = function (context) {

  var updates = context.updates;

  if (!updates) {
    updates = context.updates = this.computeUpdates(context.flowNodeShapes, context.laneShapes);
  }

  updates.forEach(function (update) {

    var flowNode = update.flowNode,
        lanes = flowNode.get(LANES_ATTR);

    // unwire old
    update.remove.forEach(function (oldLane) {
      (0, _Collections.remove)(lanes, oldLane);
      (0, _Collections.remove)(oldLane.get(FLOW_NODE_REFS_ATTR), flowNode);
    });

    // wire new
    update.add.forEach(function (newLane) {
      (0, _Collections.add)(lanes, newLane);
      (0, _Collections.add)(newLane.get(FLOW_NODE_REFS_ATTR), flowNode);
    });
  });

  // TODO(nikku): return changed elements
  // return [ ... ];
};

UpdateFlowNodeRefsHandler.prototype.revert = function (context) {

  var updates = context.updates;

  updates.forEach(function (update) {

    var flowNode = update.flowNode,
        lanes = flowNode.get(LANES_ATTR);

    // unwire new
    update.add.forEach(function (newLane) {
      (0, _Collections.remove)(lanes, newLane);
      (0, _Collections.remove)(newLane.get(FLOW_NODE_REFS_ATTR), flowNode);
    });

    // wire old
    update.remove.forEach(function (oldLane) {
      (0, _Collections.add)(lanes, oldLane);
      (0, _Collections.add)(oldLane.get(FLOW_NODE_REFS_ATTR), flowNode);
    });
  });

  // TODO(nikku): return changed elements
  // return [ ... ];
};

},{"../../../util/ModelUtil":216,"../util/LaneUtil":188,"diagram-js/lib/layout/LayoutUtil":380,"diagram-js/lib/util/Collections":393}],185:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = UpdatePropertiesHandler;

var _minDash = require('min-dash');

var _ModelUtil = require('../../../util/ModelUtil');

var DEFAULT_FLOW = 'default',
    ID = 'id',
    DI = 'di';

var NULL_DIMENSIONS = {
  width: 0,
  height: 0
};

/**
 * 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) {

  this._elementRegistry = elementRegistry;
  this._moddle = moddle;
  this._translate = translate;
  this._modeling = modeling;
  this._textRenderer = textRenderer;
}

UpdatePropertiesHandler.$inject = ['elementRegistry', 'moddle', 'translate', 'modeling', 'textRenderer'];

// api //////////////////////

/**
 * 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) {

  var element = context.element,
      changed = [element],
      translate = this._translate;

  if (!element) {
    throw new Error(translate('element required'));
  }

  var elementRegistry = this._elementRegistry,
      ids = this._moddle.ids;

  var businessObject = element.businessObject,
      properties = unwrapBusinessObjects(context.properties),
      oldProperties = context.oldProperties || getProperties(businessObject, properties);

  if (isIdChange(properties, businessObject)) {
    ids.unclaim(businessObject[ID]);

    elementRegistry.updateId(element, properties[ID]);

    ids.claim(properties[ID], businessObject);
  }

  // correctly indicate visual changes on default flow updates
  if (DEFAULT_FLOW in properties) {

    if (properties[DEFAULT_FLOW]) {
      changed.push(elementRegistry.get(properties[DEFAULT_FLOW].id));
    }

    if (businessObject[DEFAULT_FLOW]) {
      changed.push(elementRegistry.get(businessObject[DEFAULT_FLOW].id));
    }
  }

  // update properties
  setProperties(businessObject, properties);

  // store old values
  context.oldProperties = oldProperties;
  context.changed = changed;

  // indicate changed on objects affected by the update
  return changed;
};

UpdatePropertiesHandler.prototype.postExecute = function (context) {
  var element = context.element,
      label = element.label;

  var text = label && (0, _ModelUtil.getBusinessObject)(label).name;

  if (!text) {
    return;
  }

  // get layouted text bounds and resize external
  // external label accordingly
  var newLabelBounds = this._textRenderer.getExternalLabelBounds(label, text);

  this._modeling.resizeShape(label, newLabelBounds, NULL_DIMENSIONS);
};

/**
 * Reverts the update on a BPMN elements properties.
 *
 * @param  {Object} context
 *
 * @return {djs.model.Base} the updated element
 */
UpdatePropertiesHandler.prototype.revert = function (context) {

  var element = context.element,
      properties = context.properties,
      oldProperties = context.oldProperties,
      businessObject = element.businessObject,
      elementRegistry = this._elementRegistry,
      ids = this._moddle.ids;

  // update properties
  setProperties(businessObject, oldProperties);

  if (isIdChange(properties, businessObject)) {
    ids.unclaim(properties[ID]);

    elementRegistry.updateId(element, oldProperties[ID]);

    ids.claim(oldProperties[ID], businessObject);
  }

  return context.changed;
};

function isIdChange(properties, businessObject) {
  return ID in properties && properties[ID] !== businessObject[ID];
}

function getProperties(businessObject, properties) {
  var propertyNames = (0, _minDash.keys)(properties);

  return (0, _minDash.reduce)(propertyNames, function (result, key) {

    // handle DI seperately
    if (key !== DI) {
      result[key] = businessObject.get(key);
    } else {
      result[key] = getDiProperties(businessObject.di, (0, _minDash.keys)(properties.di));
    }

    return result;
  }, {});
}

function getDiProperties(di, propertyNames) {
  return (0, _minDash.reduce)(propertyNames, function (result, key) {
    result[key] = di.get(key);

    return result;
  }, {});
}

function setProperties(businessObject, properties) {
  (0, _minDash.forEach)(properties, function (value, key) {

    if (key !== DI) {
      businessObject.set(key, value);
    } else {
      // only update, if businessObject.di exists
      if (businessObject.di) {
        setDiProperties(businessObject.di, value);
      }
    }
  });
}

function setDiProperties(di, properties) {
  (0, _minDash.forEach)(properties, function (value, key) {
    di.set(key, value);
  });
}

var referencePropertyNames = ['default'];

/**
 * 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) {

  var unwrappedProps = (0, _minDash.assign)({}, properties);

  referencePropertyNames.forEach(function (name) {
    if (name in properties) {
      unwrappedProps[name] = (0, _ModelUtil.getBusinessObject)(unwrappedProps[name]);
    }
  });

  return unwrappedProps;
}

},{"../../../util/ModelUtil":216,"min-dash":505}],186:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = UpdateSemanticParentHandler;
function UpdateSemanticParentHandler(bpmnUpdater) {
  this._bpmnUpdater = bpmnUpdater;
}

UpdateSemanticParentHandler.$inject = ['bpmnUpdater'];

UpdateSemanticParentHandler.prototype.execute = function (context) {
  var dataStoreBo = context.dataStoreBo,
      newSemanticParent = context.newSemanticParent,
      newDiParent = context.newDiParent;

  context.oldSemanticParent = dataStoreBo.$parent;
  context.oldDiParent = dataStoreBo.di.$parent;

  // update semantic parent
  this._bpmnUpdater.updateSemanticParent(dataStoreBo, newSemanticParent);

  // update DI parent
  this._bpmnUpdater.updateDiParent(dataStoreBo.di, newDiParent);
};

UpdateSemanticParentHandler.prototype.revert = function (context) {
  var dataStoreBo = context.dataStoreBo,
      oldSemanticParent = context.oldSemanticParent,
      oldDiParent = context.oldDiParent;

  // update semantic parent
  this._bpmnUpdater.updateSemanticParent(dataStoreBo, oldSemanticParent);

  // update DI parent
  this._bpmnUpdater.updateDiParent(dataStoreBo.di, oldDiParent);
};

},{}],187:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _behavior = require('./behavior');

var _behavior2 = _interopRequireDefault(_behavior);

var _rules = require('../rules');

var _rules2 = _interopRequireDefault(_rules);

var _ordering = require('../ordering');

var _ordering2 = _interopRequireDefault(_ordering);

var _replace = require('../replace');

var _replace2 = _interopRequireDefault(_replace);

var _command = require('diagram-js/lib/command');

var _command2 = _interopRequireDefault(_command);

var _tooltips = require('diagram-js/lib/features/tooltips');

var _tooltips2 = _interopRequireDefault(_tooltips);

var _labelSupport = require('diagram-js/lib/features/label-support');

var _labelSupport2 = _interopRequireDefault(_labelSupport);

var _attachSupport = require('diagram-js/lib/features/attach-support');

var _attachSupport2 = _interopRequireDefault(_attachSupport);

var _selection = require('diagram-js/lib/features/selection');

var _selection2 = _interopRequireDefault(_selection);

var _changeSupport = require('diagram-js/lib/features/change-support');

var _changeSupport2 = _interopRequireDefault(_changeSupport);

var _spaceTool = require('diagram-js/lib/features/space-tool');

var _spaceTool2 = _interopRequireDefault(_spaceTool);

var _BpmnFactory = require('./BpmnFactory');

var _BpmnFactory2 = _interopRequireDefault(_BpmnFactory);

var _BpmnUpdater = require('./BpmnUpdater');

var _BpmnUpdater2 = _interopRequireDefault(_BpmnUpdater);

var _ElementFactory = require('./ElementFactory');

var _ElementFactory2 = _interopRequireDefault(_ElementFactory);

var _Modeling = require('./Modeling');

var _Modeling2 = _interopRequireDefault(_Modeling);

var _BpmnLayouter = require('./BpmnLayouter');

var _BpmnLayouter2 = _interopRequireDefault(_BpmnLayouter);

var _CroppingConnectionDocking = require('diagram-js/lib/layout/CroppingConnectionDocking');

var _CroppingConnectionDocking2 = _interopRequireDefault(_CroppingConnectionDocking);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __init__: ['modeling', 'bpmnUpdater'],
  __depends__: [_behavior2.default, _rules2.default, _ordering2.default, _replace2.default, _command2.default, _tooltips2.default, _labelSupport2.default, _attachSupport2.default, _selection2.default, _changeSupport2.default, _spaceTool2.default],
  bpmnFactory: ['type', _BpmnFactory2.default],
  bpmnUpdater: ['type', _BpmnUpdater2.default],
  elementFactory: ['type', _ElementFactory2.default],
  modeling: ['type', _Modeling2.default],
  layouter: ['type', _BpmnLayouter2.default],
  connectionDocking: ['type', _CroppingConnectionDocking2.default]
};

},{"../ordering":191,"../replace":201,"../rules":203,"./BpmnFactory":145,"./BpmnLayouter":146,"./BpmnUpdater":147,"./ElementFactory":148,"./Modeling":149,"./behavior":173,"diagram-js/lib/command":245,"diagram-js/lib/features/attach-support":259,"diagram-js/lib/features/change-support":271,"diagram-js/lib/features/label-support":302,"diagram-js/lib/features/selection":361,"diagram-js/lib/features/space-tool":368,"diagram-js/lib/features/tooltips":372,"diagram-js/lib/layout/CroppingConnectionDocking":379}],188:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.LANE_INDENTATION = undefined;
exports.collectLanes = collectLanes;
exports.getChildLanes = getChildLanes;
exports.getLanesRoot = getLanesRoot;
exports.computeLanesResize = computeLanesResize;

var _ModelUtil = require('../../../util/ModelUtil');

var _ModelingUtil = require('./ModelingUtil');

var _LayoutUtil = require('diagram-js/lib/layout/LayoutUtil');

var _ResizeUtil = require('diagram-js/lib/features/resize/ResizeUtil');

var abs = Math.abs;

function getTRBLResize(oldBounds, newBounds) {
  return (0, _ResizeUtil.substractTRBL)((0, _LayoutUtil.asTRBL)(newBounds), (0, _LayoutUtil.asTRBL)(oldBounds));
}

var LANE_PARENTS = ['bpmn:Participant', 'bpmn:Process', 'bpmn:SubProcess'];

var LANE_INDENTATION = exports.LANE_INDENTATION = 30;

/**
 * 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) {

  collectedShapes = collectedShapes || [];

  shape.children.filter(function (s) {
    if ((0, _ModelUtil.is)(s, 'bpmn:Lane')) {
      collectLanes(s, collectedShapes);

      collectedShapes.push(s);
    }
  });

  return collectedShapes;
}

/**
 * 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 (0, _ModelUtil.is)(c, 'bpmn:Lane');
  });
}

/**
 * Return the root element containing the given lane shape
 *
 * @param {djs.model.Shape} shape
 *
 * @return {djs.model.Shape}
 */
function getLanesRoot(shape) {
  return (0, _ModelingUtil.getParent)(shape, LANE_PARENTS) || shape;
}

/**
 * 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) {

  var rootElement = getLanesRoot(shape);

  var initialShapes = (0, _ModelUtil.is)(rootElement, 'bpmn:Process') ? [] : [rootElement];

  var allLanes = collectLanes(rootElement, initialShapes),
      shapeTrbl = (0, _LayoutUtil.asTRBL)(shape),
      shapeNewTrbl = (0, _LayoutUtil.asTRBL)(newBounds),
      trblResize = getTRBLResize(shape, newBounds),
      resizeNeeded = [];

  allLanes.forEach(function (other) {

    if (other === shape) {
      return;
    }

    var topResize = 0,
        rightResize = trblResize.right,
        bottomResize = 0,
        leftResize = trblResize.left;

    var otherTrbl = (0, _LayoutUtil.asTRBL)(other);

    if (trblResize.top) {
      if (abs(otherTrbl.bottom - shapeTrbl.top) < 10) {
        bottomResize = shapeNewTrbl.top - otherTrbl.bottom;
      }

      if (abs(otherTrbl.top - shapeTrbl.top) < 5) {
        topResize = shapeNewTrbl.top - otherTrbl.top;
      }
    }

    if (trblResize.bottom) {
      if (abs(otherTrbl.top - shapeTrbl.bottom) < 10) {
        topResize = shapeNewTrbl.bottom - otherTrbl.top;
      }

      if (abs(otherTrbl.bottom - shapeTrbl.bottom) < 5) {
        bottomResize = shapeNewTrbl.bottom - otherTrbl.bottom;
      }
    }

    if (topResize || rightResize || bottomResize || leftResize) {

      resizeNeeded.push({
        shape: other,
        newBounds: (0, _ResizeUtil.resizeTRBL)(other, {
          top: topResize,
          right: rightResize,
          bottom: bottomResize,
          left: leftResize
        })
      });
    }
  });

  return resizeNeeded;
}

},{"../../../util/ModelUtil":216,"./ModelingUtil":189,"diagram-js/lib/features/resize/ResizeUtil":351,"diagram-js/lib/layout/LayoutUtil":380}],189:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.isAny = isAny;
exports.getParent = getParent;

var _minDash = require('min-dash');

var _ModelUtil = require('../../../util/ModelUtil');

/**
 * 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 (0, _minDash.some)(types, function (t) {
    return (0, _ModelUtil.is)(element, t);
  });
}

/**
 * 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) {

  if (typeof anyType === 'string') {
    anyType = [anyType];
  }

  while (element = element.parent) {
    if (isAny(element, anyType)) {
      return element;
    }
  }

  return null;
}

},{"../../../util/ModelUtil":216,"min-dash":505}],190:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = BpmnOrderingProvider;

var _inherits = require('inherits');

var _inherits2 = _interopRequireDefault(_inherits);

var _OrderingProvider = require('diagram-js/lib/features/ordering/OrderingProvider');

var _OrderingProvider2 = _interopRequireDefault(_OrderingProvider);

var _ModelingUtil = require('../modeling/util/ModelingUtil');

var _minDash = require('min-dash');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * a simple ordering provider that makes sure:
 *
 * (0) labels are rendered always on top
 * (1) elements are ordered by a {level} property
 */
function BpmnOrderingProvider(eventBus, canvas, translate) {

  _OrderingProvider2.default.call(this, eventBus);

  var orders = [{ type: 'bpmn:SubProcess', order: { level: 6 } }, {
    type: 'bpmn:SequenceFlow',
    order: {
      level: 3,
      containers: ['bpmn:Participant', 'bpmn:FlowElementsContainer']
    }
  },
  // handle DataAssociation(s) like message flows and render them always on top
  {
    type: 'bpmn:DataAssociation',
    order: {
      level: 9,
      containers: ['bpmn:Collaboration', 'bpmn:Process']
    }
  }, {
    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:FlowElement', order: { level: 5 } }, { type: 'bpmn:Participant', order: { level: -2 } }, { type: 'bpmn:Lane', order: { level: -1 } }];

  function computeOrder(element) {
    if (element.labelTarget) {
      return { level: 10 };
    }

    var entry = (0, _minDash.find)(orders, function (o) {
      return (0, _ModelingUtil.isAny)(element, [o.type]);
    });

    return entry && entry.order || { level: 1 };
  }

  function getOrder(element) {

    var order = element.order;

    if (!order) {
      element.order = order = computeOrder(element);
    }

    return order;
  }

  function findActualParent(element, newParent, containers) {

    var actualParent = newParent;

    while (actualParent) {

      if ((0, _ModelingUtil.isAny)(actualParent, containers)) {
        break;
      }

      actualParent = actualParent.parent;
    }

    if (!actualParent) {
      throw new Error(translate('no parent for {element} in {parent}', {
        element: element.id,
        parent: newParent.id
      }));
    }

    return actualParent;
  }

  this.getOrdering = function (element, newParent) {

    // render labels always on top
    if (element.labelTarget) {
      return {
        parent: canvas.getRootElement(),
        index: -1
      };
    }

    var elementOrder = getOrder(element);

    if (elementOrder.containers) {
      newParent = findActualParent(element, newParent, elementOrder.containers);
    }

    var currentIndex = newParent.children.indexOf(element);

    var insertIndex = (0, _minDash.findIndex)(newParent.children, function (child) {

      // 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;
      }

      return elementOrder.level < getOrder(child).level;
    });

    // if the element is already in the child list at
    // a smaller index, we need to adjust the inser 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;
      }
    }

    return {
      index: insertIndex,
      parent: newParent
    };
  };
}

BpmnOrderingProvider.$inject = ['eventBus', 'canvas', 'translate'];

(0, _inherits2.default)(BpmnOrderingProvider, _OrderingProvider2.default);

},{"../modeling/util/ModelingUtil":189,"diagram-js/lib/features/ordering/OrderingProvider":335,"inherits":415,"min-dash":505}],191:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _translate = require('diagram-js/lib/i18n/translate');

var _translate2 = _interopRequireDefault(_translate);

var _BpmnOrderingProvider = require('./BpmnOrderingProvider');

var _BpmnOrderingProvider2 = _interopRequireDefault(_BpmnOrderingProvider);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __depends__: [_translate2.default],
  __init__: ['bpmnOrderingProvider'],
  bpmnOrderingProvider: ['type', _BpmnOrderingProvider2.default]
};

},{"./BpmnOrderingProvider":190,"diagram-js/lib/i18n/translate":376}],192:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = PaletteProvider;

var _minDash = require('min-dash');

/**
 * A palette provider for BPMN 2.0 elements.
 */
function PaletteProvider(palette, create, elementFactory, spaceTool, lassoTool, handTool, globalConnect, translate) {

  this._palette = palette;
  this._create = create;
  this._elementFactory = elementFactory;
  this._spaceTool = spaceTool;
  this._lassoTool = lassoTool;
  this._handTool = handTool;
  this._globalConnect = globalConnect;
  this._translate = translate;

  palette.registerProvider(this);
}

PaletteProvider.$inject = ['palette', 'create', 'elementFactory', 'spaceTool', 'lassoTool', 'handTool', 'globalConnect', 'translate'];

PaletteProvider.prototype.getPaletteEntries = function (element) {

  var actions = {},
      create = this._create,
      elementFactory = this._elementFactory,
      spaceTool = this._spaceTool,
      lassoTool = this._lassoTool,
      handTool = this._handTool,
      globalConnect = this._globalConnect,
      translate = this._translate;

  function createAction(type, group, className, title, options) {

    function createListener(event) {
      var shape = elementFactory.createShape((0, _minDash.assign)({ type: type }, options));

      if (options) {
        shape.businessObject.di.isExpanded = options.isExpanded;
      }

      create.start(event, shape);
    }

    var shortType = type.replace(/^bpmn:/, '');

    return {
      group: group,
      className: className,
      title: title || translate('Create {type}', { type: shortType }),
      action: {
        dragstart: createListener,
        click: createListener
      }
    };
  }

  function createParticipant(event, collapsed) {
    create.start(event, elementFactory.createParticipantShape(collapsed));
  }

  (0, _minDash.assign)(actions, {
    'hand-tool': {
      group: 'tools',
      className: 'bpmn-icon-hand-tool',
      title: translate('Activate the hand tool'),
      action: {
        click: function click(event) {
          handTool.activateHand(event);
        }
      }
    },
    'lasso-tool': {
      group: 'tools',
      className: 'bpmn-icon-lasso-tool',
      title: translate('Activate the lasso tool'),
      action: {
        click: function click(event) {
          lassoTool.activateSelection(event);
        }
      }
    },
    'space-tool': {
      group: 'tools',
      className: 'bpmn-icon-space-tool',
      title: translate('Activate the create/remove space tool'),
      action: {
        click: function click(event) {
          spaceTool.activateSelection(event);
        }
      }
    },
    'global-connect-tool': {
      group: 'tools',
      className: 'bpmn-icon-connection-multi',
      title: translate('Activate the global connect tool'),
      action: {
        click: function click(event) {
          globalConnect.toggle(event);
        }
      }
    },
    'tool-separator': {
      group: 'tools',
      separator: true
    },
    'create.start-event': createAction('bpmn:StartEvent', 'event', 'bpmn-icon-start-event-none'),
    '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'),
    'create.exclusive-gateway': createAction('bpmn:ExclusiveGateway', 'gateway', 'bpmn-icon-gateway-none', translate('Create Gateway')),
    'create.task': createAction('bpmn:Task', 'activity', 'bpmn-icon-task'),
    'create.data-object': createAction('bpmn:DataObjectReference', 'data-object', 'bpmn-icon-data-object'),
    'create.data-store': createAction('bpmn:DataStoreReference', 'data-store', 'bpmn-icon-data-store'),
    'create.subprocess-expanded': createAction('bpmn:SubProcess', 'activity', 'bpmn-icon-subprocess-expanded', translate('Create expanded SubProcess'), { isExpanded: true }),
    'create.participant-expanded': {
      group: 'collaboration',
      className: 'bpmn-icon-participant',
      title: translate('Create Pool/Participant'),
      action: {
        dragstart: createParticipant,
        click: createParticipant
      }
    }
  });

  return actions;
};

},{"min-dash":505}],193:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _palette = require('diagram-js/lib/features/palette');

var _palette2 = _interopRequireDefault(_palette);

var _create = require('diagram-js/lib/features/create');

var _create2 = _interopRequireDefault(_create);

var _spaceTool = require('diagram-js/lib/features/space-tool');

var _spaceTool2 = _interopRequireDefault(_spaceTool);

var _lassoTool = require('diagram-js/lib/features/lasso-tool');

var _lassoTool2 = _interopRequireDefault(_lassoTool);

var _handTool = require('diagram-js/lib/features/hand-tool');

var _handTool2 = _interopRequireDefault(_handTool);

var _globalConnect = require('diagram-js/lib/features/global-connect');

var _globalConnect2 = _interopRequireDefault(_globalConnect);

var _translate = require('diagram-js/lib/i18n/translate');

var _translate2 = _interopRequireDefault(_translate);

var _PaletteProvider = require('./PaletteProvider');

var _PaletteProvider2 = _interopRequireDefault(_PaletteProvider);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __depends__: [_palette2.default, _create2.default, _spaceTool2.default, _lassoTool2.default, _handTool2.default, _globalConnect2.default, _translate2.default],
  __init__: ['paletteProvider'],
  paletteProvider: ['type', _PaletteProvider2.default]
};

},{"./PaletteProvider":192,"diagram-js/lib/features/create":281,"diagram-js/lib/features/global-connect":290,"diagram-js/lib/features/hand-tool":292,"diagram-js/lib/features/lasso-tool":304,"diagram-js/lib/features/palette":341,"diagram-js/lib/features/space-tool":368,"diagram-js/lib/i18n/translate":376}],194:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = ReplaceMenuProvider;

var _ModelUtil = require('../../util/ModelUtil');

var _DiUtil = require('../../util/DiUtil');

var _TypeUtil = require('./util/TypeUtil');

var _minDash = require('min-dash');

var _ReplaceOptions = require('../replace/ReplaceOptions');

var replaceOptions = _interopRequireWildcard(_ReplaceOptions);

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

/**
 * This module is an element agnostic replace menu provider for the popup menu.
 */
function ReplaceMenuProvider(popupMenu, modeling, moddle, bpmnReplace, rules, translate) {

  this._popupMenu = popupMenu;
  this._modeling = modeling;
  this._moddle = moddle;
  this._bpmnReplace = bpmnReplace;
  this._rules = rules;
  this._translate = translate;

  this.register();
}

ReplaceMenuProvider.$inject = ['popupMenu', 'modeling', 'moddle', 'bpmnReplace', 'rules', 'translate'];

/**
 * Register replace menu provider in the popup menu
 */
ReplaceMenuProvider.prototype.register = function () {
  this._popupMenu.registerProvider('bpmn-replace', this);
};

/**
 * 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) {

  var businessObject = element.businessObject;

  var rules = this._rules;

  var entries;

  if (!rules.allowed('shape.replace', { element: element })) {
    return [];
  }

  var differentType = (0, _TypeUtil.isDifferentType)(element);

  // start events outside event sub processes
  if ((0, _ModelUtil.is)(businessObject, 'bpmn:StartEvent') && !(0, _DiUtil.isEventSubProcess)(businessObject.$parent)) {

    entries = (0, _minDash.filter)(replaceOptions.START_EVENT, differentType);

    return this._createEntries(element, entries);
  }

  // expanded/collapsed pools
  if ((0, _ModelUtil.is)(businessObject, 'bpmn:Participant')) {

    entries = (0, _minDash.filter)(replaceOptions.PARTICIPANT, function (entry) {
      return (0, _DiUtil.isExpanded)(businessObject) !== entry.target.isExpanded;
    });

    return this._createEntries(element, entries);
  }

  // start events inside event sub processes
  if ((0, _ModelUtil.is)(businessObject, 'bpmn:StartEvent') && (0, _DiUtil.isEventSubProcess)(businessObject.$parent)) {

    entries = (0, _minDash.filter)(replaceOptions.EVENT_SUB_PROCESS_START_EVENT, function (entry) {

      var target = entry.target;

      var isInterrupting = target.isInterrupting !== false;

      var isInterruptingEqual = (0, _ModelUtil.getBusinessObject)(element).isInterrupting === isInterrupting;

      // filters elements which types and event definition are equal but have have different interrupting types
      return differentType(entry) || !differentType(entry) && !isInterruptingEqual;
    });

    return this._createEntries(element, entries);
  }

  // end events
  if ((0, _ModelUtil.is)(businessObject, 'bpmn:EndEvent')) {

    entries = (0, _minDash.filter)(replaceOptions.END_EVENT, function (entry) {
      var target = entry.target;

      // hide cancel end events outside transactions
      if (target.eventDefinitionType == 'bpmn:CancelEventDefinition' && !(0, _ModelUtil.is)(businessObject.$parent, 'bpmn:Transaction')) {
        return false;
      }

      return differentType(entry);
    });

    return this._createEntries(element, entries);
  }

  // boundary events
  if ((0, _ModelUtil.is)(businessObject, 'bpmn:BoundaryEvent')) {

    entries = (0, _minDash.filter)(replaceOptions.BOUNDARY_EVENT, function (entry) {

      var target = entry.target;

      if (target.eventDefinition == 'bpmn:CancelEventDefinition' && !(0, _ModelUtil.is)(businessObject.attachedToRef, 'bpmn:Transaction')) {
        return false;
      }
      var cancelActivity = target.cancelActivity !== false;

      var isCancelActivityEqual = businessObject.cancelActivity == cancelActivity;

      return differentType(entry) || !differentType(entry) && !isCancelActivityEqual;
    });

    return this._createEntries(element, entries);
  }

  // intermediate events
  if ((0, _ModelUtil.is)(businessObject, 'bpmn:IntermediateCatchEvent') || (0, _ModelUtil.is)(businessObject, 'bpmn:IntermediateThrowEvent')) {

    entries = (0, _minDash.filter)(replaceOptions.INTERMEDIATE_EVENT, differentType);

    return this._createEntries(element, entries);
  }

  // gateways
  if ((0, _ModelUtil.is)(businessObject, 'bpmn:Gateway')) {

    entries = (0, _minDash.filter)(replaceOptions.GATEWAY, differentType);

    return this._createEntries(element, entries);
  }

  // transactions
  if ((0, _ModelUtil.is)(businessObject, 'bpmn:Transaction')) {

    entries = (0, _minDash.filter)(replaceOptions.TRANSACTION, differentType);

    return this._createEntries(element, entries);
  }

  // expanded event sub processes
  if ((0, _DiUtil.isEventSubProcess)(businessObject) && (0, _DiUtil.isExpanded)(businessObject)) {

    entries = (0, _minDash.filter)(replaceOptions.EVENT_SUB_PROCESS, differentType);

    return this._createEntries(element, entries);
  }

  // expanded sub processes
  if ((0, _ModelUtil.is)(businessObject, 'bpmn:SubProcess') && (0, _DiUtil.isExpanded)(businessObject)) {

    entries = (0, _minDash.filter)(replaceOptions.SUBPROCESS_EXPANDED, differentType);

    return this._createEntries(element, entries);
  }

  // collapsed ad hoc sub processes
  if ((0, _ModelUtil.is)(businessObject, 'bpmn:AdHocSubProcess') && !(0, _DiUtil.isExpanded)(businessObject)) {

    entries = (0, _minDash.filter)(replaceOptions.TASK, function (entry) {

      var target = entry.target;

      var isTargetSubProcess = target.type === 'bpmn:SubProcess';

      var isTargetExpanded = target.isExpanded === true;

      return (0, _TypeUtil.isDifferentType)(element, target) && (!isTargetSubProcess || isTargetExpanded);
    });

    return this._createEntries(element, entries);
  }

  // sequence flows
  if ((0, _ModelUtil.is)(businessObject, 'bpmn:SequenceFlow')) {
    return this._createSequenceFlowEntries(element, replaceOptions.SEQUENCE_FLOW);
  }

  // flow nodes
  if ((0, _ModelUtil.is)(businessObject, 'bpmn:FlowNode')) {
    entries = (0, _minDash.filter)(replaceOptions.TASK, differentType);

    // collapsed SubProcess can not be replaced with itself
    if ((0, _ModelUtil.is)(businessObject, 'bpmn:SubProcess') && !(0, _DiUtil.isExpanded)(businessObject)) {
      entries = (0, _minDash.filter)(entries, function (entry) {
        return entry.label !== 'Sub Process (collapsed)';
      });
    }

    return this._createEntries(element, entries);
  }

  return [];
};

/**
 * 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) {

  var headerEntries = [];

  if ((0, _ModelUtil.is)(element, 'bpmn:Activity') && !(0, _DiUtil.isEventSubProcess)(element)) {
    headerEntries = headerEntries.concat(this._getLoopEntries(element));
  }

  if ((0, _ModelUtil.is)(element, 'bpmn:SubProcess') && !(0, _ModelUtil.is)(element, 'bpmn:Transaction') && !(0, _DiUtil.isEventSubProcess)(element)) {
    headerEntries.push(this._getAdHocEntry(element));
  }

  return headerEntries;
};

/**
 * 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 = [];

  var self = this;

  (0, _minDash.forEach)(replaceOptions, function (definition) {
    var entry = self._createMenuEntry(definition, element);

    menuEntries.push(entry);
  });

  return menuEntries;
};

/**
 * Creates an array of menu entry objects for a given sequence flow.
 *
 * @param  {djs.model.Base} element
 * @param  {Object} replaceOptions

 * @return {Array<Object>} a list of menu items
 */
ReplaceMenuProvider.prototype._createSequenceFlowEntries = function (element, replaceOptions) {

  var businessObject = (0, _ModelUtil.getBusinessObject)(element);

  var menuEntries = [];

  var modeling = this._modeling,
      moddle = this._moddle;

  var self = this;

  (0, _minDash.forEach)(replaceOptions, function (entry) {

    switch (entry.actionName) {
      case 'replace-with-default-flow':
        if (businessObject.sourceRef.default !== businessObject && ((0, _ModelUtil.is)(businessObject.sourceRef, 'bpmn:ExclusiveGateway') || (0, _ModelUtil.is)(businessObject.sourceRef, 'bpmn:InclusiveGateway') || (0, _ModelUtil.is)(businessObject.sourceRef, 'bpmn:ComplexGateway') || (0, _ModelUtil.is)(businessObject.sourceRef, 'bpmn:Activity'))) {

          menuEntries.push(self._createMenuEntry(entry, element, function () {
            modeling.updateProperties(element.source, { default: businessObject });
          }));
        }
        break;
      case 'replace-with-conditional-flow':
        if (!businessObject.conditionExpression && (0, _ModelUtil.is)(businessObject.sourceRef, 'bpmn:Activity')) {

          menuEntries.push(self._createMenuEntry(entry, element, function () {
            var conditionExpression = moddle.create('bpmn:FormalExpression', { body: '' });

            modeling.updateProperties(element, { conditionExpression: conditionExpression });
          }));
        }
        break;
      default:
        // default flows
        if ((0, _ModelUtil.is)(businessObject.sourceRef, 'bpmn:Activity') && businessObject.conditionExpression) {
          return menuEntries.push(self._createMenuEntry(entry, element, function () {
            modeling.updateProperties(element, { conditionExpression: undefined });
          }));
        }
        // conditional flows
        if (((0, _ModelUtil.is)(businessObject.sourceRef, 'bpmn:ExclusiveGateway') || (0, _ModelUtil.is)(businessObject.sourceRef, 'bpmn:InclusiveGateway') || (0, _ModelUtil.is)(businessObject.sourceRef, 'bpmn:ComplexGateway') || (0, _ModelUtil.is)(businessObject.sourceRef, 'bpmn:Activity')) && businessObject.sourceRef.default === businessObject) {

          return menuEntries.push(self._createMenuEntry(entry, element, function () {
            modeling.updateProperties(element.source, { default: undefined });
          }));
        }
    }
  });

  return menuEntries;
};

/**
 * 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;

  var replaceAction = function replaceAction() {
    return replaceElement(element, definition.target);
  };

  action = action || replaceAction;

  var menuEntry = {
    label: translate(definition.label),
    className: definition.className,
    id: definition.actionName,
    action: action
  };

  return menuEntry;
};

/**
 * 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) {

  var self = this;
  var translate = this._translate;

  function toggleLoopEntry(event, entry) {
    var loopCharacteristics;

    if (entry.active) {
      loopCharacteristics = undefined;
    } else {
      loopCharacteristics = self._moddle.create(entry.options.loopCharacteristics);

      if (entry.options.isSequential) {
        loopCharacteristics.isSequential = entry.options.isSequential;
      }
    }
    self._modeling.updateProperties(element, { loopCharacteristics: loopCharacteristics });
  }

  var businessObject = (0, _ModelUtil.getBusinessObject)(element),
      loopCharacteristics = businessObject.loopCharacteristics;

  var isSequential, isLoop, isParallel;

  if (loopCharacteristics) {
    isSequential = loopCharacteristics.isSequential;
    isLoop = loopCharacteristics.isSequential === undefined;
    isParallel = loopCharacteristics.isSequential !== undefined && !loopCharacteristics.isSequential;
  }

  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;
};

/**
 * 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 = (0, _ModelUtil.getBusinessObject)(element);

  var isAdHoc = (0, _ModelUtil.is)(businessObject, 'bpmn:AdHocSubProcess');

  var replaceElement = this._bpmnReplace.replaceElement;

  var adHocEntry = {
    id: 'toggle-adhoc',
    className: 'bpmn-icon-ad-hoc-marker',
    title: translate('Ad-hoc'),
    active: isAdHoc,
    action: function action(event, entry) {
      if (isAdHoc) {
        return replaceElement(element, { type: 'bpmn:SubProcess' });
      } else {
        return replaceElement(element, { type: 'bpmn:AdHocSubProcess' });
      }
    }
  };

  return adHocEntry;
};

},{"../../util/DiUtil":214,"../../util/ModelUtil":216,"../replace/ReplaceOptions":200,"./util/TypeUtil":196,"min-dash":505}],195:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _popupMenu = require('diagram-js/lib/features/popup-menu');

var _popupMenu2 = _interopRequireDefault(_popupMenu);

var _replace = require('../replace');

var _replace2 = _interopRequireDefault(_replace);

var _ReplaceMenuProvider = require('./ReplaceMenuProvider');

var _ReplaceMenuProvider2 = _interopRequireDefault(_ReplaceMenuProvider);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __depends__: [_popupMenu2.default, _replace2.default],
  __init__: ['replaceMenuProvider'],
  replaceMenuProvider: ['type', _ReplaceMenuProvider2.default]
};

},{"../replace":201,"./ReplaceMenuProvider":194,"diagram-js/lib/features/popup-menu":343}],196:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.isDifferentType = isDifferentType;

var _ModelUtil = require('../../../util/ModelUtil');

var _DiUtil = require('../../../util/DiUtil');

/**
 * 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) {

  return function (entry) {
    var target = entry.target;

    var businessObject = (0, _ModelUtil.getBusinessObject)(element),
        eventDefinition = businessObject.eventDefinitions && businessObject.eventDefinitions[0];

    var isTypeEqual = businessObject.$type === target.type;

    var isEventDefinitionEqual = (eventDefinition && eventDefinition.$type) === target.eventDefinitionType;

    var isTriggeredByEventEqual = businessObject.triggeredByEvent === target.triggeredByEvent;

    var isExpandedEqual = target.isExpanded === undefined || target.isExpanded === (0, _DiUtil.isExpanded)(businessObject);

    return !isTypeEqual || !isEventDefinitionEqual || !isTriggeredByEventEqual || !isExpandedEqual;
  };
}

},{"../../../util/DiUtil":214,"../../../util/ModelUtil":216}],197:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = BpmnReplacePreview;

var _CommandInterceptor = require('diagram-js/lib/command/CommandInterceptor');

var _CommandInterceptor2 = _interopRequireDefault(_CommandInterceptor);

var _inherits = require('inherits');

var _inherits2 = _interopRequireDefault(_inherits);

var _css = require('css.escape');

var _css2 = _interopRequireDefault(_css);

var _minDash = require('min-dash');

var _minDom = require('min-dom');

var _tinySvg = require('tiny-svg');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var LOW_PRIORITY = 250;

function BpmnReplacePreview(eventBus, elementRegistry, elementFactory, canvas, previewSupport) {

  _CommandInterceptor2.default.call(this, eventBus);

  /**
   * Replace the visuals of all elements in the context which can be replaced
   *
   * @param  {Object} context
   */
  function replaceVisual(context) {

    var replacements = context.canExecute.replacements;

    (0, _minDash.forEach)(replacements, function (replacement) {

      var id = replacement.oldElementId;

      var newElement = {
        type: replacement.newElementType
      };

      // if the visual of the element is already replaced
      if (context.visualReplacements[id]) {
        return;
      }

      var element = elementRegistry.get(id);

      (0, _minDash.assign)(newElement, { x: element.x, y: element.y });

      // create a temporary shape
      var tempShape = elementFactory.createShape(newElement);

      canvas.addShape(tempShape, element.parent);

      // select the original SVG element related to the element and hide it
      var gfx = (0, _minDom.query)('[data-element-id="' + (0, _css2.default)(element.id) + '"]', context.dragGroup);

      if (gfx) {
        (0, _tinySvg.attr)(gfx, { display: 'none' });
      }

      // clone the gfx of the temporary shape and add it to the drag group
      var dragger = previewSupport.addDragger(tempShape, context.dragGroup);

      context.visualReplacements[id] = dragger;

      canvas.removeShape(tempShape);
    });
  }

  /**
   * Restore the original visuals of the previously replaced elements
   *
   * @param  {Object} context
   */
  function restoreVisual(context) {

    var visualReplacements = context.visualReplacements;

    (0, _minDash.forEach)(visualReplacements, function (dragger, id) {

      var originalGfx = (0, _minDom.query)('[data-element-id="' + (0, _css2.default)(id) + '"]', context.dragGroup);

      if (originalGfx) {
        (0, _tinySvg.attr)(originalGfx, { display: 'inline' });
      }

      dragger.remove();

      if (visualReplacements[id]) {
        delete visualReplacements[id];
      }
    });
  }

  eventBus.on('shape.move.move', LOW_PRIORITY, function (event) {

    var context = event.context,
        canExecute = context.canExecute;

    if (!context.visualReplacements) {
      context.visualReplacements = {};
    }

    if (canExecute.replacements) {
      replaceVisual(context);
    } else {
      restoreVisual(context);
    }
  });
}

BpmnReplacePreview.$inject = ['eventBus', 'elementRegistry', 'elementFactory', 'canvas', 'previewSupport'];

(0, _inherits2.default)(BpmnReplacePreview, _CommandInterceptor2.default);

},{"css.escape":237,"diagram-js/lib/command/CommandInterceptor":243,"inherits":415,"min-dash":505,"min-dom":506,"tiny-svg":535}],198:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _previewSupport = require('diagram-js/lib/features/preview-support');

var _previewSupport2 = _interopRequireDefault(_previewSupport);

var _BpmnReplacePreview = require('./BpmnReplacePreview');

var _BpmnReplacePreview2 = _interopRequireDefault(_BpmnReplacePreview);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __depends__: [_previewSupport2.default],
  __init__: ['bpmnReplacePreview'],
  bpmnReplacePreview: ['type', _BpmnReplacePreview2.default]
};

},{"./BpmnReplacePreview":197,"diagram-js/lib/features/preview-support":345}],199:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = BpmnReplace;

var _minDash = require('min-dash');

var _ModelUtil = require('../../util/ModelUtil');

var _ModelingUtil = require('../modeling/util/ModelingUtil');

var _DiUtil = require('../../util/DiUtil');

var _ModelCloneUtils = require('../../util/model/ModelCloneUtils');

var _ModelCloneHelper = require('../../util/model/ModelCloneHelper');

var _ModelCloneHelper2 = _interopRequireDefault(_ModelCloneHelper);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var CUSTOM_PROPERTIES = ['cancelActivity', 'instantiate', 'eventGatewayType', 'triggeredByEvent', 'isInterrupting'];

function toggeling(element, target) {

  var oldCollapsed = element && (0, _minDash.has)(element, 'collapsed') ? element.collapsed : !(0, _DiUtil.isExpanded)(element);

  var targetCollapsed;

  if (target && ((0, _minDash.has)(target, 'collapsed') || (0, _minDash.has)(target, 'isExpanded'))) {
    // property is explicitly set so use it
    targetCollapsed = (0, _minDash.has)(target, 'collapsed') ? target.collapsed : !target.isExpanded;
  } else {
    // keep old state
    targetCollapsed = oldCollapsed;
  }

  if (oldCollapsed !== targetCollapsed) {
    element.collapsed = oldCollapsed;
    return true;
  }

  return false;
}

/**
 * This module takes care of replacing BPMN elements
 */
function BpmnReplace(bpmnFactory, replace, selection, modeling, eventBus) {

  var helper = new _ModelCloneHelper2.default(eventBus, bpmnFactory);

  /**
   * 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) {

    hints = hints || {};

    var type = target.type,
        oldBusinessObject = element.businessObject;

    if (isSubProcess(oldBusinessObject)) {
      if (type === 'bpmn:SubProcess') {
        if (toggeling(element, target)) {
          // expanding or collapsing process
          modeling.toggleCollapse(element);

          return element;
        }
      }
    }

    var newBusinessObject = bpmnFactory.create(type);

    var newElement = {
      type: type,
      businessObject: newBusinessObject
    };

    var elementProps = (0, _ModelCloneUtils.getProperties)(oldBusinessObject.$descriptor),
        newElementProps = (0, _ModelCloneUtils.getProperties)(newBusinessObject.$descriptor, true),
        copyProps = intersection(elementProps, newElementProps);

    // initialize special properties defined in target definition
    (0, _minDash.assign)(newBusinessObject, (0, _minDash.pick)(target, CUSTOM_PROPERTIES));

    var properties = (0, _minDash.filter)(copyProps, function (property) {
      var propName = property.replace(/bpmn:/, '');

      // copying event definitions, unless we replace
      if (propName === 'eventDefinitions') {
        return hasEventDefinition(element, target.eventDefinitionType);
      }

      // retain loop characteristics if the target element
      // is not an event sub process
      if (propName === 'loopCharacteristics') {
        return !(0, _DiUtil.isEventSubProcess)(newBusinessObject);
      }

      // so the applied properties from 'target' don't get lost
      if (property in newBusinessObject) {
        return false;
      }

      if (propName === 'processRef' && target.isExpanded === false) {
        return false;
      }

      if (propName === 'triggeredByEvent') {
        return false;
      }

      return _ModelCloneUtils.IGNORED_PROPERTIES.indexOf(propName) === -1;
    });

    newBusinessObject = helper.clone(oldBusinessObject, newBusinessObject, properties);

    // initialize custom BPMN extensions
    if (target.eventDefinitionType) {

      // only initialize with new eventDefinition
      // if we did not set an event definition yet,
      // i.e. because we cloned it
      if (!hasEventDefinition(newBusinessObject, target.eventDefinitionType)) {
        newElement.eventDefinitionType = target.eventDefinitionType;
      }
    }

    if ((0, _ModelUtil.is)(oldBusinessObject, 'bpmn:Activity')) {

      if (isSubProcess(oldBusinessObject)) {
        // no toggeling, so keep old state
        newElement.isExpanded = (0, _DiUtil.isExpanded)(oldBusinessObject);
      }
      // else if property is explicitly set, use it
      else if (target && (0, _minDash.has)(target, 'isExpanded')) {
          newElement.isExpanded = target.isExpanded;
        }

      // 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 ((0, _DiUtil.isExpanded)(oldBusinessObject) && !(0, _ModelUtil.is)(oldBusinessObject, 'bpmn:Task') && newElement.isExpanded) {
        newElement.width = element.width;
        newElement.height = element.height;
      }
    }

    // remove children if not expanding sub process
    if (isSubProcess(oldBusinessObject) && !isSubProcess(newBusinessObject)) {
      hints.moveChildren = false;
    }

    // transform collapsed/expanded pools
    if ((0, _ModelUtil.is)(oldBusinessObject, 'bpmn:Participant')) {

      // create expanded pool
      if (target.isExpanded === true) {
        newBusinessObject.processRef = bpmnFactory.create('bpmn:Process');
      } else {
        // remove children when transforming to collapsed pool
        hints.moveChildren = false;
      }

      // apply same size
      newElement.width = element.width;
      newElement.height = element.height;
    }

    newBusinessObject.name = oldBusinessObject.name;

    // retain default flow's reference between inclusive <-> exclusive gateways and activities
    if ((0, _ModelingUtil.isAny)(oldBusinessObject, ['bpmn:ExclusiveGateway', 'bpmn:InclusiveGateway', 'bpmn:Activity']) && (0, _ModelingUtil.isAny)(newBusinessObject, ['bpmn:ExclusiveGateway', 'bpmn:InclusiveGateway', 'bpmn:Activity'])) {
      newBusinessObject.default = oldBusinessObject.default;
    }

    if ('fill' in oldBusinessObject.di || 'stroke' in oldBusinessObject.di) {
      (0, _minDash.assign)(newElement, { colors: (0, _minDash.pick)(oldBusinessObject.di, ['fill', 'stroke']) });
    }

    newElement = replace.replaceElement(element, newElement, hints);

    if (hints.select !== false) {
      selection.select(newElement);
    }

    return newElement;
  }

  this.replaceElement = replaceElement;
}

BpmnReplace.$inject = ['bpmnFactory', 'replace', 'selection', 'modeling', 'eventBus'];

function isSubProcess(bo) {
  return (0, _ModelUtil.is)(bo, 'bpmn:SubProcess');
}

function hasEventDefinition(element, type) {

  var bo = (0, _ModelUtil.getBusinessObject)(element);

  return type && bo.get('eventDefinitions').some(function (definition) {
    return (0, _ModelUtil.is)(definition, type);
  });
}

/**
 * Compute intersection between two arrays.
 */
function intersection(a1, a2) {
  return a1.filter(function (el) {
    return a2.indexOf(el) !== -1;
  });
}

},{"../../util/DiUtil":214,"../../util/ModelUtil":216,"../../util/model/ModelCloneHelper":218,"../../util/model/ModelCloneUtils":219,"../modeling/util/ModelingUtil":189,"min-dash":505}],200:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
var START_EVENT = exports.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'
  }
}];

var INTERMEDIATE_EVENT = exports.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'
  }
}, {
  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'
  }
}, {
  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'
  }
}];

var END_EVENT = exports.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'
  }
}];

var GATEWAY = exports.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'
  }
  // 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' }
  //   }
  // }
}];

var SUBPROCESS_EXPANDED = exports.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
  }
}];

var TRANSACTION = exports.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
  }
}];

var EVENT_SUB_PROCESS = exports.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
  }
}];

var TASK = exports.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
  }
}];

var BOUNDARY_EVENT = exports.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
  }
}];

var EVENT_SUB_PROCESS_START_EVENT = exports.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
  }
}];

var SEQUENCE_FLOW = exports.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'
}];

var PARTICIPANT = exports.PARTICIPANT = [{
  label: 'Expanded Pool',
  actionName: 'replace-with-expanded-pool',
  className: 'bpmn-icon-participant',
  target: {
    type: 'bpmn:Participant',
    isExpanded: true
  }
}, {
  label: 'Collapsed Pool',
  actionName: 'replace-with-collapsed-pool',
  // TODO(@janstuemmel): maybe design new icon
  className: 'bpmn-icon-lane',
  target: {
    type: 'bpmn:Participant',
    isExpanded: false
  }
}];

},{}],201:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _selection = require('diagram-js/lib/features/selection');

var _selection2 = _interopRequireDefault(_selection);

var _replace = require('diagram-js/lib/features/replace');

var _replace2 = _interopRequireDefault(_replace);

var _BpmnReplace = require('./BpmnReplace');

var _BpmnReplace2 = _interopRequireDefault(_BpmnReplace);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __depends__: [_selection2.default, _replace2.default],
  bpmnReplace: ['type', _BpmnReplace2.default]
};

},{"./BpmnReplace":199,"diagram-js/lib/features/replace":347,"diagram-js/lib/features/selection":361}],202:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = BpmnRules;

var _minDash = require('min-dash');

var _inherits = require('inherits');

var _inherits2 = _interopRequireDefault(_inherits);

var _ModelUtil = require('../../util/ModelUtil');

var _ModelingUtil = require('../modeling/util/ModelingUtil');

var _LabelUtil = require('../../util/LabelUtil');

var _DiUtil = require('../../util/DiUtil');

var _RuleProvider = require('diagram-js/lib/features/rules/RuleProvider');

var _RuleProvider2 = _interopRequireDefault(_RuleProvider);

var _BpmnSnappingUtil = require('../snapping/BpmnSnappingUtil');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * BPMN specific modeling rule
 */
function BpmnRules(eventBus) {
  _RuleProvider2.default.call(this, eventBus);
}

(0, _inherits2.default)(BpmnRules, _RuleProvider2.default);

BpmnRules.$inject = ['eventBus'];

BpmnRules.prototype.init = function () {

  this.addRule('connection.start', function (context) {
    var source = context.source;

    return canStartConnection(source);
  });

  this.addRule('connection.create', function (context) {
    var source = context.source,
        target = context.target,
        hints = context.hints || {},
        targetParent = hints.targetParent,
        targetAttach = hints.targetAttach;

    // don't allow incoming connections on
    // newly created boundary events
    // to boundary events
    if (targetAttach) {
      return false;
    }

    // temporarily set target parent for scoping
    // checks to work
    if (targetParent) {
      target.parent = targetParent;
    }

    try {
      return canConnect(source, target);
    } finally {
      // unset temporary target parent
      if (targetParent) {
        target.parent = null;
      }
    }
  });

  this.addRule('connection.reconnectStart', function (context) {

    var connection = context.connection,
        source = context.hover || context.source,
        target = connection.target;

    return canConnect(source, target, connection);
  });

  this.addRule('connection.reconnectEnd', function (context) {

    var connection = context.connection,
        source = connection.source,
        target = context.hover || context.target;

    return canConnect(source, target, connection);
  });

  this.addRule('connection.updateWaypoints', function (context) {
    // OK! but visually ignore
    return null;
  });

  this.addRule('shape.resize', function (context) {

    var shape = context.shape,
        newBounds = context.newBounds;

    return canResize(shape, newBounds);
  });

  this.addRule('elements.move', function (context) {

    var target = context.target,
        shapes = context.shapes,
        position = context.position;

    return canAttach(shapes, target, null, position) || canReplace(shapes, target, position) || canMove(shapes, target, position) || canInsert(shapes, target, position);
  });

  this.addRule('shape.create', function (context) {
    return canCreate(context.shape, context.target, context.source, context.position);
  });

  this.addRule('shape.attach', function (context) {

    return canAttach(context.shape, context.target, null, context.position);
  });

  this.addRule('element.copy', function (context) {
    var collection = context.collection,
        element = context.element;

    return canCopy(collection, element);
  });

  this.addRule('element.paste', function (context) {
    var parent = context.parent,
        element = context.element,
        position = context.position,
        source = context.source,
        target = context.target;

    if (source || target) {
      return canConnect(source, target);
    }

    return canAttach([element], parent, null, position) || canCreate(element, parent, null, position);
  });

  this.addRule('elements.paste', function (context) {
    var tree = context.tree,
        target = context.target;

    return canPaste(tree, target);
  });
};

BpmnRules.prototype.canConnectMessageFlow = canConnectMessageFlow;

BpmnRules.prototype.canConnectSequenceFlow = canConnectSequenceFlow;

BpmnRules.prototype.canConnectDataAssociation = canConnectDataAssociation;

BpmnRules.prototype.canConnectAssociation = canConnectAssociation;

BpmnRules.prototype.canMove = canMove;

BpmnRules.prototype.canAttach = canAttach;

BpmnRules.prototype.canReplace = canReplace;

BpmnRules.prototype.canDrop = canDrop;

BpmnRules.prototype.canInsert = canInsert;

BpmnRules.prototype.canCreate = canCreate;

BpmnRules.prototype.canConnect = canConnect;

BpmnRules.prototype.canResize = canResize;

BpmnRules.prototype.canCopy = canCopy;

/**
 * Utility functions for rule checking
 */

/**
 * Checks if given element can be used for starting connection.
 *
 * @param  {Element} source
 * @return {Boolean}
 */
function canStartConnection(element) {
  if (nonExistingOrLabel(element)) {
    return null;
  }

  return (0, _ModelingUtil.isAny)(element, ['bpmn:FlowNode', 'bpmn:InteractionNode', 'bpmn:DataObjectReference', 'bpmn:DataStoreReference']);
}

function nonExistingOrLabel(element) {
  return !element || (0, _LabelUtil.isLabel)(element);
}

function isSame(a, b) {
  return a === b;
}

function getOrganizationalParent(element) {

  do {
    if ((0, _ModelUtil.is)(element, 'bpmn:Process')) {
      return (0, _ModelUtil.getBusinessObject)(element);
    }

    if ((0, _ModelUtil.is)(element, 'bpmn:Participant')) {
      return (0, _ModelUtil.getBusinessObject)(element).processRef || (0, _ModelUtil.getBusinessObject)(element);
    }
  } while (element = element.parent);
}

function isTextAnnotation(element) {
  return (0, _ModelUtil.is)(element, 'bpmn:TextAnnotation');
}

function isCompensationBoundary(element) {
  return (0, _ModelUtil.is)(element, 'bpmn:BoundaryEvent') && hasEventDefinition(element, 'bpmn:CompensateEventDefinition');
}

function isForCompensation(e) {
  return (0, _ModelUtil.getBusinessObject)(e).isForCompensation;
}

function isSameOrganization(a, b) {
  var parentA = getOrganizationalParent(a),
      parentB = getOrganizationalParent(b);

  return parentA === parentB;
}

function isMessageFlowSource(element) {
  return (0, _ModelUtil.is)(element, 'bpmn:InteractionNode') && (!(0, _ModelUtil.is)(element, 'bpmn:Event') || (0, _ModelUtil.is)(element, 'bpmn:ThrowEvent') && hasEventDefinitionOrNone(element, 'bpmn:MessageEventDefinition'));
}

function isMessageFlowTarget(element) {
  return (0, _ModelUtil.is)(element, 'bpmn:InteractionNode') && !isForCompensation(element) && (!(0, _ModelUtil.is)(element, 'bpmn:Event') || (0, _ModelUtil.is)(element, 'bpmn:CatchEvent') && hasEventDefinitionOrNone(element, 'bpmn:MessageEventDefinition'));
}

function getScopeParent(element) {

  var parent = element;

  while (parent = parent.parent) {

    if ((0, _ModelUtil.is)(parent, 'bpmn:FlowElementsContainer')) {
      return (0, _ModelUtil.getBusinessObject)(parent);
    }

    if ((0, _ModelUtil.is)(parent, 'bpmn:Participant')) {
      return (0, _ModelUtil.getBusinessObject)(parent).processRef;
    }
  }

  return null;
}

function isSameScope(a, b) {
  var scopeParentA = getScopeParent(a),
      scopeParentB = getScopeParent(b);

  return scopeParentA && scopeParentA === scopeParentB;
}

function hasEventDefinition(element, eventDefinition) {
  var bo = (0, _ModelUtil.getBusinessObject)(element);

  return !!(0, _minDash.find)(bo.eventDefinitions || [], function (definition) {
    return (0, _ModelUtil.is)(definition, eventDefinition);
  });
}

function hasEventDefinitionOrNone(element, eventDefinition) {
  var bo = (0, _ModelUtil.getBusinessObject)(element);

  return (bo.eventDefinitions || []).every(function (definition) {
    return (0, _ModelUtil.is)(definition, eventDefinition);
  });
}

function isSequenceFlowSource(element) {
  return (0, _ModelUtil.is)(element, 'bpmn:FlowNode') && !(0, _ModelUtil.is)(element, 'bpmn:EndEvent') && !(0, _DiUtil.isEventSubProcess)(element) && !((0, _ModelUtil.is)(element, 'bpmn:IntermediateThrowEvent') && hasEventDefinition(element, 'bpmn:LinkEventDefinition')) && !isCompensationBoundary(element) && !isForCompensation(element);
}

function isSequenceFlowTarget(element) {
  return (0, _ModelUtil.is)(element, 'bpmn:FlowNode') && !(0, _ModelUtil.is)(element, 'bpmn:StartEvent') && !(0, _ModelUtil.is)(element, 'bpmn:BoundaryEvent') && !(0, _DiUtil.isEventSubProcess)(element) && !((0, _ModelUtil.is)(element, 'bpmn:IntermediateCatchEvent') && hasEventDefinition(element, 'bpmn:LinkEventDefinition')) && !isForCompensation(element);
}

function isEventBasedTarget(element) {
  return (0, _ModelUtil.is)(element, 'bpmn:ReceiveTask') || (0, _ModelUtil.is)(element, 'bpmn:IntermediateCatchEvent') && (hasEventDefinition(element, 'bpmn:MessageEventDefinition') || hasEventDefinition(element, 'bpmn:TimerEventDefinition') || hasEventDefinition(element, 'bpmn:ConditionalEventDefinition') || hasEventDefinition(element, 'bpmn:SignalEventDefinition'));
}

function isConnection(element) {
  return element.waypoints;
}

function getParents(element) {

  var parents = [];

  while (element) {
    element = element.parent;

    if (element) {
      parents.push(element);
    }
  }

  return parents;
}

function isParent(possibleParent, element) {
  var allParents = getParents(element);
  return allParents.indexOf(possibleParent) !== -1;
}

function canConnect(source, target, connection) {

  if (nonExistingOrLabel(source) || nonExistingOrLabel(target)) {
    return null;
  }

  if (!(0, _ModelUtil.is)(connection, 'bpmn:DataAssociation')) {

    if (canConnectMessageFlow(source, target)) {
      return { type: 'bpmn:MessageFlow' };
    }

    if (canConnectSequenceFlow(source, target)) {
      return { type: 'bpmn:SequenceFlow' };
    }
  }

  var connectDataAssociation = canConnectDataAssociation(source, target);

  if (connectDataAssociation) {
    return connectDataAssociation;
  }

  if (isCompensationBoundary(source) && isForCompensation(target)) {
    return {
      type: 'bpmn:Association',
      associationDirection: 'One'
    };
  }

  if (canConnectAssociation(source, target)) {

    return {
      type: 'bpmn:Association'
    };
  }

  return false;
}

/**
 * Can an element be dropped into the target element
 *
 * @return {Boolean}
 */
function canDrop(element, target, position) {

  // can move labels everywhere
  if ((0, _LabelUtil.isLabel)(element)) {
    return true;
  }

  // disallow to create elements on collapsed pools
  if ((0, _ModelUtil.is)(target, 'bpmn:Participant') && !(0, _DiUtil.isExpanded)(target)) {
    return false;
  }

  // allow to create new participants on
  // on existing collaboration and process diagrams
  if ((0, _ModelUtil.is)(element, 'bpmn:Participant')) {
    return (0, _ModelUtil.is)(target, 'bpmn:Process') || (0, _ModelUtil.is)(target, 'bpmn:Collaboration');
  }

  // allow creating lanes on participants and other lanes only
  if ((0, _ModelUtil.is)(element, 'bpmn:Lane')) {
    return (0, _ModelUtil.is)(target, 'bpmn:Participant') || (0, _ModelUtil.is)(target, 'bpmn:Lane');
  }

  if ((0, _ModelUtil.is)(element, 'bpmn:BoundaryEvent')) {
    return false;
  }

  // drop flow elements onto flow element containers
  // and participants
  if ((0, _ModelUtil.is)(element, 'bpmn:FlowElement') && !(0, _ModelUtil.is)(element, 'bpmn:DataStoreReference')) {
    if ((0, _ModelUtil.is)(target, 'bpmn:FlowElementsContainer')) {
      return (0, _DiUtil.isExpanded)(target);
    }

    return (0, _ModelingUtil.isAny)(target, ['bpmn:Participant', 'bpmn:Lane']);
  }

  // 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 ((0, _ModelingUtil.isAny)(element, ['bpmn:Artifact', 'bpmn:DataAssociation', 'bpmn:DataStoreReference'])) {
    return (0, _ModelingUtil.isAny)(target, ['bpmn:Collaboration', 'bpmn:Lane', 'bpmn:Participant', 'bpmn:Process', 'bpmn:SubProcess']);
  }

  if ((0, _ModelUtil.is)(element, 'bpmn:MessageFlow')) {
    return (0, _ModelUtil.is)(target, 'bpmn:Collaboration') || element.source.parent == target || element.target.parent == target;
  }

  return false;
}

function canPaste(tree, target) {
  var topLevel = tree[0],
      participants;

  if ((0, _ModelUtil.is)(target, 'bpmn:Collaboration')) {
    return (0, _minDash.every)(topLevel, function (e) {
      return e.type === 'bpmn:Participant';
    });
  }

  if ((0, _ModelUtil.is)(target, 'bpmn:Process')) {
    participants = (0, _minDash.some)(topLevel, function (e) {
      return e.type === 'bpmn:Participant';
    });

    return !(participants && target.children.length > 0);
  }

  // disallow to create elements on collapsed pools
  if ((0, _ModelUtil.is)(target, 'bpmn:Participant') && !(0, _DiUtil.isExpanded)(target)) {
    return false;
  }

  if ((0, _ModelUtil.is)(target, 'bpmn:FlowElementsContainer')) {
    return (0, _DiUtil.isExpanded)(target);
  }

  return (0, _ModelingUtil.isAny)(target, ['bpmn:Collaboration', 'bpmn:Lane', 'bpmn:Participant', 'bpmn:Process', 'bpmn:SubProcess']);
}

function isBoundaryEvent(element) {
  return !(0, _LabelUtil.isLabel)(element) && (0, _ModelUtil.is)(element, 'bpmn:BoundaryEvent');
}

function isLane(element) {
  return (0, _ModelUtil.is)(element, 'bpmn:Lane');
}

/**
 * We treat IntermediateThrowEvents as boundary events during create,
 * this must be reflected in the rules.
 */
function isBoundaryCandidate(element) {
  return isBoundaryEvent(element) || (0, _ModelUtil.is)(element, 'bpmn:IntermediateThrowEvent') && !element.parent;
}

function isReceiveTaskAfterEventBasedGateway(element) {
  return (0, _ModelUtil.is)(element, 'bpmn:ReceiveTask') && (0, _minDash.find)(element.incoming, function (incoming) {
    return (0, _ModelUtil.is)(incoming.source, 'bpmn:EventBasedGateway');
  });
}

function canAttach(elements, target, source, position) {

  if (!Array.isArray(elements)) {
    elements = [elements];
  }

  // disallow appending as boundary event
  if (source) {
    return false;
  }

  // only (re-)attach one element at a time
  if (elements.length !== 1) {
    return false;
  }

  var element = elements[0];

  // do not attach labels
  if ((0, _LabelUtil.isLabel)(element)) {
    return false;
  }

  // only handle boundary events
  if (!isBoundaryCandidate(element)) {
    return false;
  }

  // allow default move operation
  if (!target) {
    return true;
  }

  // disallow drop on event sub processes
  if ((0, _DiUtil.isEventSubProcess)(target)) {
    return false;
  }

  // only allow drop on non compensation activities
  if (!(0, _ModelUtil.is)(target, 'bpmn:Activity') || isForCompensation(target)) {
    return false;
  }

  // only attach to subprocess border
  if (position && !(0, _BpmnSnappingUtil.getBoundaryAttachment)(position, target)) {
    return false;
  }

  // do not attach on receive tasks after event based gateways
  if (isReceiveTaskAfterEventBasedGateway(target)) {
    return false;
  }

  return 'attach';
}

/**
 * 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) {

  if (!target) {
    return false;
  }

  var canExecute = {
    replacements: []
  };

  (0, _minDash.forEach)(elements, function (element) {

    if (!(0, _DiUtil.isEventSubProcess)(target)) {

      if ((0, _ModelUtil.is)(element, 'bpmn:StartEvent') && element.type !== 'label' && canDrop(element, target)) {

        // replace a non-interrupting start event by a blank interrupting start event
        // when the target is not an event sub process
        if (!(0, _DiUtil.isInterrupting)(element)) {
          canExecute.replacements.push({
            oldElementId: element.id,
            newElementType: 'bpmn:StartEvent'
          });
        }

        // replace an error/escalation/compansate start event by a blank interrupting start event
        // when the target is not an event sub process
        if ((0, _DiUtil.hasErrorEventDefinition)(element) || (0, _DiUtil.hasEscalationEventDefinition)(element) || (0, _DiUtil.hasCompensateEventDefinition)(element)) {
          canExecute.replacements.push({
            oldElementId: element.id,
            newElementType: 'bpmn:StartEvent'
          });
        }
      }
    }

    if (!(0, _ModelUtil.is)(target, 'bpmn:Transaction')) {
      if (hasEventDefinition(element, 'bpmn:CancelEventDefinition') && element.type !== 'label') {

        if ((0, _ModelUtil.is)(element, 'bpmn:EndEvent') && canDrop(element, target)) {
          canExecute.replacements.push({
            oldElementId: element.id,
            newElementType: 'bpmn:EndEvent'
          });
        }

        if ((0, _ModelUtil.is)(element, 'bpmn:BoundaryEvent') && canAttach(element, target, null, position)) {
          canExecute.replacements.push({
            oldElementId: element.id,
            newElementType: 'bpmn:BoundaryEvent'
          });
        }
      }
    }
  });

  return canExecute.replacements.length ? canExecute : false;
}

function canMove(elements, target) {

  // do not move selection containing boundary events
  if ((0, _minDash.some)(elements, isBoundaryEvent)) {
    return false;
  }

  // do not move selection containing lanes
  if ((0, _minDash.some)(elements, isLane)) {
    return false;
  }

  // allow default move check to start move operation
  if (!target) {
    return true;
  }

  return elements.every(function (element) {
    return canDrop(element, target);
  });
}

function canCreate(shape, target, source, position) {

  if (!target) {
    return false;
  }

  if ((0, _LabelUtil.isLabel)(target)) {
    return null;
  }

  if (isSame(source, target)) {
    return false;
  }

  // ensure we do not drop the element
  // into source
  if (source && isParent(source, target)) {
    return false;
  }

  return canDrop(shape, target, position) || canInsert(shape, target, position);
}

function canResize(shape, newBounds) {
  if ((0, _ModelUtil.is)(shape, 'bpmn:SubProcess')) {
    return (0, _DiUtil.isExpanded)(shape) && (!newBounds || newBounds.width >= 100 && newBounds.height >= 80);
  }

  if ((0, _ModelUtil.is)(shape, 'bpmn:Lane')) {
    return !newBounds || newBounds.width >= 130 && newBounds.height >= 60;
  }

  if ((0, _ModelUtil.is)(shape, 'bpmn:Participant')) {
    return !newBounds || newBounds.width >= 250 && newBounds.height >= 50;
  }

  if (isTextAnnotation(shape)) {
    return true;
  }

  return false;
}

/**
 * Check, whether one side of the relationship
 * is a text annotation.
 */
function isOneTextAnnotation(source, target) {

  var sourceTextAnnotation = isTextAnnotation(source),
      targetTextAnnotation = isTextAnnotation(target);

  return (sourceTextAnnotation || targetTextAnnotation) && sourceTextAnnotation !== targetTextAnnotation;
}

function canConnectAssociation(source, target) {

  // do not connect connections
  if (isConnection(source) || isConnection(target)) {
    return false;
  }

  // compensation boundary events are exception
  if (isCompensationBoundary(source) && isForCompensation(target)) {
    return true;
  }

  // don't connect parent <-> child
  if (isParent(target, source) || isParent(source, target)) {
    return false;
  }

  // allow connection of associations between <!TextAnnotation> and <TextAnnotation>
  return isOneTextAnnotation(source, target);
}

function canConnectMessageFlow(source, target) {

  return isMessageFlowSource(source) && isMessageFlowTarget(target) && !isSameOrganization(source, target);
}

function canConnectSequenceFlow(source, target) {

  return isSequenceFlowSource(source) && isSequenceFlowTarget(target) && isSameScope(source, target) && !((0, _ModelUtil.is)(source, 'bpmn:EventBasedGateway') && !isEventBasedTarget(target));
}

function canConnectDataAssociation(source, target) {

  if ((0, _ModelingUtil.isAny)(source, ['bpmn:DataObjectReference', 'bpmn:DataStoreReference']) && (0, _ModelingUtil.isAny)(target, ['bpmn:Activity', 'bpmn:ThrowEvent'])) {
    return { type: 'bpmn:DataInputAssociation' };
  }

  if ((0, _ModelingUtil.isAny)(target, ['bpmn:DataObjectReference', 'bpmn:DataStoreReference']) && (0, _ModelingUtil.isAny)(source, ['bpmn:Activity', 'bpmn:CatchEvent'])) {
    return { type: 'bpmn:DataOutputAssociation' };
  }

  return false;
}

function canInsert(shape, flow, position) {

  if (!flow) {
    return false;
  }

  if (Array.isArray(shape)) {
    if (shape.length !== 1) {
      return false;
    }

    shape = shape[0];
  }

  if (flow.source === shape || flow.target === shape) {
    return false;
  }

  // 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)

  return (0, _ModelingUtil.isAny)(flow, ['bpmn:SequenceFlow', 'bpmn:MessageFlow']) && !(0, _LabelUtil.isLabel)(flow) && (0, _ModelUtil.is)(shape, 'bpmn:FlowNode') && !(0, _ModelUtil.is)(shape, 'bpmn:BoundaryEvent') && canDrop(shape, flow.parent, position);
}

function contains(collection, element) {
  return collection && element && collection.indexOf(element) !== -1;
}

function canCopy(collection, element) {
  if ((0, _ModelUtil.is)(element, 'bpmn:Lane') && !contains(collection, element.parent)) {
    return false;
  }

  if ((0, _ModelUtil.is)(element, 'bpmn:BoundaryEvent') && !contains(collection, element.host)) {
    return false;
  }

  return true;
}

},{"../../util/DiUtil":214,"../../util/LabelUtil":215,"../../util/ModelUtil":216,"../modeling/util/ModelingUtil":189,"../snapping/BpmnSnappingUtil":207,"diagram-js/lib/features/rules/RuleProvider":353,"inherits":415,"min-dash":505}],203:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _rules = require('diagram-js/lib/features/rules');

var _rules2 = _interopRequireDefault(_rules);

var _BpmnRules = require('./BpmnRules');

var _BpmnRules2 = _interopRequireDefault(_BpmnRules);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __depends__: [_rules2.default],
  __init__: ['bpmnRules'],
  bpmnRules: ['type', _BpmnRules2.default]
};

},{"./BpmnRules":202,"diagram-js/lib/features/rules":355}],204:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = BpmnSearchProvider;

var _minDash = require('min-dash');

var _LabelUtil = require('../label-editing/LabelUtil');

/**
 * Provides ability to search through BPMN elements
 */
function BpmnSearchProvider(elementRegistry, searchPad, canvas) {

  this._elementRegistry = elementRegistry;
  this._canvas = canvas;

  searchPad.registerProvider(this);
}

BpmnSearchProvider.$inject = ['elementRegistry', 'searchPad', 'canvas'];

/**
 * 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();

  var elements = this._elementRegistry.filter(function (element) {
    if (element.labelTarget) {
      return false;
    }
    return true;
  });

  // do not include root element
  elements = (0, _minDash.filter)(elements, function (element) {
    return element !== rootElement;
  });

  elements = (0, _minDash.map)(elements, function (element) {
    return {
      primaryTokens: matchAndSplit((0, _LabelUtil.getLabel)(element), pattern),
      secondaryTokens: matchAndSplit(element.id, pattern),
      element: element
    };
  });

  // exclude non-matched elements
  elements = (0, _minDash.filter)(elements, function (element) {
    return hasMatched(element.primaryTokens) || hasMatched(element.secondaryTokens);
  });

  elements = (0, _minDash.sortBy)(elements, function (element) {
    return (0, _LabelUtil.getLabel)(element.element) + element.element.id;
  });

  return elements;
};

function hasMatched(tokens) {
  var matched = (0, _minDash.filter)(tokens, function (t) {
    return !!t.matched;
  });

  return matched.length > 0;
}

function matchAndSplit(text, pattern) {
  var tokens = [],
      originalText = text;

  if (!text) {
    return tokens;
  }

  text = text.toLowerCase();
  pattern = pattern.toLowerCase();

  var i = text.indexOf(pattern);

  if (i > -1) {
    if (i !== 0) {
      tokens.push({
        normal: originalText.substr(0, i)
      });
    }

    tokens.push({
      matched: originalText.substr(i, pattern.length)
    });

    if (pattern.length + i < text.length) {
      tokens.push({
        normal: originalText.substr(pattern.length + i, text.length)
      });
    }
  } else {
    tokens.push({
      normal: originalText
    });
  }

  return tokens;
}

},{"../label-editing/LabelUtil":142,"min-dash":505}],205:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _searchPad = require('diagram-js/lib/features/search-pad');

var _searchPad2 = _interopRequireDefault(_searchPad);

var _BpmnSearchProvider = require('./BpmnSearchProvider');

var _BpmnSearchProvider2 = _interopRequireDefault(_BpmnSearchProvider);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __depends__: [_searchPad2.default],
  __init__: ['bpmnSearch'],
  bpmnSearch: ['type', _BpmnSearchProvider2.default]
};

},{"./BpmnSearchProvider":204,"diagram-js/lib/features/search-pad":357}],206:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = BpmnSnapping;

var _inherits = require('inherits');

var _inherits2 = _interopRequireDefault(_inherits);

var _minDash = require('min-dash');

var _Elements = require('diagram-js/lib/util/Elements');

var _ModelUtil = require('../../util/ModelUtil');

var _ModelingUtil = require('../modeling/util/ModelingUtil');

var _DiUtil = require('../../util/DiUtil');

var _Snapping = require('diagram-js/lib/features/snapping/Snapping');

var _Snapping2 = _interopRequireDefault(_Snapping);

var _SnapUtil = require('diagram-js/lib/features/snapping/SnapUtil');

var _LayoutUtil = require('diagram-js/lib/layout/LayoutUtil');

var _BpmnSnappingUtil = require('./BpmnSnappingUtil');

var _LaneUtil = require('../modeling/util/LaneUtil');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var round = Math.round;

var HIGH_PRIORITY = 1500;

/**
 * BPMN specific snapping functionality
 *
 *  * snap on process elements if a pool is created inside a
 *    process diagram
 *
 * @param {EventBus} eventBus
 * @param {Canvas} canvas
 */
function BpmnSnapping(eventBus, canvas, bpmnRules, elementRegistry) {

  // instantiate super
  _Snapping2.default.call(this, eventBus, canvas);

  /**
   * Drop participant on process <> process elements snapping
   */
  eventBus.on('create.start', function (event) {

    var context = event.context,
        shape = context.shape,
        rootElement = canvas.getRootElement();

    // snap participant around existing elements (if any)
    if ((0, _ModelUtil.is)(shape, 'bpmn:Participant') && (0, _ModelUtil.is)(rootElement, 'bpmn:Process')) {
      initParticipantSnapping(context, shape, rootElement.children);
    }
  });

  eventBus.on(['create.move', 'create.end'], HIGH_PRIORITY, function (event) {

    var context = event.context,
        shape = context.shape,
        participantSnapBox = context.participantSnapBox;

    if (!(0, _SnapUtil.isSnapped)(event) && participantSnapBox) {
      snapParticipant(participantSnapBox, shape, event);
    }
  });

  eventBus.on('shape.move.start', function (event) {

    var context = event.context,
        shape = context.shape,
        rootElement = canvas.getRootElement();

    // snap participant around existing elements (if any)
    if ((0, _ModelUtil.is)(shape, 'bpmn:Participant') && (0, _ModelUtil.is)(rootElement, 'bpmn:Process')) {
      initParticipantSnapping(context, shape, rootElement.children);
    }
  });

  function canAttach(shape, target, position) {
    return bpmnRules.canAttach([shape], target, null, position) === 'attach';
  }

  function canConnect(source, target) {
    return bpmnRules.canConnect(source, target);
  }

  /**
   * Snap boundary events to elements border
   */
  eventBus.on(['create.move', 'create.end', 'shape.move.move', 'shape.move.end'], HIGH_PRIORITY, function (event) {

    var context = event.context,
        target = context.target,
        shape = context.shape;

    if (target && !(0, _SnapUtil.isSnapped)(event) && canAttach(shape, target, event)) {
      snapBoundaryEvent(event, shape, target);
    }
  });

  /**
   * Adjust parent for flowElements to the target participant
   * when droping onto lanes.
   */
  eventBus.on(['shape.move.hover', 'shape.move.move', 'shape.move.end', 'create.hover', 'create.move', 'create.end'], HIGH_PRIORITY, function (event) {
    var context = event.context,
        shape = context.shape,
        hover = event.hover;

    if ((0, _ModelUtil.is)(hover, 'bpmn:Lane') && !(0, _ModelingUtil.isAny)(shape, ['bpmn:Lane', 'bpmn:Participant'])) {
      event.hover = (0, _LaneUtil.getLanesRoot)(hover);
      event.hoverGfx = elementRegistry.getGraphics(event.hover);
    }
  });

  /**
   * Snap sequence flows.
   */
  eventBus.on(['connect.move', 'connect.hover', 'connect.end'], HIGH_PRIORITY, function (event) {
    var context = event.context,
        source = context.source,
        target = context.target;

    var connection = canConnect(source, target) || {};

    if (!context.initialSourcePosition) {
      context.initialSourcePosition = context.sourcePosition;
    }

    if (target && (connection.type === 'bpmn:Association' || connection.type === 'bpmn:DataOutputAssociation' || connection.type === 'bpmn:DataInputAssociation' || connection.type === 'bpmn:SequenceFlow')) {
      // snap source
      context.sourcePosition = (0, _SnapUtil.mid)(source);

      // snap target
      snapToPosition(event, (0, _SnapUtil.mid)(target));
    } else if (connection.type === 'bpmn:MessageFlow') {

      if ((0, _ModelUtil.is)(source, 'bpmn:Event')) {
        // snap source
        context.sourcePosition = (0, _SnapUtil.mid)(source);
      }

      if ((0, _ModelUtil.is)(target, 'bpmn:Event')) {
        // snap target
        snapToPosition(event, (0, _SnapUtil.mid)(target));
      }
    } else {
      // otherwise reset source snap
      context.sourcePosition = context.initialSourcePosition;
    }
  });

  eventBus.on('resize.start', HIGH_PRIORITY, function (event) {
    var context = event.context,
        shape = context.shape;

    if ((0, _ModelUtil.is)(shape, 'bpmn:SubProcess') && (0, _DiUtil.isExpanded)(shape)) {
      context.minDimensions = { width: 140, height: 120 };
    }

    if ((0, _ModelUtil.is)(shape, 'bpmn:Participant')) {
      context.minDimensions = { width: 300, height: 150 };
    }

    if ((0, _ModelUtil.is)(shape, 'bpmn:Lane') || (0, _ModelUtil.is)(shape, 'bpmn:Participant')) {
      context.resizeConstraints = (0, _BpmnSnappingUtil.getParticipantSizeConstraints)(shape, context.direction, context.balanced);
    }

    if ((0, _ModelUtil.is)(shape, 'bpmn:TextAnnotation')) {
      context.minDimensions = { width: 50, height: 30 };
    }
  });
}

(0, _inherits2.default)(BpmnSnapping, _Snapping2.default);

BpmnSnapping.$inject = ['eventBus', 'canvas', 'bpmnRules', 'elementRegistry'];

BpmnSnapping.prototype.initSnap = function (event) {

  var context = event.context,
      shape = event.shape,
      shapeMid,
      shapeBounds,
      shapeTopLeft,
      shapeBottomRight,
      snapContext;

  snapContext = _Snapping2.default.prototype.initSnap.call(this, event);

  if ((0, _ModelUtil.is)(shape, 'bpmn:Participant')) {
    // assign higher priority for outer snaps on participants
    snapContext.setSnapLocations(['top-left', 'bottom-right', 'mid']);
  }

  if (shape) {

    shapeMid = (0, _SnapUtil.mid)(shape, event);

    shapeBounds = {
      width: shape.width,
      height: shape.height,
      x: isNaN(shape.x) ? round(shapeMid.x - shape.width / 2) : shape.x,
      y: isNaN(shape.y) ? round(shapeMid.y - shape.height / 2) : shape.y
    };

    shapeTopLeft = (0, _SnapUtil.topLeft)(shapeBounds);
    shapeBottomRight = (0, _SnapUtil.bottomRight)(shapeBounds);

    snapContext.setSnapOrigin('top-left', {
      x: shapeTopLeft.x - event.x,
      y: shapeTopLeft.y - event.y
    });

    snapContext.setSnapOrigin('bottom-right', {
      x: shapeBottomRight.x - event.x,
      y: shapeBottomRight.y - event.y
    });

    (0, _minDash.forEach)(shape.outgoing, function (c) {
      var docking = c.waypoints[0];

      docking = docking.original || docking;

      snapContext.setSnapOrigin(c.id + '-docking', {
        x: docking.x - event.x,
        y: docking.y - event.y
      });
    });

    (0, _minDash.forEach)(shape.incoming, function (c) {
      var docking = c.waypoints[c.waypoints.length - 1];

      docking = docking.original || docking;

      snapContext.setSnapOrigin(c.id + '-docking', {
        x: docking.x - event.x,
        y: docking.y - event.y
      });
    });
  }

  var source = context.source;

  if (source) {
    snapContext.addDefaultSnap('mid', (0, _SnapUtil.mid)(source));
  }
};

BpmnSnapping.prototype.addTargetSnaps = function (snapPoints, shape, target) {

  // use target parent as snap target
  if ((0, _ModelUtil.is)(shape, 'bpmn:BoundaryEvent') && shape.type !== 'label') {
    target = target.parent;
  }

  // add sequence flow parents as snap targets
  if ((0, _ModelUtil.is)(target, 'bpmn:SequenceFlow')) {
    this.addTargetSnaps(snapPoints, shape, target.parent);
  }

  var siblings = this.getSiblings(shape, target) || [];

  (0, _minDash.forEach)(siblings, function (sibling) {

    // do not snap to lanes
    if ((0, _ModelUtil.is)(sibling, 'bpmn:Lane')) {
      return;
    }

    if (sibling.waypoints) {

      (0, _minDash.forEach)(sibling.waypoints.slice(1, -1), function (waypoint, i) {
        var nextWaypoint = sibling.waypoints[i + 2],
            previousWaypoint = sibling.waypoints[i];

        if (!nextWaypoint || !previousWaypoint) {
          throw new Error('waypoints must exist');
        }

        if (nextWaypoint.x === waypoint.x || nextWaypoint.y === waypoint.y || previousWaypoint.x === waypoint.x || previousWaypoint.y === waypoint.y) {
          snapPoints.add('mid', waypoint);
        }
      });

      return;
    }

    snapPoints.add('mid', (0, _SnapUtil.mid)(sibling));

    if ((0, _ModelUtil.is)(sibling, 'bpmn:Participant')) {
      snapPoints.add('top-left', (0, _SnapUtil.topLeft)(sibling));
      snapPoints.add('bottom-right', (0, _SnapUtil.bottomRight)(sibling));
    }
  });

  (0, _minDash.forEach)(shape.incoming, function (c) {

    if (siblings.indexOf(c.source) === -1) {
      snapPoints.add('mid', (0, _SnapUtil.mid)(c.source));
    }

    var docking = c.waypoints[0];
    snapPoints.add(c.id + '-docking', docking.original || docking);
  });

  (0, _minDash.forEach)(shape.outgoing, function (c) {

    if (siblings.indexOf(c.target) === -1) {
      snapPoints.add('mid', (0, _SnapUtil.mid)(c.target));
    }

    var docking = c.waypoints[c.waypoints.length - 1];
    snapPoints.add(c.id + '-docking', docking.original || docking);
  });
};

// participant snapping //////////////////////

function initParticipantSnapping(context, shape, elements) {

  if (!elements.length) {
    return;
  }

  var snapBox = (0, _Elements.getBBox)(elements.filter(function (e) {
    return !e.labelTarget && !e.waypoints;
  }));

  snapBox.x -= 50;
  snapBox.y -= 20;
  snapBox.width += 70;
  snapBox.height += 40;

  // adjust shape height to include bounding box
  shape.width = Math.max(shape.width, snapBox.width);
  shape.height = Math.max(shape.height, snapBox.height);

  context.participantSnapBox = snapBox;
}

function snapParticipant(snapBox, shape, event, offset) {
  offset = offset || 0;

  var shapeHalfWidth = shape.width / 2 - offset,
      shapeHalfHeight = shape.height / 2;

  var currentTopLeft = {
    x: event.x - shapeHalfWidth - offset,
    y: event.y - shapeHalfHeight
  };

  var currentBottomRight = {
    x: event.x + shapeHalfWidth + offset,
    y: event.y + shapeHalfHeight
  };

  var snapTopLeft = snapBox,
      snapBottomRight = (0, _SnapUtil.bottomRight)(snapBox);

  if (currentTopLeft.x >= snapTopLeft.x) {
    (0, _SnapUtil.setSnapped)(event, 'x', snapTopLeft.x + offset + shapeHalfWidth);
  } else if (currentBottomRight.x <= snapBottomRight.x) {
    (0, _SnapUtil.setSnapped)(event, 'x', snapBottomRight.x - offset - shapeHalfWidth);
  }

  if (currentTopLeft.y >= snapTopLeft.y) {
    (0, _SnapUtil.setSnapped)(event, 'y', snapTopLeft.y + shapeHalfHeight);
  } else if (currentBottomRight.y <= snapBottomRight.y) {
    (0, _SnapUtil.setSnapped)(event, 'y', snapBottomRight.y - shapeHalfHeight);
  }
}

// boundary event snapping //////////////////////

function snapBoundaryEvent(event, shape, target) {
  var targetTRBL = (0, _LayoutUtil.asTRBL)(target);

  var direction = (0, _BpmnSnappingUtil.getBoundaryAttachment)(event, target);

  if (/top/.test(direction)) {
    (0, _SnapUtil.setSnapped)(event, 'y', targetTRBL.top);
  } else if (/bottom/.test(direction)) {
    (0, _SnapUtil.setSnapped)(event, 'y', targetTRBL.bottom);
  }

  if (/left/.test(direction)) {
    (0, _SnapUtil.setSnapped)(event, 'x', targetTRBL.left);
  } else if (/right/.test(direction)) {
    (0, _SnapUtil.setSnapped)(event, 'x', targetTRBL.right);
  }
}

function snapToPosition(event, position) {
  (0, _SnapUtil.setSnapped)(event, 'x', position.x);
  (0, _SnapUtil.setSnapped)(event, 'y', position.y);
}

},{"../../util/DiUtil":214,"../../util/ModelUtil":216,"../modeling/util/LaneUtil":188,"../modeling/util/ModelingUtil":189,"./BpmnSnappingUtil":207,"diagram-js/lib/features/snapping/SnapUtil":363,"diagram-js/lib/features/snapping/Snapping":364,"diagram-js/lib/layout/LayoutUtil":380,"diagram-js/lib/util/Elements":396,"inherits":415,"min-dash":505}],207:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.getBoundaryAttachment = getBoundaryAttachment;
exports.getParticipantSizeConstraints = getParticipantSizeConstraints;

var _LayoutUtil = require('diagram-js/lib/layout/LayoutUtil');

var _ModelUtil = require('../../util/ModelUtil');

var _LaneUtil = require('../modeling/util/LaneUtil');

function getBoundaryAttachment(position, targetBounds) {

  var orientation = (0, _LayoutUtil.getOrientation)(position, targetBounds, -15);

  if (orientation !== 'intersect') {
    return orientation;
  } else {
    return null;
  }
}

// participant snapping box implementation //////////////////////

var abs = Math.abs,
    min = Math.min,
    max = Math.max;

function addToTrbl(trbl, attr, value, choice) {

  var current = trbl[attr];

  // make sure to set the value if it does not exist
  // or apply the correct value by comparing against
  // choice(value, currentValue)
  trbl[attr] = current === undefined ? value : choice(value, current);
}

function addMin(trbl, attr, value) {
  return addToTrbl(trbl, attr, value, min);
}

function addMax(trbl, attr, value) {
  return addToTrbl(trbl, attr, value, max);
}

var LANE_MIN_HEIGHT = 60,
    LANE_MIN_WIDTH = 300,
    LANE_RIGHT_PADDING = 20,
    LANE_LEFT_PADDING = 50,
    LANE_TOP_PADDING = 20,
    LANE_BOTTOM_PADDING = 20;

function getParticipantSizeConstraints(laneShape, resizeDirection, balanced) {

  var lanesRoot = (0, _LaneUtil.getLanesRoot)(laneShape);

  var isFirst = true,
      isLast = true;

  // max top/bottom size for lanes

  var allLanes = (0, _LaneUtil.collectLanes)(lanesRoot, [lanesRoot]);

  var laneTrbl = (0, _LayoutUtil.asTRBL)(laneShape);

  var maxTrbl = {},
      minTrbl = {};

  if (/e/.test(resizeDirection)) {
    minTrbl.right = laneTrbl.left + LANE_MIN_WIDTH;
  } else if (/w/.test(resizeDirection)) {
    minTrbl.left = laneTrbl.right - LANE_MIN_WIDTH;
  }

  allLanes.forEach(function (other) {

    var otherTrbl = (0, _LayoutUtil.asTRBL)(other);

    if (/n/.test(resizeDirection)) {

      if (otherTrbl.top < laneTrbl.top - 10) {
        isFirst = false;
      }

      // max top size (based on next element)
      if (balanced && abs(laneTrbl.top - otherTrbl.bottom) < 10) {
        addMax(maxTrbl, 'top', otherTrbl.top + LANE_MIN_HEIGHT);
      }

      // min top size (based on self or nested element)
      if (abs(laneTrbl.top - otherTrbl.top) < 5) {
        addMin(minTrbl, 'top', otherTrbl.bottom - LANE_MIN_HEIGHT);
      }
    }

    if (/s/.test(resizeDirection)) {

      if (otherTrbl.bottom > laneTrbl.bottom + 10) {
        isLast = false;
      }

      // max bottom size (based on previous element)
      if (balanced && abs(laneTrbl.bottom - otherTrbl.top) < 10) {
        addMin(maxTrbl, 'bottom', otherTrbl.bottom - LANE_MIN_HEIGHT);
      }

      // min bottom size (based on self or nested element)
      if (abs(laneTrbl.bottom - otherTrbl.bottom) < 5) {
        addMax(minTrbl, 'bottom', otherTrbl.top + LANE_MIN_HEIGHT);
      }
    }
  });

  // max top/bottom/left/right size based on flow nodes

  var flowElements = lanesRoot.children.filter(function (s) {
    return !s.hidden && !s.waypoints && ((0, _ModelUtil.is)(s, 'bpmn:FlowElement') || (0, _ModelUtil.is)(s, 'bpmn:Artifact'));
  });

  flowElements.forEach(function (flowElement) {

    var flowElementTrbl = (0, _LayoutUtil.asTRBL)(flowElement);

    if (isFirst && /n/.test(resizeDirection)) {
      addMin(minTrbl, 'top', flowElementTrbl.top - LANE_TOP_PADDING);
    }

    if (/e/.test(resizeDirection)) {
      addMax(minTrbl, 'right', flowElementTrbl.right + LANE_RIGHT_PADDING);
    }

    if (isLast && /s/.test(resizeDirection)) {
      addMax(minTrbl, 'bottom', flowElementTrbl.bottom + LANE_BOTTOM_PADDING);
    }

    if (/w/.test(resizeDirection)) {
      addMin(minTrbl, 'left', flowElementTrbl.left - LANE_LEFT_PADDING);
    }
  });

  return {
    min: minTrbl,
    max: maxTrbl
  };
}

},{"../../util/ModelUtil":216,"../modeling/util/LaneUtil":188,"diagram-js/lib/layout/LayoutUtil":380}],208:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _BpmnSnapping = require('./BpmnSnapping');

var _BpmnSnapping2 = _interopRequireDefault(_BpmnSnapping);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __init__: ['snapping'],
  snapping: ['type', _BpmnSnapping2.default]
};

},{"./BpmnSnapping":206}],209:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = BpmnImporter;

var _minDash = require('min-dash');

var _ModelUtil = require('../util/ModelUtil');

var _LabelUtil = require('../util/LabelUtil');

var _LayoutUtil = require('diagram-js/lib/layout/LayoutUtil');

var _DiUtil = require('../util/DiUtil');

var _Util = require('./Util');

function elementData(semantic, attrs) {
  return (0, _minDash.assign)({
    id: semantic.id,
    type: semantic.$type,
    businessObject: semantic
  }, attrs);
}

function collectWaypoints(waypoints) {
  return (0, _minDash.map)(waypoints, function (p) {
    return { x: p.x, y: p.y };
  });
}

function notYetDrawn(translate, semantic, refSemantic, property) {
  return new Error(translate('element {element} referenced by {referenced}#{property} not yet drawn', {
    element: (0, _Util.elementToString)(refSemantic),
    referenced: (0, _Util.elementToString)(semantic),
    property: property
  }));
}

/**
 * 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) {

  this._eventBus = eventBus;
  this._canvas = canvas;
  this._elementFactory = elementFactory;
  this._elementRegistry = elementRegistry;
  this._translate = translate;
  this._textRenderer = textRenderer;
}

BpmnImporter.$inject = ['eventBus', 'canvas', 'elementFactory', 'elementRegistry', 'translate', 'textRenderer'];

/**
 * Add bpmn element (semantic) to the canvas onto the
 * specified parent shape.
 */
BpmnImporter.prototype.add = function (semantic, parentElement) {

  var di = semantic.di,
      element,
      translate = this._translate,
      hidden;

  var parentIndex;

  // ROOT ELEMENT
  // handle the special case that we deal with a
  // invisible root element (process or collaboration)
  if ((0, _ModelUtil.is)(di, 'bpmndi:BPMNPlane')) {

    // add a virtual element (not being drawn)
    element = this._elementFactory.createRoot(elementData(semantic));

    this._canvas.setRootElement(element);
  }

  // SHAPE
  else if ((0, _ModelUtil.is)(di, 'bpmndi:BPMNShape')) {

      var collapsed = !(0, _DiUtil.isExpanded)(semantic);
      hidden = parentElement && (parentElement.hidden || parentElement.collapsed);

      var bounds = semantic.di.bounds;

      element = this._elementFactory.createShape(elementData(semantic, {
        collapsed: collapsed,
        hidden: hidden,
        x: Math.round(bounds.x),
        y: Math.round(bounds.y),
        width: Math.round(bounds.width),
        height: Math.round(bounds.height)
      }));

      if ((0, _ModelUtil.is)(semantic, 'bpmn:BoundaryEvent')) {
        this._attachBoundary(semantic, element);
      }

      // insert lanes behind other flow nodes (cf. #727)
      if ((0, _ModelUtil.is)(semantic, 'bpmn:Lane')) {
        parentIndex = 0;
      }

      if ((0, _ModelUtil.is)(semantic, 'bpmn:DataStoreReference')) {

        // check wether data store is inside our outside of its semantic parent
        if (!isPointInsideBBox(parentElement, (0, _LayoutUtil.getMid)(bounds))) {
          parentElement = this._canvas.getRootElement();
        }
      }

      this._canvas.addShape(element, parentElement, parentIndex);
    }

    // CONNECTION
    else if ((0, _ModelUtil.is)(di, 'bpmndi:BPMNEdge')) {

        var source = this._getSource(semantic),
            target = this._getTarget(semantic);

        hidden = parentElement && (parentElement.hidden || parentElement.collapsed);

        element = this._elementFactory.createConnection(elementData(semantic, {
          hidden: hidden,
          source: source,
          target: target,
          waypoints: collectWaypoints(semantic.di.waypoint)
        }));

        if ((0, _ModelUtil.is)(semantic, 'bpmn:DataAssociation')) {

          // 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 = null;
        }

        // insert sequence flows behind other flow nodes (cf. #727)
        if ((0, _ModelUtil.is)(semantic, 'bpmn:SequenceFlow')) {
          parentIndex = 0;
        }

        this._canvas.addConnection(element, parentElement, parentIndex);
      } else {
        throw new Error(translate('unknown di {di} for element {semantic}', {
          di: (0, _Util.elementToString)(di),
          semantic: (0, _Util.elementToString)(semantic)
        }));
      }
  // (optional) LABEL
  if ((0, _LabelUtil.isLabelExternal)(semantic) && semantic.name) {
    this.addLabel(semantic, element);
  }

  this._eventBus.fire('bpmnElement.added', { element: element });

  return element;
};

/**
 * 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;

  if (!hostSemantic) {
    throw new Error(translate('missing {semantic}#attachedToRef', {
      semantic: (0, _Util.elementToString)(boundarySemantic)
    }));
  }

  var host = this._elementRegistry.get(hostSemantic.id),
      attachers = host && host.attachers;

  if (!host) {
    throw notYetDrawn(translate, boundarySemantic, hostSemantic, 'attachedToRef');
  }

  // wire element.host <> host.attachers
  boundaryElement.host = host;

  if (!attachers) {
    host.attachers = attachers = [];
  }

  if (attachers.indexOf(boundaryElement) === -1) {
    attachers.push(boundaryElement);
  }
};

/**
 * add label for an element
 */
BpmnImporter.prototype.addLabel = function (semantic, element) {
  var bounds, text, label;

  bounds = (0, _LabelUtil.getExternalLabelBounds)(semantic, element);

  text = semantic.name;

  if (text) {
    // get corrected bounds from actual layouted text
    bounds = this._textRenderer.getExternalLabelBounds(bounds, text);
  }

  label = this._elementFactory.createLabel(elementData(semantic, {
    id: semantic.id + '_label',
    labelTarget: element,
    type: 'label',
    hidden: element.hidden || !semantic.name,
    x: Math.round(bounds.x),
    y: Math.round(bounds.y),
    width: Math.round(bounds.width),
    height: Math.round(bounds.height)
  }));

  return this._canvas.addShape(label, element.parent);
};

/**
 * 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) {

  var element,
      refSemantic,
      type = semantic.$type,
      translate = this._translate;

  refSemantic = semantic[side + 'Ref'];

  // handle mysterious isMany DataAssociation#sourceRef
  if (side === 'source' && type === 'bpmn:DataInputAssociation') {
    refSemantic = refSemantic && refSemantic[0];
  }

  // fix source / target for DataInputAssociation / DataOutputAssociation
  if (side === 'source' && type === 'bpmn:DataOutputAssociation' || side === 'target' && type === 'bpmn:DataInputAssociation') {

    refSemantic = semantic.$parent;
  }

  element = refSemantic && this._getElement(refSemantic);

  if (element) {
    return element;
  }

  if (refSemantic) {
    throw notYetDrawn(translate, semantic, refSemantic, side + 'Ref');
  } else {
    throw new Error(translate('{semantic}#{side} Ref not specified', {
      semantic: (0, _Util.elementToString)(semantic),
      side: side
    }));
  }
};

BpmnImporter.prototype._getSource = function (semantic) {
  return this._getEnd(semantic, 'source');
};

BpmnImporter.prototype._getTarget = function (semantic) {
  return this._getEnd(semantic, 'target');
};

BpmnImporter.prototype._getElement = function (semantic) {
  return this._elementRegistry.get(semantic.id);
};

// helpers ////////////////////

function isPointInsideBBox(bbox, point) {
  var x = point.x,
      y = point.y;

  return x >= bbox.x && x <= bbox.x + bbox.width && y >= bbox.y && y <= bbox.y + bbox.height;
}

},{"../util/DiUtil":214,"../util/LabelUtil":215,"../util/ModelUtil":216,"./Util":212,"diagram-js/lib/layout/LayoutUtil":380,"min-dash":505}],210:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = BpmnTreeWalker;

var _minDash = require('min-dash');

var _objectRefs = require('object-refs');

var _objectRefs2 = _interopRequireDefault(_objectRefs);

var _Util = require('./Util');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var diRefs = new _objectRefs2.default({ name: 'bpmnElement', enumerable: true }, { name: 'di', configurable: true });

/**
 * Returns true if an element has the given meta-model type
 *
 * @param  {ModdleElement}  element
 * @param  {String}         type
 *
 * @return {Boolean}
 */
function is(element, type) {
  return element.$instanceOf(type);
}

/**
 * Find a suitable display candidate for definitions where the DI does not
 * correctly specify one.
 */
function findDisplayCandidate(definitions) {
  return (0, _minDash.find)(definitions.rootElements, function (e) {
    return is(e, 'bpmn:Process') || is(e, 'bpmn:Collaboration');
  });
}

function BpmnTreeWalker(handler, translate) {

  // list of containers already walked
  var handledElements = {};

  // list of elements to handle deferred to ensure
  // prerequisites are drawn
  var deferred = [];

  // Helpers //////////////////////

  function contextual(fn, ctx) {
    return function (e) {
      fn(e, ctx);
    };
  }

  function handled(element) {
    handledElements[element.id] = element;
  }

  function isHandled(element) {
    return handledElements[element.id];
  }

  function visit(element, ctx) {

    var gfx = element.gfx;

    // avoid multiple rendering of elements
    if (gfx) {
      throw new Error(translate('already rendered {element}', { element: (0, _Util.elementToString)(element) }));
    }

    // call handler
    return handler.element(element, ctx);
  }

  function visitRoot(element, diagram) {
    return handler.root(element, diagram);
  }

  function visitIfDi(element, ctx) {

    try {
      var gfx = element.di && visit(element, ctx);

      handled(element);

      return gfx;
    } catch (e) {
      logError(e.message, { element: element, error: e });

      console.error(translate('failed to import {element}', { element: (0, _Util.elementToString)(element) }));
      console.error(e);
    }
  }

  function logError(message, context) {
    handler.error(message, context);
  }

  // DI handling //////////////////////

  function registerDi(di) {
    var bpmnElement = di.bpmnElement;

    if (bpmnElement) {
      if (bpmnElement.di) {
        logError(translate('multiple DI elements defined for {element}', {
          element: (0, _Util.elementToString)(bpmnElement)
        }), { element: bpmnElement });
      } else {
        diRefs.bind(bpmnElement, 'di');
        bpmnElement.di = di;
      }
    } else {
      logError(translate('no bpmnElement referenced in {element}', {
        element: (0, _Util.elementToString)(di)
      }), { element: di });
    }
  }

  function handleDiagram(diagram) {
    handlePlane(diagram.plane);
  }

  function handlePlane(plane) {
    registerDi(plane);

    (0, _minDash.forEach)(plane.planeElement, handlePlaneElement);
  }

  function handlePlaneElement(planeElement) {
    registerDi(planeElement);
  }

  // Semantic handling //////////////////////

  /**
   * 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) {
    // make sure we walk the correct bpmnElement

    var diagrams = definitions.diagrams;

    if (diagram && diagrams.indexOf(diagram) === -1) {
      throw new Error(translate('diagram not part of bpmn:Definitions'));
    }

    if (!diagram && diagrams && diagrams.length) {
      diagram = diagrams[0];
    }

    // no diagram -> nothing to import
    if (!diagram) {
      throw new Error(translate('no diagram to display'));
    }

    // load DI from selected diagram only
    handleDiagram(diagram);

    var plane = diagram.plane;

    if (!plane) {
      throw new Error(translate('no plane for {element}', { element: (0, _Util.elementToString)(diagram) }));
    }

    var rootElement = plane.bpmnElement;

    // ensure we default to a suitable display candidate (process or collaboration),
    // even if non is specified in DI
    if (!rootElement) {
      rootElement = findDisplayCandidate(definitions);

      if (!rootElement) {
        throw new Error(translate('no process or collaboration to display'));
      } else {

        logError(translate('correcting missing bpmnElement on {plane} to {rootElement}', {
          plane: (0, _Util.elementToString)(plane),
          rootElement: (0, _Util.elementToString)(rootElement)
        }));

        // correct DI on the fly
        plane.bpmnElement = rootElement;
        registerDi(plane);
      }
    }

    var ctx = visitRoot(rootElement, plane);

    if (is(rootElement, 'bpmn:Process')) {
      handleProcess(rootElement, ctx);
    } else if (is(rootElement, 'bpmn:Collaboration')) {
      handleCollaboration(rootElement, ctx);

      // 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: (0, _Util.elementToString)(plane),
        rootElement: (0, _Util.elementToString)(rootElement)
      }));
    }

    // handle all deferred elements
    handleDeferred(deferred);
  }

  function handleDeferred() {

    var fn;

    // drain deferred until empty
    while (deferred.length) {
      fn = deferred.shift();

      fn();
    }
  }

  function handleProcess(process, context) {
    handleFlowElementsContainer(process, context);
    handleIoSpecification(process.ioSpecification, context);

    handleArtifacts(process.artifacts, context);

    // log process handled
    handled(process);
  }

  function handleUnhandledProcesses(rootElements) {

    // 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 = (0, _minDash.filter)(rootElements, function (e) {
      return !isHandled(e) && is(e, 'bpmn:Process') && e.laneSets;
    });

    processes.forEach(contextual(handleProcess));
  }

  function handleMessageFlow(messageFlow, context) {
    visitIfDi(messageFlow, context);
  }

  function handleMessageFlows(messageFlows, context) {
    (0, _minDash.forEach)(messageFlows, contextual(handleMessageFlow, context));
  }

  function handleDataAssociation(association, context) {
    visitIfDi(association, context);
  }

  function handleDataInput(dataInput, context) {
    visitIfDi(dataInput, context);
  }

  function handleDataOutput(dataOutput, context) {
    visitIfDi(dataOutput, context);
  }

  function handleArtifact(artifact, context) {

    // bpmn:TextAnnotation
    // bpmn:Group
    // bpmn:Association

    visitIfDi(artifact, context);
  }

  function handleArtifacts(artifacts, context) {

    (0, _minDash.forEach)(artifacts, function (e) {
      if (is(e, 'bpmn:Association')) {
        deferred.push(function () {
          handleArtifact(e, context);
        });
      } else {
        handleArtifact(e, context);
      }
    });
  }

  function handleIoSpecification(ioSpecification, context) {

    if (!ioSpecification) {
      return;
    }

    (0, _minDash.forEach)(ioSpecification.dataInputs, contextual(handleDataInput, context));
    (0, _minDash.forEach)(ioSpecification.dataOutputs, contextual(handleDataOutput, context));
  }

  function handleSubProcess(subProcess, context) {
    handleFlowElementsContainer(subProcess, context);
    handleArtifacts(subProcess.artifacts, context);
  }

  function handleFlowNode(flowNode, context) {
    var childCtx = visitIfDi(flowNode, context);

    if (is(flowNode, 'bpmn:SubProcess')) {
      handleSubProcess(flowNode, childCtx || context);
    }

    if (is(flowNode, 'bpmn:Activity')) {
      handleIoSpecification(flowNode.ioSpecification, context);
    }

    // defer handling of associations
    // affected types:
    //
    //   * bpmn:Activity
    //   * bpmn:ThrowEvent
    //   * bpmn:CatchEvent
    //
    deferred.push(function () {
      (0, _minDash.forEach)(flowNode.dataInputAssociations, contextual(handleDataAssociation, context));
      (0, _minDash.forEach)(flowNode.dataOutputAssociations, contextual(handleDataAssociation, context));
    });
  }

  function handleSequenceFlow(sequenceFlow, context) {
    visitIfDi(sequenceFlow, context);
  }

  function handleDataElement(dataObject, context) {
    visitIfDi(dataObject, context);
  }

  function handleBoundaryEvent(dataObject, context) {
    visitIfDi(dataObject, context);
  }

  function handleLane(lane, context) {

    deferred.push(function () {

      var newContext = visitIfDi(lane, context);

      if (lane.childLaneSet) {
        handleLaneSet(lane.childLaneSet, newContext || context);
      }

      wireFlowNodeRefs(lane);
    });
  }

  function handleLaneSet(laneSet, context) {
    (0, _minDash.forEach)(laneSet.lanes, contextual(handleLane, context));
  }

  function handleLaneSets(laneSets, context) {
    (0, _minDash.forEach)(laneSets, contextual(handleLaneSet, context));
  }

  function handleFlowElementsContainer(container, context) {
    handleFlowElements(container.flowElements, context);

    if (container.laneSets) {
      handleLaneSets(container.laneSets, context);
    }
  }

  function handleFlowElements(flowElements, context) {
    (0, _minDash.forEach)(flowElements, function (e) {
      if (is(e, 'bpmn:SequenceFlow')) {
        deferred.push(function () {
          handleSequenceFlow(e, context);
        });
      } else if (is(e, 'bpmn:BoundaryEvent')) {
        deferred.unshift(function () {
          handleBoundaryEvent(e, context);
        });
      } else if (is(e, 'bpmn:FlowNode')) {
        handleFlowNode(e, context);
      } else if (is(e, 'bpmn:DataObject')) {
        // SKIP (assume correct referencing via DataObjectReference)
      } else if (is(e, 'bpmn:DataStoreReference')) {
        handleDataElement(e, context);
      } else if (is(e, 'bpmn:DataObjectReference')) {
        handleDataElement(e, context);
      } else {
        logError(translate('unrecognized flowElement {element} in context {context}', {
          element: (0, _Util.elementToString)(e),
          context: context ? (0, _Util.elementToString)(context.businessObject) : 'null'
        }), { element: e, context: context });
      }
    });
  }

  function handleParticipant(participant, context) {
    var newCtx = visitIfDi(participant, context);

    var process = participant.processRef;
    if (process) {
      handleProcess(process, newCtx || context);
    }
  }

  function handleCollaboration(collaboration) {

    (0, _minDash.forEach)(collaboration.participants, contextual(handleParticipant));

    handleArtifacts(collaboration.artifacts);

    // handle message flows latest in the process
    deferred.push(function () {
      handleMessageFlows(collaboration.messageFlows);
    });
  }

  function wireFlowNodeRefs(lane) {
    // wire the virtual flowNodeRefs <-> relationship
    (0, _minDash.forEach)(lane.flowNodeRef, function (flowNode) {
      var lanes = flowNode.get('lanes');

      if (lanes) {
        lanes.push(lane);
      }
    });
  }

  // API //////////////////////

  return {
    handleDeferred: handleDeferred,
    handleDefinitions: handleDefinitions,
    handleSubProcess: handleSubProcess,
    registerDi: registerDi
  };
}

},{"./Util":212,"min-dash":505,"object-refs":520}],211:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.importBpmnDiagram = importBpmnDiagram;

var _BpmnTreeWalker = require('./BpmnTreeWalker');

var _BpmnTreeWalker2 = _interopRequireDefault(_BpmnTreeWalker);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * Import the definitions into a diagram.
 *
 * Errors and warnings are reported through the specified callback.
 *
 * @param  {Diagram} diagram
 * @param  {ModdleElement} definitions
 * @param  {Function} done the callback, invoked with (err, [ warning ]) once the import is done
 */
function importBpmnDiagram(diagram, definitions, done) {

  var importer, eventBus, translate;

  var error,
      warnings = [];

  /**
   * Walk the diagram semantically, importing (=drawing)
   * all elements you encounter.
   *
   * @param {ModdleElement} definitions
   */
  function render(definitions) {

    var visitor = {

      root: function root(element) {
        return importer.add(element);
      },

      element: function element(_element, parentShape) {
        return importer.add(_element, parentShape);
      },

      error: function error(message, context) {
        warnings.push({ message: message, context: context });
      }
    };

    var walker = new _BpmnTreeWalker2.default(visitor, translate);

    // traverse BPMN 2.0 document model,
    // starting at definitions
    walker.handleDefinitions(definitions);
  }

  try {
    importer = diagram.get('bpmnImporter');
    eventBus = diagram.get('eventBus');
    translate = diagram.get('translate');

    eventBus.fire('import.render.start', { definitions: definitions });

    render(definitions);

    eventBus.fire('import.render.complete', {
      error: error,
      warnings: warnings
    });
  } catch (e) {
    error = e;
  }

  done(error, warnings);
}

},{"./BpmnTreeWalker":210}],212:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.elementToString = elementToString;
function elementToString(e) {
  if (!e) {
    return '<null>';
  }

  return '<' + e.$type + (e.id ? ' id="' + e.id : '') + '" />';
}

},{}],213:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _translate = require('diagram-js/lib/i18n/translate');

var _translate2 = _interopRequireDefault(_translate);

var _BpmnImporter = require('./BpmnImporter');

var _BpmnImporter2 = _interopRequireDefault(_BpmnImporter);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __depends__: [_translate2.default],
  bpmnImporter: ['type', _BpmnImporter2.default]
};

},{"./BpmnImporter":209,"diagram-js/lib/i18n/translate":376}],214:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.isExpanded = isExpanded;
exports.isInterrupting = isInterrupting;
exports.isEventSubProcess = isEventSubProcess;
exports.hasEventDefinition = hasEventDefinition;
exports.hasErrorEventDefinition = hasErrorEventDefinition;
exports.hasEscalationEventDefinition = hasEscalationEventDefinition;
exports.hasCompensateEventDefinition = hasCompensateEventDefinition;

var _ModelUtil = require('./ModelUtil');

var _minDash = require('min-dash');

function isExpanded(element) {

  if ((0, _ModelUtil.is)(element, 'bpmn:CallActivity')) {
    return false;
  }

  if ((0, _ModelUtil.is)(element, 'bpmn:SubProcess')) {
    return !!(0, _ModelUtil.getBusinessObject)(element).di.isExpanded;
  }

  if ((0, _ModelUtil.is)(element, 'bpmn:Participant')) {
    return !!(0, _ModelUtil.getBusinessObject)(element).processRef;
  }

  return true;
}

function isInterrupting(element) {
  return element && (0, _ModelUtil.getBusinessObject)(element).isInterrupting !== false;
}

function isEventSubProcess(element) {
  return element && !!(0, _ModelUtil.getBusinessObject)(element).triggeredByEvent;
}

function hasEventDefinition(element, eventType) {
  var bo = (0, _ModelUtil.getBusinessObject)(element),
      hasEventDefinition = false;

  if (bo.eventDefinitions) {
    (0, _minDash.forEach)(bo.eventDefinitions, function (event) {
      if ((0, _ModelUtil.is)(event, eventType)) {
        hasEventDefinition = true;
      }
    });
  }

  return hasEventDefinition;
}

function hasErrorEventDefinition(element) {
  return hasEventDefinition(element, 'bpmn:ErrorEventDefinition');
}

function hasEscalationEventDefinition(element) {
  return hasEventDefinition(element, 'bpmn:EscalationEventDefinition');
}

function hasCompensateEventDefinition(element) {
  return hasEventDefinition(element, 'bpmn:CompensateEventDefinition');
}

},{"./ModelUtil":216,"min-dash":505}],215:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.FLOW_LABEL_INDENT = exports.DEFAULT_LABEL_SIZE = undefined;
exports.isLabelExternal = isLabelExternal;
exports.hasExternalLabel = hasExternalLabel;
exports.getFlowLabelPosition = getFlowLabelPosition;
exports.getWaypointsMid = getWaypointsMid;
exports.getExternalLabelMid = getExternalLabelMid;
exports.getExternalLabelBounds = getExternalLabelBounds;
exports.isLabel = isLabel;

var _minDash = require('min-dash');

var _ModelUtil = require('./ModelUtil');

var DEFAULT_LABEL_SIZE = exports.DEFAULT_LABEL_SIZE = {
  width: 90,
  height: 20
};

var FLOW_LABEL_INDENT = exports.FLOW_LABEL_INDENT = 15;

/**
 * Returns true if the given semantic has an external label
 *
 * @param {BpmnElement} semantic
 * @return {Boolean} true if has label
 */
function isLabelExternal(semantic) {
  return (0, _ModelUtil.is)(semantic, 'bpmn:Event') || (0, _ModelUtil.is)(semantic, 'bpmn:Gateway') || (0, _ModelUtil.is)(semantic, 'bpmn:DataStoreReference') || (0, _ModelUtil.is)(semantic, 'bpmn:DataObjectReference') || (0, _ModelUtil.is)(semantic, 'bpmn:SequenceFlow') || (0, _ModelUtil.is)(semantic, 'bpmn:MessageFlow');
}

/**
 * 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(element.label);
}

/**
 * Get the position for sequence flow labels
 *
 * @param  {Array<Point>} waypoints
 * @return {Point} the label position
 */
function getFlowLabelPosition(waypoints) {

  // get the waypoints mid
  var mid = waypoints.length / 2 - 1;

  var first = waypoints[Math.floor(mid)];
  var second = waypoints[Math.ceil(mid + 0.01)];

  // get position
  var position = getWaypointsMid(waypoints);

  // calculate angle
  var angle = Math.atan((second.y - first.y) / (second.x - first.x));

  var x = position.x,
      y = position.y;

  if (Math.abs(angle) < Math.PI / 2) {
    y -= FLOW_LABEL_INDENT;
  } else {
    x += FLOW_LABEL_INDENT;
  }

  return { x: x, y: y };
}

/**
 * Get the middle of a number of waypoints
 *
 * @param  {Array<Point>} waypoints
 * @return {Point} the mid point
 */
function getWaypointsMid(waypoints) {

  var mid = waypoints.length / 2 - 1;

  var first = waypoints[Math.floor(mid)];
  var second = waypoints[Math.ceil(mid + 0.01)];

  return {
    x: first.x + (second.x - first.x) / 2,
    y: first.y + (second.y - first.y) / 2
  };
}

function getExternalLabelMid(element) {

  if (element.waypoints) {
    return getFlowLabelPosition(element.waypoints);
  } else {
    return {
      x: element.x + element.width / 2,
      y: element.y + element.height + DEFAULT_LABEL_SIZE.height / 2
    };
  }
}

/**
 * Returns the bounds of an elements label, parsed from the elements DI or
 * generated from its bounds.
 *
 * @param {BpmnElement} semantic
 * @param {djs.model.Base} element
 */
function getExternalLabelBounds(semantic, element) {

  var mid,
      size,
      bounds,
      di = semantic.di,
      label = di.label;

  if (label && label.bounds) {
    bounds = label.bounds;

    size = {
      width: Math.max(DEFAULT_LABEL_SIZE.width, bounds.width),
      height: bounds.height
    };

    mid = {
      x: bounds.x + bounds.width / 2,
      y: bounds.y + bounds.height / 2
    };
  } else {

    mid = getExternalLabelMid(element);

    size = DEFAULT_LABEL_SIZE;
  }

  return (0, _minDash.assign)({
    x: mid.x - size.width / 2,
    y: mid.y - size.height / 2
  }, size);
}

function isLabel(element) {
  return element && element.labelTarget;
}

},{"./ModelUtil":216,"min-dash":505}],216:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.is = is;
exports.getBusinessObject = getBusinessObject;
/**
 * Is an element of the given BPMN type?
 *
 * @param  {djs.model.Base|ModdleElement} element
 * @param  {String} type
 *
 * @return {Boolean}
 */
function is(element, type) {
  var bo = getBusinessObject(element);

  return bo && typeof bo.$instanceOf === 'function' && bo.$instanceOf(type);
}

/**
 * Return the business object for a given element.
 *
 * @param  {djs.model.Base|ModdleElement} element
 *
 * @return {ModdleElement}
 */
function getBusinessObject(element) {
  return element && element.businessObject || element;
}

},{}],217:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.BPMNIO_IMG = undefined;
exports.open = open;

var _minDom = require('min-dom');

// inlined ../../resources/logo.svg
var BPMNIO_LOGO_SVG = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 960 960"><path fill="#fff" d="M960 60v839c0 33-27 61-60 61H60c-33 0-60-27-60-60V60C0 27 27 0 60 0h839c34 0 61 27 61 60z"/><path fill="#52b415" d="M217 548a205 205 0 0 0-144 58 202 202 0 0 0-4 286 202 202 0 0 0 285 3 200 200 0 0 0 48-219 203 203 0 0 0-185-128zM752 6a206 206 0 0 0-192 285 206 206 0 0 0 269 111 207 207 0 0 0 111-260A204 204 0 0 0 752 6zM62 0A62 62 0 0 0 0 62v398l60 46a259 259 0 0 1 89-36c5-28 10-57 14-85l99 2 12 85a246 246 0 0 1 88 38l70-52 69 71-52 68c17 30 29 58 35 90l86 14-2 100-86 12a240 240 0 0 1-38 89l43 58h413c37 0 60-27 60-61V407a220 220 0 0 1-44 40l21 85-93 39-45-76a258 258 0 0 1-98 1l-45 76-94-39 22-85a298 298 0 0 1-70-69l-86 22-38-94 76-45a258 258 0 0 1-1-98l-76-45 40-94 85 22a271 271 0 0 1 41-47z"/></svg>'; /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    * This file must not be changed or exchanged.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    *
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    * @see http://bpmn.io/license for more information.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    */

var BPMNIO_LOGO_URL = 'data:image/svg+xml,' + encodeURIComponent(BPMNIO_LOGO_SVG);

var BPMNIO_IMG = exports.BPMNIO_IMG = '<img width="52" height="52" src="' + BPMNIO_LOGO_URL + '" />';

function css(attrs) {
  return attrs.join(';');
}

var LIGHTBOX_STYLES = css(['z-index: 1001', 'position: fixed', 'top: 0', 'left: 0', 'right: 0', 'bottom: 0']);

var BACKDROP_STYLES = css(['width: 100%', 'height: 100%', 'background: rgba(0,0,0,0.2)']);

var NOTICE_STYLES = css(['position: absolute', 'left: 50%', 'top: 40%', 'margin: 0 -130px', 'width: 260px', 'padding: 10px', 'background: white', 'border: solid 1px #AAA', 'border-radius: 3px', 'font-family: Helvetica, Arial, sans-serif', 'font-size: 14px', 'line-height: 1.2em']);

var LIGHTBOX_MARKUP = '<div class="bjs-powered-by-lightbox" style="' + LIGHTBOX_STYLES + '">' + '<div class="backdrop" style="' + BACKDROP_STYLES + '"></div>' + '<div class="notice" style="' + NOTICE_STYLES + '">' + '<a href="http://bpmn.io" target="_blank" style="float: left; margin-right: 10px">' + BPMNIO_IMG + '</a>' + 'Web-based tooling for BPMN, DMN and CMMN diagrams ' + 'powered by <a href="http://bpmn.io" target="_blank">bpmn.io</a>.' + '</div>' + '</div>';

var lightbox;

function open() {

  if (!lightbox) {
    lightbox = (0, _minDom.domify)(LIGHTBOX_MARKUP);

    _minDom.delegate.bind(lightbox, '.backdrop', 'click', function (event) {
      document.body.removeChild(lightbox);
    });
  }

  document.body.appendChild(lightbox);
}

},{"min-dom":506}],218:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

exports.default = ModelCloneHelper;

var _minDash = require('min-dash');

var _ModelCloneUtils = require('./ModelCloneUtils');

function isAllowedIn(extProp, type) {
  var allowedIn = extProp.meta.allowedIn;

  // '*' is a wildcard, which means any element is allowed to use this property
  if (allowedIn.length === 1 && allowedIn[0] === '*') {
    return true;
  }

  return allowedIn.indexOf(type) !== -1;
}

function isType(element, types) {
  return (0, _minDash.some)(types, function (type) {
    return (typeof element === 'undefined' ? 'undefined' : _typeof(element)) === type;
  });
}

/**
 * A bpmn properties cloning interface
 *
 */
function ModelCloneHelper(eventBus, bpmnFactory) {
  this._eventBus = eventBus;
  this._bpmnFactory = bpmnFactory;
}

ModelCloneHelper.prototype.clone = function (refElement, newElement, properties) {

  var self = this;

  // hasNestedProperty: property allows us to avoid ending up with empty (xml) tags
  // f.ex: if extensionElements.values is empty, don't set it
  var context = {
    newElement: newElement,
    hasNestedProperty: false
  };

  // we want the extensionElements to be cloned last
  // so that they can check certain properties
  properties = (0, _minDash.sortBy)(properties, function (prop) {
    return prop === 'bpmn:extensionElements';
  });

  (0, _minDash.forEach)(properties, function (propName) {
    var refElementProp = refElement.get(propName),
        newElementProp = newElement.get(propName),
        propDescriptor = newElement.$model.getPropertyDescriptor(newElement, propName),
        newProperty,
        name;

    // we're not interested in cloning:
    // - same values from simple types
    // - cloning id's
    // - cloning reference elements
    if (newElementProp === refElementProp) {
      return;
    }

    if (propDescriptor && (propDescriptor.isId || propDescriptor.isReference)) {
      return;
    }

    // if the property is of type 'boolean', 'string', 'number' or 'null', just set it
    if (isType(refElementProp, ['boolean', 'string', 'number']) || refElementProp === null) {
      newElement.set(propName, refElementProp);

      return;
    }

    if ((0, _minDash.isArray)(refElementProp)) {

      (0, _minDash.forEach)(refElementProp, function (extElement) {
        var newProp;

        context.refTopLevelProperty = extElement;

        newProp = self._deepClone(extElement, context);

        if (context.hasNestedProperty) {
          newProp.$parent = newElement;

          newElementProp.push(newProp);
        }

        context.hasNestedProperty = false;
      });
    } else {
      name = propName.replace(/bpmn:/, '');

      context.refTopLevelProperty = refElementProp;

      newProperty = self._deepClone(refElementProp, context);

      if (context.hasNestedProperty) {
        newProperty.$parent = newElement;

        newElement.set(name, newProperty);
      }

      context.hasNestedProperty = false;
    }
  });

  return newElement;
};

ModelCloneHelper.prototype._deepClone = function _deepClone(propertyElement, context) {
  var self = this;

  var eventBus = this._eventBus;
  var bpmnFactory = this._bpmnFactory;

  var newProp = bpmnFactory.create(propertyElement.$type);

  var properties = (0, _minDash.filter)(Object.keys(propertyElement), function (prop) {
    var descriptor = newProp.$model.getPropertyDescriptor(newProp, prop);

    if (descriptor && (descriptor.isId || descriptor.isReference)) {
      return false;
    }

    // we need to make sure we don't clone certain properties
    // which we cannot easily know if they hold references or not
    if (_ModelCloneUtils.IGNORED_PROPERTIES.indexOf(prop) !== -1) {
      return false;
    }

    // make sure we don't copy the type
    return prop !== '$type';
  });

  if (!properties.length) {
    context.hasNestedProperty = true;
  }

  (0, _minDash.forEach)(properties, function (propName) {
    // check if the propertyElement has this property defined
    if (propertyElement[propName] !== undefined && (propertyElement[propName].$type || (0, _minDash.isArray)(propertyElement[propName]))) {

      if ((0, _minDash.isArray)(propertyElement[propName])) {
        newProp[propName] = [];

        (0, _minDash.forEach)(propertyElement[propName], function (property) {
          var extProp = propertyElement.$model.getTypeDescriptor(property.$type),
              newDeepProp;

          // we're not going to copy undefined types
          if (!extProp) {
            return;
          }

          var canClone = eventBus.fire('property.clone', {
            newElement: context.newElement,
            refTopLevelProperty: context.refTopLevelProperty,
            propertyDescriptor: extProp
          });

          if (!canClone) {
            // if can clone is 'undefined' or 'false'
            // check for the meta information if it is allowed
            if (propertyElement.$type === 'bpmn:ExtensionElements' && extProp.meta && extProp.meta.allowedIn && !isAllowedIn(extProp, context.newElement.$type)) {
              return false;
            }
          }

          newDeepProp = self._deepClone(property, context);

          newDeepProp.$parent = newProp;

          if (!newProp[propName]) {
            newProp[propName] = [];
          }

          context.hasNestedProperty = true;

          newProp[propName].push(newDeepProp);
        });
      } else if (propertyElement[propName].$type) {
        newProp[propName] = self._deepClone(propertyElement[propName], context);

        if (newProp[propName]) {
          context.hasNestedProperty = true;

          newProp[propName].$parent = newProp;
        }
      }
    } else {
      context.hasNestedProperty = true;

      // just assign directly if it's a value
      newProp[propName] = propertyElement[propName];
    }
  });

  return newProp;
};

},{"./ModelCloneUtils":219,"min-dash":505}],219:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.IGNORED_PROPERTIES = undefined;
exports.getProperties = getProperties;

var _minDash = require('min-dash');

/**
 * These are the properties that should be ignored when cloning elements.
 *
 * @type {Array}
 */
var IGNORED_PROPERTIES = exports.IGNORED_PROPERTIES = ['lanes', 'incoming', 'outgoing', 'artifacts', 'default', 'flowElements', 'dataInputAssociations', 'dataOutputAssociations'];

function getProperties(descriptor, keepDefault) {
  var properties = [];

  (0, _minDash.forEach)(descriptor.properties, function (property) {

    if (keepDefault && property.default) {
      return;
    }

    properties.push(property.ns.name);
  });

  return properties;
}

},{"min-dash":505}],220:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _simple = require('./lib/simple');

Object.defineProperty(exports, 'default', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_simple).default;
  }
});

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

},{"./lib/simple":222}],221:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = BpmnModdle;

var _minDash = require('min-dash');

var _moddle = require('moddle');

var _moddle2 = _interopRequireDefault(_moddle);

var _moddleXml = require('moddle-xml');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * 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) {
  _moddle2.default.call(this, packages, options);
}

BpmnModdle.prototype = Object.create(_moddle2.default.prototype);

/**
 * 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
 * @param {Function} done       callback that is invoked with (err, result, parseContext)
 *                              once the import completes
 */
BpmnModdle.prototype.fromXML = function (xmlStr, typeName, options, done) {

  if (!(0, _minDash.isString)(typeName)) {
    done = options;
    options = typeName;
    typeName = 'bpmn:Definitions';
  }

  if ((0, _minDash.isFunction)(options)) {
    done = options;
    options = {};
  }

  var reader = new _moddleXml.Reader((0, _minDash.assign)({ model: this, lax: true }, options));
  var rootHandler = reader.handler(typeName);

  reader.fromXML(xmlStr, rootHandler, done);
};

/**
 * 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
 * @param {Function} done       callback invoked with (err, xmlStr) once the import completes
 */
BpmnModdle.prototype.toXML = function (element, options, done) {

  if ((0, _minDash.isFunction)(options)) {
    done = options;
    options = {};
  }

  var writer = new _moddleXml.Writer(options);

  var result;
  var err;

  try {
    result = writer.toXML(element);
  } catch (e) {
    err = e;
  }

  return done(err, result);
};

},{"min-dash":505,"moddle":511,"moddle-xml":507}],222:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

exports.default = function (additionalPackages, options) {
  var pks = (0, _minDash.assign)({}, packages, additionalPackages);

  return new _bpmnModdle2.default(pks, options);
};

var _minDash = require('min-dash');

var _bpmnModdle = require('./bpmn-moddle');

var _bpmnModdle2 = _interopRequireDefault(_bpmnModdle);

var _bpmn = require('../resources/bpmn/json/bpmn.json');

var _bpmn2 = _interopRequireDefault(_bpmn);

var _bpmndi = require('../resources/bpmn/json/bpmndi.json');

var _bpmndi2 = _interopRequireDefault(_bpmndi);

var _dc = require('../resources/bpmn/json/dc.json');

var _dc2 = _interopRequireDefault(_dc);

var _di = require('../resources/bpmn/json/di.json');

var _di2 = _interopRequireDefault(_di);

var _bioc = require('../resources/bpmn-io/json/bioc.json');

var _bioc2 = _interopRequireDefault(_bioc);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var packages = {
  bpmn: _bpmn2.default,
  bpmndi: _bpmndi2.default,
  dc: _dc2.default,
  di: _di2.default,
  bioc: _bioc2.default
};

},{"../resources/bpmn-io/json/bioc.json":223,"../resources/bpmn/json/bpmn.json":224,"../resources/bpmn/json/bpmndi.json":225,"../resources/bpmn/json/dc.json":226,"../resources/bpmn/json/di.json":227,"./bpmn-moddle":221,"min-dash":505}],223:[function(require,module,exports){
module.exports={
  "name": "bpmn.io colors for BPMN",
  "uri": "http://bpmn.io/schema/bpmn/biocolor/1.0",
  "prefix": "bioc",
  "types": [
    {
      "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"
        }
      ]
    }
  ],
  "enumerations": [],
  "associations": []
}

},{}],224:[function(require,module,exports){
module.exports={
  "name": "BPMN20",
  "uri": "http://www.omg.org/spec/BPMN/20100524/MODEL",
  "associations": [],
  "types": [
    {
      "name": "Interface",
      "superClass": [
        "RootElement"
      ],
      "properties": [
        {
          "name": "name",
          "isAttr": true,
          "type": "String"
        },
        {
          "name": "operations",
          "type": "Operation",
          "isMany": true
        },
        {
          "name": "implementationRef",
          "type": "String",
          "isAttr": true
        }
      ]
    },
    {
      "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",
          "type": "String",
          "isAttr": true
        }
      ]
    },
    {
      "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",
          "type": "LaneSet",
          "isMany": true,
          "replaces": "FlowElementsContainer#laneSets"
        },
        {
          "name": "flowElements",
          "type": "FlowElement",
          "isMany": true,
          "replaces": "FlowElementsContainer#flowElements"
        },
        {
          "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": "assignment",
          "type": "Assignment",
          "isMany": true
        },
        {
          "name": "sourceRef",
          "type": "ItemAwareElement",
          "isMany": true,
          "isReference": true
        },
        {
          "name": "targetRef",
          "type": "ItemAwareElement",
          "isReference": true
        },
        {
          "name": "transformation",
          "type": "FormalExpression",
          "xml": {
            "serialize": "property"
          }
        }
      ]
    },
    {
      "name": "DataInput",
      "superClass": [
        "ItemAwareElement"
      ],
      "properties": [
        {
          "name": "name",
          "isAttr": true,
          "type": "String"
        },
        {
          "name": "isCollection",
          "default": false,
          "isAttr": true,
          "type": "Boolean"
        },
        {
          "name": "inputSetRef",
          "type": "InputSet",
          "isVirtual": true,
          "isMany": true,
          "isReference": true
        },
        {
          "name": "inputSetWithOptional",
          "type": "InputSet",
          "isVirtual": true,
          "isMany": true,
          "isReference": true
        },
        {
          "name": "inputSetWithWhileExecuting",
          "type": "InputSet",
          "isVirtual": true,
          "isMany": 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",
          "isVirtual": true,
          "isMany": true,
          "isReference": true
        },
        {
          "name": "outputSetWithOptional",
          "type": "OutputSet",
          "isVirtual": true,
          "isMany": true,
          "isReference": true
        },
        {
          "name": "outputSetWithWhileExecuting",
          "type": "OutputSet",
          "isVirtual": true,
          "isMany": 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",
          "type": "String",
          "isBody": true
        }
      ]
    },
    {
      "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",
          "type": "String",
          "isAttr": true
        },
        {
          "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",
          "isVirtual": true,
          "isMany": 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",
          "isVirtual": true,
          "isMany": true,
          "isReference": true
        },
        {
          "name": "outgoingConversationLinks",
          "type": "ConversationLink",
          "isVirtual": true,
          "isMany": 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",
          "isVirtual": true,
          "isMany": 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"
      ],
      "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"
        }
      ]
    }
  ],
  "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"
        }
      ]
    }
  ],
  "prefix": "bpmn",
  "xml": {
    "tagAlias": "lowerCase",
    "typePrefix": "t"
  }
}
},{}],225:[function(require,module,exports){
module.exports={
  "name": "BPMNDI",
  "uri": "http://www.omg.org/spec/BPMN/20100524/DI",
  "types": [
    {
      "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"
      ]
    }
  ],
  "enumerations": [
    {
      "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"
        }
      ]
    }
  ],
  "associations": [],
  "prefix": "bpmndi"
}
},{}],226:[function(require,module,exports){
module.exports={
  "name": "DC",
  "uri": "http://www.omg.org/spec/DD/20100524/DC",
  "types": [
    {
      "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
        }
      ]
    }
  ],
  "prefix": "dc",
  "associations": []
}
},{}],227:[function(require,module,exports){
module.exports={
  "name": "DI",
  "uri": "http://www.omg.org/spec/DD/20100524/DI",
  "types": [
    {
      "name": "DiagramElement",
      "isAbstract": true,
      "properties": [
        {
          "name": "id",
          "type": "String",
          "isAttr": true,
          "isId": true
        },
        {
          "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,
          "isVirtual": true,
          "isMany": 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",
          "type": "String",
          "isAttr": true,
          "isId": true
        },
        {
          "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,
          "isVirtual": true,
          "isMany": 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",
          "isVirtual": true,
          "isMany": true
        }
      ]
    },
    {
      "name": "LabeledShape",
      "isAbstract": true,
      "superClass": [
        "Shape"
      ],
      "properties": [
        {
          "name": "ownedLabel",
          "type": "Label",
          "isReadOnly": true,
          "subsettedProperty": "DiagramElement-ownedElement",
          "isVirtual": true,
          "isMany": true
        }
      ]
    },
    {
      "name": "Label",
      "isAbstract": true,
      "superClass": [
        "Node"
      ],
      "properties": [
        {
          "name": "bounds",
          "type": "dc:Bounds"
        }
      ]
    },
    {
      "name": "Style",
      "isAbstract": true,
      "properties": [
        {
          "name": "id",
          "type": "String",
          "isAttr": true,
          "isId": true
        }
      ]
    },
    {
      "name": "Extension",
      "properties": [
        {
          "name": "values",
          "type": "Element",
          "isMany": true
        }
      ]
    }
  ],
  "associations": [],
  "prefix": "di",
  "xml": {
    "tagAlias": "lowerCase"
  }
}
},{}],228:[function(require,module,exports){
'use strict';

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.

var objectCreate = Object.create || objectCreatePolyfill;
var objectKeys = Object.keys || objectKeysPolyfill;
var bind = Function.prototype.bind || functionBindPolyfill;

function EventEmitter() {
  if (!this._events || !Object.prototype.hasOwnProperty.call(this, '_events')) {
    this._events = objectCreate(null);
    this._eventsCount = 0;
  }

  this._maxListeners = this._maxListeners || undefined;
}
module.exports = EventEmitter;

// Backwards-compat with node 0.10.x
EventEmitter.EventEmitter = EventEmitter;

EventEmitter.prototype._events = undefined;
EventEmitter.prototype._maxListeners = undefined;

// By default EventEmitters will print a warning if more than 10 listeners are
// added to it. This is a useful default which helps finding memory leaks.
var defaultMaxListeners = 10;

var hasDefineProperty;
try {
  var o = {};
  if (Object.defineProperty) Object.defineProperty(o, 'x', { value: 0 });
  hasDefineProperty = o.x === 0;
} catch (err) {
  hasDefineProperty = false;
}
if (hasDefineProperty) {
  Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
    enumerable: true,
    get: function get() {
      return defaultMaxListeners;
    },
    set: function set(arg) {
      // check whether the input is a positive number (whose value is zero or
      // greater and not a NaN).
      if (typeof arg !== 'number' || arg < 0 || arg !== arg) throw new TypeError('"defaultMaxListeners" must be a positive number');
      defaultMaxListeners = arg;
    }
  });
} else {
  EventEmitter.defaultMaxListeners = defaultMaxListeners;
}

// Obviously not all Emitters should be limited to 10. This function allows
// that to be increased. Set to zero for unlimited.
EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
  if (typeof n !== 'number' || n < 0 || isNaN(n)) throw new TypeError('"n" argument must be a positive number');
  this._maxListeners = n;
  return this;
};

function $getMaxListeners(that) {
  if (that._maxListeners === undefined) return EventEmitter.defaultMaxListeners;
  return that._maxListeners;
}

EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
  return $getMaxListeners(this);
};

// These standalone emit* functions are used to optimize calling of event
// handlers for fast cases because emit() itself often has a variable number of
// arguments and can be deoptimized because of that. These functions always have
// the same number of arguments and thus do not get deoptimized, so the code
// inside them can execute faster.
function emitNone(handler, isFn, self) {
  if (isFn) handler.call(self);else {
    var len = handler.length;
    var listeners = arrayClone(handler, len);
    for (var i = 0; i < len; ++i) {
      listeners[i].call(self);
    }
  }
}
function emitOne(handler, isFn, self, arg1) {
  if (isFn) handler.call(self, arg1);else {
    var len = handler.length;
    var listeners = arrayClone(handler, len);
    for (var i = 0; i < len; ++i) {
      listeners[i].call(self, arg1);
    }
  }
}
function emitTwo(handler, isFn, self, arg1, arg2) {
  if (isFn) handler.call(self, arg1, arg2);else {
    var len = handler.length;
    var listeners = arrayClone(handler, len);
    for (var i = 0; i < len; ++i) {
      listeners[i].call(self, arg1, arg2);
    }
  }
}
function emitThree(handler, isFn, self, arg1, arg2, arg3) {
  if (isFn) handler.call(self, arg1, arg2, arg3);else {
    var len = handler.length;
    var listeners = arrayClone(handler, len);
    for (var i = 0; i < len; ++i) {
      listeners[i].call(self, arg1, arg2, arg3);
    }
  }
}

function emitMany(handler, isFn, self, args) {
  if (isFn) handler.apply(self, args);else {
    var len = handler.length;
    var listeners = arrayClone(handler, len);
    for (var i = 0; i < len; ++i) {
      listeners[i].apply(self, args);
    }
  }
}

EventEmitter.prototype.emit = function emit(type) {
  var er, handler, len, args, i, events;
  var doError = type === 'error';

  events = this._events;
  if (events) doError = doError && events.error == null;else if (!doError) return false;

  // If there is no 'error' event listener then throw.
  if (doError) {
    if (arguments.length > 1) er = arguments[1];
    if (er instanceof Error) {
      throw er; // Unhandled 'error' event
    } else {
      // At least give some kind of context to the user
      var err = new Error('Unhandled "error" event. (' + er + ')');
      err.context = er;
      throw err;
    }
    return false;
  }

  handler = events[type];

  if (!handler) return false;

  var isFn = typeof handler === 'function';
  len = arguments.length;
  switch (len) {
    // fast cases
    case 1:
      emitNone(handler, isFn, this);
      break;
    case 2:
      emitOne(handler, isFn, this, arguments[1]);
      break;
    case 3:
      emitTwo(handler, isFn, this, arguments[1], arguments[2]);
      break;
    case 4:
      emitThree(handler, isFn, this, arguments[1], arguments[2], arguments[3]);
      break;
    // slower
    default:
      args = new Array(len - 1);
      for (i = 1; i < len; i++) {
        args[i - 1] = arguments[i];
      }emitMany(handler, isFn, this, args);
  }

  return true;
};

function _addListener(target, type, listener, prepend) {
  var m;
  var events;
  var existing;

  if (typeof listener !== 'function') throw new TypeError('"listener" argument must be a function');

  events = target._events;
  if (!events) {
    events = target._events = objectCreate(null);
    target._eventsCount = 0;
  } else {
    // To avoid recursion in the case that type === "newListener"! Before
    // adding it to the listeners, first emit "newListener".
    if (events.newListener) {
      target.emit('newListener', type, listener.listener ? listener.listener : listener);

      // Re-assign `events` because a newListener handler could have caused the
      // this._events to be assigned to a new object
      events = target._events;
    }
    existing = events[type];
  }

  if (!existing) {
    // Optimize the case of one listener. Don't need the extra array object.
    existing = events[type] = listener;
    ++target._eventsCount;
  } else {
    if (typeof existing === 'function') {
      // Adding the second element, need to change to array.
      existing = events[type] = prepend ? [listener, existing] : [existing, listener];
    } else {
      // If we've already got an array, just append.
      if (prepend) {
        existing.unshift(listener);
      } else {
        existing.push(listener);
      }
    }

    // Check for listener leak
    if (!existing.warned) {
      m = $getMaxListeners(target);
      if (m && m > 0 && existing.length > m) {
        existing.warned = true;
        var w = new Error('Possible EventEmitter memory leak detected. ' + existing.length + ' "' + String(type) + '" listeners ' + 'added. Use emitter.setMaxListeners() to ' + 'increase limit.');
        w.name = 'MaxListenersExceededWarning';
        w.emitter = target;
        w.type = type;
        w.count = existing.length;
        if ((typeof console === 'undefined' ? 'undefined' : _typeof(console)) === 'object' && console.warn) {
          console.warn('%s: %s', w.name, w.message);
        }
      }
    }
  }

  return target;
}

EventEmitter.prototype.addListener = function addListener(type, listener) {
  return _addListener(this, type, listener, false);
};

EventEmitter.prototype.on = EventEmitter.prototype.addListener;

EventEmitter.prototype.prependListener = function prependListener(type, listener) {
  return _addListener(this, type, listener, true);
};

function onceWrapper() {
  if (!this.fired) {
    this.target.removeListener(this.type, this.wrapFn);
    this.fired = true;
    switch (arguments.length) {
      case 0:
        return this.listener.call(this.target);
      case 1:
        return this.listener.call(this.target, arguments[0]);
      case 2:
        return this.listener.call(this.target, arguments[0], arguments[1]);
      case 3:
        return this.listener.call(this.target, arguments[0], arguments[1], arguments[2]);
      default:
        var args = new Array(arguments.length);
        for (var i = 0; i < args.length; ++i) {
          args[i] = arguments[i];
        }this.listener.apply(this.target, args);
    }
  }
}

function _onceWrap(target, type, listener) {
  var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };
  var wrapped = bind.call(onceWrapper, state);
  wrapped.listener = listener;
  state.wrapFn = wrapped;
  return wrapped;
}

EventEmitter.prototype.once = function once(type, listener) {
  if (typeof listener !== 'function') throw new TypeError('"listener" argument must be a function');
  this.on(type, _onceWrap(this, type, listener));
  return this;
};

EventEmitter.prototype.prependOnceListener = function prependOnceListener(type, listener) {
  if (typeof listener !== 'function') throw new TypeError('"listener" argument must be a function');
  this.prependListener(type, _onceWrap(this, type, listener));
  return this;
};

// Emits a 'removeListener' event if and only if the listener was removed.
EventEmitter.prototype.removeListener = function removeListener(type, listener) {
  var list, events, position, i, originalListener;

  if (typeof listener !== 'function') throw new TypeError('"listener" argument must be a function');

  events = this._events;
  if (!events) return this;

  list = events[type];
  if (!list) return this;

  if (list === listener || list.listener === listener) {
    if (--this._eventsCount === 0) this._events = objectCreate(null);else {
      delete events[type];
      if (events.removeListener) this.emit('removeListener', type, list.listener || listener);
    }
  } else if (typeof list !== 'function') {
    position = -1;

    for (i = list.length - 1; i >= 0; i--) {
      if (list[i] === listener || list[i].listener === listener) {
        originalListener = list[i].listener;
        position = i;
        break;
      }
    }

    if (position < 0) return this;

    if (position === 0) list.shift();else spliceOne(list, position);

    if (list.length === 1) events[type] = list[0];

    if (events.removeListener) this.emit('removeListener', type, originalListener || listener);
  }

  return this;
};

EventEmitter.prototype.removeAllListeners = function removeAllListeners(type) {
  var listeners, events, i;

  events = this._events;
  if (!events) return this;

  // not listening for removeListener, no need to emit
  if (!events.removeListener) {
    if (arguments.length === 0) {
      this._events = objectCreate(null);
      this._eventsCount = 0;
    } else if (events[type]) {
      if (--this._eventsCount === 0) this._events = objectCreate(null);else delete events[type];
    }
    return this;
  }

  // emit removeListener for all listeners on all events
  if (arguments.length === 0) {
    var keys = objectKeys(events);
    var key;
    for (i = 0; i < keys.length; ++i) {
      key = keys[i];
      if (key === 'removeListener') continue;
      this.removeAllListeners(key);
    }
    this.removeAllListeners('removeListener');
    this._events = objectCreate(null);
    this._eventsCount = 0;
    return this;
  }

  listeners = events[type];

  if (typeof listeners === 'function') {
    this.removeListener(type, listeners);
  } else if (listeners) {
    // LIFO order
    for (i = listeners.length - 1; i >= 0; i--) {
      this.removeListener(type, listeners[i]);
    }
  }

  return this;
};

function _listeners(target, type, unwrap) {
  var events = target._events;

  if (!events) return [];

  var evlistener = events[type];
  if (!evlistener) return [];

  if (typeof evlistener === 'function') return unwrap ? [evlistener.listener || evlistener] : [evlistener];

  return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
}

EventEmitter.prototype.listeners = function listeners(type) {
  return _listeners(this, type, true);
};

EventEmitter.prototype.rawListeners = function rawListeners(type) {
  return _listeners(this, type, false);
};

EventEmitter.listenerCount = function (emitter, type) {
  if (typeof emitter.listenerCount === 'function') {
    return emitter.listenerCount(type);
  } else {
    return listenerCount.call(emitter, type);
  }
};

EventEmitter.prototype.listenerCount = listenerCount;
function listenerCount(type) {
  var events = this._events;

  if (events) {
    var evlistener = events[type];

    if (typeof evlistener === 'function') {
      return 1;
    } else if (evlistener) {
      return evlistener.length;
    }
  }

  return 0;
}

EventEmitter.prototype.eventNames = function eventNames() {
  return this._eventsCount > 0 ? Reflect.ownKeys(this._events) : [];
};

// About 1.5x faster than the two-arg version of Array#splice().
function spliceOne(list, index) {
  for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1) {
    list[i] = list[k];
  }list.pop();
}

function arrayClone(arr, n) {
  var copy = new Array(n);
  for (var i = 0; i < n; ++i) {
    copy[i] = arr[i];
  }return copy;
}

function unwrapListeners(arr) {
  var ret = new Array(arr.length);
  for (var i = 0; i < ret.length; ++i) {
    ret[i] = arr[i].listener || arr[i];
  }
  return ret;
}

function objectCreatePolyfill(proto) {
  var F = function F() {};
  F.prototype = proto;
  return new F();
}
function objectKeysPolyfill(obj) {
  var keys = [];
  for (var k in obj) {
    if (Object.prototype.hasOwnProperty.call(obj, k)) {
      keys.push(k);
    }
  }return k;
}
function functionBindPolyfill(context) {
  var fn = this;
  return function () {
    return fn.apply(context, arguments);
  };
}

},{}],229:[function(require,module,exports){
module.exports={
  "name": "Camunda",
  "uri": "http://camunda.org/schema/1.0/bpmn",
  "prefix": "camunda",
  "xml": {
    "tagAlias": "lowerCase"
  },
  "associations": [],
  "types": [
    {
      "name": "InOutBinding",
      "superClass": [
        "Element"
      ],
      "isAbstract": true,
      "properties": [
        {
          "name": "source",
          "isAttr": true,
          "type": "String"
        },
        {
          "name": "sourceExpression",
          "isAttr": true,
          "type": "String"
        },
        {
          "name": "target",
          "isAttr": true,
          "type": "String"
        },
        {
          "name": "businessKey",
          "isAttr": true,
          "type": "String"
        },
        {
          "name": "local",
          "isAttr": true,
          "type": "Boolean",
          "default": false
        },
        {
          "name": "variables",
          "isAttr": true,
          "type": "String"
        }
      ]
    },
    {
      "name": "In",
      "superClass": [
        "InOutBinding"
      ],
      "meta": {
        "allowedIn": [
          "bpmn:CallActivity"
        ]
      }
    },
    {
      "name": "Out",
      "superClass": [
        "InOutBinding"
      ],
      "meta": {
        "allowedIn": [
          "bpmn:CallActivity"
        ]
      }
    },
    {
      "name": "AsyncCapable",
      "isAbstract": true,
      "extends": [
        "bpmn:Activity",
        "bpmn:Gateway",
        "bpmn:Event"
      ],
      "properties": [
        {
          "name": "async",
          "isAttr": true,
          "type": "Boolean",
          "default": false
        },
        {
          "name": "asyncBefore",
          "isAttr": true,
          "type": "Boolean",
          "default": false
        },
        {
          "name": "asyncAfter",
          "isAttr": true,
          "type": "Boolean",
          "default": false
        },
        {
          "name": "exclusive",
          "isAttr": true,
          "type": "Boolean",
          "default": true
        }
      ]
    },
    {
      "name": "JobPriorized",
      "isAbstract": true,
      "extends": [
        "bpmn:Process",
        "camunda:AsyncCapable"
      ],
      "properties": [
        {
          "name": "jobPriority",
          "isAttr": true,
          "type": "String"
        }
      ]
    },
    {
      "name": "SignalEventDefinition",
      "isAbstract": true,
      "extends": [
        "bpmn:SignalEventDefinition"
      ],
      "properties": [
        {
          "name": "async",
          "isAttr": true,
          "type": "Boolean",
          "default": false
        }
      ]
    },
    {
      "name": "ErrorEventDefinition",
      "isAbstract": true,
      "extends": [
        "bpmn:ErrorEventDefinition"
      ],
      "properties": [
        {
          "name": "errorCodeVariable",
          "isAttr": true,
          "type": "String"
        },
        {
          "name": "errorMessageVariable",
          "isAttr": true,
          "type": "String"
        }
      ]
    },
    {
      "name": "PotentialStarter",
      "superClass": [
        "Element"
      ],
      "properties": [
        {
          "name": "resourceAssignmentExpression",
          "type": "bpmn:ResourceAssignmentExpression"
        }
      ]
    },
    {
      "name": "FormSupported",
      "isAbstract": true,
      "extends": [
        "bpmn:StartEvent",
        "bpmn:UserTask"
      ],
      "properties": [
        {
          "name": "formHandlerClass",
          "isAttr": true,
          "type": "String"
        },
        {
          "name": "formKey",
          "isAttr": true,
          "type": "String"
        }
      ]
    },
    {
      "name": "TemplateSupported",
      "isAbstract": true,
      "extends": [
        "bpmn:Process",
        "bpmn:FlowElement"
      ],
      "properties": [
        {
          "name": "modelerTemplate",
          "isAttr": true,
          "type": "String"
        }
      ]
    },
    {
      "name": "Initiator",
      "isAbstract": true,
      "extends": [ "bpmn:StartEvent" ],
      "properties": [
        {
          "name": "initiator",
          "isAttr": true,
          "type": "String"
        }
      ]
    },
    {
      "name": "ScriptTask",
      "isAbstract": true,
      "extends": [
        "bpmn:ScriptTask"
      ],
      "properties": [
        {
          "name": "resultVariable",
          "isAttr": true,
          "type": "String"
        },
        {
          "name": "resource",
          "isAttr": true,
          "type": "String"
        }
      ]
    },
    {
      "name": "Process",
      "isAbstract": true,
      "extends": [
        "bpmn:Process"
      ],
      "properties": [
        {
          "name": "candidateStarterGroups",
          "isAttr": true,
          "type": "String"
        },
        {
          "name": "candidateStarterUsers",
          "isAttr": true,
          "type": "String"
        },
        {
          "name": "versionTag",
          "isAttr": true,
          "type": "String"
        },
        {
          "name": "historyTimeToLive",
          "isAttr": true,
          "type": "String"
        },
        {
          "name": "isStartableInTasklist",
          "isAttr": true,
          "type": "Boolean",
          "default": true
        }
      ]
    },
    {
      "name": "EscalationEventDefinition",
      "isAbstract": true,
      "extends": [
        "bpmn:EscalationEventDefinition"
      ],
      "properties": [
        {
          "name": "escalationCodeVariable",
          "isAttr": true,
          "type": "String"
        }
      ]
    },
    {
      "name": "FormalExpression",
      "isAbstract": true,
      "extends": [
        "bpmn:FormalExpression"
      ],
      "properties": [
        {
          "name": "resource",
          "isAttr": true,
          "type": "String"
        }
      ]
    },
    {
      "name": "Assignable",
      "extends": [ "bpmn:UserTask" ],
      "properties": [
        {
          "name": "assignee",
          "isAttr": true,
          "type": "String"
        },
        {
          "name": "candidateUsers",
          "isAttr": true,
          "type": "String"
        },
        {
          "name": "candidateGroups",
          "isAttr": true,
          "type": "String"
        },
        {
          "name": "dueDate",
          "isAttr": true,
          "type": "String"
        },
        {
          "name": "followUpDate",
          "isAttr": true,
          "type": "String"
        },
        {
          "name": "priority",
          "isAttr": true,
          "type": "String"
        }
      ]
    },
    {
      "name": "CallActivity",
      "extends": [ "bpmn:CallActivity" ],
      "properties": [
        {
          "name": "calledElementBinding",
          "isAttr": true,
          "type": "String",
          "default": "latest"
        },
        {
          "name": "calledElementVersion",
          "isAttr": true,
          "type": "String"
        },
        {
          "name": "calledElementVersionTag",
          "isAttr": true,
          "type": "String"
        },
        {
          "name": "calledElementTenantId",
          "isAttr": true,
          "type": "String"
        },
        {
          "name": "caseRef",
          "isAttr": true,
          "type": "String"
        },
        {
          "name": "caseBinding",
          "isAttr": true,
          "type": "String",
          "default": "latest"
        },
        {
          "name": "caseVersion",
          "isAttr": true,
          "type": "String"
        },
        {
          "name": "caseTenantId",
          "isAttr": true,
          "type": "String"
        },
        {
          "name": "variableMappingClass",
          "isAttr": true,
          "type": "String"
        },
        {
          "name": "variableMappingDelegateExpression",
          "isAttr": true,
          "type": "String"
        }
      ]
    },
    {
      "name": "ServiceTaskLike",
      "extends": [
        "bpmn:ServiceTask",
        "bpmn:BusinessRuleTask",
        "bpmn:SendTask",
        "bpmn:MessageEventDefinition"
      ],
      "properties": [
        {
          "name": "expression",
          "isAttr": true,
          "type": "String"
        },
        {
          "name": "class",
          "isAttr": true,
          "type": "String"
        },
        {
          "name": "delegateExpression",
          "isAttr": true,
          "type": "String"
        },
        {
          "name": "resultVariable",
          "isAttr": true,
          "type": "String"
        }
      ]
    },
    {
      "name": "DmnCapable",
      "extends": [
        "bpmn:BusinessRuleTask"
      ],
      "properties": [
        {
          "name": "decisionRef",
          "isAttr": true,
          "type": "String"
        },
        {
          "name": "decisionRefBinding",
          "isAttr": true,
          "type": "String",
          "default": "latest"
        },
        {
          "name": "decisionRefVersion",
          "isAttr": true,
          "type": "String"
        },
        {
          "name": "mapDecisionResult",
          "isAttr": true,
          "type": "String",
          "default": "resultList"
        },
        {
          "name": "decisionRefTenantId",
          "isAttr": true,
          "type": "String"
        }
      ]
    },
    {
      "name": "ExternalCapable",
      "extends": [
        "camunda:ServiceTaskLike"
      ],
      "properties": [
        {
          "name": "type",
          "isAttr": true,
          "type": "String"
        },
        {
          "name": "topic",
          "isAttr": true,
          "type": "String"
        }
      ]
    },
    {
      "name": "TaskPriorized",
      "extends": [
        "bpmn:Process",
        "camunda:ExternalCapable"
      ],
      "properties": [
        {
          "name": "taskPriority",
          "isAttr": true,
          "type": "String"
        }
      ]
    },
    {
      "name": "Properties",
      "superClass": [
        "Element"
      ],
      "meta": {
        "allowedIn": [ "*" ]
      },
      "properties": [
        {
          "name": "values",
          "type": "Property",
          "isMany": true
        }
      ]
    },
    {
      "name": "Property",
      "superClass": [
        "Element"
      ],
      "properties": [
        {
          "name": "id",
          "type": "String",
          "isAttr": true
        },
        {
          "name": "name",
          "type": "String",
          "isAttr": true
        },
        {
          "name": "value",
          "type": "String",
          "isAttr": true
        }
      ]
    },
    {
      "name": "Connector",
      "superClass": [
        "Element"
      ],
      "meta": {
        "allowedIn": [
          "bpmn:ServiceTask",
          "bpmn:BusinessRuleTask",
          "bpmn:SendTask"
        ]
      },
      "properties": [
        {
          "name": "inputOutput",
          "type": "InputOutput"
        },
        {
          "name": "connectorId",
          "type": "String"
        }
      ]
    },
    {
      "name": "InputOutput",
      "superClass": [
        "Element"
      ],
      "meta": {
        "allowedIn": [
          "bpmn:Task",
          "bpmn:UserTask",
          "bpmn:ServiceTask",
          "bpmn:SendTask",
          "bpmn:BusinessRuleTask",
          "bpmn:ReceiveTask",
          "bpmn:ScriptTask",
          "bpmn:ManualTask",
          "bpmn:GlobalUserTask",
          "bpmn:GlobalScriptTask",
          "bpmn:GlobalBusinessRuleTask",
          "bpmn:GlobalTask",
          "bpmn:GlobalManualTask",
          "bpmn:SubProcess",
          "bpmn:Transaction",
          "bpmn:IntermediateCatchEvent",
          "bpmn:IntermediateThrowEvent",
          "bpmn:EndEvent",
          "bpmn:ThrowEvent",
          "bpmn:CatchEvent",
          "bpmn:ImplicitThrowEvent",
          "bpmn:CallActivity"
        ]
      },
      "properties": [
        {
          "name": "inputOutput",
          "type": "InputOutput"
        },
        {
          "name": "connectorId",
          "type": "String"
        },
        {
          "name": "inputParameters",
          "isMany": true,
          "type": "InputParameter"
        },
        {
          "name": "outputParameters",
          "isMany": true,
          "type": "OutputParameter"
        }
      ]
    },
    {
      "name": "InputOutputParameter",
      "properties": [
        {
          "name": "name",
          "isAttr": true,
          "type": "String"
        },
        {
          "name": "value",
          "isBody": true,
          "type": "String"
        },
        {
          "name": "definition",
          "type": "InputOutputParameterDefinition"
        }
      ]
    },
    {
      "name": "InputOutputParameterDefinition",
      "isAbstract": true
    },
    {
      "name": "List",
      "superClass": [ "InputOutputParameterDefinition" ],
      "properties": [
        {
          "name": "items",
          "isMany": true,
          "type": "InputOutputParameterDefinition"
        }
      ]
    },
    {
      "name": "Map",
      "superClass": [ "InputOutputParameterDefinition" ],
      "properties": [
        {
          "name": "entries",
          "isMany": true,
          "type": "Entry"
        }
      ]
    },
    {
      "name": "Entry",
      "properties": [
        {
          "name": "key",
          "isAttr": true,
          "type": "String"
        },
        {
          "name": "value",
          "isBody": true,
          "type": "String"
        },
        {
          "name": "definition",
          "type": "InputOutputParameterDefinition"
        }
      ]
    },
    {
      "name": "Value",
      "superClass": [
        "InputOutputParameterDefinition"
      ],
      "properties": [
        {
          "name": "id",
          "isAttr": true,
          "type": "String"
        },
        {
          "name": "name",
          "isAttr": true,
          "type": "String"
        },
        {
          "name": "value",
          "isBody": true,
          "type": "String"
        }
      ]
    },
    {
      "name": "Script",
      "superClass": [ "InputOutputParameterDefinition" ],
      "properties": [
        {
          "name": "scriptFormat",
          "isAttr": true,
          "type": "String"
        },
        {
          "name": "resource",
          "isAttr": true,
          "type": "String"
        },
        {
          "name": "value",
          "isBody": true,
          "type": "String"
        }
      ]
    },
    {
      "name": "Field",
      "superClass": [ "Element" ],
      "meta": {
        "allowedIn": [
          "bpmn:ServiceTask",
          "bpmn:BusinessRuleTask",
          "bpmn:SendTask"
        ]
      },
      "properties": [
        {
          "name": "name",
          "isAttr": true,
          "type": "String"
        },
        {
          "name": "expression",
          "type": "String"
        },
        {
          "name": "stringValue",
          "isAttr": true,
          "type": "String"
        },
        {
          "name": "string",
          "type": "String"
        }
      ]
    },
    {
      "name": "InputParameter",
      "superClass": [ "InputOutputParameter" ]
    },
    {
      "name": "OutputParameter",
      "superClass": [ "InputOutputParameter" ]
    },
    {
      "name": "Collectable",
      "isAbstract": true,
      "extends": [ "bpmn:MultiInstanceLoopCharacteristics" ],
      "superClass": [ "camunda:AsyncCapable" ],
      "properties": [
        {
          "name": "collection",
          "isAttr": true,
          "type": "String"
        },
        {
          "name": "elementVariable",
          "isAttr": true,
          "type": "String"
        }
      ]
    },
    {
      "name": "FailedJobRetryTimeCycle",
      "superClass": [ "Element" ],
      "meta": {
        "allowedIn": [
          "bpmn:Task",
          "bpmn:ServiceTask",
          "bpmn:SendTask",
          "bpmn:UserTask",
          "bpmn:BusinessRuleTask",
          "bpmn:ScriptTask",
          "bpmn:ReceiveTask",
          "bpmn:CallActivity",
          "bpmn:TimerEventDefinition",
          "bpmn:SignalEventDefinition",
          "bpmn:MultiInstanceLoopCharacteristics"
        ]
      },
      "properties": [
        {
          "name": "body",
          "isBody": true,
          "type": "String"
        }
      ]
    },
    {
      "name": "ExecutionListener",
      "superClass": [ "Element" ],
      "meta": {
        "allowedIn": [
          "bpmn:Task",
          "bpmn:ServiceTask",
          "bpmn:UserTask",
          "bpmn:BusinessRuleTask",
          "bpmn:ScriptTask",
          "bpmn:ReceiveTask",
          "bpmn:ManualTask",
          "bpmn:ExclusiveGateway",
          "bpmn:SequenceFlow",
          "bpmn:ParallelGateway",
          "bpmn:InclusiveGateway",
          "bpmn:EventBasedGateway",
          "bpmn:StartEvent",
          "bpmn:IntermediateCatchEvent",
          "bpmn:IntermediateThrowEvent",
          "bpmn:EndEvent",
          "bpmn:BoundaryEvent",
          "bpmn:CallActivity",
          "bpmn:SubProcess"
        ]
      },
      "properties": [
        {
          "name": "expression",
          "isAttr": true,
          "type": "String"
        },
        {
          "name": "class",
          "isAttr": true,
          "type": "String"
        },
        {
          "name": "delegateExpression",
          "isAttr": true,
          "type": "String"
        },
        {
          "name": "event",
          "isAttr": true,
          "type": "String"
        },
        {
          "name": "script",
          "type": "Script"
        },
        {
          "name": "fields",
          "type": "Field",
          "isMany": true
        }
      ]
    },
    {
      "name": "TaskListener",
      "superClass": [ "Element" ],
      "meta": {
        "allowedIn": [
          "bpmn:UserTask"
        ]
      },
      "properties": [
        {
          "name": "expression",
          "isAttr": true,
          "type": "String"
        },
        {
          "name": "class",
          "isAttr": true,
          "type": "String"
        },
        {
          "name": "delegateExpression",
          "isAttr": true,
          "type": "String"
        },
        {
          "name": "event",
          "isAttr": true,
          "type": "String"
        },
        {
          "name": "script",
          "type": "Script"
        },
        {
          "name": "fields",
          "type": "Field",
          "isMany": true
        }
      ]
    },
    {
      "name": "FormProperty",
      "superClass": [ "Element" ],
      "meta": {
        "allowedIn": [
          "bpmn:StartEvent",
          "bpmn:UserTask"
        ]
      },
      "properties": [
        {
          "name": "id",
          "type": "String",
          "isAttr": true
        },
        {
          "name": "name",
          "type": "String",
          "isAttr": true
        },
        {
          "name": "type",
          "type": "String",
          "isAttr": true
        },
        {
          "name": "required",
          "type": "String",
          "isAttr": true
        },
        {
          "name": "readable",
          "type": "String",
          "isAttr": true
        },
        {
          "name": "writable",
          "type": "String",
          "isAttr": true
        },
        {
          "name": "variable",
          "type": "String",
          "isAttr": true
        },
        {
          "name": "expression",
          "type": "String",
          "isAttr": true
        },
        {
          "name": "datePattern",
          "type": "String",
          "isAttr": true
        },
        {
          "name": "default",
          "type": "String",
          "isAttr": true
        },
        {
          "name": "values",
          "type": "Value",
          "isMany": true
        }
      ]
    },
    {
      "name": "FormData",
      "superClass": [ "Element" ],
      "meta": {
        "allowedIn": [
          "bpmn:StartEvent",
          "bpmn:UserTask"
        ]
      },
      "properties": [
        {
          "name": "fields",
          "type": "FormField",
          "isMany": true
        },
        {
          "name": "businessKey",
          "type": "String",
          "isAttr": true
        }
      ]
    },
    {
      "name": "FormField",
      "superClass": [ "Element" ],
      "properties": [
        {
          "name": "id",
          "type": "String",
          "isAttr": true
        },
        {
          "name": "label",
          "type": "String",
          "isAttr": true
        },
        {
          "name": "type",
          "type": "String",
          "isAttr": true
        },
        {
          "name": "datePattern",
          "type": "String",
          "isAttr": true
        },
        {
          "name": "defaultValue",
          "type": "String",
          "isAttr": true
        },
        {
          "name": "properties",
          "type": "Properties"
        },
        {
          "name": "validation",
          "type": "Validation"
        },
        {
          "name": "values",
          "type": "Value",
          "isMany": true
        }
      ]
    },
    {
      "name": "Validation",
      "superClass": [ "Element" ],
      "properties": [
        {
          "name": "constraints",
          "type": "Constraint",
          "isMany": true
        }
      ]
    },
    {
      "name": "Constraint",
      "superClass": [ "Element" ],
      "properties": [
        {
          "name": "name",
          "type": "String",
          "isAttr": true
        },
        {
          "name": "config",
          "type": "String",
          "isAttr": true
        }
      ]
    },
    {
      "name": "ConditionalEventDefinition",
      "isAbstract": true,
      "extends": [
        "bpmn:ConditionalEventDefinition"
      ],
      "properties": [
        {
          "name": "variableName",
          "isAttr": true,
          "type": "String"
        },
        {
          "name": "variableEvent",
          "isAttr": true,
          "type": "String"
        }
      ]
    }
  ],
  "emumerations": [ ]
}

},{}],230:[function(require,module,exports){
'use strict';

/**
 * Module dependencies.
 */

try {
  var index = require('indexof');
} catch (err) {
  var index = require('component-indexof');
}

/**
 * Whitespace regexp.
 */

var re = /\s+/;

/**
 * toString reference.
 */

var toString = Object.prototype.toString;

/**
 * Wrap `el` in a `ClassList`.
 *
 * @param {Element} el
 * @return {ClassList}
 * @api public
 */

module.exports = function (el) {
  return new ClassList(el);
};

/**
 * Initialize a new ClassList for `el`.
 *
 * @param {Element} el
 * @api private
 */

function ClassList(el) {
  if (!el || !el.nodeType) {
    throw new Error('A DOM element reference is required');
  }
  this.el = el;
  this.list = el.classList;
}

/**
 * Add class `name` if not already present.
 *
 * @param {String} name
 * @return {ClassList}
 * @api public
 */

ClassList.prototype.add = function (name) {
  // classList
  if (this.list) {
    this.list.add(name);
    return this;
  }

  // fallback
  var arr = this.array();
  var i = index(arr, name);
  if (!~i) arr.push(name);
  this.el.className = arr.join(' ');
  return this;
};

/**
 * Remove class `name` when present, or
 * pass a regular expression to remove
 * any which match.
 *
 * @param {String|RegExp} name
 * @return {ClassList}
 * @api public
 */

ClassList.prototype.remove = function (name) {
  if ('[object RegExp]' == toString.call(name)) {
    return this.removeMatching(name);
  }

  // classList
  if (this.list) {
    this.list.remove(name);
    return this;
  }

  // fallback
  var arr = this.array();
  var i = index(arr, name);
  if (~i) arr.splice(i, 1);
  this.el.className = arr.join(' ');
  return this;
};

/**
 * Remove all classes matching `re`.
 *
 * @param {RegExp} re
 * @return {ClassList}
 * @api private
 */

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;
};

/**
 * 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
 */

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;
  }

  // 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);
    }
  }

  return this;
};

/**
 * Return an array of classes.
 *
 * @return {Array}
 * @api public
 */

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;
};

/**
 * Check if class `name` is present.
 *
 * @param {String} name
 * @return {ClassList}
 * @api public
 */

ClassList.prototype.has = ClassList.prototype.contains = function (name) {
  return this.list ? this.list.contains(name) : !!~index(this.array(), name);
};

},{"component-indexof":234,"indexof":234}],231:[function(require,module,exports){
'use strict';

var matches = require('matches-selector');

module.exports = function (element, selector, checkYoSelf, root) {
  element = checkYoSelf ? { parentNode: element } : element;

  root = root || document;

  // Make sure `element !== document` and `element != null`
  // otherwise we get an illegal invocation
  while ((element = element.parentNode) && element !== document) {
    if (matches(element, selector)) return element;
    // After `matches` on the edge case that
    // the selector matches the root
    // (when the root is not the document)
    if (element === root) return;
  }
};

},{"matches-selector":235}],232:[function(require,module,exports){
'use strict';

/**
 * Module dependencies.
 */

try {
  var closest = require('closest');
} catch (err) {
  var closest = require('component-closest');
}

try {
  var event = require('event');
} catch (err) {
  var event = require('component-event');
}

/**
 * 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
 */

exports.bind = function (el, selector, type, fn, capture) {
  return event.bind(el, type, function (e) {
    var target = e.target || e.srcElement;
    e.delegateTarget = closest(target, selector, true, el);
    if (e.delegateTarget) fn.call(el, e);
  }, capture);
};

/**
 * Unbind event `type`'s callback `fn`.
 *
 * @param {Element} el
 * @param {String} type
 * @param {Function} fn
 * @param {Boolean} capture
 * @api public
 */

exports.unbind = function (el, type, fn, capture) {
  event.unbind(el, type, fn, capture);
};

},{"closest":231,"component-closest":231,"component-event":233,"event":233}],233:[function(require,module,exports){
'use strict';

var bind = window.addEventListener ? 'addEventListener' : 'attachEvent',
    unbind = window.removeEventListener ? 'removeEventListener' : 'detachEvent',
    prefix = bind !== 'addEventListener' ? 'on' : '';

/**
 * Bind `el` event `type` to `fn`.
 *
 * @param {Element} el
 * @param {String} type
 * @param {Function} fn
 * @param {Boolean} capture
 * @return {Function}
 * @api public
 */

exports.bind = function (el, type, fn, capture) {
  el[bind](prefix + type, fn, capture || false);
  return fn;
};

/**
 * Unbind `el` event `type`'s callback `fn`.
 *
 * @param {Element} el
 * @param {String} type
 * @param {Function} fn
 * @param {Boolean} capture
 * @return {Function}
 * @api public
 */

exports.unbind = function (el, type, fn, capture) {
  el[unbind](prefix + type, fn, capture || false);
  return fn;
};

},{}],234:[function(require,module,exports){
"use strict";

module.exports = function (arr, obj) {
  if (arr.indexOf) return arr.indexOf(obj);
  for (var i = 0; i < arr.length; ++i) {
    if (arr[i] === obj) return i;
  }
  return -1;
};

},{}],235:[function(require,module,exports){
'use strict';

/**
 * Module dependencies.
 */

try {
  var query = require('query');
} catch (err) {
  var query = require('component-query');
}

/**
 * Element prototype.
 */

var proto = Element.prototype;

/**
 * Vendor function.
 */

var vendor = proto.matches || proto.webkitMatchesSelector || proto.mozMatchesSelector || proto.msMatchesSelector || proto.oMatchesSelector;

/**
 * Expose `match()`.
 */

module.exports = match;

/**
 * Match `el` to `selector`.
 *
 * @param {Element} el
 * @param {String} selector
 * @return {Boolean}
 * @api public
 */

function match(el, selector) {
  if (!el || el.nodeType !== 1) return false;
  if (vendor) return vendor.call(el, selector);
  var nodes = query.all(selector, el.parentNode);
  for (var i = 0; i < nodes.length; ++i) {
    if (nodes[i] == el) return true;
  }
  return false;
}

},{"component-query":236,"query":236}],236:[function(require,module,exports){
'use strict';

function one(selector, el) {
  return el.querySelector(selector);
}

exports = module.exports = function (selector, el) {
  el = el || document;
  return one(selector, el);
};

exports.all = function (selector, el) {
  el = el || document;
  return el.querySelectorAll(selector);
};

exports.engine = function (obj) {
  if (!obj.one) throw new Error('.one callback required');
  if (!obj.all) throw new Error('.all callback required');
  one = obj.one;
  exports.all = obj.all;
  return exports;
};

},{}],237:[function(require,module,exports){
(function (global){
'use strict';

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

/*! https://mths.be/cssescape v1.5.1 by @mathias | MIT license */
;(function (root, factory) {
	// https://github.com/umdjs/umd/blob/master/returnExports.js
	if ((typeof exports === 'undefined' ? 'undefined' : _typeof(exports)) == 'object') {
		// For Node.js.
		module.exports = factory(root);
	} else if (typeof define == 'function' && define.amd) {
		// For AMD. Register as an anonymous module.
		define([], factory.bind(root, root));
	} else {
		// For browser globals (not exposing the function separately).
		factory(root);
	}
})(typeof global != 'undefined' ? global : undefined, function (root) {

	if (root.CSS && root.CSS.escape) {
		return root.CSS.escape;
	}

	// https://drafts.csswg.org/cssom/#serialize-an-identifier
	var cssEscape = function cssEscape(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.

			// If the character is NULL (U+0000), then the REPLACEMENT CHARACTER
			// (U+FFFD).
			if (codeUnit == 0x0000) {
				result += '\uFFFD';
				continue;
			}

			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;
			}

			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;
			}

			// 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;
			}

			// Otherwise, the escaped character.
			// https://drafts.csswg.org/cssom/#escape-a-character
			result += '\\' + string.charAt(index);
		}
		return result;
	};

	if (!root.CSS) {
		root.CSS = {};
	}

	root.CSS.escape = cssEscape;
	return cssEscape;
});

}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})

},{}],238:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _interactionEvents = require('diagram-js/lib/features/interaction-events');

var _interactionEvents2 = _interopRequireDefault(_interactionEvents);

var _DirectEditing = require('./lib/DirectEditing');

var _DirectEditing2 = _interopRequireDefault(_DirectEditing);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __depends__: [_interactionEvents2.default],
  __init__: ['directEditing'],
  directEditing: ['type', _DirectEditing2.default]
};

},{"./lib/DirectEditing":239,"diagram-js/lib/features/interaction-events":294}],239:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = DirectEditing;

var _minDash = require('min-dash');

var _TextBox = require('./TextBox');

var _TextBox2 = _interopRequireDefault(_TextBox);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * 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) {

  this._eventBus = eventBus;

  this._providers = [];
  this._textbox = new _TextBox2.default({
    container: canvas.getContainer(),
    keyHandler: (0, _minDash.bind)(this._handleKey, this),
    resizeHandler: (0, _minDash.bind)(this._handleResize, this)
  });
}

DirectEditing.$inject = ['eventBus', 'canvas'];

/**
 * Register a direct editing provider

 * @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);
};

/**
 * Returns true if direct editing is currently active
 *
 * @return {Boolean}
 */
DirectEditing.prototype.isActive = function () {
  return !!this._active;
};

/**
 * Cancel direct editing, if it is currently active
 */
DirectEditing.prototype.cancel = function () {
  if (!this._active) {
    return;
  }

  this._fire('cancel');
  this.close();
};

DirectEditing.prototype._fire = function (event, context) {
  this._eventBus.fire('directEditing.' + event, context || { active: this._active });
};

DirectEditing.prototype.close = function () {
  this._textbox.destroy();

  this._fire('deactivate');

  this._active = null;

  this.resizable = undefined;
};

DirectEditing.prototype.complete = function () {

  var active = this._active;

  if (!active) {
    return;
  }

  var text = this.getValue();

  var bounds = this.$textbox.getBoundingClientRect();

  if (text !== active.context.text || this.resizable) {
    active.provider.update(active.element, text, active.context.text, {
      x: bounds.top,
      y: bounds.left,
      width: bounds.width,
      height: bounds.height
    });
  }

  this._fire('complete');

  this.close();
};

DirectEditing.prototype.getValue = function () {
  return this._textbox.getValue();
};

DirectEditing.prototype._handleKey = function (e) {

  // stop bubble
  e.stopPropagation();

  var key = e.keyCode || e.charCode;

  // ESC
  if (key === 27) {
    e.preventDefault();
    return this.cancel();
  }

  // Enter
  if (key === 13 && !e.shiftKey) {
    e.preventDefault();
    return this.complete();
  }
};

DirectEditing.prototype._handleResize = function (event) {
  this._fire('resize', event);
};

/**
 * 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();
  }

  // the direct editing context
  var context;

  var provider = (0, _minDash.find)(this._providers, function (p) {
    return (context = p.activate(element)) ? p : null;
  });

  // check if activation took place
  if (context) {
    this.$textbox = this._textbox.create(context.bounds, context.style, context.text, context.options);

    this._active = {
      element: element,
      context: context,
      provider: provider
    };

    if (context.options && context.options.resizable) {
      this.resizable = true;
    }

    this._fire('activate');
  }

  return !!context;
};

},{"./TextBox":240,"min-dash":505}],240:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = TextBox;

var _minDash = require('min-dash');

var _minDom = require('min-dom');

var min = Math.min,
    max = Math.max;

function preventDefault(e) {
  e.preventDefault();
}

function stopPropagation(e) {
  e.stopPropagation();
}

function isTextNode(node) {
  return node.nodeType === Node.TEXT_NODE;
}

function toArray(nodeList) {
  return [].slice.call(nodeList);
}

/**
 * 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;

  this.parent = (0, _minDom.domify)('<div class="djs-direct-editing-parent">' + '<div class="djs-direct-editing-content" contenteditable="true"></div>' + '</div>');

  this.content = (0, _minDom.query)('[contenteditable]', this.parent);

  this.keyHandler = options.keyHandler || function () {};
  this.resizeHandler = options.resizeHandler || function () {};

  this.autoResize = (0, _minDash.bind)(this.autoResize, this);
  this.handlePaste = (0, _minDash.bind)(this.handlePaste, this);
}

/**
 * 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;

  var parent = this.parent,
      content = this.content,
      container = this.container;

  options = this.options = options || {};

  style = this.style = style || {};

  var parentStyle = (0, _minDash.pick)(style, ['width', 'height', 'maxWidth', 'maxHeight', 'minWidth', 'minHeight', 'left', 'top', 'backgroundColor', 'position', 'overflow', 'border', 'wordWrap', 'textAlign', 'outline', 'transform']);

  (0, _minDash.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);

  var contentStyle = (0, _minDash.pick)(style, ['fontFamily', 'fontSize', 'fontWeight', 'lineHeight', 'padding', 'paddingTop', 'paddingRight', 'paddingBottom', 'paddingLeft']);

  (0, _minDash.assign)(content.style, {
    boxSizing: 'border-box',
    width: '100%',
    outline: 'none',
    wordWrap: 'break-word'
  }, contentStyle);

  if (options.centerVertically) {
    (0, _minDash.assign)(content.style, {
      position: 'absolute',
      top: '50%',
      transform: 'translate(0, -50%)'
    }, contentStyle);
  }

  content.innerText = value;

  _minDom.event.bind(content, 'keydown', this.keyHandler);
  _minDom.event.bind(content, 'mousedown', stopPropagation);
  _minDom.event.bind(content, 'paste', self.handlePaste);

  if (options.autoResize) {
    _minDom.event.bind(content, 'input', this.autoResize);
  }

  if (options.resizable) {
    this.resizable(style);
  }

  container.appendChild(parent);

  // set selection to end of text
  this.setSelection(content.lastChild, content.lastChild && content.lastChild.length);

  return parent;
};

/**
 * Intercept paste events to remove formatting from pasted text.
 */
TextBox.prototype.handlePaste = function (e) {
  var self = this;

  var options = this.options,
      style = this.style;

  e.preventDefault();

  var text;

  if (e.clipboardData) {

    // Chrome, Firefox, Safari
    text = e.clipboardData.getData('text/plain');
  } else {

    // Internet Explorer
    text = window.clipboardData.getData('Text');
  }

  // insertHTML command not supported by Internet Explorer
  var success = document.execCommand('insertHTML', false, text);

  if (!success) {

    // Internet Explorer
    var range = this.getSelection(),
        startContainer = range.startContainer,
        endContainer = range.endContainer,
        startOffset = range.startOffset,
        endOffset = range.endOffset,
        commonAncestorContainer = range.commonAncestorContainer;

    var childNodesArray = toArray(commonAncestorContainer.childNodes);

    var container, offset;

    if (isTextNode(commonAncestorContainer)) {
      var containerTextContent = startContainer.textContent;

      startContainer.textContent = containerTextContent.substring(0, startOffset) + text + containerTextContent.substring(endOffset);

      container = startContainer;
      offset = startOffset + text.length;
    } else if (startContainer === this.content && endContainer === this.content) {
      var textNode = document.createTextNode(text);

      this.content.insertBefore(textNode, childNodesArray[startOffset]);

      container = textNode;
      offset = textNode.textContent.length;
    } else {
      var startContainerChildIndex = childNodesArray.indexOf(startContainer),
          endContainerChildIndex = childNodesArray.indexOf(endContainer);

      childNodesArray.forEach(function (childNode, index) {

        if (index === startContainerChildIndex) {
          childNode.textContent = startContainer.textContent.substring(0, startOffset) + text + endContainer.textContent.substring(endOffset);
        } else if (index > startContainerChildIndex && index <= endContainerChildIndex) {
          (0, _minDom.remove)(childNode);
        }
      });

      container = startContainer;
      offset = startOffset + text.length;
    }

    if (container && offset !== undefined) {

      // is necessary in Internet Explorer
      setTimeout(function () {
        self.setSelection(container, offset);
      });
    }
  }

  if (options.autoResize) {
    var hasResized = this.autoResize(style);

    if (hasResized) {
      this.resizeHandler(hasResized);
    }
  }
};

/**
 * Automatically resize element vertically to fit its content.
 */
TextBox.prototype.autoResize = function () {
  var parent = this.parent,
      content = this.content;

  var fontSize = parseInt(this.style.fontSize) || 12;

  if (content.scrollHeight > parent.offsetHeight || content.scrollHeight < parent.offsetHeight - fontSize) {
    var bounds = parent.getBoundingClientRect();

    var height = content.scrollHeight;
    parent.style.height = height + 'px';

    this.resizeHandler({
      width: bounds.width,
      height: bounds.height,
      dx: 0,
      dy: height - bounds.height
    });
  }
};

/**
 * Make an element resizable by adding a resize handle.
 */
TextBox.prototype.resizable = function () {
  var self = this;

  var parent = this.parent,
      resizeHandle = this.resizeHandle;

  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;

  if (!resizeHandle) {
    resizeHandle = this.resizeHandle = (0, _minDom.domify)('<div class="djs-direct-editing-resize-handle"></div>');

    var startX, startY, startWidth, startHeight;

    var onMouseDown = function onMouseDown(e) {
      preventDefault(e);
      stopPropagation(e);

      startX = e.clientX;
      startY = e.clientY;

      var bounds = parent.getBoundingClientRect();

      startWidth = bounds.width;
      startHeight = bounds.height;

      _minDom.event.bind(document, 'mousemove', onMouseMove);
      _minDom.event.bind(document, 'mouseup', onMouseUp);
    };

    var onMouseMove = function onMouseMove(e) {
      preventDefault(e);
      stopPropagation(e);

      var newWidth = min(max(startWidth + e.clientX - startX, minWidth), maxWidth);
      var newHeight = min(max(startHeight + e.clientY - startY, minHeight), maxHeight);

      parent.style.width = newWidth + 'px';
      parent.style.height = newHeight + 'px';

      self.resizeHandler({
        width: startWidth,
        height: startHeight,
        dx: e.clientX - startX,
        dy: e.clientY - startY
      });
    };

    var onMouseUp = function onMouseUp(e) {
      preventDefault(e);
      stopPropagation(e);

      _minDom.event.unbind(document, 'mousemove', onMouseMove, false);
      _minDom.event.unbind(document, 'mouseup', onMouseUp, false);
    };

    _minDom.event.bind(resizeHandle, 'mousedown', onMouseDown);
  }

  (0, _minDash.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'
  });

  parent.appendChild(resizeHandle);
};

/**
 * 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;

  // clear content
  content.innerText = '';

  // clear styles
  parent.removeAttribute('style');
  content.removeAttribute('style');

  _minDom.event.unbind(content, 'keydown', this.keyHandler);
  _minDom.event.unbind(content, 'mousedown', stopPropagation);
  _minDom.event.unbind(content, 'input', this.autoResize);
  _minDom.event.unbind(content, 'paste', this.handlePaste);

  if (resizeHandle) {
    resizeHandle.removeAttribute('style');

    (0, _minDom.remove)(resizeHandle);
  }

  (0, _minDom.remove)(parent);
};

TextBox.prototype.getValue = function () {
  return this.content.innerText;
};

TextBox.prototype.getSelection = function () {
  var selection = window.getSelection(),
      range = selection.getRangeAt(0);

  return range;
};

TextBox.prototype.setSelection = function (container, offset) {
  var range = document.createRange();

  if (container === null) {
    range.selectNodeContents(this.content);
  } else {
    range.setStart(container, offset);
    range.setEnd(container, offset);
  }

  var selection = window.getSelection();

  selection.removeAllRanges();
  selection.addRange(range);
};

},{"min-dash":505,"min-dom":506}],241:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _Diagram = require('./lib/Diagram');

Object.defineProperty(exports, 'default', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_Diagram).default;
  }
});

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

},{"./lib/Diagram":242}],242:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = Diagram;

var _didi = require('didi');

var _core = require('./core');

var _core2 = _interopRequireDefault(_core);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * 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) {

  var modules = [],
      components = [];

  function hasModule(m) {
    return modules.indexOf(m) >= 0;
  }

  function addModule(m) {
    modules.push(m);
  }

  function visit(m) {
    if (hasModule(m)) {
      return;
    }

    (m.__depends__ || []).forEach(visit);

    if (hasModule(m)) {
      return;
    }

    addModule(m);

    (m.__init__ || []).forEach(function (c) {
      components.push(c);
    });
  }

  bootstrapModules.forEach(visit);

  var injector = new _didi.Injector(modules);

  components.forEach(function (c) {

    try {
      // 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);

      throw e;
    }
  });

  return injector;
}

/**
 * Creates an injector from passed options.
 *
 * @ignore
 * @param  {Object} options
 * @return {didi.Injector}
 */
function createInjector(options) {

  options = options || {};

  var configModule = {
    'config': ['value', options]
  };

  var modules = [configModule, _core2.default].concat(options.modules || []);

  return bootstrap(modules);
}

/**
 * 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) {

  // create injector unless explicitly specified
  this.injector = injector = injector || createInjector(options);

  // API

  /**
   * 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;

  /**
   * 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;

  // init

  // indicate via event


  /**
   * 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');
}

/**
 * Destroys the diagram
 *
 * @method  Diagram#destroy
 */
Diagram.prototype.destroy = function () {
  this.get('eventBus').fire('diagram.destroy');
};

/**
 * Clear the diagram, removing all contents.
 */
Diagram.prototype.clear = function () {
  this.get('eventBus').fire('diagram.clear');
};

},{"./core":251,"didi":410}],243:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = CommandInterceptor;

var _minDash = require('min-dash');

var DEFAULT_PRIORITY = 1000;

/**
 * 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;
}

CommandInterceptor.$inject = ['eventBus'];

function unwrapEvent(fn, that) {
  return function (event) {
    return fn.call(that || null, event.context, event.command, event);
  };
}

/**
 * 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) {

  if ((0, _minDash.isFunction)(hook) || (0, _minDash.isNumber)(hook)) {
    that = unwrap;
    unwrap = handlerFn;
    handlerFn = priority;
    priority = hook;
    hook = null;
  }

  if ((0, _minDash.isFunction)(priority)) {
    that = unwrap;
    unwrap = handlerFn;
    handlerFn = priority;
    priority = DEFAULT_PRIORITY;
  }

  if ((0, _minDash.isObject)(unwrap)) {
    that = unwrap;
    unwrap = false;
  }

  if (!(0, _minDash.isFunction)(handlerFn)) {
    throw new Error('handlerFn must be a function');
  }

  if (!(0, _minDash.isArray)(events)) {
    events = [events];
  }

  var eventBus = this._eventBus;

  (0, _minDash.forEach)(events, function (event) {
    // concat commandStack(.event)?(.hook)?
    var fullEvent = ['commandStack', event, hook].filter(function (e) {
      return e;
    }).join('.');

    eventBus.on(fullEvent, priority, unwrap ? unwrapEvent(handlerFn, that) : handlerFn, that);
  });
};

var hooks = ['canExecute', 'preExecute', 'preExecuted', 'execute', 'executed', 'postExecute', 'postExecuted', 'revert', 'reverted'];

/*
 * Install hook shortcuts
 *
 * This will generate the CommandInterceptor#(preExecute|...|reverted) methods
 * which will in term forward to CommandInterceptor#on.
 */
(0, _minDash.forEach)(hooks, function (hook) {

  /**
   * {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) {

    if ((0, _minDash.isFunction)(events) || (0, _minDash.isNumber)(events)) {
      that = unwrap;
      unwrap = handlerFn;
      handlerFn = priority;
      priority = events;
      events = null;
    }

    this.on(events, hook, priority, handlerFn, unwrap, that);
  };
});

},{"min-dash":505}],244:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = CommandStack;

var _minDash = require('min-dash');

/**
 * 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) {

  /**
   * A map of all registered command handlers.
   *
   * @type {Object}
   */
  this._handlerMap = {};

  /**
   * A stack containing all re/undoable actions on the diagram
   *
   * @type {Array<Object>}
   */
  this._stack = [];

  /**
   * The current index on the stack
   *
   * @type {Number}
   */
  this._stackIdx = -1;

  /**
   * Current active commandStack execution
   *
   * @type {Object}
   */
  this._currentExecution = {
    actions: [],
    dirty: []
  };

  this._injector = injector;
  this._eventBus = eventBus;

  this._uid = 1;

  eventBus.on(['diagram.destroy', 'diagram.clear'], function () {
    this.clear(false);
  }, this);
}

CommandStack.$inject = ['eventBus', 'injector'];

/**
 * 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');
  }

  var action = { command: command, context: context };

  this._pushAction(action);
  this._internalExecute(action);
  this._popAction(action);
};

/**
 * 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) {

  var action = { command: command, context: context };

  var handler = this._getHandler(command);

  var result = this._fire(command, 'canExecute', action);

  // handler#canExecute will only be called if no listener
  // decided on a result already
  if (result === undefined) {
    if (!handler) {
      return false;
    }

    if (handler.canExecute) {
      result = handler.canExecute(context);
    }
  }

  return result;
};

/**
 * Clear the command stack, erasing all undo / redo history
 */
CommandStack.prototype.clear = function (emit) {
  this._stack.length = 0;
  this._stackIdx = -1;

  if (emit !== false) {
    this._fire('changed');
  }
};

/**
 * Undo last command(s)
 */
CommandStack.prototype.undo = function () {
  var action = this._getUndoAction(),
      next;

  if (action) {
    this._pushAction(action);

    while (action) {
      this._internalUndo(action);
      next = this._getUndoAction();

      if (!next || next.id !== action.id) {
        break;
      }

      action = next;
    }

    this._popAction();
  }
};

/**
 * Redo last command(s)
 */
CommandStack.prototype.redo = function () {
  var action = this._getRedoAction(),
      next;

  if (action) {
    this._pushAction(action);

    while (action) {
      this._internalExecute(action, true);
      next = this._getRedoAction();

      if (!next || next.id !== action.id) {
        break;
      }

      action = next;
    }

    this._popAction();
  }
};

/**
 * Register a handler instance with the command stack
 *
 * @param {String} command
 * @param {CommandHandler} handler
 */
CommandStack.prototype.register = function (command, handler) {
  this._setHandler(command, handler);
};

/**
 * Register a handler type with the command stack
 * by instantiating it and injecting its dependencies.
 *
 * @param {String} command
 * @param {Function} a constructor for a {@link CommandHandler}
 */
CommandStack.prototype.registerHandler = function (command, handlerCls) {

  if (!command || !handlerCls) {
    throw new Error('command and handlerCls must be defined');
  }

  var handler = this._injector.instantiate(handlerCls);
  this.register(command, handler);
};

CommandStack.prototype.canUndo = function () {
  return !!this._getUndoAction();
};

CommandStack.prototype.canRedo = function () {
  return !!this._getRedoAction();
};

// stack access  //////////////////////

CommandStack.prototype._getRedoAction = function () {
  return this._stack[this._stackIdx + 1];
};

CommandStack.prototype._getUndoAction = function () {
  return this._stack[this._stackIdx];
};

// internal functionality //////////////////////

CommandStack.prototype._internalUndo = function (action) {
  var self = this;

  var command = action.command,
      context = action.context;

  var handler = this._getHandler(command);

  // guard against illegal nested command stack invocations
  this._atomicDo(function () {
    self._fire(command, 'revert', action);

    if (handler.revert) {
      self._markDirty(handler.revert(context));
    }

    self._revertedAction(action);

    self._fire(command, 'reverted', action);
  });
};

CommandStack.prototype._fire = function (command, qualifier, event) {
  if (arguments.length < 3) {
    event = qualifier;
    qualifier = null;
  }

  var names = qualifier ? [command + '.' + qualifier, qualifier] : [command],
      i,
      name,
      result;

  event = this._eventBus.createEvent(event);

  for (i = 0; name = names[i]; i++) {
    result = this._eventBus.fire('commandStack.' + name, event);

    if (event.cancelBubble) {
      break;
    }
  }

  return result;
};

CommandStack.prototype._createId = function () {
  return this._uid++;
};

CommandStack.prototype._atomicDo = function (fn) {

  var execution = this._currentExecution;

  execution.atomic = true;

  try {
    fn();
  } finally {
    execution.atomic = false;
  }
};

CommandStack.prototype._internalExecute = function (action, redo) {
  var self = this;

  var command = action.command,
      context = action.context;

  var handler = this._getHandler(command);

  if (!handler) {
    throw new Error('no command handler registered for <' + command + '>');
  }

  this._pushAction(action);

  if (!redo) {
    this._fire(command, 'preExecute', action);

    if (handler.preExecute) {
      handler.preExecute(context);
    }

    this._fire(command, 'preExecuted', action);
  }

  // guard against illegal nested command stack invocations
  this._atomicDo(function () {

    self._fire(command, 'execute', action);

    if (handler.execute) {
      // actual execute + mark return results as dirty
      self._markDirty(handler.execute(context));
    }

    // log to stack
    self._executedAction(action, redo);

    self._fire(command, 'executed', action);
  });

  if (!redo) {
    this._fire(command, 'postExecute', action);

    if (handler.postExecute) {
      handler.postExecute(context);
    }

    this._fire(command, 'postExecuted', action);
  }

  this._popAction(action);
};

CommandStack.prototype._pushAction = function (action) {

  var execution = this._currentExecution,
      actions = execution.actions;

  var baseAction = actions[0];

  if (execution.atomic) {
    throw new Error('illegal invocation in <execute> or <revert> phase (action: ' + action.command + ')');
  }

  if (!action.id) {
    action.id = baseAction && baseAction.id || this._createId();
  }

  actions.push(action);
};

CommandStack.prototype._popAction = function () {
  var execution = this._currentExecution,
      actions = execution.actions,
      dirty = execution.dirty;

  actions.pop();

  if (!actions.length) {
    this._eventBus.fire('elements.changed', { elements: (0, _minDash.uniqueBy)('id', dirty) });

    dirty.length = 0;

    this._fire('changed');
  }
};

CommandStack.prototype._markDirty = function (elements) {
  var execution = this._currentExecution;

  if (!elements) {
    return;
  }

  elements = (0, _minDash.isArray)(elements) ? elements : [elements];

  execution.dirty = execution.dirty.concat(elements);
};

CommandStack.prototype._executedAction = function (action, redo) {
  var stackIdx = ++this._stackIdx;

  if (!redo) {
    this._stack.splice(stackIdx, this._stack.length, action);
  }
};

CommandStack.prototype._revertedAction = function (action) {
  this._stackIdx--;
};

CommandStack.prototype._getHandler = function (command) {
  return this._handlerMap[command];
};

CommandStack.prototype._setHandler = function (command, handler) {
  if (!command || !handler) {
    throw new Error('command and handler required');
  }

  if (this._handlerMap[command]) {
    throw new Error('overriding handler for command <' + command + '>');
  }

  this._handlerMap[command] = handler;
};

},{"min-dash":505}],245:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _CommandStack = require('./CommandStack');

var _CommandStack2 = _interopRequireDefault(_CommandStack);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  commandStack: ['type', _CommandStack2.default]
};

},{"./CommandStack":244}],246:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

exports.default = Canvas;

var _minDash = require('min-dash');

var _Collections = require('../util/Collections');

var _Elements = require('../util/Elements');

var _tinySvg = require('tiny-svg');

function round(number, resolution) {
  return Math.round(number * resolution) / resolution;
}

function ensurePx(number) {
  return (0, _minDash.isNumber)(number) ? number + 'px' : number;
}

/**
 * Creates a HTML container element for a SVG element with
 * the given configuration
 *
 * @param  {Object} options
 * @return {HTMLElement} the container element
 */
function createContainer(options) {

  options = (0, _minDash.assign)({}, { width: '100%', height: '100%' }, options);

  var container = options.container || document.body;

  // 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');

  (0, _minDash.assign)(parent.style, {
    position: 'relative',
    overflow: 'hidden',
    width: ensurePx(options.width),
    height: ensurePx(options.height)
  });

  container.appendChild(parent);

  return parent;
}

function createGroup(parent, cls, childIndex) {
  var group = (0, _tinySvg.create)('g');
  (0, _tinySvg.classes)(group).add(cls);

  var index = childIndex !== undefined ? childIndex : parent.childNodes.length - 1;

  // 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);

  return group;
}

var BASE_LAYER = 'base';

var REQUIRED_MODEL_ATTRS = {
  shape: ['x', 'y', 'width', 'height'],
  connection: ['waypoints']
};

/**
 * 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) {

  this._eventBus = eventBus;
  this._elementRegistry = elementRegistry;
  this._graphicsFactory = graphicsFactory;

  this._init(config || {});
}

Canvas.$inject = ['config.canvas', 'eventBus', 'graphicsFactory', 'elementRegistry'];

Canvas.prototype._init = function (config) {

  var eventBus = this._eventBus;

  // 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.
  //
  // (It is not possible to get the size of a svg element cross browser @ 2014-04-01)
  //
  // <div class="djs-container" style="width: {desired-width}, height: {desired-height}">
  //   <svg width="100%" height="100%">
  //    ...
  //   </svg>
  // </div>

  // html container
  var container = this._container = createContainer(config);

  var svg = this._svg = (0, _tinySvg.create)('svg');
  (0, _tinySvg.attr)(svg, { width: '100%', height: '100%' });

  (0, _tinySvg.append)(container, svg);

  var viewport = this._viewport = createGroup(svg, 'viewport');

  this._layers = {};

  // debounce canvas.viewbox.changed events
  // for smoother diagram interaction
  if (config.deferUpdate !== false) {
    this._viewboxChanged = (0, _minDash.debounce)((0, _minDash.bind)(this._viewboxChanged, this), 300);
  }

  eventBus.on('diagram.init', function () {

    /**
     * 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
    });
  }, this);

  // reset viewbox on shape changes to
  // recompute the viewbox
  eventBus.on(['shape.added', 'connection.added', 'shape.removed', 'connection.removed', 'elements.changed'], function () {
    delete this._cachedViewbox;
  }, this);

  eventBus.on('diagram.destroy', 500, this._destroy, this);
  eventBus.on('diagram.clear', 500, this._clear, this);
};

Canvas.prototype._destroy = function (emit) {
  this._eventBus.fire('canvas.destroy', {
    svg: this._svg,
    viewport: this._viewport
  });

  var parent = this._container.parentNode;

  if (parent) {
    parent.removeChild(this._container);
  }

  delete this._svg;
  delete this._container;
  delete this._layers;
  delete this._rootElement;
  delete this._viewport;
};

Canvas.prototype._clear = function () {

  var self = this;

  var allElements = this._elementRegistry.getAll();

  // remove all elements
  allElements.forEach(function (element) {
    var type = (0, _Elements.getType)(element);

    if (type === 'root') {
      self.setRootElement(null, true);
    } else {
      self._removeElement(element, type);
    }
  });

  // force recomputation of view box
  delete this._cachedViewbox;
};

/**
 * Returns the default layer on which
 * all elements are drawn.
 *
 * @returns {SVGElement}
 */
Canvas.prototype.getDefaultLayer = function () {
  return this.getLayer(BASE_LAYER, 0);
};

/**
 * 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) {

  if (!name) {
    throw new Error('must specify a name');
  }

  var layer = this._layers[name];

  if (!layer) {
    layer = this._layers[name] = this._createLayer(name, index);
  }

  // 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 + '>');
  }

  return layer.group;
};

/**
 * 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) {

  if (!index) {
    index = 0;
  }

  var childIndex = (0, _minDash.reduce)(this._layers, function (childIndex, layer) {
    if (index >= layer.index) {
      childIndex++;
    }

    return childIndex;
  }, 0);

  return {
    group: createGroup(this._viewport, 'layer-' + name, childIndex),
    index: index
  };
};

/**
 * Returns the html element that encloses the
 * drawing canvas.
 *
 * @return {DOMNode}
 */
Canvas.prototype.getContainer = function () {
  return this._container;
};

// markers //////////////////////

Canvas.prototype._updateMarker = function (element, marker, add) {
  var container;

  if (!element.id) {
    element = this._elementRegistry.get(element);
  }

  // we need to access all
  container = this._elementRegistry._elements[element.id];

  if (!container) {
    return;
  }

  (0, _minDash.forEach)([container.gfx, container.secondaryGfx], function (gfx) {
    if (gfx) {
      // invoke either addClass or removeClass based on mode
      if (add) {
        (0, _tinySvg.classes)(gfx).add(marker);
      } else {
        (0, _tinySvg.classes)(gfx).remove(marker);
      }
    }
  });

  /**
   * 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 });
};

/**
 * 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);
};

/**
 * 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);
};

/**
 * 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);
  }

  var gfx = this.getGraphics(element);

  return (0, _tinySvg.classes)(gfx).has(marker);
};

/**
 * 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);
  }
};

Canvas.prototype.getRootElement = function () {
  if (!this._rootElement) {
    this.setRootElement({ id: '__implicitroot', children: [] });
  }

  return this._rootElement;
};

// root element handling //////////////////////

/**
 * Sets a given element as the new root element for the canvas
 * and returns the new root element.
 *
 * @param {Object|djs.model.Root} element
 * @param {Boolean} [override] whether to override the current root element, if any
 *
 * @return {Object|djs.model.Root} new root element
 */
Canvas.prototype.setRootElement = function (element, override) {

  if (element) {
    this._ensureValid('root', element);
  }

  var currentRoot = this._rootElement,
      elementRegistry = this._elementRegistry,
      eventBus = this._eventBus;

  if (currentRoot) {
    if (!override) {
      throw new Error('rootElement already set, need to specify override');
    }

    // simulate element remove event sequence
    eventBus.fire('root.remove', { element: currentRoot });
    eventBus.fire('root.removed', { element: currentRoot });

    elementRegistry.remove(currentRoot);
  }

  if (element) {
    var gfx = this.getDefaultLayer();

    // resemble element add event sequence
    eventBus.fire('root.add', { element: element });

    elementRegistry.add(element, gfx, this._svg);

    eventBus.fire('root.added', { element: element, gfx: gfx });
  }

  this._rootElement = element;

  return element;
};

// add functionality //////////////////////

Canvas.prototype._ensureValid = function (type, element) {
  if (!element.id) {
    throw new Error('element must have an id');
  }

  if (this._elementRegistry.get(element.id)) {
    throw new Error('element with id ' + element.id + ' already exists');
  }

  var requiredAttrs = REQUIRED_MODEL_ATTRS[type];

  var valid = (0, _minDash.every)(requiredAttrs, function (attr) {
    return typeof element[attr] !== 'undefined';
  });

  if (!valid) {
    throw new Error('must supply { ' + requiredAttrs.join(', ') + ' } with ' + type);
  }
};

Canvas.prototype._setParent = function (element, parent, parentIndex) {
  (0, _Collections.add)(parent.children, element, parentIndex);
  element.parent = parent;
};

/**
 * 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) {

  parent = parent || this.getRootElement();

  var eventBus = this._eventBus,
      graphicsFactory = this._graphicsFactory;

  this._ensureValid(type, element);

  eventBus.fire(type + '.add', { element: element, parent: parent });

  this._setParent(element, parent, parentIndex);

  // create graphics
  var gfx = graphicsFactory.create(type, element, parentIndex);

  this._elementRegistry.add(element, gfx);

  // update its visual
  graphicsFactory.update(type, element, gfx);

  eventBus.fire(type + '.added', { element: element, gfx: gfx });

  return element;
};

/**
 * 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);
};

/**
 * 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);
};

/**
 * Internal remove element
 */
Canvas.prototype._removeElement = function (element, type) {

  var elementRegistry = this._elementRegistry,
      graphicsFactory = this._graphicsFactory,
      eventBus = this._eventBus;

  element = elementRegistry.get(element.id || element);

  if (!element) {
    // element was removed already
    return;
  }

  eventBus.fire(type + '.remove', { element: element });

  graphicsFactory.remove(element);

  // unset parent <-> child relationship
  (0, _Collections.remove)(element.parent && element.parent.children, element);
  element.parent = null;

  eventBus.fire(type + '.removed', { element: element });

  elementRegistry.remove(element);

  return element;
};

/**
 * 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) {

  /**
   * 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
   */

  /**
   * 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');
};

/**
 * 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) {

  /**
   * 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
   */

  /**
   * 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');
};

/**
 * 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);
};

/**
 * Perform a viewbox update via a given change function.
 *
 * @param {Function} changeFn
 */
Canvas.prototype._changeViewbox = function (changeFn) {

  // notify others of the upcoming viewbox change
  this._eventBus.fire('canvas.viewbox.changing');

  // perform actual change
  changeFn.apply(this);

  // reset the cached viewbox so that
  // a new get operation on viewbox or zoom
  // triggers a viewbox re-computation
  this._cachedViewbox = null;

  // notify others of the change; this step
  // may or may not be debounced
  this._viewboxChanged();
};

Canvas.prototype._viewboxChanged = function () {
  this._eventBus.fire('canvas.viewbox.changed', { viewbox: this.viewbox() });
};

/**
 * 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) {

  if (box === undefined && this._cachedViewbox) {
    return this._cachedViewbox;
  }

  var viewport = this._viewport,
      innerBox,
      outerBox = this.getSize(),
      matrix,
      transform,
      scale,
      x,
      y;

  if (!box) {
    // compute the inner box based on the
    // diagrams default layer. This allows us to exclude
    // external components, such as overlays
    innerBox = this.getDefaultLayer().getBBox();

    transform = (0, _tinySvg.transform)(viewport);
    matrix = transform ? transform.matrix : (0, _tinySvg.createMatrix)();
    scale = round(matrix.a, 1000);

    x = round(-matrix.e || 0, 1000);
    y = round(-matrix.f || 0, 1000);

    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,
        height: innerBox.height,
        x: innerBox.x,
        y: innerBox.y
      },
      outer: outerBox
    };

    return box;
  } else {

    this._changeViewbox(function () {
      scale = Math.min(outerBox.width / box.width, outerBox.height / box.height);

      var matrix = this._svg.createSVGMatrix().scale(scale).translate(-box.x, -box.y);

      (0, _tinySvg.transform)(viewport, matrix);
    });
  }

  return box;
};

/**
 * 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) {

  var node = this._viewport;
  var matrix = node.getCTM();

  if (delta) {
    this._changeViewbox(function () {
      delta = (0, _minDash.assign)({ dx: 0, dy: 0 }, delta || {});

      matrix = this._svg.createSVGMatrix().translate(delta.dx, delta.dy).multiply(matrix);

      setCTM(node, matrix);
    });
  }

  return { x: matrix.e, y: matrix.f };
};

/**
 * 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) {

  if (!newScale) {
    return this.viewbox(newScale).scale;
  }

  if (newScale === 'fit-viewport') {
    return this._fitViewport(center);
  }

  var outer, matrix;

  this._changeViewbox(function () {

    if ((typeof center === 'undefined' ? 'undefined' : _typeof(center)) !== 'object') {
      outer = this.viewbox().outer;

      center = {
        x: outer.width / 2,
        y: outer.height / 2
      };
    }

    matrix = this._setZoom(newScale, center);
  });

  return round(matrix.a, 1000);
};

function setCTM(node, m) {
  var mstr = 'matrix(' + m.a + ',' + m.b + ',' + m.c + ',' + m.d + ',' + m.e + ',' + m.f + ')';
  node.setAttribute('transform', mstr);
}

Canvas.prototype._fitViewport = function (center) {

  var vbox = this.viewbox(),
      outer = vbox.outer,
      inner = vbox.inner,
      newScale,
      newViewbox;

  // 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

  if (inner.x >= 0 && inner.y >= 0 && inner.x + inner.width <= outer.width && inner.y + inner.height <= outer.height && !center) {

    newViewbox = {
      x: 0,
      y: 0,
      width: Math.max(inner.width + inner.x, outer.width),
      height: Math.max(inner.height + inner.y, outer.height)
    };
  } else {

    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
    };
  }

  this.viewbox(newViewbox);

  return this.viewbox(false).scale;
};

Canvas.prototype._setZoom = function (scale, center) {

  var svg = this._svg,
      viewport = this._viewport;

  var matrix = svg.createSVGMatrix();
  var point = svg.createSVGPoint();

  var centerPoint, originalPoint, currentMatrix, scaleMatrix, newMatrix;

  currentMatrix = viewport.getCTM();

  var currentScale = currentMatrix.a;

  if (center) {
    centerPoint = (0, _minDash.assign)(point, center);

    // revert applied viewport transformations
    originalPoint = centerPoint.matrixTransform(currentMatrix.inverse());

    // create scale matrix
    scaleMatrix = matrix.translate(originalPoint.x, originalPoint.y).scale(1 / currentScale * scale).translate(-originalPoint.x, -originalPoint.y);

    newMatrix = currentMatrix.multiply(scaleMatrix);
  } else {
    newMatrix = matrix.scale(scale);
  }

  setCTM(this._viewport, newMatrix);

  return newMatrix;
};

/**
 * Returns the size of the canvas
 *
 * @return {Dimensions}
 */
Canvas.prototype.getSize = function () {
  return {
    width: this._container.clientWidth,
    height: this._container.clientHeight
  };
};

/**
 * 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;

  // connection
  // use svg bbox
  if (element.waypoints) {
    var gfx = this.getGraphics(element);

    bbox = gfx.getBBox();
  }
  // shapes
  // use data
  else {
      bbox = element;
    }

  var x = bbox.x * vbox.scale - vbox.x * vbox.scale;
  var y = bbox.y * vbox.scale - vbox.y * vbox.scale;

  var width = bbox.width * vbox.scale;
  var height = bbox.height * vbox.scale;

  return {
    x: x,
    y: y,
    width: width,
    height: height
  };
};

/**
 * Fires an event in order other modules can react to the
 * canvas resizing
 */
Canvas.prototype.resized = function () {

  // force recomputation of view box
  delete this._cachedViewbox;

  this._eventBus.fire('canvas.resized');
};

},{"../util/Collections":393,"../util/Elements":396,"min-dash":505,"tiny-svg":535}],247:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = ElementFactory;

var _model = require('../model');

var _minDash = require('min-dash');

/**
 * A factory for diagram-js shapes
 */
function ElementFactory() {
  this._uid = 12;
}

ElementFactory.prototype.createRoot = function (attrs) {
  return this.create('root', attrs);
};

ElementFactory.prototype.createLabel = function (attrs) {
  return this.create('label', attrs);
};

ElementFactory.prototype.createShape = function (attrs) {
  return this.create('shape', attrs);
};

ElementFactory.prototype.createConnection = function (attrs) {
  return this.create('connection', attrs);
};

/**
 * 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.prototype.create = function (type, attrs) {

  attrs = (0, _minDash.assign)({}, attrs || {});

  if (!attrs.id) {
    attrs.id = type + '_' + this._uid++;
  }

  return (0, _model.create)(type, attrs);
};

},{"../model":382,"min-dash":505}],248:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = ElementRegistry;

var _tinySvg = require('tiny-svg');

var ELEMENT_ID = 'data-element-id';

/**
 * @class
 *
 * A registry that keeps track of all shapes in the diagram.
 */
function ElementRegistry(eventBus) {
  this._elements = {};

  this._eventBus = eventBus;
}

ElementRegistry.$inject = ['eventBus'];

/**
 * 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) {

  var id = element.id;

  this._validateId(id);

  // associate dom node with element
  (0, _tinySvg.attr)(gfx, ELEMENT_ID, id);

  if (secondaryGfx) {
    (0, _tinySvg.attr)(secondaryGfx, ELEMENT_ID, id);
  }

  this._elements[id] = { element: element, gfx: gfx, secondaryGfx: secondaryGfx };
};

/**
 * 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];

  if (container) {

    // unset element id on gfx
    (0, _tinySvg.attr)(container.gfx, ELEMENT_ID, '');

    if (container.secondaryGfx) {
      (0, _tinySvg.attr)(container.secondaryGfx, ELEMENT_ID, '');
    }

    delete elements[id];
  }
};

/**
 * Update the id of an element
 *
 * @param {djs.model.Base} element
 * @param {String} newId
 */
ElementRegistry.prototype.updateId = function (element, newId) {

  this._validateId(newId);

  if (typeof element === 'string') {
    element = this.get(element);
  }

  this._eventBus.fire('element.updateId', {
    element: element,
    newId: newId
  });

  var gfx = this.getGraphics(element),
      secondaryGfx = this.getGraphics(element, true);

  this.remove(element);

  element.id = newId;

  this.add(element, gfx, secondaryGfx);
};

/**
 * 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;

  if (typeof filter === 'string') {
    id = filter;
  } else {
    id = filter && (0, _tinySvg.attr)(filter, ELEMENT_ID);
  }

  var container = this._elements[id];
  return container && container.element;
};

/**
 * Return all elements that match a given filter function.
 *
 * @param {Function} fn
 *
 * @return {Array<djs.model.Base>}
 */
ElementRegistry.prototype.filter = function (fn) {

  var filtered = [];

  this.forEach(function (element, gfx) {
    if (fn(element, gfx)) {
      filtered.push(element);
    }
  });

  return filtered;
};

/**
 * Return all rendered model elements.
 *
 * @return {Array<djs.model.Base>}
 */
ElementRegistry.prototype.getAll = function () {
  return this.filter(function (e) {
    return e;
  });
};

/**
 * Iterate over all diagram elements.
 *
 * @param {Function} fn
 */
ElementRegistry.prototype.forEach = function (fn) {

  var map = this._elements;

  Object.keys(map).forEach(function (id) {
    var container = map[id],
        element = container.element,
        gfx = container.gfx;

    return fn(element, gfx);
  });
};

/**
 * 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;

  var container = this._elements[id];
  return container && (secondary ? container.secondaryGfx : container.gfx);
};

/**
 * 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');
  }

  if (this._elements[id]) {
    throw new Error('element with id ' + id + ' already added');
  }
};

},{"tiny-svg":535}],249:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

exports.default = EventBus;

var _minDash = require('min-dash');

var FN_REF = '__fn';

var DEFAULT_PRIORITY = 1000;

var slice = Array.prototype.slice;

/**
 * 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 = {};

  // cleanup on destroy on lowest priority to allow
  // message passing until the bitter end
  this.on('diagram.destroy', 1, this._destroy, this);
}

/**
 * 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) {

  events = (0, _minDash.isArray)(events) ? events : [events];

  if ((0, _minDash.isFunction)(priority)) {
    that = callback;
    callback = priority;
    priority = DEFAULT_PRIORITY;
  }

  if (!(0, _minDash.isNumber)(priority)) {
    throw new Error('priority must be a number');
  }

  var actualCallback = callback;

  if (that) {
    actualCallback = (0, _minDash.bind)(callback, that);

    // 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;
  }

  var self = this;

  events.forEach(function (e) {
    self._addListener(e, {
      priority: priority,
      callback: actualCallback,
      next: null
    });
  });
};

/**
 * Register an event listener that is executed only once.
 *
 * @param {String} event the event name to register for
 * @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;

  if ((0, _minDash.isFunction)(priority)) {
    that = callback;
    callback = priority;
    priority = DEFAULT_PRIORITY;
  }

  if (!(0, _minDash.isNumber)(priority)) {
    throw new Error('priority must be a number');
  }

  function wrappedCallback() {
    var result = callback.apply(that, arguments);

    self.off(event, wrappedCallback);

    return result;
  }

  // make sure we remember and are able to remove
  // bound callbacks via {@link #off} using the original
  // callback
  wrappedCallback[FN_REF] = callback;

  this.on(event, priority, wrappedCallback);
};

/**
 * 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) {

  events = (0, _minDash.isArray)(events) ? events : [events];

  var self = this;

  events.forEach(function (event) {
    self._removeListener(event, callback);
  });
};

/**
 * Create an EventBus event.
 *
 * @param {Object} data
 *
 * @return {Object} event, recognized by the eventBus
 */
EventBus.prototype.createEvent = function (data) {
  var event = new InternalEvent();

  event.init(data);

  return event;
};

/**
 * 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;

  args = slice.call(arguments);

  if ((typeof type === 'undefined' ? 'undefined' : _typeof(type)) === 'object') {
    event = type;
    type = event.type;
  }

  if (!type) {
    throw new Error('no event type specified');
  }

  firstListener = this._listeners[type];

  if (!firstListener) {
    return;
  }

  // we make sure we fire instances of our home made
  // events here. We wrap them only once, though
  if (data instanceof InternalEvent) {
    // we are fine, we alread have an event
    event = data;
  } else {
    event = this.createEvent(data);
  }

  // ensure we pass the event as the first parameter
  args[0] = event;

  // original event type (in case we delegate)
  var originalType = event.type;

  // update event type before delegation
  if (type !== originalType) {
    event.type = type;
  }

  try {
    returnValue = this._invokeListeners(event, args, firstListener);
  } finally {
    // reset event type after delegation
    if (type !== originalType) {
      event.type = originalType;
    }
  }

  // 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;
  }

  return returnValue;
};

EventBus.prototype.handleError = function (error) {
  return this.fire('error', { error: error }) === false;
};

EventBus.prototype._destroy = function () {
  this._listeners = {};
};

EventBus.prototype._invokeListeners = function (event, args, listener) {

  var returnValue;

  while (listener) {

    // handle stopped propagation
    if (event.cancelBubble) {
      break;
    }

    returnValue = this._invokeListener(event, args, listener);

    listener = listener.next;
  }

  return returnValue;
};

EventBus.prototype._invokeListener = function (event, args, listener) {

  var returnValue;

  try {
    // returning false prevents the default action
    returnValue = invokeFunction(listener.callback, args);

    // stop propagation on return value
    if (returnValue !== undefined) {
      event.returnValue = returnValue;
      event.stopPropagation();
    }

    // prevent default on return false
    if (returnValue === false) {
      event.preventDefault();
    }
  } catch (e) {
    if (!this.handleError(e)) {
      console.error('unhandled error in event listener');
      console.error(e.stack);

      throw e;
    }
  }

  return returnValue;
};

/*
 * 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) {

  var listener = this._getListeners(event),
      previousListener;

  // no prior listeners
  if (!listener) {
    this._setListeners(event, newListener);

    return;
  }

  // ensure we order listeners by priority from
  // 0 (high) to n > 0 (low)
  while (listener) {

    if (listener.priority < newListener.priority) {

      newListener.next = listener;

      if (previousListener) {
        previousListener.next = newListener;
      } else {
        this._setListeners(event, newListener);
      }

      return;
    }

    previousListener = listener;
    listener = listener.next;
  }

  // add new listener to back
  previousListener.next = newListener;
};

EventBus.prototype._getListeners = function (name) {
  return this._listeners[name];
};

EventBus.prototype._setListeners = function (name, listener) {
  this._listeners[name] = listener;
};

EventBus.prototype._removeListener = function (event, callback) {

  var listener = this._getListeners(event),
      nextListener,
      previousListener,
      listenerCallback;

  if (!callback) {
    // clear listeners
    this._setListeners(event, null);

    return;
  }

  while (listener) {

    nextListener = listener.next;

    listenerCallback = listener.callback;

    if (listenerCallback === callback || listenerCallback[FN_REF] === callback) {
      if (previousListener) {
        previousListener.next = nextListener;
      } else {
        // new first listener
        this._setListeners(event, nextListener);
      }
    }

    previousListener = listener;
    listener = nextListener;
  }
};

/**
 * A event that is emitted via the event bus.
 */
function InternalEvent() {}

InternalEvent.prototype.stopPropagation = function () {
  this.cancelBubble = true;
};

InternalEvent.prototype.preventDefault = function () {
  this.defaultPrevented = true;
};

InternalEvent.prototype.init = function (data) {
  (0, _minDash.assign)(this, data || {});
};

/**
 * Invoke function. Be fast...
 *
 * @param {Function} fn
 * @param {Array<Object>} args
 *
 * @return {Any}
 */
function invokeFunction(fn, args) {
  return fn.apply(null, args);
}

},{"min-dash":505}],250:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = GraphicsFactory;

var _minDash = require('min-dash');

var _GraphicsUtil = require('../util/GraphicsUtil');

var _SvgTransformUtil = require('../util/SvgTransformUtil');

var _minDom = require('min-dom');

var _tinySvg = require('tiny-svg');

/**
 * A factory that creates graphical elements
 *
 * @param {EventBus} eventBus
 * @param {ElementRegistry} elementRegistry
 */
function GraphicsFactory(eventBus, elementRegistry) {
  this._eventBus = eventBus;
  this._elementRegistry = elementRegistry;
}

GraphicsFactory.$inject = ['eventBus', 'elementRegistry'];

GraphicsFactory.prototype._getChildren = function (element) {

  var gfx = this._elementRegistry.getGraphics(element);

  var childrenGfx;

  // root element
  if (!element.parent) {
    childrenGfx = gfx;
  } else {
    childrenGfx = (0, _GraphicsUtil.getChildren)(gfx);
    if (!childrenGfx) {
      childrenGfx = (0, _tinySvg.create)('g');
      (0, _tinySvg.classes)(childrenGfx).add('djs-children');

      (0, _tinySvg.append)(gfx.parentNode, childrenGfx);
    }
  }

  return childrenGfx;
};

/**
 * 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 = (0, _GraphicsUtil.getVisual)(gfx);

  (0, _minDom.clear)(visual);

  return visual;
};

/**
 * 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)">
 *     <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 {Object} parent
 * @param {String} type the type of the element, i.e. shape | connection
 * @param {Number} [parentIndex] position to create container in parent
 */
GraphicsFactory.prototype._createContainer = function (type, childrenGfx, parentIndex) {
  var outerGfx = (0, _tinySvg.create)('g');
  (0, _tinySvg.classes)(outerGfx).add('djs-group');

  // insert node at position
  if (typeof parentIndex !== 'undefined') {
    prependTo(outerGfx, childrenGfx, childrenGfx.childNodes[parentIndex]);
  } else {
    (0, _tinySvg.append)(childrenGfx, outerGfx);
  }

  var gfx = (0, _tinySvg.create)('g');
  (0, _tinySvg.classes)(gfx).add('djs-element');
  (0, _tinySvg.classes)(gfx).add('djs-' + type);

  (0, _tinySvg.append)(outerGfx, gfx);

  // create visual
  var visual = (0, _tinySvg.create)('g');
  (0, _tinySvg.classes)(visual).add('djs-visual');

  (0, _tinySvg.append)(gfx, visual);

  return gfx;
};

GraphicsFactory.prototype.create = function (type, element, parentIndex) {
  var childrenGfx = this._getChildren(element.parent);
  return this._createContainer(type, childrenGfx, parentIndex);
};

GraphicsFactory.prototype.updateContainments = function (elements) {

  var self = this,
      elementRegistry = this._elementRegistry,
      parents;

  parents = (0, _minDash.reduce)(elements, function (map, e) {

    if (e.parent) {
      map[e.parent.id] = e.parent;
    }

    return map;
  }, {});

  // update all parents of changed and reorganized their children
  // in the correct order (as indicated in our model)
  (0, _minDash.forEach)(parents, function (parent) {

    var children = parent.children;

    if (!children) {
      return;
    }

    var childGfx = self._getChildren(parent);

    (0, _minDash.forEach)(children.slice().reverse(), function (c) {
      var gfx = elementRegistry.getGraphics(c);

      prependTo(gfx.parentNode, childGfx);
    });
  });
};

GraphicsFactory.prototype.drawShape = function (visual, element) {
  var eventBus = this._eventBus;

  return eventBus.fire('render.shape', { gfx: visual, element: element });
};

GraphicsFactory.prototype.getShapePath = function (element) {
  var eventBus = this._eventBus;

  return eventBus.fire('render.getShapePath', element);
};

GraphicsFactory.prototype.drawConnection = function (visual, element) {
  var eventBus = this._eventBus;

  return eventBus.fire('render.connection', { gfx: visual, element: element });
};

GraphicsFactory.prototype.getConnectionPath = function (waypoints) {
  var eventBus = this._eventBus;

  return eventBus.fire('render.getConnectionPath', waypoints);
};

GraphicsFactory.prototype.update = function (type, element, gfx) {
  // Do not update root element
  if (!element.parent) {
    return;
  }

  var visual = this._clear(gfx);

  // redraw
  if (type === 'shape') {
    this.drawShape(visual, element);

    // update positioning
    (0, _SvgTransformUtil.translate)(gfx, element.x, element.y);
  } else if (type === 'connection') {
    this.drawConnection(visual, element);
  } else {
    throw new Error('unknown type: ' + type);
  }

  if (element.hidden) {
    (0, _tinySvg.attr)(gfx, 'display', 'none');
  } else {
    (0, _tinySvg.attr)(gfx, 'display', 'block');
  }
};

GraphicsFactory.prototype.remove = function (element) {
  var gfx = this._elementRegistry.getGraphics(element);

  // remove
  (0, _tinySvg.remove)(gfx.parentNode);
};

// helpers //////////////////////

function prependTo(newNode, parentNode, siblingNode) {
  parentNode.insertBefore(newNode, siblingNode || parentNode.firstChild);
}

},{"../util/GraphicsUtil":399,"../util/SvgTransformUtil":408,"min-dash":505,"min-dom":506,"tiny-svg":535}],251:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _draw = require('../draw');

var _draw2 = _interopRequireDefault(_draw);

var _Canvas = require('./Canvas');

var _Canvas2 = _interopRequireDefault(_Canvas);

var _ElementRegistry = require('./ElementRegistry');

var _ElementRegistry2 = _interopRequireDefault(_ElementRegistry);

var _ElementFactory = require('./ElementFactory');

var _ElementFactory2 = _interopRequireDefault(_ElementFactory);

var _EventBus = require('./EventBus');

var _EventBus2 = _interopRequireDefault(_EventBus);

var _GraphicsFactory = require('./GraphicsFactory');

var _GraphicsFactory2 = _interopRequireDefault(_GraphicsFactory);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __depends__: [_draw2.default],
  __init__: ['canvas'],
  canvas: ['type', _Canvas2.default],
  elementRegistry: ['type', _ElementRegistry2.default],
  elementFactory: ['type', _ElementFactory2.default],
  eventBus: ['type', _EventBus2.default],
  graphicsFactory: ['type', _GraphicsFactory2.default]
};

},{"../draw":255,"./Canvas":246,"./ElementFactory":247,"./ElementRegistry":248,"./EventBus":249,"./GraphicsFactory":250}],252:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = BaseRenderer;
var DEFAULT_RENDER_PRIORITY = 1000;

/**
 * The base implementation of shape and connection renderers.
 *
 * @param {EventBus} eventBus
 * @param {Number} [renderPriority=1000]
 */
function BaseRenderer(eventBus, renderPriority) {
  var self = this;

  renderPriority = renderPriority || DEFAULT_RENDER_PRIORITY;

  eventBus.on(['render.shape', 'render.connection'], renderPriority, function (evt, context) {
    var type = evt.type,
        element = context.element,
        visuals = context.gfx;

    if (self.canRender(element)) {
      if (type === 'render.shape') {
        return self.drawShape(visuals, element);
      } else {
        return self.drawConnection(visuals, element);
      }
    }
  });

  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);
      }
    }
  });
}

/**
 * Should check whether *this* renderer can render
 * the element/connection.
 *
 * @param {element} element
 *
 * @returns {Boolean}
 */
BaseRenderer.prototype.canRender = function () {};

/**
 * 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 () {};

/**
 * 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 () {};

/**
 * Gets the SVG path of a shape that represents it's visual bounds.
 *
 * @param {Shape} shape
 *
 * @return {string} svg path
 */
BaseRenderer.prototype.getShapePath = function () {};

/**
 * Gets the SVG path of a connection that represents it's visual bounds.
 *
 * @param {Connection} connection
 *
 * @return {string} svg path
 */
BaseRenderer.prototype.getConnectionPath = function () {};

},{}],253:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = DefaultRenderer;

var _inherits = require('inherits');

var _inherits2 = _interopRequireDefault(_inherits);

var _BaseRenderer = require('./BaseRenderer');

var _BaseRenderer2 = _interopRequireDefault(_BaseRenderer);

var _RenderUtil = require('../util/RenderUtil');

var _tinySvg = require('tiny-svg');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

// apply default renderer with lowest possible priority
// so that it only kicks in if noone else could render
var DEFAULT_RENDER_PRIORITY = 1;

/**
 * The default renderer used for shapes and connections.
 *
 * @param {EventBus} eventBus
 * @param {Styles} styles
 */
function DefaultRenderer(eventBus, styles) {
  //
  _BaseRenderer2.default.call(this, eventBus, DEFAULT_RENDER_PRIORITY);

  this.CONNECTION_STYLE = styles.style(['no-fill'], { strokeWidth: 5, stroke: 'fuchsia' });
  this.SHAPE_STYLE = styles.style({ fill: 'white', stroke: 'fuchsia', strokeWidth: 2 });
}

(0, _inherits2.default)(DefaultRenderer, _BaseRenderer2.default);

DefaultRenderer.prototype.canRender = function () {
  return true;
};

DefaultRenderer.prototype.drawShape = function drawShape(visuals, element) {

  var rect = (0, _tinySvg.create)('rect');
  (0, _tinySvg.attr)(rect, {
    x: 0,
    y: 0,
    width: element.width || 0,
    height: element.height || 0
  });
  (0, _tinySvg.attr)(rect, this.SHAPE_STYLE);

  (0, _tinySvg.append)(visuals, rect);

  return rect;
};

DefaultRenderer.prototype.drawConnection = function drawConnection(visuals, connection) {

  var line = (0, _RenderUtil.createLine)(connection.waypoints, this.CONNECTION_STYLE);
  (0, _tinySvg.append)(visuals, line);

  return line;
};

DefaultRenderer.prototype.getShapePath = function getShapePath(shape) {

  var x = shape.x,
      y = shape.y,
      width = shape.width,
      height = shape.height;

  var shapePath = [['M', x, y], ['l', width, 0], ['l', 0, height], ['l', -width, 0], ['z']];

  return (0, _RenderUtil.componentsToPath)(shapePath);
};

DefaultRenderer.prototype.getConnectionPath = function getConnectionPath(connection) {
  var waypoints = connection.waypoints;

  var idx,
      point,
      connectionPath = [];

  for (idx = 0; point = waypoints[idx]; idx++) {

    // take invisible docking into account
    // when creating the path
    point = point.original || point;

    connectionPath.push([idx === 0 ? 'M' : 'L', point.x, point.y]);
  }

  return (0, _RenderUtil.componentsToPath)(connectionPath);
};

DefaultRenderer.$inject = ['eventBus', 'styles'];

},{"../util/RenderUtil":407,"./BaseRenderer":252,"inherits":415,"tiny-svg":535}],254:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = Styles;

var _minDash = require('min-dash');

/**
 * A component that manages shape styles
 */
function Styles() {

  var defaultTraits = {

    'no-fill': {
      fill: 'none'
    },
    'no-border': {
      strokeOpacity: 0.0
    },
    'no-events': {
      pointerEvents: 'none'
    }
  };

  var self = this;

  /**
   * 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);

    return (0, _minDash.assign)(attrs, { 'class': className });
  };

  /**
   * 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) {

    if (!(0, _minDash.isArray)(traits) && !additionalAttrs) {
      additionalAttrs = traits;
      traits = [];
    }

    var attrs = (0, _minDash.reduce)(traits, function (attrs, t) {
      return (0, _minDash.assign)(attrs, defaultTraits[t] || {});
    }, {});

    return additionalAttrs ? (0, _minDash.assign)(attrs, additionalAttrs) : attrs;
  };

  this.computeStyle = function (custom, traits, defaultStyles) {
    if (!(0, _minDash.isArray)(traits)) {
      defaultStyles = traits;
      traits = [];
    }

    return self.style(traits || [], (0, _minDash.assign)({}, defaultStyles, custom || {}));
  };
}

},{"min-dash":505}],255:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _DefaultRenderer = require('./DefaultRenderer');

var _DefaultRenderer2 = _interopRequireDefault(_DefaultRenderer);

var _Styles = require('./Styles');

var _Styles2 = _interopRequireDefault(_Styles);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __init__: ['defaultRenderer'],
  defaultRenderer: ['type', _DefaultRenderer2.default],
  styles: ['type', _Styles2.default]
};

},{"./DefaultRenderer":253,"./Styles":254}],256:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = AlignElements;

var _minDash = require('min-dash');

function last(arr) {
  return arr && arr[arr.length - 1];
}

function sortTopOrMiddle(element) {
  return element.y;
}

function sortLeftOrCenter(element) {
  return element.x;
}

/**
 * Sorting functions for different types of alignment
 *
 * @type {Object}
 *
 * @return {Function}
 */
var ALIGNMENT_SORTING = {
  left: sortLeftOrCenter,
  center: sortLeftOrCenter,
  right: function right(element) {
    return element.x + element.width;
  },
  top: sortTopOrMiddle,
  middle: sortTopOrMiddle,
  bottom: function bottom(element) {
    return element.y + element.height;
  }
};

function AlignElements(modeling) {
  this._modeling = modeling;
}

AlignElements.$inject = ['modeling'];

/**
 * 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.prototype._getOrientationDetails = function (type) {
  var vertical = ['top', 'bottom', 'middle'],
      axis = 'x',
      dimension = 'width';

  if (vertical.indexOf(type) !== -1) {
    axis = 'y';
    dimension = 'height';
  }

  return {
    axis: axis,
    dimension: dimension
  };
};

AlignElements.prototype._isType = function (type, types) {
  return types.indexOf(type) !== -1;
};

/**
 * 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.prototype._alignmentPosition = function (type, sortedElements) {
  var orientation = this._getOrientationDetails(type),
      axis = orientation.axis,
      dimension = orientation.dimension,
      alignment = {},
      centers = {},
      hasSharedCenters = false,
      centeredElements,
      firstElement,
      lastElement;

  function getMiddleOrTop(first, last) {
    return Math.round((first[axis] + last[axis] + last[dimension]) / 2);
  }

  if (this._isType(type, ['left', 'top'])) {
    alignment[type] = sortedElements[0][axis];
  } else if (this._isType(type, ['right', 'bottom'])) {
    lastElement = last(sortedElements);

    alignment[type] = lastElement[axis] + lastElement[dimension];
  } else if (this._isType(type, ['center', 'middle'])) {

    // check if there is a center shared by more than one shape
    // if not, just take the middle of the range
    (0, _minDash.forEach)(sortedElements, function (element) {
      var center = element[axis] + Math.round(element[dimension] / 2);

      if (centers[center]) {
        centers[center].elements.push(element);
      } else {
        centers[center] = {
          elements: [element],
          center: center
        };
      }
    });

    centeredElements = (0, _minDash.sortBy)(centers, function (center) {
      if (center.elements.length > 1) {
        hasSharedCenters = true;
      }

      return center.elements.length;
    });

    if (hasSharedCenters) {
      alignment[type] = last(centeredElements).center;

      return alignment;
    }

    firstElement = sortedElements[0];

    sortedElements = (0, _minDash.sortBy)(sortedElements, function (element) {
      return element[axis] + element[dimension];
    });

    lastElement = last(sortedElements);

    alignment[type] = getMiddleOrTop(firstElement, lastElement);
  }

  return alignment;
};

/**
 * Executes the alignment of a selection of elements
 *
 * @param  {Array} elements [description]
 * @param  {String} type left|right|center|top|bottom|middle
 */
AlignElements.prototype.trigger = function (elements, type) {
  var modeling = this._modeling;

  var filteredElements = (0, _minDash.filter)(elements, function (element) {
    return !(element.waypoints || element.host || element.labelTarget);
  });

  var sortFn = ALIGNMENT_SORTING[type];

  var sortedElements = (0, _minDash.sortBy)(filteredElements, sortFn);

  var alignment = this._alignmentPosition(type, sortedElements);

  modeling.alignElements(sortedElements, alignment);
};

},{"min-dash":505}],257:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _AlignElements = require('./AlignElements');

var _AlignElements2 = _interopRequireDefault(_AlignElements);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __init__: ['alignElements'],
  alignElements: ['type', _AlignElements2.default]
};

},{"./AlignElements":256}],258:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = AttachSupport;

var _minDash = require('min-dash');

var _Removal = require('../../util/Removal');

var _Collections = require('../../util/Collections');

var _AttachUtil = require('../../util/AttachUtil');

var _inherits = require('inherits');

var _inherits2 = _interopRequireDefault(_inherits);

var _CommandInterceptor = require('../../command/CommandInterceptor');

var _CommandInterceptor2 = _interopRequireDefault(_CommandInterceptor);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var LOW_PRIORITY = 251,
    HIGH_PRIORITY = 1401;

/**
 * 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 {Rules} rules
 * @param {Modeling} modeling
 */
function AttachSupport(injector, eventBus, rules, modeling) {

  _CommandInterceptor2.default.call(this, eventBus);

  var movePreview = injector.get('movePreview', false);

  // 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, function (e) {

    var context = e.context,
        shapes = context.shapes,
        validatedShapes = context.validatedShapes;

    context.shapes = addAttached(shapes);

    context.validatedShapes = removeAttached(validatedShapes);
  });

  // add attachers to the visual's group
  movePreview && eventBus.on('shape.move.start', LOW_PRIORITY, function (e) {

    var context = e.context,
        shapes = context.shapes,
        attachers = getAttachers(shapes);

    (0, _minDash.forEach)(attachers, function (attacher) {
      movePreview.makeDraggable(context, attacher, true);

      (0, _minDash.forEach)(attacher.labels, function (label) {
        movePreview.makeDraggable(context, label, true);
      });
    });
  });

  // add all attachers to move closure
  this.preExecuted('elements.move', HIGH_PRIORITY, function (e) {
    var context = e.context,
        closure = context.closure,
        shapes = context.shapes,
        attachers = getAttachers(shapes);

    (0, _minDash.forEach)(attachers, function (attacher) {
      closure.add(attacher, closure.topLevel[attacher.host.id]);
    });
  });

  // perform the attaching after shapes are done moving
  this.postExecuted('elements.move', function (e) {

    var context = e.context,
        shapes = context.shapes,
        newHost = context.newHost,
        attachers;

    // we only support attachment / detachment of one element
    if (shapes.length > 1) {
      return;
    }

    if (newHost) {

      attachers = shapes;
    } else {

      attachers = (0, _minDash.filter)(shapes, function (s) {
        return !!s.host;
      });
    }

    (0, _minDash.forEach)(attachers, function (attacher) {
      modeling.updateAttachment(attacher, newHost);
    });
  });

  // ensure invalid attachment connections are removed
  this.postExecuted('elements.move', function (e) {

    var shapes = e.context.shapes;

    (0, _minDash.forEach)(shapes, function (shape) {

      (0, _minDash.forEach)(shape.attachers, function (attacher) {

        // remove invalid outgoing connections
        (0, _minDash.forEach)(attacher.outgoing.slice(), function (connection) {
          var allowed = rules.allowed('connection.reconnectStart', {
            connection: connection,
            source: connection.source,
            target: connection.target
          });

          if (!allowed) {
            modeling.removeConnection(connection);
          }
        });

        // remove invalid incoming connections
        (0, _minDash.forEach)(attacher.incoming.slice(), function (connection) {
          var allowed = rules.allowed('connection.reconnectEnd', {
            connection: connection,
            source: connection.source,
            target: connection.target
          });

          if (!allowed) {
            modeling.removeConnection(connection);
          }
        });
      });
    });
  });

  this.postExecute('shape.create', function (e) {
    var context = e.context,
        shape = context.shape,
        host = context.host;

    if (host) {
      modeling.updateAttachment(shape, host);
    }
  });

  // update attachments if the host is replaced
  this.postExecute('shape.replace', function (e) {

    var context = e.context,
        oldShape = context.oldShape,
        newShape = context.newShape;

    // move the attachers to the new host
    (0, _Removal.saveClear)(oldShape.attachers, function (attacher) {
      var allowed = rules.allowed('elements.move', {
        target: newShape,
        shapes: [attacher]
      });

      if (allowed === 'attach') {
        modeling.updateAttachment(attacher, newShape);
      } else {
        modeling.removeShape(attacher);
      }
    });

    // move attachers if new host has different size
    if (newShape.attachers.length) {

      (0, _minDash.forEach)(newShape.attachers, function (attacher) {
        var delta = (0, _AttachUtil.getNewAttachShapeDelta)(attacher, oldShape, newShape);
        modeling.moveShape(attacher, delta, attacher.parent);
      });
    }
  });

  // 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;

    (0, _minDash.forEach)(attachers, function (attacher) {
      var delta = (0, _AttachUtil.getNewAttachShapeDelta)(attacher, oldBounds, newBounds);

      modeling.moveShape(attacher, delta, attacher.parent);

      (0, _minDash.forEach)(attacher.labels, function (label) {
        modeling.moveShape(label, delta, label.parent);
      });
    });
  });

  // remove attachments
  this.preExecute('shape.delete', function (event) {

    var shape = event.context.shape;

    (0, _Removal.saveClear)(shape.attachers, function (attacher) {
      modeling.removeShape(attacher);
    });

    if (shape.host) {
      modeling.updateAttachment(shape, null);
    }
  });

  // Prevent attachers and their labels from moving, when the space tool is performed.
  // Otherwise the attachers and their labels would be moved twice.
  eventBus.on('spaceTool.move', function (event) {

    var context = event.context,
        initialized = context.initialized,
        attachSupportInitialized = context.attachSupportInitialized;

    if (!initialized || attachSupportInitialized) {
      return;
    }

    var movingShapes = context.movingShapes;

    // collect attachers whose host is not being moved using the space tool
    var staticAttachers = (0, _minDash.filter)(movingShapes, function (shape) {
      var host = shape.host;

      return host && movingShapes.indexOf(host) === -1;
    });

    // remove attachers that are not going to be moved from moving shapes
    (0, _minDash.forEach)(staticAttachers, function (shape) {
      (0, _Collections.remove)(movingShapes, shape);

      (0, _minDash.forEach)(shape.labels, function (label) {
        (0, _Collections.remove)(movingShapes, shape.label);
      });
    });

    context.attachSupportInitialized = true;
  });
}

(0, _inherits2.default)(AttachSupport, _CommandInterceptor2.default);

AttachSupport.$inject = ['injector', 'eventBus', 'rules', 'modeling'];

/**
 * Return attachers of the given shapes
 *
 * @param {Array<djs.model.Base>} shapes
 * @return {Array<djs.model.Base>}
 */
function getAttachers(shapes) {
  return (0, _minDash.flatten)((0, _minDash.map)(shapes, function (s) {
    return s.attachers || [];
  }));
}

/**
 * Return a combined list of elements and
 * attachers.
 *
 * @param {Array<djs.model.Base>} elements
 * @return {Array<djs.model.Base>} filtered
 */
function addAttached(elements) {
  var attachers = getAttachers(elements);

  return (0, _minDash.unionBy)('id', elements, attachers);
}

/**
 * Return a filtered list of elements that do not
 * contain attached elements with hosts being part
 * of the selection.
 *
 * @param  {Array<djs.model.Base>} elements
 *
 * @return {Array<djs.model.Base>} filtered
 */
function removeAttached(elements) {

  var ids = (0, _minDash.groupBy)(elements, 'id');

  return (0, _minDash.filter)(elements, function (element) {
    while (element) {

      // host in selection
      if (element.host && ids[element.host.id]) {
        return false;
      }

      element = element.parent;
    }

    return true;
  });
}

},{"../../command/CommandInterceptor":243,"../../util/AttachUtil":391,"../../util/Collections":393,"../../util/Removal":406,"inherits":415,"min-dash":505}],259:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _rules = require('../rules');

var _rules2 = _interopRequireDefault(_rules);

var _AttachSupport = require('./AttachSupport');

var _AttachSupport2 = _interopRequireDefault(_AttachSupport);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __depends__: [_rules2.default],
  __init__: ['attachSupport'],
  attachSupport: ['type', _AttachSupport2.default]
};

},{"../rules":355,"./AttachSupport":258}],260:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = AutoResize;

var _inherits = require('inherits');

var _inherits2 = _interopRequireDefault(_inherits);

var _Elements = require('../../util/Elements');

var _LayoutUtil = require('../../layout/LayoutUtil');

var _minDash = require('min-dash');

var _CommandInterceptor = require('../../command/CommandInterceptor');

var _CommandInterceptor2 = _interopRequireDefault(_CommandInterceptor);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * 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) {

  _CommandInterceptor2.default.call(this, eventBus);

  this._elementRegistry = elementRegistry;
  this._modeling = modeling;
  this._rules = rules;

  var self = this;

  this.postExecuted(['shape.create'], function (event) {
    var context = event.context,
        hints = context.hints,
        shape = context.shape,
        parent = context.parent || context.newParent;

    if (hints && (hints.root === false || hints.autoResize === false)) {
      return;
    }

    self._expand([shape], parent);
  });

  this.postExecuted(['elements.move'], function (event) {
    var context = event.context,
        elements = (0, _minDash.flatten)((0, _minDash.values)(context.closure.topLevel)),
        hints = context.hints;

    var autoResize = hints ? hints.autoResize : true;

    if (autoResize === false) {
      return;
    }

    var expandings = (0, _minDash.groupBy)(elements, function (element) {
      return element.parent.id;
    });

    (0, _minDash.forEach)(expandings, function (elements, parentId) {

      // optionally filter elements to be considered when resizing
      if ((0, _minDash.isArray)(autoResize)) {
        elements = elements.filter(function (element) {
          return autoResize.indexOf(element) !== -1;
        });
      }

      self._expand(elements, parentId);
    });
  });

  this.postExecuted(['shape.toggleCollapse'], function (event) {
    var context = event.context,
        hints = context.hints,
        shape = context.shape;

    if (hints && (hints.root === false || hints.autoResize === false)) {
      return;
    }

    if (shape.collapsed) {
      return;
    }

    self._expand(shape.children || [], shape);
  });

  this.postExecuted(['shape.resize'], function (event) {
    var context = event.context,
        hints = context.hints,
        shape = context.shape,
        parent = shape.parent;

    if (hints && (hints.root === false || hints.autoResize === false)) {
      return;
    }

    if (parent) {
      self._expand([shape], parent);
    }
  });
}

AutoResize.$inject = ['eventBus', 'elementRegistry', 'modeling', 'rules'];

(0, _inherits2.default)(AutoResize, _CommandInterceptor2.default);

/**
 * 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) {

  var offset = this.getOffset(target),
      padding = this.getPadding(target);

  var elementsTrbl = (0, _LayoutUtil.asTRBL)((0, _Elements.getBBox)(elements)),
      targetTrbl = (0, _LayoutUtil.asTRBL)(target);

  var newTrbl = {};

  if (elementsTrbl.top - targetTrbl.top < padding.top) {
    newTrbl.top = elementsTrbl.top - offset.top;
  }

  if (elementsTrbl.left - targetTrbl.left < padding.left) {
    newTrbl.left = elementsTrbl.left - offset.left;
  }

  if (targetTrbl.right - elementsTrbl.right < padding.right) {
    newTrbl.right = elementsTrbl.right + offset.right;
  }

  if (targetTrbl.bottom - elementsTrbl.bottom < padding.bottom) {
    newTrbl.bottom = elementsTrbl.bottom + offset.bottom;
  }

  return (0, _LayoutUtil.asBounds)((0, _minDash.assign)({}, targetTrbl, newTrbl));
};

/**
 * 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) {

  if (typeof target === 'string') {
    target = this._elementRegistry.get(target);
  }

  var allowed = this._rules.allowed('element.autoResize', {
    elements: elements,
    target: target
  });

  if (!allowed) {
    return;
  }

  // calculate the new bounds
  var newBounds = this._getOptimalBounds(elements, target);

  if (!boundsChanged(newBounds, target)) {
    return;
  }

  // resize the parent shape
  this.resize(target, newBounds);

  var parent = target.parent;

  // recursively expand parent elements
  if (parent) {
    this._expand([target], parent);
  }
};

/**
 * Get the amount to expand the given shape in each direction.
 *
 * @param {djs.model.Shape} shape
 *
 * @return {Object} {top, bottom, left, right}
 */
AutoResize.prototype.getOffset = function (shape) {
  return { top: 60, bottom: 60, left: 100, right: 100 };
};

/**
 * Get the activation threshold for each side for which
 * resize triggers.
 *
 * @param {djs.model.Shape} shape
 *
 * @return {Object} {top, bottom, left, right}
 */
AutoResize.prototype.getPadding = function (shape) {
  return { top: 2, bottom: 2, left: 15, right: 15 };
};

/**
 * Perform the actual resize operation.
 *
 * @param {djs.model.Shape} target
 * @param {Object} newBounds
 */
AutoResize.prototype.resize = function (target, newBounds) {
  this._modeling.resizeShape(target, newBounds);
};

function boundsChanged(newBounds, oldBounds) {
  return newBounds.x !== oldBounds.x || newBounds.y !== oldBounds.y || newBounds.width !== oldBounds.width || newBounds.height !== oldBounds.height;
}

},{"../../command/CommandInterceptor":243,"../../layout/LayoutUtil":380,"../../util/Elements":396,"inherits":415,"min-dash":505}],261:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = AutoResizeProvider;

var _RuleProvider = require('../rules/RuleProvider');

var _RuleProvider2 = _interopRequireDefault(_RuleProvider);

var _inherits = require('inherits');

var _inherits2 = _interopRequireDefault(_inherits);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * This is a base rule provider for the element.autoResize rule.
 */
function AutoResizeProvider(eventBus) {

  _RuleProvider2.default.call(this, eventBus);

  var self = this;

  this.addRule('element.autoResize', function (context) {
    return self.canResize(context.elements, context.target);
  });
}

AutoResizeProvider.$inject = ['eventBus'];

(0, _inherits2.default)(AutoResizeProvider, _RuleProvider2.default);

/**
 * 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;
};

},{"../rules/RuleProvider":353,"inherits":415}],262:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = AutoScroll;

var _minDash = require('min-dash');

var _Event = require('../../util/Event');

/**
 * 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, mouseTracking) {

  this._canvas = canvas;
  this._mouseTracking = mouseTracking;

  this._opts = (0, _minDash.assign)({
    scrollThresholdIn: [20, 20, 20, 20],
    scrollThresholdOut: [0, 0, 0, 0],
    scrollRepeatTimeout: 15,
    scrollStep: 10
  }, config);

  var self = this;

  eventBus.on('drag.move', function (e) {
    var point = self._toBorderPoint(e);

    self.startScroll(point);
  });

  eventBus.on(['drag.cleanup'], function () {
    self.stopScroll();
  });
}

AutoScroll.$inject = ['config.autoScroll', 'eventBus', 'canvas', 'mouseTracking'];

/**
 * 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) {

  var canvas = this._canvas;
  var opts = this._opts;
  var self = this;

  var clientRect = canvas.getContainer().getBoundingClientRect();

  var diff = [point.x, point.y, clientRect.width - point.x, clientRect.height - point.y];

  this.stopScroll();

  var dx = 0,
      dy = 0;

  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;
      }
    }
  }

  if (dx !== 0 || dy !== 0) {
    canvas.scroll({ dx: dx, dy: dy });

    this._scrolling = setTimeout(function () {
      self.startScroll(point);
    }, opts.scrollRepeatTimeout);
  }
};

function between(val, start, end) {
  if (start < val && val < end) {
    return true;
  }

  return false;
}

/**
 * Stops scrolling loop.
 */
AutoScroll.prototype.stopScroll = function () {
  clearTimeout(this._scrolling);
};

/**
 * Overrides defaults options.
 *
 * @param  {Object} options
 */
AutoScroll.prototype.setOptions = function (options) {
  this._opts = (0, _minDash.assign)({}, this._opts, options);
};

/**
 * 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();

  var globalPosition = (0, _Event.toPoint)(event.originalEvent);

  return {
    x: globalPosition.x - clientRect.left,
    y: globalPosition.y - clientRect.top
  };
};

},{"../../util/Event":397,"min-dash":505}],263:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _dragging = require('../dragging');

var _dragging2 = _interopRequireDefault(_dragging);

var _mouseTracking = require('../mouse-tracking');

var _mouseTracking2 = _interopRequireDefault(_mouseTracking);

var _AutoScroll = require('./AutoScroll');

var _AutoScroll2 = _interopRequireDefault(_AutoScroll);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __depends__: [_dragging2.default, _mouseTracking2.default],
  __init__: ['autoScroll'],
  autoScroll: ['type', _AutoScroll2.default]
};

},{"../dragging":286,"../mouse-tracking":331,"./AutoScroll":262}],264:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = BendpointMove;

var _Geometry = require('../../util/Geometry');

var _BendpointUtil = require('./BendpointUtil');

var _tinySvg = require('tiny-svg');

var _SvgTransformUtil = require('../../util/SvgTransformUtil');

var MARKER_OK = 'connect-ok',
    MARKER_NOT_OK = 'connect-not-ok',
    MARKER_CONNECT_HOVER = 'connect-hover',
    MARKER_CONNECT_UPDATING = 'djs-updating';

var COMMAND_BENDPOINT_UPDATE = 'connection.updateWaypoints',
    COMMAND_RECONNECT_START = 'connection.reconnectStart',
    COMMAND_RECONNECT_END = 'connection.reconnectEnd';

var round = Math.round;

/**
 * A component that implements moving of bendpoints
 */
function BendpointMove(injector, eventBus, canvas, dragging, graphicsFactory, rules, modeling) {

  // optional connection docking integration
  var connectionDocking = injector.get('connectionDocking', false);

  // API

  this.start = function (event, connection, bendpointIndex, insert) {

    var type,
        context,
        waypoints = connection.waypoints,
        gfx = canvas.getGraphics(connection);

    if (!insert && bendpointIndex === 0) {
      type = COMMAND_RECONNECT_START;
    } else if (!insert && bendpointIndex === waypoints.length - 1) {
      type = COMMAND_RECONNECT_END;
    } else {
      type = COMMAND_BENDPOINT_UPDATE;
    }

    context = {
      connection: connection,
      bendpointIndex: bendpointIndex,
      insert: insert,
      type: type
    };

    dragging.init(event, 'bendpoint.move', {
      data: {
        connection: connection,
        connectionGfx: gfx,
        context: context
      }
    });
  };

  // DRAGGING IMPLEMENTATION


  function redrawConnection(data) {
    graphicsFactory.update('connection', data.connection, data.connectionGfx);
  }

  function filterRedundantWaypoints(waypoints) {

    // alter copy of waypoints, not original
    waypoints = waypoints.slice();

    var idx = 0,
        point,
        previousPoint,
        nextPoint;

    while (waypoints[idx]) {
      point = waypoints[idx];
      previousPoint = waypoints[idx - 1];
      nextPoint = waypoints[idx + 1];

      if ((0, _Geometry.pointDistance)(point, nextPoint) === 0 || (0, _Geometry.pointsOnLine)(previousPoint, nextPoint, point)) {

        // remove point, if overlapping with {nextPoint}
        // or on line with {previousPoint} -> {point} -> {nextPoint}
        waypoints.splice(idx, 1);
      } else {
        idx++;
      }
    }

    return waypoints;
  }

  eventBus.on('bendpoint.move.start', function (e) {

    var context = e.context,
        connection = context.connection,
        originalWaypoints = connection.waypoints,
        waypoints = originalWaypoints.slice(),
        insert = context.insert,
        idx = context.bendpointIndex;

    context.originalWaypoints = originalWaypoints;

    if (insert) {
      // insert placeholder for bendpoint to-be-added
      waypoints.splice(idx, 0, null);
    }

    connection.waypoints = waypoints;

    // add dragger gfx
    context.draggerGfx = (0, _BendpointUtil.addBendpoint)(canvas.getLayer('overlays'));
    (0, _tinySvg.classes)(context.draggerGfx).add('djs-dragging');

    canvas.addMarker(connection, MARKER_CONNECT_UPDATING);
  });

  eventBus.on('bendpoint.move.hover', function (e) {
    var context = e.context;

    context.hover = e.hover;

    if (e.hover) {
      canvas.addMarker(e.hover, MARKER_CONNECT_HOVER);

      // asks whether reconnect / bendpoint move / bendpoint add
      // is allowed at the given position
      var allowed = context.allowed = rules.allowed(context.type, context);

      if (allowed) {
        canvas.removeMarker(context.hover, MARKER_NOT_OK);
        canvas.addMarker(context.hover, MARKER_OK);

        context.target = context.hover;
      } else if (allowed === false) {
        canvas.removeMarker(context.hover, MARKER_OK);
        canvas.addMarker(context.hover, MARKER_NOT_OK);

        context.target = null;
      }
    }
  });

  eventBus.on(['bendpoint.move.out', 'bendpoint.move.cleanup'], function (e) {

    // remove connect marker
    // if it was added
    var hover = e.context.hover;

    if (hover) {
      canvas.removeMarker(hover, MARKER_CONNECT_HOVER);
      canvas.removeMarker(hover, e.context.target ? MARKER_OK : MARKER_NOT_OK);
    }
  });

  eventBus.on('bendpoint.move.move', function (e) {

    var context = e.context,
        moveType = context.type,
        connection = e.connection,
        source,
        target;

    connection.waypoints[context.bendpointIndex] = { x: e.x, y: e.y };

    if (connectionDocking) {

      if (context.hover) {
        if (moveType === COMMAND_RECONNECT_START) {
          source = context.hover;
        }

        if (moveType === COMMAND_RECONNECT_END) {
          target = context.hover;
        }
      }

      connection.waypoints = connectionDocking.getCroppedWaypoints(connection, source, target);
    }

    // add dragger gfx
    (0, _SvgTransformUtil.translate)(context.draggerGfx, e.x, e.y);

    redrawConnection(e);
  });

  eventBus.on(['bendpoint.move.end', 'bendpoint.move.cancel'], function (e) {

    var context = e.context,
        hover = context.hover,
        connection = context.connection;

    // remove dragger gfx
    (0, _tinySvg.remove)(context.draggerGfx);
    context.newWaypoints = connection.waypoints.slice();
    connection.waypoints = context.originalWaypoints;
    canvas.removeMarker(connection, MARKER_CONNECT_UPDATING);

    if (hover) {
      canvas.removeMarker(hover, MARKER_OK);
      canvas.removeMarker(hover, MARKER_NOT_OK);
    }
  });

  eventBus.on('bendpoint.move.end', function (e) {

    var context = e.context,
        waypoints = context.newWaypoints,
        bendpointIndex = context.bendpointIndex,
        bendpoint = waypoints[bendpointIndex],
        allowed = context.allowed,
        hints;

    // ensure we have actual pixel values bendpoint
    // coordinates (important when zoom level was > 1 during move)
    bendpoint.x = round(bendpoint.x);
    bendpoint.y = round(bendpoint.y);

    if (allowed && context.type === COMMAND_RECONNECT_START) {
      modeling.reconnectStart(context.connection, context.target, bendpoint);
    } else if (allowed && context.type === COMMAND_RECONNECT_END) {
      modeling.reconnectEnd(context.connection, context.target, bendpoint);
    } else if (allowed !== false && context.type === COMMAND_BENDPOINT_UPDATE) {

      // pass hints on the actual moved bendpoint
      // this is useful for connection and label layouting
      hints = {
        bendpointMove: {
          insert: e.context.insert,
          bendpointIndex: bendpointIndex
        }
      };

      modeling.updateWaypoints(context.connection, filterRedundantWaypoints(waypoints), hints);
    } else {
      redrawConnection(e);

      return false;
    }
  });

  eventBus.on('bendpoint.move.cancel', function (e) {
    redrawConnection(e);
  });
}

BendpointMove.$inject = ['injector', 'eventBus', 'canvas', 'dragging', 'graphicsFactory', 'rules', 'modeling'];

},{"../../util/Geometry":398,"../../util/SvgTransformUtil":408,"./BendpointUtil":266,"tiny-svg":535}],265:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = BendpointSnapping;

var _minDash = require('min-dash');

var abs = Math.abs,
    round = Math.round;

var TOLERANCE = 10;

function BendpointSnapping(eventBus) {

  function snapTo(values, value) {

    if ((0, _minDash.isArray)(values)) {
      var i = values.length;

      while (i--) {
        if (abs(values[i] - value) <= TOLERANCE) {
          return values[i];
        }
      }
    } else {
      values = +values;
      var rem = value % values;

      if (rem < TOLERANCE) {
        return value - rem;
      }

      if (rem > values - TOLERANCE) {
        return value - rem + values;
      }
    }

    return value;
  }

  function mid(element) {
    if (element.width) {
      return {
        x: round(element.width / 2 + element.x),
        y: round(element.height / 2 + element.y)
      };
    }
  }

  // connection segment snapping //////////////////////

  function getConnectionSegmentSnaps(context) {

    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;

    if (snapPoints) {
      return snapPoints;
    }

    var referenceWaypoints = [waypoints[segmentStartIndex - 1], segmentStart, segmentEnd, waypoints[segmentEndIndex + 1]];

    if (segmentStartIndex < 2) {
      referenceWaypoints.unshift(mid(connection.source));
    }

    if (segmentEndIndex > waypoints.length - 3) {
      referenceWaypoints.unshift(mid(connection.target));
    }

    context.snapPoints = snapPoints = { horizontal: [], vertical: [] };

    (0, _minDash.forEach)(referenceWaypoints, function (p) {
      // we snap on existing bendpoints only,
      // not placeholders that are inserted during add
      if (p) {
        p = p.original || p;

        if (axis === 'y') {
          snapPoints.horizontal.push(p.y);
        }

        if (axis === 'x') {
          snapPoints.vertical.push(p.x);
        }
      }
    });

    return snapPoints;
  }

  eventBus.on('connectionSegment.move.move', 1500, function (event) {
    var context = event.context,
        snapPoints = getConnectionSegmentSnaps(context),
        x = event.x,
        y = event.y,
        sx,
        sy;

    if (!snapPoints) {
      return;
    }

    // snap
    sx = snapTo(snapPoints.vertical, x);
    sy = snapTo(snapPoints.horizontal, y);

    // correction x/y
    var cx = x - sx,
        cy = y - sy;

    // update delta
    (0, _minDash.assign)(event, {
      dx: event.dx - cx,
      dy: event.dy - cy,
      x: sx,
      y: sy
    });
  });

  // bendpoint snapping //////////////////////

  function getBendpointSnaps(context) {

    var snapPoints = context.snapPoints,
        waypoints = context.connection.waypoints,
        bendpointIndex = context.bendpointIndex;

    if (snapPoints) {
      return snapPoints;
    }

    var referenceWaypoints = [waypoints[bendpointIndex - 1], waypoints[bendpointIndex + 1]];

    context.snapPoints = snapPoints = { horizontal: [], vertical: [] };

    (0, _minDash.forEach)(referenceWaypoints, function (p) {
      // we snap on existing bendpoints only,
      // not placeholders that are inserted during add
      if (p) {
        p = p.original || p;

        snapPoints.horizontal.push(p.y);
        snapPoints.vertical.push(p.x);
      }
    });

    return snapPoints;
  }

  eventBus.on('bendpoint.move.move', 1500, function (event) {

    var context = event.context,
        snapPoints = getBendpointSnaps(context),
        target = context.target,
        targetMid = target && mid(target),
        x = event.x,
        y = event.y,
        sx,
        sy;

    if (!snapPoints) {
      return;
    }

    // snap
    sx = snapTo(targetMid ? snapPoints.vertical.concat([targetMid.x]) : snapPoints.vertical, x);
    sy = snapTo(targetMid ? snapPoints.horizontal.concat([targetMid.y]) : snapPoints.horizontal, y);

    // correction x/y
    var cx = x - sx,
        cy = y - sy;

    // update delta
    (0, _minDash.assign)(event, {
      dx: event.dx - cx,
      dy: event.dy - cy,
      x: event.x - cx,
      y: event.y - cy
    });
  });
}

BendpointSnapping.$inject = ['eventBus'];

},{"min-dash":505}],266:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.SEGMENT_DRAGGER_CLS = exports.BENDPOINT_CLS = undefined;
exports.toCanvasCoordinates = toCanvasCoordinates;
exports.addBendpoint = addBendpoint;
exports.addSegmentDragger = addSegmentDragger;

var _Event = require('../../util/Event');

var _Geometry = require('../../util/Geometry');

var _tinySvg = require('tiny-svg');

var _SvgTransformUtil = require('../../util/SvgTransformUtil');

var BENDPOINT_CLS = exports.BENDPOINT_CLS = 'djs-bendpoint';
var SEGMENT_DRAGGER_CLS = exports.SEGMENT_DRAGGER_CLS = 'djs-segment-dragger';

function toCanvasCoordinates(canvas, event) {

  var position = (0, _Event.toPoint)(event),
      clientRect = canvas._container.getBoundingClientRect(),
      offset;

  // canvas relative position

  offset = {
    x: clientRect.left,
    y: clientRect.top
  };

  // update actual event payload with canvas relative measures

  var viewbox = canvas.viewbox();

  return {
    x: viewbox.x + (position.x - offset.x) / viewbox.scale,
    y: viewbox.y + (position.y - offset.y) / viewbox.scale
  };
}

function addBendpoint(parentGfx, cls) {
  var groupGfx = (0, _tinySvg.create)('g');
  (0, _tinySvg.classes)(groupGfx).add(BENDPOINT_CLS);

  (0, _tinySvg.append)(parentGfx, groupGfx);

  var visual = (0, _tinySvg.create)('circle');
  (0, _tinySvg.attr)(visual, {
    cx: 0,
    cy: 0,
    r: 4
  });
  (0, _tinySvg.classes)(visual).add('djs-visual');

  (0, _tinySvg.append)(groupGfx, visual);

  var hit = (0, _tinySvg.create)('circle');
  (0, _tinySvg.attr)(hit, {
    cx: 0,
    cy: 0,
    r: 10
  });
  (0, _tinySvg.classes)(hit).add('djs-hit');

  (0, _tinySvg.append)(groupGfx, hit);

  if (cls) {
    (0, _tinySvg.classes)(groupGfx).add(cls);
  }

  return groupGfx;
}

function createParallelDragger(parentGfx, position, alignment) {
  var draggerGfx = (0, _tinySvg.create)('g');

  (0, _tinySvg.append)(parentGfx, draggerGfx);

  var width = 14,
      height = 3,
      padding = 6,
      hitWidth = width + padding,
      hitHeight = height + padding;

  var visual = (0, _tinySvg.create)('rect');
  (0, _tinySvg.attr)(visual, {
    x: -width / 2,
    y: -height / 2,
    width: width,
    height: height
  });
  (0, _tinySvg.classes)(visual).add('djs-visual');

  (0, _tinySvg.append)(draggerGfx, visual);

  var hit = (0, _tinySvg.create)('rect');
  (0, _tinySvg.attr)(hit, {
    x: -hitWidth / 2,
    y: -hitHeight / 2,
    width: hitWidth,
    height: hitHeight
  });
  (0, _tinySvg.classes)(hit).add('djs-hit');

  (0, _tinySvg.append)(draggerGfx, hit);

  (0, _SvgTransformUtil.rotate)(draggerGfx, alignment === 'h' ? 90 : 0, 0, 0);

  return draggerGfx;
}

function addSegmentDragger(parentGfx, segmentStart, segmentEnd) {

  var groupGfx = (0, _tinySvg.create)('g'),
      mid = (0, _Geometry.getMidPoint)(segmentStart, segmentEnd),
      alignment = (0, _Geometry.pointsAligned)(segmentStart, segmentEnd);

  (0, _tinySvg.append)(parentGfx, groupGfx);

  createParallelDragger(groupGfx, mid, alignment);

  (0, _tinySvg.classes)(groupGfx).add(SEGMENT_DRAGGER_CLS);
  (0, _tinySvg.classes)(groupGfx).add(alignment === 'h' ? 'vertical' : 'horizontal');

  (0, _SvgTransformUtil.translate)(groupGfx, mid.x, mid.y);

  return groupGfx;
}

},{"../../util/Event":397,"../../util/Geometry":398,"../../util/SvgTransformUtil":408,"tiny-svg":535}],267:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = Bendpoints;

var _minDash = require('min-dash');

var _minDom = require('min-dom');

var _BendpointUtil = require('./BendpointUtil');

var _css = require('css.escape');

var _css2 = _interopRequireDefault(_css);

var _Geometry = require('../../util/Geometry');

var _LineIntersection = require('../../util/LineIntersection');

var _tinySvg = require('tiny-svg');

var _SvgTransformUtil = require('../../util/SvgTransformUtil');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * A service that adds editable bendpoints to connections.
 */
function Bendpoints(eventBus, canvas, interactionEvents, bendpointMove, connectionSegmentMove) {

  function getConnectionIntersection(waypoints, event) {
    var localPosition = (0, _BendpointUtil.toCanvasCoordinates)(canvas, event),
        intersection = (0, _LineIntersection.getApproxIntersection)(waypoints, localPosition);

    return intersection;
  }

  function isIntersectionMiddle(intersection, waypoints, treshold) {
    var idx = intersection.index,
        p = intersection.point,
        p0,
        p1,
        mid,
        aligned,
        xDelta,
        yDelta;

    if (idx <= 0 || intersection.bendpoint) {
      return false;
    }

    p0 = waypoints[idx - 1];
    p1 = waypoints[idx];
    mid = (0, _Geometry.getMidPoint)(p0, p1), aligned = (0, _Geometry.pointsAligned)(p0, p1);
    xDelta = Math.abs(p.x - mid.x);
    yDelta = Math.abs(p.y - mid.y);

    return aligned && xDelta <= treshold && yDelta <= treshold;
  }

  function activateBendpointMove(event, connection) {
    var waypoints = connection.waypoints,
        intersection = getConnectionIntersection(waypoints, event);

    if (!intersection) {
      return;
    }

    if (isIntersectionMiddle(intersection, waypoints, 10)) {
      connectionSegmentMove.start(event, connection, intersection.index);
    } else {
      bendpointMove.start(event, connection, intersection.index, !intersection.bendpoint);
    }

    // we've handled the event
    return true;
  }

  function bindInteractionEvents(node, eventName, element) {

    _minDom.event.bind(node, eventName, function (event) {
      interactionEvents.triggerMouseEvent(eventName, event, element);
      event.stopPropagation();
    });
  }

  function getBendpointsContainer(element, create) {

    var layer = canvas.getLayer('overlays'),
        gfx = (0, _minDom.query)('.djs-bendpoints[data-element-id="' + (0, _css2.default)(element.id) + '"]', layer);

    if (!gfx && create) {
      gfx = (0, _tinySvg.create)('g');
      (0, _tinySvg.attr)(gfx, { 'data-element-id': element.id });
      (0, _tinySvg.classes)(gfx).add('djs-bendpoints');

      (0, _tinySvg.append)(layer, gfx);

      bindInteractionEvents(gfx, 'mousedown', element);
      bindInteractionEvents(gfx, 'click', element);
      bindInteractionEvents(gfx, 'dblclick', element);
    }

    return gfx;
  }

  function createBendpoints(gfx, connection) {
    connection.waypoints.forEach(function (p, idx) {
      var bendpoint = (0, _BendpointUtil.addBendpoint)(gfx);

      (0, _tinySvg.append)(gfx, bendpoint);

      (0, _SvgTransformUtil.translate)(bendpoint, p.x, p.y);
    });

    // add floating bendpoint
    (0, _BendpointUtil.addBendpoint)(gfx, 'floating');
  }

  function createSegmentDraggers(gfx, connection) {

    var waypoints = connection.waypoints;

    var segmentStart, segmentEnd;

    for (var i = 1; i < waypoints.length; i++) {

      segmentStart = waypoints[i - 1];
      segmentEnd = waypoints[i];

      if ((0, _Geometry.pointsAligned)(segmentStart, segmentEnd)) {
        (0, _BendpointUtil.addSegmentDragger)(gfx, segmentStart, segmentEnd);
      }
    }
  }

  function clearBendpoints(gfx) {
    (0, _minDash.forEach)((0, _minDom.queryAll)('.' + _BendpointUtil.BENDPOINT_CLS, gfx), function (node) {
      (0, _tinySvg.remove)(node);
    });
  }

  function clearSegmentDraggers(gfx) {
    (0, _minDash.forEach)((0, _minDom.queryAll)('.' + _BendpointUtil.SEGMENT_DRAGGER_CLS, gfx), function (node) {
      (0, _tinySvg.remove)(node);
    });
  }

  function addHandles(connection) {

    var gfx = getBendpointsContainer(connection);

    if (!gfx) {
      gfx = getBendpointsContainer(connection, true);

      createBendpoints(gfx, connection);
      createSegmentDraggers(gfx, connection);
    }

    return gfx;
  }

  function updateHandles(connection) {

    var gfx = getBendpointsContainer(connection);

    if (gfx) {
      clearSegmentDraggers(gfx);
      clearBendpoints(gfx);
      createSegmentDraggers(gfx, connection);
      createBendpoints(gfx, connection);
    }
  }

  eventBus.on('connection.changed', function (event) {
    updateHandles(event.element);
  });

  eventBus.on('connection.remove', function (event) {
    var gfx = getBendpointsContainer(event.element);

    if (gfx) {
      (0, _tinySvg.remove)(gfx);
    }
  });

  eventBus.on('element.marker.update', function (event) {

    var element = event.element,
        bendpointsGfx;

    if (!element.waypoints) {
      return;
    }

    bendpointsGfx = addHandles(element);

    if (event.add) {
      (0, _tinySvg.classes)(bendpointsGfx).add(event.marker);
    } else {
      (0, _tinySvg.classes)(bendpointsGfx).remove(event.marker);
    }
  });

  eventBus.on('element.mousemove', function (event) {

    var element = event.element,
        waypoints = element.waypoints,
        bendpointsGfx,
        floating,
        intersection;

    if (waypoints) {
      bendpointsGfx = getBendpointsContainer(element, true);
      floating = (0, _minDom.query)('.floating', bendpointsGfx);

      if (!floating) {
        return;
      }

      intersection = getConnectionIntersection(waypoints, event.originalEvent);

      if (intersection) {
        (0, _SvgTransformUtil.translate)(floating, intersection.point.x, intersection.point.y);
      }
    }
  });

  eventBus.on('element.mousedown', function (event) {

    var originalEvent = event.originalEvent,
        element = event.element,
        waypoints = element.waypoints;

    if (!waypoints) {
      return;
    }

    return activateBendpointMove(originalEvent, element, waypoints);
  });

  eventBus.on('selection.changed', function (event) {
    var newSelection = event.newSelection,
        primary = newSelection[0];

    if (primary && primary.waypoints) {
      addHandles(primary);
    }
  });

  eventBus.on('element.hover', function (event) {
    var element = event.element;

    if (element.waypoints) {
      addHandles(element);
      interactionEvents.registerEvent(event.gfx, 'mousemove', 'element.mousemove');
    }
  });

  eventBus.on('element.out', function (event) {
    interactionEvents.unregisterEvent(event.gfx, 'mousemove', 'element.mousemove');
  });

  // update bendpoint container data attribute on element ID change
  eventBus.on('element.updateId', function (context) {
    var element = context.element,
        newId = context.newId;

    if (element.waypoints) {
      var bendpointContainer = getBendpointsContainer(element);

      if (bendpointContainer) {
        (0, _tinySvg.attr)(bendpointContainer, { 'data-element-id': newId });
      }
    }
  });

  // API

  this.addHandles = addHandles;
  this.updateHandles = updateHandles;
  this.getBendpointsContainer = getBendpointsContainer;
}

Bendpoints.$inject = ['eventBus', 'canvas', 'interactionEvents', 'bendpointMove', 'connectionSegmentMove'];

},{"../../util/Geometry":398,"../../util/LineIntersection":401,"../../util/SvgTransformUtil":408,"./BendpointUtil":266,"css.escape":237,"min-dash":505,"min-dom":506,"tiny-svg":535}],268:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = ConnectionSegmentMove;

var _Geometry = require('../../util/Geometry');

var _BendpointUtil = require('./BendpointUtil');

var _LayoutUtil = require('../../layout/LayoutUtil');

var _tinySvg = require('tiny-svg');

var _SvgTransformUtil = require('../../util/SvgTransformUtil');

var MARKER_CONNECT_HOVER = 'connect-hover',
    MARKER_CONNECT_UPDATING = 'djs-updating';

function axisAdd(point, axis, delta) {
  return axisSet(point, axis, point[axis] + delta);
}

function axisSet(point, axis, value) {
  return {
    x: axis === 'x' ? value : point.x,
    y: axis === 'y' ? value : point.y
  };
}

function axisFenced(position, segmentStart, segmentEnd, axis) {

  var maxValue = Math.max(segmentStart[axis], segmentEnd[axis]),
      minValue = Math.min(segmentStart[axis], segmentEnd[axis]);

  var padding = 20;

  var fencedValue = Math.min(Math.max(minValue + padding, position[axis]), maxValue - padding);

  return axisSet(segmentStart, axis, fencedValue);
}

function flipAxis(axis) {
  return axis === 'x' ? 'y' : 'x';
}

/**
 * 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(point, referenceElement, moveAxis) {

  var referenceMid, inverseAxis;

  if (point.original) {
    return point.original;
  } else {
    referenceMid = (0, _LayoutUtil.getMid)(referenceElement);
    inverseAxis = flipAxis(moveAxis);

    return axisSet(point, inverseAxis, referenceMid[inverseAxis]);
  }
}

/**
 * A component that implements moving of bendpoints
 */
function ConnectionSegmentMove(injector, eventBus, canvas, dragging, graphicsFactory, rules, modeling) {

  // optional connection docking integration
  var connectionDocking = injector.get('connectionDocking', false);

  // API

  this.start = function (event, connection, idx) {

    var context,
        gfx = canvas.getGraphics(connection),
        segmentStartIndex = idx - 1,
        segmentEndIndex = idx,
        waypoints = connection.waypoints,
        segmentStart = waypoints[segmentStartIndex],
        segmentEnd = waypoints[segmentEndIndex],
        direction,
        axis;

    direction = (0, _Geometry.pointsAligned)(segmentStart, segmentEnd);

    // do not move diagonal connection
    if (!direction) {
      return;
    }

    // the axis where we are going to move things
    axis = direction === 'v' ? 'y' : 'x';

    if (segmentStartIndex === 0) {
      segmentStart = getDocking(segmentStart, connection.source, axis);
    }

    if (segmentEndIndex === waypoints.length - 1) {
      segmentEnd = getDocking(segmentEnd, connection.target, axis);
    }

    context = {
      connection: connection,
      segmentStartIndex: segmentStartIndex,
      segmentEndIndex: segmentEndIndex,
      segmentStart: segmentStart,
      segmentEnd: segmentEnd,
      axis: axis
    };

    dragging.init(event, {
      x: (segmentStart.x + segmentEnd.x) / 2,
      y: (segmentStart.y + segmentEnd.y) / 2
    }, 'connectionSegment.move', {
      cursor: axis === 'x' ? 'resize-ew' : 'resize-ns',
      data: {
        connection: connection,
        connectionGfx: gfx,
        context: context
      }
    });
  };

  /**
   * Crop connection if connection cropping is provided.
   *
   * @param {Connection} connection
   * @param {Array<Point>} newWaypoints
   *
   * @return {Array<Point>} cropped connection waypoints
   */
  function cropConnection(connection, newWaypoints) {

    // crop connection, if docking service is provided only
    if (!connectionDocking) {
      return newWaypoints;
    }

    var oldWaypoints = connection.waypoints,
        croppedWaypoints;

    // temporary set new waypoints
    connection.waypoints = newWaypoints;

    croppedWaypoints = connectionDocking.getCroppedWaypoints(connection);

    // restore old waypoints
    connection.waypoints = oldWaypoints;

    return croppedWaypoints;
  }

  // DRAGGING IMPLEMENTATION

  function redrawConnection(data) {
    graphicsFactory.update('connection', data.connection, data.connectionGfx);
  }

  function updateDragger(context, segmentOffset, event) {

    var newWaypoints = context.newWaypoints,
        segmentStartIndex = context.segmentStartIndex + segmentOffset,
        segmentStart = newWaypoints[segmentStartIndex],
        segmentEndIndex = context.segmentEndIndex + segmentOffset,
        segmentEnd = newWaypoints[segmentEndIndex],
        axis = flipAxis(context.axis);

    // make sure the dragger does not move
    // outside the connection
    var draggerPosition = axisFenced(event, segmentStart, segmentEnd, axis);

    // update dragger
    (0, _SvgTransformUtil.translate)(context.draggerGfx, draggerPosition.x, draggerPosition.y);
  }

  /**
   * 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) {

    var segmentOffset = 0;

    var filteredWaypoints = waypoints.filter(function (r, idx) {
      if ((0, _Geometry.pointsOnLine)(waypoints[idx - 1], waypoints[idx + 1], r)) {

        // remove point and increment offset
        segmentOffset = idx <= segmentStartIndex ? segmentOffset - 1 : segmentOffset;
        return false;
      }

      // dont remove point
      return true;
    });

    return {
      waypoints: filteredWaypoints,
      segmentOffset: segmentOffset
    };
  }

  eventBus.on('connectionSegment.move.start', function (e) {

    var context = e.context,
        connection = e.connection,
        layer = canvas.getLayer('overlays');

    context.originalWaypoints = connection.waypoints.slice();

    // add dragger gfx
    context.draggerGfx = (0, _BendpointUtil.addSegmentDragger)(layer, context.segmentStart, context.segmentEnd);
    (0, _tinySvg.classes)(context.draggerGfx).add('djs-dragging');

    canvas.addMarker(connection, MARKER_CONNECT_UPDATING);
  });

  eventBus.on('connectionSegment.move.move', function (e) {

    var context = e.context,
        connection = context.connection,
        segmentStartIndex = context.segmentStartIndex,
        segmentEndIndex = context.segmentEndIndex,
        segmentStart = context.segmentStart,
        segmentEnd = context.segmentEnd,
        axis = context.axis;

    var newWaypoints = context.originalWaypoints.slice(),
        newSegmentStart = axisAdd(segmentStart, axis, e['d' + axis]),
        newSegmentEnd = axisAdd(segmentEnd, axis, e['d' + axis]);

    // 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;

    // move segment start / end by axis delta
    newWaypoints[segmentStartIndex] = newSegmentStart;
    newWaypoints[segmentEndIndex] = newSegmentEnd;

    var sourceToSegmentOrientation, targetToSegmentOrientation;

    // handle first segment
    if (segmentStartIndex < 2) {
      sourceToSegmentOrientation = (0, _LayoutUtil.getOrientation)(connection.source, newSegmentStart);

      // first bendpoint, remove first segment if intersecting
      if (segmentStartIndex === 1) {

        if (sourceToSegmentOrientation === 'intersect') {
          newWaypoints.shift();
          newWaypoints[0] = newSegmentStart;
          segmentOffset--;
        }
      }

      // docking point, add segment if not intersecting anymore
      else {
          if (sourceToSegmentOrientation !== 'intersect') {
            newWaypoints.unshift(segmentStart);
            segmentOffset++;
          }
        }
    }

    // handle last segment
    if (segmentEndIndex > waypointCount - 3) {
      targetToSegmentOrientation = (0, _LayoutUtil.getOrientation)(connection.target, newSegmentEnd);

      // last bendpoint, remove last segment if intersecting
      if (segmentEndIndex === waypointCount - 2) {

        if (targetToSegmentOrientation === 'intersect') {
          newWaypoints.pop();
          newWaypoints[newWaypoints.length - 1] = newSegmentEnd;
        }
      }

      // last bendpoint, remove last segment if intersecting
      else {
          if (targetToSegmentOrientation !== 'intersect') {
            newWaypoints.push(segmentEnd);
          }
        }
    }

    // update connection waypoints
    context.newWaypoints = connection.waypoints = cropConnection(connection, newWaypoints);

    // update dragger position
    updateDragger(context, segmentOffset, e);

    // save segmentOffset in context
    context.newSegmentStartIndex = segmentStartIndex + segmentOffset;

    // redraw connection
    redrawConnection(e);
  });

  eventBus.on('connectionSegment.move.hover', function (e) {

    e.context.hover = e.hover;
    canvas.addMarker(e.hover, MARKER_CONNECT_HOVER);
  });

  eventBus.on(['connectionSegment.move.out', 'connectionSegment.move.cleanup'], function (e) {

    // remove connect marker
    // if it was added
    var hover = e.context.hover;

    if (hover) {
      canvas.removeMarker(hover, MARKER_CONNECT_HOVER);
    }
  });

  eventBus.on('connectionSegment.move.cleanup', function (e) {

    var context = e.context,
        connection = context.connection;

    // remove dragger gfx
    if (context.draggerGfx) {
      (0, _tinySvg.remove)(context.draggerGfx);
    }

    canvas.removeMarker(connection, MARKER_CONNECT_UPDATING);
  });

  eventBus.on(['connectionSegment.move.cancel', 'connectionSegment.move.end'], function (e) {
    var context = e.context,
        connection = context.connection;

    connection.waypoints = context.originalWaypoints;

    redrawConnection(e);
  });

  eventBus.on('connectionSegment.move.end', function (e) {

    var context = e.context,
        connection = context.connection,
        newWaypoints = context.newWaypoints,
        newSegmentStartIndex = context.newSegmentStartIndex;

    // 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)
      };
    });

    // apply filter redunant waypoints
    var filtered = filterRedundantWaypoints(newWaypoints, newSegmentStartIndex);

    // get filtered waypoints
    var filteredWaypoints = filtered.waypoints,
        croppedWaypoints = cropConnection(connection, filteredWaypoints),
        segmentOffset = filtered.segmentOffset;

    var hints = {
      segmentMove: {
        segmentStartIndex: context.segmentStartIndex,
        newSegmentStartIndex: newSegmentStartIndex + segmentOffset
      }
    };

    modeling.updateWaypoints(connection, croppedWaypoints, hints);
  });
}

ConnectionSegmentMove.$inject = ['injector', 'eventBus', 'canvas', 'dragging', 'graphicsFactory', 'rules', 'modeling'];

},{"../../layout/LayoutUtil":380,"../../util/Geometry":398,"../../util/SvgTransformUtil":408,"./BendpointUtil":266,"tiny-svg":535}],269:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _dragging = require('../dragging');

var _dragging2 = _interopRequireDefault(_dragging);

var _rules = require('../rules');

var _rules2 = _interopRequireDefault(_rules);

var _Bendpoints = require('./Bendpoints');

var _Bendpoints2 = _interopRequireDefault(_Bendpoints);

var _BendpointMove = require('./BendpointMove');

var _BendpointMove2 = _interopRequireDefault(_BendpointMove);

var _ConnectionSegmentMove = require('./ConnectionSegmentMove');

var _ConnectionSegmentMove2 = _interopRequireDefault(_ConnectionSegmentMove);

var _BendpointSnapping = require('./BendpointSnapping');

var _BendpointSnapping2 = _interopRequireDefault(_BendpointSnapping);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __depends__: [_dragging2.default, _rules2.default],
  __init__: ['bendpoints', 'bendpointSnapping'],
  bendpoints: ['type', _Bendpoints2.default],
  bendpointMove: ['type', _BendpointMove2.default],
  connectionSegmentMove: ['type', _ConnectionSegmentMove2.default],
  bendpointSnapping: ['type', _BendpointSnapping2.default]
};

},{"../dragging":286,"../rules":355,"./BendpointMove":264,"./BendpointSnapping":265,"./Bendpoints":267,"./ConnectionSegmentMove":268}],270:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = ChangeSupport;

var _Elements = require('../../util/Elements');

/**
 * 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) {

  // redraw shapes / connections on change

  eventBus.on('element.changed', function (event) {

    var element = event.element;

    // 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);
    }

    // shape + gfx may have been deleted
    if (!event.gfx) {
      return;
    }

    eventBus.fire((0, _Elements.getType)(element) + '.changed', event);
  });

  eventBus.on('elements.changed', function (event) {

    var elements = event.elements;

    elements.forEach(function (e) {
      eventBus.fire('element.changed', { element: e });
    });

    graphicsFactory.updateContainments(elements);
  });

  eventBus.on('shape.changed', function (event) {
    graphicsFactory.update('shape', event.element, event.gfx);
  });

  eventBus.on('connection.changed', function (event) {
    graphicsFactory.update('connection', event.element, event.gfx);
  });
}

ChangeSupport.$inject = ['eventBus', 'canvas', 'elementRegistry', 'graphicsFactory'];

},{"../../util/Elements":396}],271:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _ChangeSupport = require('./ChangeSupport');

var _ChangeSupport2 = _interopRequireDefault(_ChangeSupport);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __init__: ['changeSupport'],
  changeSupport: ['type', _ChangeSupport2.default]
};

},{"./ChangeSupport":270}],272:[function(require,module,exports){
"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = Clipboard;
/**
 * A clip board stub
 */
function Clipboard() {}

Clipboard.prototype.get = function () {
  return this._data;
};

Clipboard.prototype.set = function (data) {
  this._data = data;
};

Clipboard.prototype.clear = function () {
  var data = this._data;

  delete this._data;

  return data;
};

Clipboard.prototype.isEmpty = function () {
  return !this._data;
};

},{}],273:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _Clipboard = require('./Clipboard');

var _Clipboard2 = _interopRequireDefault(_Clipboard);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  clipboard: ['type', _Clipboard2.default]
};

},{"./Clipboard":272}],274:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

exports.default = Connect;

var _LayoutUtil = require('../../layout/LayoutUtil');

var _tinySvg = require('tiny-svg');

var MARKER_OK = 'connect-ok',
    MARKER_NOT_OK = 'connect-not-ok';

function Connect(eventBus, dragging, modeling, rules, canvas, graphicsFactory) {

  // TODO(nre): separate UI and events

  // rules

  function canConnect(source, target) {
    return rules.allowed('connection.create', {
      source: source,
      target: target
    });
  }

  // layouting

  function crop(start, end, source, target) {

    var sourcePath = graphicsFactory.getShapePath(source),
        targetPath = target && graphicsFactory.getShapePath(target),
        connectionPath = graphicsFactory.getConnectionPath({ waypoints: [start, end] });

    start = (0, _LayoutUtil.getElementLineIntersection)(sourcePath, connectionPath, true) || start;
    end = target && (0, _LayoutUtil.getElementLineIntersection)(targetPath, connectionPath, false) || end;

    return [start, end];
  }

  // event handlers

  eventBus.on('connect.move', function (event) {

    var context = event.context,
        source = context.source,
        target = context.target,
        visual = context.visual,
        sourcePosition = context.sourcePosition,
        endPosition,
        waypoints;

    // update connection visuals during drag

    endPosition = {
      x: event.x,
      y: event.y
    };

    waypoints = crop(sourcePosition, endPosition, source, target);

    (0, _tinySvg.attr)(visual, { 'points': [waypoints[0].x, waypoints[0].y, waypoints[1].x, waypoints[1].y] });
  });

  eventBus.on('connect.hover', function (event) {
    var context = event.context,
        source = context.source,
        hover = event.hover,
        canExecute;

    canExecute = context.canExecute = canConnect(source, hover);

    // simply ignore hover
    if (canExecute === null) {
      return;
    }

    context.target = hover;

    canvas.addMarker(hover, canExecute ? MARKER_OK : MARKER_NOT_OK);
  });

  eventBus.on(['connect.out', 'connect.cleanup'], function (event) {
    var context = event.context;

    if (context.target) {
      canvas.removeMarker(context.target, context.canExecute ? MARKER_OK : MARKER_NOT_OK);
    }

    context.target = null;
    context.canExecute = false;
  });

  eventBus.on('connect.cleanup', function (event) {
    var context = event.context;

    if (context.visual) {
      (0, _tinySvg.remove)(context.visual);
    }
  });

  eventBus.on('connect.start', function (event) {
    var context = event.context,
        visual;

    visual = (0, _tinySvg.create)('polyline');
    (0, _tinySvg.attr)(visual, {
      'stroke': '#333',
      'strokeDasharray': [1],
      'strokeWidth': 2,
      'pointer-events': 'none'
    });

    (0, _tinySvg.append)(canvas.getDefaultLayer(), visual);

    context.visual = visual;
  });

  eventBus.on('connect.end', function (event) {

    var context = event.context,
        source = context.source,
        sourcePosition = context.sourcePosition,
        target = context.target,
        targetPosition = {
      x: event.x,
      y: event.y
    },
        canExecute = context.canExecute || canConnect(source, target);

    if (!canExecute) {
      return false;
    }

    var attrs = null,
        hints = {
      connectionStart: sourcePosition,
      connectionEnd: targetPosition
    };

    if ((typeof canExecute === 'undefined' ? 'undefined' : _typeof(canExecute)) === 'object') {
      attrs = canExecute;
    }

    modeling.connect(source, target, attrs, hints);
  });

  // API

  /**
   * Start connect operation.
   *
   * @param {DOMEvent} event
   * @param {djs.model.Base} source
   * @param {Point} [sourcePosition]
   * @param {Boolean} [autoActivate=false]
   */
  this.start = function (event, source, sourcePosition, autoActivate) {

    if ((typeof sourcePosition === 'undefined' ? 'undefined' : _typeof(sourcePosition)) !== 'object') {
      autoActivate = sourcePosition;
      sourcePosition = (0, _LayoutUtil.getMid)(source);
    }

    dragging.init(event, 'connect', {
      autoActivate: autoActivate,
      data: {
        shape: source,
        context: {
          source: source,
          sourcePosition: sourcePosition
        }
      }
    });
  };
}

Connect.$inject = ['eventBus', 'dragging', 'modeling', 'rules', 'canvas', 'graphicsFactory'];

},{"../../layout/LayoutUtil":380,"tiny-svg":535}],275:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _selection = require('../selection');

var _selection2 = _interopRequireDefault(_selection);

var _rules = require('../rules');

var _rules2 = _interopRequireDefault(_rules);

var _dragging = require('../dragging');

var _dragging2 = _interopRequireDefault(_dragging);

var _Connect = require('./Connect');

var _Connect2 = _interopRequireDefault(_Connect);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __depends__: [_selection2.default, _rules2.default, _dragging2.default],
  connect: ['type', _Connect2.default]
};

},{"../dragging":286,"../rules":355,"../selection":361,"./Connect":274}],276:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = ContextPad;

var _minDash = require('min-dash');

var _minDom = require('min-dom');

var entrySelector = '.entry';

/**
 * 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) {

  this._providers = [];

  this._eventBus = eventBus;
  this._overlays = overlays;

  var scale = (0, _minDash.isDefined)(config && config.scale) ? config.scale : {
    min: 1,
    max: 1.5
  };

  this._overlaysConfig = {
    position: {
      right: -9,
      top: -6
    },
    scale: scale
  };

  this._current = null;

  this._init();
}

ContextPad.$inject = ['config.contextPad', 'eventBus', 'overlays'];

/**
 * Registers events needed for interaction with other components
 */
ContextPad.prototype._init = function () {

  var eventBus = this._eventBus;

  var self = this;

  eventBus.on('selection.changed', function (e) {

    var selection = e.newSelection;

    if (selection.length === 1) {
      self.open(selection[0]);
    } else {
      self.close();
    }
  });

  eventBus.on('elements.delete', function (event) {
    var elements = event.elements;

    (0, _minDash.forEach)(elements, function (e) {
      if (self.isOpen(e)) {
        self.close();
      }
    });
  });

  eventBus.on('element.changed', function (event) {
    var element = event.element,
        current = self._current;

    // force reopen if element for which we are currently opened changed
    if (current && current.element === element) {
      self.open(element, true);
    }
  });
};

/**
 * Register a provider with the context pad
 *
 * @param  {ContextPadProvider} provider
 */
ContextPad.prototype.registerProvider = function (provider) {
  this._providers.push(provider);
};

/**
 * 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 entries = {};

  // loop through all providers and their entries.
  // group entries by id so that overriding an entry is possible
  (0, _minDash.forEach)(this._providers, function (provider) {
    var e = provider.getContextPadEntries(element);

    (0, _minDash.forEach)(e, function (entry, id) {
      entries[id] = entry;
    });
  });

  return entries;
};

/**
 * 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) {

  var element = this._current.element,
      entries = this._current.entries,
      entry,
      handler,
      originalEvent,
      button = event.delegateTarget || event.target;

  if (!button) {
    return event.preventDefault();
  }

  entry = entries[(0, _minDom.attr)(button, 'data-action')];
  handler = entry.action;

  originalEvent = event.originalEvent || event;

  // simple action (via callback function)
  if ((0, _minDash.isFunction)(handler)) {
    if (action === 'click') {
      return handler(originalEvent, element, autoActivate);
    }
  } else {
    if (handler[action]) {
      return handler[action](originalEvent, element, autoActivate);
    }
  }

  // silence other actions
  event.preventDefault();
};

/**
 * 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;
  }

  this.close();
  this._updateAndOpen(element);
};

ContextPad.prototype._updateAndOpen = function (element) {

  var entries = this.getEntries(element),
      pad = this.getPad(element),
      html = pad.html;

  (0, _minDash.forEach)(entries, function (entry, id) {
    var grouping = entry.group || 'default',
        control = (0, _minDom.domify)(entry.html || '<div class="entry" draggable="true"></div>'),
        container;

    (0, _minDom.attr)(control, 'data-action', id);

    container = (0, _minDom.query)('[data-group=' + grouping + ']', html);
    if (!container) {
      container = (0, _minDom.domify)('<div class="group" data-group="' + grouping + '"></div>');
      html.appendChild(container);
    }

    container.appendChild(control);

    if (entry.className) {
      addClasses(control, entry.className);
    }

    if (entry.title) {
      (0, _minDom.attr)(control, 'title', entry.title);
    }

    if (entry.imageUrl) {
      control.appendChild((0, _minDom.domify)('<img src="' + entry.imageUrl + '">'));
    }
  });

  (0, _minDom.classes)(html).add('open');

  this._current = {
    element: element,
    pad: pad,
    entries: entries
  };

  this._eventBus.fire('contextPad.open', { current: this._current });
};

ContextPad.prototype.getPad = function (element) {
  if (this.isOpen()) {
    return this._current.pad;
  }

  var self = this;

  var overlays = this._overlays;

  var html = (0, _minDom.domify)('<div class="djs-context-pad"></div>');

  var overlaysConfig = (0, _minDash.assign)({
    html: html
  }, this._overlaysConfig);

  _minDom.delegate.bind(html, entrySelector, 'click', function (event) {
    self.trigger('click', event);
  });

  _minDom.delegate.bind(html, entrySelector, 'dragstart', function (event) {
    self.trigger('dragstart', event);
  });

  // stop propagation of mouse events
  _minDom.event.bind(html, 'mousedown', function (event) {
    event.stopPropagation();
  });

  this._overlayId = overlays.add(element, 'context-pad', overlaysConfig);

  var pad = overlays.get(this._overlayId);

  this._eventBus.fire('contextPad.create', { element: element, pad: pad });

  return pad;
};

/**
 * Close the context pad
 */
ContextPad.prototype.close = function () {
  if (!this.isOpen()) {
    return;
  }

  this._overlays.remove(this._overlayId);

  this._overlayId = null;

  this._eventBus.fire('contextPad.close', { current: this._current });

  this._current = null;
};

/**
 * 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);
};

// helpers //////////////////////

function addClasses(element, classNames) {

  var classes = (0, _minDom.classes)(element);

  var actualClassNames = (0, _minDash.isArray)(classNames) ? classNames : classNames.split(/\s+/g);
  actualClassNames.forEach(function (cls) {
    classes.add(cls);
  });
}

},{"min-dash":505,"min-dom":506}],277:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _interactionEvents = require('../interaction-events');

var _interactionEvents2 = _interopRequireDefault(_interactionEvents);

var _overlays = require('../overlays');

var _overlays2 = _interopRequireDefault(_overlays);

var _ContextPad = require('./ContextPad');

var _ContextPad2 = _interopRequireDefault(_ContextPad);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __depends__: [_interactionEvents2.default, _overlays2.default],
  contextPad: ['type', _ContextPad2.default]
};

},{"../interaction-events":294,"../overlays":339,"./ContextPad":276}],278:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = CopyPaste;

var _minDash = require('min-dash');

var _Elements = require('../../util/Elements');

var _PositionUtil = require('../../util/PositionUtil');

var _CopyPasteUtil = require('../../util/CopyPasteUtil');

function CopyPaste(eventBus, modeling, elementFactory, rules, clipboard, canvas) {

  this._eventBus = eventBus;
  this._modeling = modeling;
  this._elementFactory = elementFactory;
  this._rules = rules;
  this._canvas = canvas;

  this._clipboard = clipboard;

  this._descriptors = [];

  // Element creation priorities:
  // - 1: Independent shapes
  // - 2: Attached shapes
  // - 3: Connections
  // - 4: labels
  this.registerDescriptor(function (element, descriptor) {
    // Base priority
    descriptor.priority = 1;

    descriptor.id = element.id;

    if (element.parent) {
      descriptor.parent = element.parent.id;
    }

    if (element.labelTarget) {
      // Labels priority
      descriptor.priority = 4;
      descriptor.labelTarget = element.labelTarget.id;
    }

    if (element.host) {
      // Attached shapes priority
      descriptor.priority = 2;
      descriptor.host = element.host.id;
    }

    if (typeof element.x === 'number') {
      descriptor.x = element.x;
      descriptor.y = element.y;
    }

    if (element.width) {
      descriptor.width = element.width;
      descriptor.height = element.height;
    }

    if (element.waypoints) {
      // Connections priority
      descriptor.priority = 3;
      descriptor.waypoints = [];

      (0, _minDash.forEach)(element.waypoints, function (waypoint) {
        var wp = {
          x: waypoint.x,
          y: waypoint.y
        };

        if (waypoint.original) {
          wp.original = {
            x: waypoint.original.x,
            y: waypoint.original.y
          };
        }

        descriptor.waypoints.push(wp);
      });
    }

    if (element.source && element.target) {
      descriptor.source = element.source.id;
      descriptor.target = element.target.id;
    }

    return descriptor;
  });
}

CopyPaste.$inject = ['eventBus', 'modeling', 'elementFactory', 'rules', 'clipboard', 'canvas'];

/**
 * Copy a number of elements.
 *
 * @param {djs.model.Base} selectedElements
 *
 * @return {Object} the copied tree
 */
CopyPaste.prototype.copy = function (selectedElements) {
  var clipboard = this._clipboard,
      tree,
      bbox;

  if (!(0, _minDash.isArray)(selectedElements)) {
    selectedElements = selectedElements ? [selectedElements] : [];
  }

  if (!selectedElements.length) {
    return;
  }

  tree = this.createTree(selectedElements);

  bbox = this._bbox = (0, _PositionUtil.center)((0, _Elements.getBBox)(tree.allShapes));

  // not needed after computing the center position of the copied elements
  delete tree.allShapes;

  (0, _minDash.forEach)(tree, function (elements) {

    (0, _minDash.forEach)(elements, function (element) {
      var delta, labelTarget;

      // set label's relative position to their label target
      if (element.labelTarget) {
        labelTarget = (0, _minDash.find)(elements, (0, _minDash.matchPattern)({ id: element.labelTarget }));

        // just grab the delta from the first waypoint
        if (labelTarget.waypoints) {
          delta = (0, _PositionUtil.delta)(element, labelTarget.waypoints[0]);
        } else {
          delta = (0, _PositionUtil.delta)(element, labelTarget);
        }
      } else if (element.priority === 3) {
        // connections have priority 3
        delta = [];

        (0, _minDash.forEach)(element.waypoints, function (waypoint) {
          var waypointDelta = (0, _PositionUtil.delta)(waypoint, bbox);

          delta.push(waypointDelta);
        });
      } else {
        delta = (0, _PositionUtil.delta)(element, bbox);
      }

      element.delta = delta;
    });
  });

  this._eventBus.fire('elements.copy', { context: { tree: tree } });

  // if tree is empty, means that nothing can be or is allowed to be copied
  if (Object.keys(tree).length === 0) {
    clipboard.clear();
  } else {
    clipboard.set(tree);
  }

  this._eventBus.fire('elements.copied', { context: { tree: tree } });

  return tree;
};

// Allow pasting under the cursor
CopyPaste.prototype.paste = function (context) {
  var clipboard = this._clipboard,
      modeling = this._modeling,
      eventBus = this._eventBus,
      rules = this._rules;

  var tree = clipboard.get(),
      topParent = context.element,
      position = context.point,
      newTree,
      canPaste;

  if (clipboard.isEmpty()) {
    return;
  }

  newTree = (0, _minDash.reduce)(tree, function (pasteTree, elements, depthStr) {
    var depth = parseInt(depthStr, 10);

    if (isNaN(depth)) {
      return pasteTree;
    }

    pasteTree[depth] = elements;

    return pasteTree;
  }, {});

  canPaste = rules.allowed('elements.paste', {
    tree: newTree,
    target: topParent
  });

  if (!canPaste) {
    eventBus.fire('elements.paste.rejected', {
      context: {
        tree: newTree,
        position: position,
        target: topParent
      }
    });

    return;
  }

  modeling.pasteElements(newTree, topParent, position);
};

CopyPaste.prototype._computeDelta = function (elements, element) {
  var bbox = this._bbox,
      delta = {};

  // set label's relative position to their label target
  if (element.labelTarget) {
    return (0, _PositionUtil.delta)(element, element.labelTarget);
  }

  // connections have prority 3
  if (element.priority === 3) {
    delta = [];

    (0, _minDash.forEach)(element.waypoints, function (waypoint) {
      var waypointDelta = (0, _PositionUtil.delta)(waypoint, bbox);

      delta.push(waypointDelta);
    });
  } else {
    delta = (0, _PositionUtil.delta)(element, bbox);
  }

  return delta;
};

/**
 * Checks if the element in question has a relations to other elements.
 * Possible dependants: connections, labels, attachers
 *
 * @param  {Array} elements
 * @param  {Object} element
 *
 * @return {Boolean}
 */
CopyPaste.prototype.hasRelations = function (elements, element) {
  var source, target, labelTarget;

  if (element.waypoints) {
    source = (0, _minDash.find)(elements, (0, _minDash.matchPattern)({ id: element.source.id }));
    target = (0, _minDash.find)(elements, (0, _minDash.matchPattern)({ id: element.target.id }));

    if (!source || !target) {
      return false;
    }
  }

  if (element.labelTarget) {
    labelTarget = (0, _minDash.find)(elements, (0, _minDash.matchPattern)({ id: element.labelTarget.id }));

    if (!labelTarget) {
      return false;
    }
  }

  return true;
};

CopyPaste.prototype.registerDescriptor = function (descriptor) {
  if (typeof descriptor !== 'function') {
    throw new Error('the descriptor must be a function');
  }

  if (this._descriptors.indexOf(descriptor) !== -1) {
    throw new Error('this descriptor is already registered');
  }

  this._descriptors.push(descriptor);
};

CopyPaste.prototype._executeDescriptors = function (data) {
  if (!data.descriptor) {
    data.descriptor = {};
  }

  (0, _minDash.forEach)(this._descriptors, function (descriptor) {
    data.descriptor = descriptor(data.element, data.descriptor);
  });

  return data;
};

/**
 * Creates a tree like structure from an arbitrary collection of elements
 *
 * @example
 * tree: {
 *	0: [
 *		{ id: 'shape_12da', priority: 1, ... },
 *		{ id: 'shape_01bj', priority: 1, ... },
 *		{ id: 'connection_79fa', source: 'shape_12da', target: 'shape_01bj', priority: 3, ... },
 *	],
 *	1: [ ... ]
 * };
 *
 * @param  {Array} elements
 * @return {Object}
 */
CopyPaste.prototype.createTree = function (elements) {
  var rules = this._rules,
      self = this;

  var tree = {},
      includedElements = [],
      _elements;

  var topLevel = (0, _CopyPasteUtil.getTopLevel)(elements);

  tree.allShapes = [];

  function canCopy(collection, element) {
    return rules.allowed('element.copy', {
      collection: collection,
      element: element
    });
  }

  function includeElement(data) {
    var idx = (0, _minDash.findIndex)(includedElements, (0, _minDash.matchPattern)({ element: data.element })),
        element;

    if (idx !== -1) {
      element = includedElements[idx];
    } else {
      return includedElements.push(data);
    }

    // makes sure that it has the correct depth
    if (element.depth < data.depth) {
      includedElements.splice(idx, 1);

      includedElements.push(data);
    }
  }

  (0, _Elements.eachElement)(topLevel, function (element, i, depth) {
    var nestedChildren = element.children;

    // don't add labels directly
    if (element.labelTarget) {
      return;
    }

    function getNested(lists) {
      (0, _minDash.forEach)(lists, function (list) {
        if (list && list.length) {

          (0, _minDash.forEach)(list, function (elem) {

            (0, _minDash.forEach)(elem.labels, function (label) {
              includeElement({
                element: label,
                depth: depth
              });
            });

            includeElement({
              element: elem,
              depth: depth
            });
          });
        }
      });
    }

    // fetch element's labels
    (0, _minDash.forEach)(element.labels, function (label) {

      includeElement({
        element: label,
        depth: depth
      });
    });

    getNested([element.attachers, element.incoming, element.outgoing]);

    includeElement({
      element: element,
      depth: depth
    });

    if (nestedChildren) {
      return nestedChildren;
    }
  });

  includedElements = (0, _minDash.map)(includedElements, function (data) {
    // this is where other registered descriptors hook in
    return self._executeDescriptors(data);
  });

  // order the elements to check if the ones dependant on others (by relationship)
  // can be copied. f.ex: label needs it's label target
  includedElements = (0, _minDash.sortBy)(includedElements, function (data) {
    return data.descriptor.priority;
  });

  _elements = (0, _minDash.map)(includedElements, function (data) {
    return data.element;
  });

  (0, _minDash.forEach)(includedElements, function (data) {
    var depth = data.depth;

    if (!self.hasRelations(tree.allShapes, data.element)) {
      return;
    }

    if (!canCopy(_elements, data.element)) {
      return;
    }

    tree.allShapes.push(data.element);

    // create depth branches
    if (!tree[depth]) {
      tree[depth] = [];
    }

    tree[depth].push(data.descriptor);
  });

  return tree;
};

},{"../../util/CopyPasteUtil":394,"../../util/Elements":396,"../../util/PositionUtil":405,"min-dash":505}],279:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _clipboard = require('../clipboard');

var _clipboard2 = _interopRequireDefault(_clipboard);

var _rules = require('../rules');

var _rules2 = _interopRequireDefault(_rules);

var _mouseTracking = require('../mouse-tracking');

var _mouseTracking2 = _interopRequireDefault(_mouseTracking);

var _CopyPaste = require('./CopyPaste');

var _CopyPaste2 = _interopRequireDefault(_CopyPaste);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __depends__: [_clipboard2.default, _rules2.default, _mouseTracking2.default],
  __init__: ['copyPaste'],
  copyPaste: ['type', _CopyPaste2.default]
};

},{"../clipboard":273,"../mouse-tracking":331,"../rules":355,"./CopyPaste":278}],280:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = Create;

var _tinySvg = require('tiny-svg');

var _SvgTransformUtil = require('../../util/SvgTransformUtil');

var LOW_PRIORITY = 750;

var MARKER_OK = 'drop-ok',
    MARKER_NOT_OK = 'drop-not-ok',
    MARKER_ATTACH = 'attach-ok',
    MARKER_NEW_PARENT = 'new-parent';

/**
 * Adds the ability to create new shapes via drag and drop.
 *
 * Create must be activated via {@link Create#start}. From that
 * point on, create will invoke `shape.create` and `shape.attach`
 * rules to query whether or not creation or attachment on a certain
 * position is allowed.
 *
 * If create or attach is allowed and a source is given, Create it
 * will invoke `connection.create` rules to query whether a connection
 * can be drawn between source and new shape. During rule evaluation
 * the target is not attached yet, however
 *
 *   hints = { targetParent, targetAttach }
 *
 * are passed to the evaluating rules.
 *
 *
 * ## Rule Return Values
 *
 * Return values interpreted from  `shape.create`:
 *
 *   * `true`: create is allowed
 *   * `false`: create is disallowed
 *   * `null`: create is not allowed but should be ignored visually
 *
 * Return values interpreted from `shape.attach`:
 *
 *   * `true`: attach is allowed
 *   * `Any`: attach is allowed with the constraints
 *   * `false`: attach is disallowed
 *
 * Return values interpreted from `connection.create`:
 *
 *   * `true`: connection can be created
 *   * `Any`: connection with the given attributes can be created
 *   * `false`: connection can't be created
 *
 *
 * @param {EventBus} eventBus
 * @param {Dragging} dragging
 * @param {Rules} rules
 * @param {Modeling} modeling
 * @param {Canvas} canvas
 * @param {Styles} styles
 * @param {GraphicsFactory} graphicsFactory
 */
function Create(eventBus, dragging, rules, modeling, canvas, styles, graphicsFactory) {

  // rules

  function canCreate(shape, target, source, position) {

    if (!target) {
      return false;
    }

    var ctx = {
      source: source,
      shape: shape,
      target: target,
      position: position
    };

    var create, attach, connect;

    attach = rules.allowed('shape.attach', ctx);

    if (!attach) {
      create = rules.allowed('shape.create', ctx);
    }

    if (create || attach) {

      connect = source && rules.allowed('connection.create', {
        source: source,
        target: shape,
        hints: {
          targetParent: target,
          targetAttach: attach
        }
      });
    }

    if (create || attach) {
      return {
        attach: attach,
        connect: connect
      };
    }

    return false;
  }

  /** set drop marker on an element */
  function setMarker(element, marker) {

    [MARKER_ATTACH, MARKER_OK, MARKER_NOT_OK, MARKER_NEW_PARENT].forEach(function (m) {

      if (m === marker) {
        canvas.addMarker(element, m);
      } else {
        canvas.removeMarker(element, m);
      }
    });
  }

  // visual helpers

  function createVisual(shape) {
    var group, preview, visual;

    group = (0, _tinySvg.create)('g');
    (0, _tinySvg.attr)(group, styles.cls('djs-drag-group', ['no-events']));

    (0, _tinySvg.append)(canvas.getDefaultLayer(), group);

    preview = (0, _tinySvg.create)('g');
    (0, _tinySvg.classes)(preview).add('djs-dragger');

    (0, _tinySvg.append)(group, preview);

    (0, _SvgTransformUtil.translate)(preview, shape.width / -2, shape.height / -2);

    var visualGroup = (0, _tinySvg.create)('g');
    (0, _tinySvg.classes)(visualGroup).add('djs-visual');

    (0, _tinySvg.append)(preview, visualGroup);

    visual = visualGroup;

    // hijack renderer to draw preview
    graphicsFactory.drawShape(visual, shape);

    return group;
  }

  // event handlers

  eventBus.on('create.move', function (event) {

    var context = event.context,
        hover = event.hover,
        shape = context.shape,
        source = context.source,
        canExecute;

    var position = {
      x: event.x,
      y: event.y
    };

    canExecute = context.canExecute = hover && canCreate(shape, hover, source, position);

    // ignore hover visually if canExecute is null
    if (hover && canExecute !== null) {
      context.target = hover;

      if (canExecute && canExecute.attach) {
        setMarker(hover, MARKER_ATTACH);
      } else {
        setMarker(hover, canExecute ? MARKER_NEW_PARENT : MARKER_NOT_OK);
      }
    }
  });

  eventBus.on('create.move', LOW_PRIORITY, function (event) {

    var context = event.context,
        shape = context.shape,
        visual = context.visual;

    // lazy init drag visual once we received the first real
    // drag move event (this allows us to get the proper canvas local coordinates)
    if (!visual) {
      visual = context.visual = createVisual(shape);
    }

    (0, _SvgTransformUtil.translate)(visual, event.x, event.y);
  });

  eventBus.on(['create.end', 'create.out', 'create.cleanup'], function (event) {
    var context = event.context,
        target = context.target;

    if (target) {
      setMarker(target, null);
    }
  });

  eventBus.on('create.end', function (event) {
    var context = event.context,
        source = context.source,
        shape = context.shape,
        target = context.target,
        canExecute = context.canExecute,
        attach = canExecute && canExecute.attach,
        connect = canExecute && canExecute.connect,
        position = {
      x: event.x,
      y: event.y
    };

    if (!canExecute) {
      return false;
    }

    if (connect) {
      // invoke append if connect is set via rules
      shape = modeling.appendShape(source, shape, position, target, {
        attach: attach,
        connection: connect === true ? {} : connect
      });
    } else {
      // invoke create, if connect is not set
      shape = modeling.createShape(shape, position, target, {
        attach: attach
      });
    }

    // make sure we provide the actual attached
    // shape with the context so that selection and
    // other components can use it right after the create
    // operation ends
    context.shape = shape;
  });

  eventBus.on('create.cleanup', function (event) {
    var context = event.context;

    if (context.visual) {
      (0, _tinySvg.remove)(context.visual);
    }
  });

  // API

  this.start = function (event, shape, source) {

    dragging.init(event, 'create', {
      cursor: 'grabbing',
      autoActivate: true,
      data: {
        shape: shape,
        context: {
          shape: shape,
          source: source
        }
      }
    });
  };
}

Create.$inject = ['eventBus', 'dragging', 'rules', 'modeling', 'canvas', 'styles', 'graphicsFactory'];

},{"../../util/SvgTransformUtil":408,"tiny-svg":535}],281:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _dragging = require('../dragging');

var _dragging2 = _interopRequireDefault(_dragging);

var _selection = require('../selection');

var _selection2 = _interopRequireDefault(_selection);

var _rules = require('../rules');

var _rules2 = _interopRequireDefault(_rules);

var _Create = require('./Create');

var _Create2 = _interopRequireDefault(_Create);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __depends__: [_dragging2.default, _selection2.default, _rules2.default],
  create: ['type', _Create2.default]
};

},{"../dragging":286,"../rules":355,"../selection":361,"./Create":280}],282:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = DistributeElements;

var _minDash = require('min-dash');

var AXIS_DIMENSIONS = {
  horizontal: ['x', 'width'],
  vertical: ['y', 'height']
};

var THRESHOLD = 5;

/**
 * Groups and filters elements and then trigger even distribution.
 */
function DistributeElements(modeling) {
  this._modeling = modeling;

  this._filters = [];

  // register filter for filtering big elements
  this.registerFilter(function (elements, axis, dimension) {
    var elementsSize = 0,
        numOfShapes = 0,
        avgDimension;

    (0, _minDash.forEach)(elements, function (element) {
      if (element.waypoints || element.labelTarget) {
        return;
      }

      elementsSize += element[dimension];

      numOfShapes += 1;
    });

    avgDimension = Math.round(elementsSize / numOfShapes);

    return (0, _minDash.filter)(elements, function (element) {
      return element[dimension] < avgDimension + 50;
    });
  });
}

DistributeElements.$inject = ['modeling'];

/**
 * Registers filter functions that allow external parties to filter
 * out certain elements.
 *
 * @param  {Function} filterFn
 */
DistributeElements.prototype.registerFilter = function (filterFn) {
  if (typeof filterFn !== 'function') {
    throw new Error('the filter has to be a function');
  }

  this._filters.push(filterFn);
};

/**
 * Distributes the elements with a given orientation
 *
 * @param  {Array} elements    [description]
 * @param  {String} orientation [description]
 */
DistributeElements.prototype.trigger = function (elements, orientation) {
  var modeling = this._modeling;

  var groups, distributableElements;

  if (elements.length < 3) {
    return;
  }

  this._setOrientation(orientation);

  distributableElements = this._filterElements(elements);

  groups = this._createGroups(distributableElements);

  // nothing to distribute
  if (groups.length <= 2) {
    return;
  }

  modeling.distributeElements(groups, this._axis, this._dimension);

  return groups;
};

/**
 * Filters the elements with provided filters by external parties
 *
 * @param  {Array[Elements]} elements
 *
 * @return {Array[Elements]}
 */
DistributeElements.prototype._filterElements = function (elements) {
  var filters = this._filters,
      axis = this._axis,
      dimension = this._dimension,
      distributableElements = [].concat(elements);

  if (!filters.length) {
    return elements;
  }

  (0, _minDash.forEach)(filters, function (filterFn) {
    distributableElements = filterFn(distributableElements, axis, dimension);
  });

  return distributableElements;
};

/**
 * 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.prototype._createGroups = function (elements) {
  var rangeGroups = [],
      self = this,
      axis = this._axis,
      dimension = this._dimension;

  if (!axis) {
    throw new Error('must have a defined "axis" and "dimension"');
  }

  // sort by 'left->right' or 'top->bottom'
  var sortedElements = (0, _minDash.sortBy)(elements, axis);

  (0, _minDash.forEach)(sortedElements, function (element, idx) {
    var elementRange = self._findRange(element, axis, dimension),
        range;

    var previous = rangeGroups[rangeGroups.length - 1];

    if (previous && self._hasIntersection(previous.range, elementRange)) {
      rangeGroups[rangeGroups.length - 1].elements.push(element);
    } else {
      range = { range: elementRange, elements: [element] };

      rangeGroups.push(range);
    }
  });

  return rangeGroups;
};

/**
 * Maps a direction to the according axis and dimension
 *
 * @param  {String} direction 'horizontal' or 'vertical'
 */
DistributeElements.prototype._setOrientation = function (direction) {
  var orientation = AXIS_DIMENSIONS[direction];

  this._axis = orientation[0];
  this._dimension = orientation[1];
};

/**
 * Checks if the two ranges intercept each other
 *
 * @param  {Object} rangeA {min, max}
 * @param  {Object} rangeB {min, max}
 *
 * @return {Boolean}
 */
DistributeElements.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);
};

/**
 * Returns the min and max values for an element
 *
 * @param  {[type]} element   [description]
 * @param  {[type]} axis      [description]
 * @param  {[type]} dimension [description]
 *
 * @return {[type]}           [description]
 */
DistributeElements.prototype._findRange = function (element) {
  var axis = element[this._axis],
      dimension = element[this._dimension];

  return {
    min: axis + THRESHOLD,
    max: axis + dimension - THRESHOLD
  };
};

},{"min-dash":505}],283:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _DistributeElements = require('./DistributeElements');

var _DistributeElements2 = _interopRequireDefault(_DistributeElements);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __init__: ['distributeElements'],
  distributeElements: ['type', _DistributeElements2.default]
};

},{"./DistributeElements":282}],284:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = Dragging;

var _minDash = require('min-dash');

var _minDom = require('min-dom');

var _Event = require('../../util/Event');

var _Cursor = require('../../util/Cursor');

var _ClickTrap = require('../../util/ClickTrap');

var _PositionUtil = require('../../util/PositionUtil');

/* global TouchEvent */

var round = Math.round;

var DRAG_ACTIVE_CLS = 'djs-drag-active';

function preventDefault(event) {
  event.preventDefault();
}

function isTouchEvent(event) {
  // check for TouchEvent being available first
  // (i.e. not available on desktop Firefox)
  return typeof TouchEvent !== 'undefined' && event instanceof TouchEvent;
}

function getLength(point) {
  return Math.sqrt(Math.pow(point.x, 2) + Math.pow(point.y, 2));
}

/**
 * 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
 *   * 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) {

  var defaultOptions = {
    threshold: 5,
    trapClick: true
  };

  // 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;

  /* convert a global event into local coordinates */
  function toLocalPoint(globalPosition) {

    var viewbox = canvas.viewbox();

    var clientRect = canvas._container.getBoundingClientRect();

    return {
      x: viewbox.x + (globalPosition.x - clientRect.left) / viewbox.scale,
      y: viewbox.y + (globalPosition.y - clientRect.top) / viewbox.scale
    };
  }

  // helpers

  function fire(type, dragContext) {
    dragContext = dragContext || context;

    var event = eventBus.createEvent((0, _minDash.assign)({}, dragContext.payload, dragContext.data, { isTouch: dragContext.isTouch }));

    // default integration
    if (eventBus.fire('drag.' + type, event) === false) {
      return false;
    }

    return eventBus.fire(dragContext.prefix + '.' + type, event);
  }

  // event listeners

  function move(event, activate) {
    var payload = context.payload,
        displacement = context.displacement;

    var globalStart = context.globalStart,
        globalCurrent = (0, _Event.toPoint)(event),
        globalDelta = (0, _PositionUtil.delta)(globalCurrent, globalStart);

    var localStart = context.localStart,
        localCurrent = toLocalPoint(globalCurrent),
        localDelta = (0, _PositionUtil.delta)(localCurrent, localStart);

    // activate context explicitly or once threshold is reached
    if (!context.active && (activate || getLength(globalDelta) > context.threshold)) {

      // fire start event with original
      // starting coordinates

      (0, _minDash.assign)(payload, {
        x: round(localStart.x + displacement.x),
        y: round(localStart.y + displacement.y),
        dx: 0,
        dy: 0
      }, { originalEvent: event });

      if (false === fire('start')) {
        return cancel();
      }

      context.active = true;

      // 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);
      }

      // allow custom cursor
      if (context.cursor) {
        (0, _Cursor.set)(context.cursor);
      }

      // indicate dragging via marker on root element
      canvas.addMarker(canvas.getRootElement(), DRAG_ACTIVE_CLS);
    }

    (0, _Event.stopPropagation)(event);

    if (context.active) {

      // update payload with actual coordinates
      (0, _minDash.assign)(payload, {
        x: round(localCurrent.x + displacement.x),
        y: round(localCurrent.y + displacement.y),
        dx: round(localDelta.x),
        dy: round(localDelta.y)
      }, { originalEvent: event });

      // emit move event
      fire('move');
    }
  }

  function end(event) {
    var previousContext,
        returnValue = true;

    if (context.active) {

      if (event) {
        context.payload.originalEvent = event;

        // suppress original event (click, ...)
        // because we just ended a drag operation
        (0, _Event.stopPropagation)(event);
      }

      // implementations may stop restoring the
      // original state (selections, ...) by preventing the
      // end events default action
      returnValue = fire('end');
    }

    if (returnValue === false) {
      fire('rejected');
    }

    previousContext = cleanup(returnValue !== true);

    // 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);
  }

  // cancel active drag operation if the user presses
  // the ESC key on the keyboard

  function checkCancel(event) {

    if (event.which === 27) {
      preventDefault(event);

      cancel();
    }
  }

  // prevent ghost click that might occur after a finished
  // drag and drop session

  function trapClickAndEnd(event) {

    var untrap;

    // 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) {

      untrap = (0, _ClickTrap.install)(eventBus);

      // remove trap after minimal delay
      setTimeout(untrap, 400);

      // prevent default action (click)
      preventDefault(event);
    }

    end(event);
  }

  function trapTouch(event) {
    move(event);
  }

  // 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

  function hover(event) {
    var payload = context.payload;

    payload.hoverGfx = event.gfx;
    payload.hover = event.element;

    fire('hover');
  }

  function out(event) {
    fire('out');

    var payload = context.payload;

    payload.hoverGfx = null;
    payload.hover = null;
  }

  // life-cycle methods

  function cancel(restore) {
    var previousContext;

    if (!context) {
      return;
    }

    var wasActive = context.active;

    if (wasActive) {
      fire('cancel');
    }

    previousContext = cleanup(restore);

    if (wasActive) {
      // 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);
    }
  }

  function cleanup(restore) {
    var previousContext, endDrag;

    fire('cleanup');

    // reset cursor
    (0, _Cursor.unset)();

    if (context.trapClick) {
      endDrag = trapClickAndEnd;
    } else {
      endDrag = end;
    }

    // reset dom listeners
    _minDom.event.unbind(document, 'mousemove', move);

    _minDom.event.unbind(document, 'dragstart', preventDefault);
    _minDom.event.unbind(document, 'selectstart', preventDefault);

    _minDom.event.unbind(document, 'mousedown', endDrag, true);
    _minDom.event.unbind(document, 'mouseup', endDrag, true);

    _minDom.event.unbind(document, 'keyup', checkCancel);

    _minDom.event.unbind(document, 'touchstart', trapTouch, true);
    _minDom.event.unbind(document, 'touchcancel', cancel, true);
    _minDom.event.unbind(document, 'touchmove', move, true);
    _minDom.event.unbind(document, 'touchend', end, true);

    eventBus.off('element.hover', hover);
    eventBus.off('element.out', out);

    // remove drag marker on root element
    canvas.removeMarker(canvas.getRootElement(), DRAG_ACTIVE_CLS);

    // restore selection, unless it has changed
    var previousSelection = context.payload.previousSelection;

    if (restore !== false && previousSelection && !selection.get().length) {
      selection.select(previousSelection);
    }

    previousContext = context;

    context = null;

    return previousContext;
  }

  /**
   * 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) {

    // only one drag operation may be active, at a time
    if (context) {
      cancel(false);
    }

    if (typeof relativeTo === 'string') {
      options = prefix;
      prefix = relativeTo;
      relativeTo = null;
    }

    options = (0, _minDash.assign)({}, defaultOptions, options || {});

    var data = options.data || {},
        originalEvent,
        globalStart,
        localStart,
        endDrag,
        isTouch;

    if (options.trapClick) {
      endDrag = trapClickAndEnd;
    } else {
      endDrag = end;
    }

    if (event) {
      originalEvent = (0, _Event.getOriginal)(event) || event;
      globalStart = (0, _Event.toPoint)(event);

      (0, _Event.stopPropagation)(event);

      // prevent default browser dragging behavior
      if (originalEvent.type === 'dragstart') {
        preventDefault(originalEvent);
      }
    } else {
      originalEvent = null;
      globalStart = { x: 0, y: 0 };
    }

    localStart = toLocalPoint(globalStart);

    if (!relativeTo) {
      relativeTo = localStart;
    }

    isTouch = isTouchEvent(originalEvent);

    context = (0, _minDash.assign)({
      prefix: prefix,
      data: data,
      payload: {},
      globalStart: globalStart,
      displacement: (0, _PositionUtil.delta)(relativeTo, localStart),
      localStart: localStart,
      isTouch: isTouch
    }, options);

    // skip dom registration if trigger
    // is set to manual (during testing)
    if (!options.manual) {

      // add dom listeners

      if (isTouch) {
        _minDom.event.bind(document, 'touchstart', trapTouch, true);
        _minDom.event.bind(document, 'touchcancel', cancel, true);
        _minDom.event.bind(document, 'touchmove', move, true);
        _minDom.event.bind(document, 'touchend', end, true);
      } else {
        // assume we use the mouse to interact per default
        _minDom.event.bind(document, 'mousemove', move);

        // prevent default browser drag and text selection behavior
        _minDom.event.bind(document, 'dragstart', preventDefault);
        _minDom.event.bind(document, 'selectstart', preventDefault);

        _minDom.event.bind(document, 'mousedown', endDrag, true);
        _minDom.event.bind(document, 'mouseup', endDrag, true);
      }

      _minDom.event.bind(document, 'keyup', checkCancel);

      eventBus.on('element.hover', hover);
      eventBus.on('element.out', out);
    }

    fire('init');

    if (options.autoActivate) {
      move(event, true);
    }
  }

  // cancel on diagram destruction
  eventBus.on('diagram.destroy', cancel);

  // API

  this.init = init;
  this.move = move;
  this.hover = hover;
  this.out = out;
  this.end = end;

  this.cancel = cancel;

  // for introspection

  this.context = function () {
    return context;
  };

  this.setOptions = function (options) {
    (0, _minDash.assign)(defaultOptions, options);
  };
}

Dragging.$inject = ['eventBus', 'canvas', 'selection'];

},{"../../util/ClickTrap":392,"../../util/Cursor":395,"../../util/Event":397,"../../util/PositionUtil":405,"min-dash":505,"min-dom":506}],285:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = HoverFix;

var _minDom = require('min-dom');

var _Event = require('../../util/Event');

function getGfx(target) {
  var node = (0, _minDom.closest)(target, 'svg, .djs-element', true);
  return node;
}

/**
 * Browsers may swallow the hover event 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
 * have a hover state after a successive drag.move event.
 *
 * @param {EventBus} eventBus
 * @param {Dragging} dragging
 * @param {ElementRegistry} elementRegistry
 */
function HoverFix(eventBus, dragging, elementRegistry) {

  var self = this;

  // we wait for a specific sequence of events before
  // emitting a fake drag.hover event.
  //
  // Event Sequence:
  //
  // drag.start
  // drag.move
  // drag.move >> ensure we are hovering
  //
  eventBus.on('drag.start', function (event) {

    eventBus.once('drag.move', function () {

      eventBus.once('drag.move', function (event) {

        self.ensureHover(event);
      });
    });
  });

  /**
   * Make sure we are god damn hovering!
   *
   * @param {Event} dragging event
   */
  this.ensureHover = function (event) {

    if (event.hover) {
      return;
    }

    var originalEvent = event.originalEvent,
        position,
        target,
        element,
        gfx;

    if (!(originalEvent instanceof MouseEvent)) {
      return;
    }

    position = (0, _Event.toPoint)(originalEvent);

    // damn expensive operation, ouch!
    target = document.elementFromPoint(position.x, position.y);

    gfx = getGfx(target);

    if (gfx) {
      element = elementRegistry.get(gfx);

      dragging.hover({ element: element, gfx: gfx });
    }
  };
}

HoverFix.$inject = ['eventBus', 'dragging', 'elementRegistry'];

},{"../../util/Event":397,"min-dom":506}],286:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _selection = require('../selection');

var _selection2 = _interopRequireDefault(_selection);

var _Dragging = require('./Dragging');

var _Dragging2 = _interopRequireDefault(_Dragging);

var _HoverFix = require('./HoverFix');

var _HoverFix2 = _interopRequireDefault(_HoverFix);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __init__: ['hoverFix'],
  __depends__: [_selection2.default],
  dragging: ['type', _Dragging2.default],
  hoverFix: ['type', _HoverFix2.default]
};

},{"../selection":361,"./Dragging":284,"./HoverFix":285}],287:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = EditorActions;

var _minDash = require('min-dash');

var NOT_REGISTERED_ERROR = 'is not a registered action',
    IS_REGISTERED_ERROR = 'is already registered';

/**
 * 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) {

  // initialize actions
  this._actions = {};

  var self = this;

  eventBus.on('diagram.init', function () {

    // all diagram modules got loaded; check which ones
    // are available and register the respective default actions
    self._registerDefaultActions(injector);

    // ask interested parties to register available editor
    // actions on diagram initialization
    eventBus.fire('editorActions.init', {
      editorActions: self
    });
  });
}

EditorActions.$inject = ['eventBus', 'injector'];

/**
 * Register default actions.
 *
 * @param {Injector} injector
 */
EditorActions.prototype._registerDefaultActions = function (injector) {

  // (1) retrieve optional components to integrate with

  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 mouseTracking = injector.get('mouseTracking', false);
  var keyboardMove = injector.get('keyboardMove', false);
  var keyboardMoveSelection = injector.get('keyboardMoveSelection', false);

  // (2) check components and register actions

  if (commandStack) {
    this.register('undo', function () {
      commandStack.undo();
    });

    this.register('redo', function () {
      commandStack.redo();
    });
  }

  if (copyPaste && selection) {
    this.register('copy', function () {
      var selectedElements = selection.get();

      copyPaste.copy(selectedElements);
    });
  }

  if (mouseTracking && copyPaste) {
    this.register('paste', function () {
      var context = mouseTracking.getHoverContext();

      copyPaste.paste(context);
    });
  }

  if (zoomScroll) {
    this.register('stepZoom', function (opts) {
      zoomScroll.stepZoom(opts.value);
    });
  }

  if (canvas) {
    this.register('zoom', function (opts) {
      canvas.zoom(opts.value);
    });
  }

  if (modeling && selection && rules) {
    this.register('removeSelection', function () {

      var selectedElements = selection.get();

      if (!selectedElements.length) {
        return;
      }

      var allowed = rules.allowed('elements.delete', { elements: selectedElements }),
          removableElements;

      if (allowed === false) {
        return;
      } else if ((0, _minDash.isArray)(allowed)) {
        removableElements = allowed;
      } else {
        removableElements = selectedElements;
      }

      if (removableElements.length) {
        modeling.removeElements(removableElements.slice());
      }
    });
  }

  if (keyboardMove) {
    this.register('moveCanvas', function (opts) {
      keyboardMove.moveCanvas(opts);
    });
  }

  if (keyboardMoveSelection) {
    this.register('moveSelection', function (opts) {
      keyboardMoveSelection.moveSelection(opts.direction, opts.accelerated);
    });
  }
};

/**
 * 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);
  }

  return this._actions[action](opts);
};

/**
 * 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;

  if (typeof actions === 'string') {
    return this._registerAction(actions, listener);
  }

  (0, _minDash.forEach)(actions, function (listener, action) {
    self._registerAction(action, listener);
  });
};

/**
 * 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);
  }

  this._actions[action] = listener;
};

/**
 * Unregister an existing action
 *
 * @param {String} action
 */
EditorActions.prototype.unregister = function (action) {
  if (!this.isRegistered(action)) {
    throw error(action, NOT_REGISTERED_ERROR);
  }

  this._actions[action] = undefined;
};

/**
 * Returns the number of actions that are currently registered
 *
 * @return {Number}
 */
EditorActions.prototype.getActions = function () {
  return Object.keys(this._actions);
};

/**
 * Checks wether the given action is registered
 *
 * @param {String} action
 *
 * @return {Boolean}
 */
EditorActions.prototype.isRegistered = function (action) {
  return !!this._actions[action];
};

function error(action, message) {
  return new Error(action + ' ' + message);
}

},{"min-dash":505}],288:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _EditorActions = require('./EditorActions');

var _EditorActions2 = _interopRequireDefault(_EditorActions);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __init__: ['editorActions'],
  editorActions: ['type', _EditorActions2.default]
};

},{"./EditorActions":287}],289:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = GlobalConnect;
var MARKER_OK = 'connect-ok',
    MARKER_NOT_OK = 'connect-not-ok';

/**
 * @class
 * @constructor
 *
 * @param {EventBus} eventBus
 * @param {Dragging} dragging
 * @param {Connect} connect
 * @param {Canvas} canvas
 * @param {ToolManager} toolManager
 * @param {Rules} rules
 */
function GlobalConnect(eventBus, dragging, connect, canvas, toolManager, rules) {

  var self = this;

  this._dragging = dragging;
  this._rules = rules;

  toolManager.registerTool('global-connect', {
    tool: 'global-connect',
    dragging: 'global-connect.drag'
  });

  eventBus.on('global-connect.hover', function (event) {
    var context = event.context,
        startTarget = event.hover;

    var canStartConnect = context.canStartConnect = self.canStartConnect(startTarget);

    // simply ignore hover
    if (canStartConnect === null) {
      return;
    }

    context.startTarget = startTarget;

    canvas.addMarker(startTarget, canStartConnect ? MARKER_OK : MARKER_NOT_OK);
  });

  eventBus.on(['global-connect.out', 'global-connect.cleanup'], function (event) {
    var startTarget = event.context.startTarget,
        canStartConnect = event.context.canStartConnect;

    if (startTarget) {
      canvas.removeMarker(startTarget, canStartConnect ? MARKER_OK : MARKER_NOT_OK);
    }
  });

  eventBus.on(['global-connect.ended'], function (event) {
    var context = event.context,
        startTarget = context.startTarget,
        startPosition = {
      x: event.x,
      y: event.y
    };

    var canStartConnect = self.canStartConnect(startTarget);

    if (!canStartConnect) {
      return;
    }

    eventBus.once('element.out', function () {
      eventBus.once(['connect.ended', 'connect.canceled'], function () {
        eventBus.fire('global-connect.drag.ended');
      });

      connect.start(null, startTarget, startPosition);
    });

    return false;
  });
}

GlobalConnect.$inject = ['eventBus', 'dragging', 'connect', 'canvas', 'toolManager', 'rules'];

/**
 * Initiates tool activity.
 */
GlobalConnect.prototype.start = function (event) {
  this._dragging.init(event, 'global-connect', {
    trapClick: false,
    data: {
      context: {}
    }
  });
};

GlobalConnect.prototype.toggle = function () {
  if (this.isActive()) {
    this._dragging.cancel();
  } else {
    this.start();
  }
};

GlobalConnect.prototype.isActive = function () {
  var context = this._dragging.context();

  return context && /^global-connect/.test(context.prefix);
};

/**
 * 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 });
};

},{}],290:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _connect = require('../connect');

var _connect2 = _interopRequireDefault(_connect);

var _rules = require('../rules');

var _rules2 = _interopRequireDefault(_rules);

var _dragging = require('../dragging');

var _dragging2 = _interopRequireDefault(_dragging);

var _toolManager = require('../tool-manager');

var _toolManager2 = _interopRequireDefault(_toolManager);

var _GlobalConnect = require('./GlobalConnect');

var _GlobalConnect2 = _interopRequireDefault(_GlobalConnect);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __depends__: [_connect2.default, _rules2.default, _dragging2.default, _toolManager2.default],
  globalConnect: ['type', _GlobalConnect2.default]
};

},{"../connect":275,"../dragging":286,"../rules":355,"../tool-manager":370,"./GlobalConnect":289}],291:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

exports.default = HandTool;

var _Mouse = require('../../util/Mouse');

var HIGH_PRIORITY = 1500;
var HAND_CURSOR = 'grab';

function HandTool(eventBus, canvas, dragging, toolManager) {
  this._dragging = dragging;

  toolManager.registerTool('hand', {
    tool: 'hand',
    dragging: 'hand.move'
  });

  eventBus.on('element.mousedown', HIGH_PRIORITY, function (event) {
    if ((0, _Mouse.hasPrimaryModifier)(event)) {
      this.activateMove(event.originalEvent);

      return false;
    }
  }, this);

  eventBus.on('hand.end', function (event) {
    var target = event.originalEvent.target;

    // 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;
    }

    eventBus.once('hand.ended', function () {
      this.activateMove(event.originalEvent, { reactivate: true });
    }, this);
  }, this);

  eventBus.on('hand.move.move', function (event) {
    var scale = canvas.viewbox().scale;

    canvas.scroll({
      dx: event.dx * scale,
      dy: event.dy * scale
    });
  });

  eventBus.on('hand.move.end', function (event) {
    var context = event.context,
        reactivate = context.reactivate;

    // Don't reactivate if the user is using the keyboard keybinding
    if (!(0, _Mouse.hasPrimaryModifier)(event) && reactivate) {

      eventBus.once('hand.move.ended', function (event) {
        this.activateHand(event.originalEvent, true, true);
      }, this);
    }

    return false;
  }, this);
}

HandTool.$inject = ['eventBus', 'canvas', 'dragging', 'toolManager'];

HandTool.prototype.activateMove = function (event, autoActivate, context) {
  if ((typeof autoActivate === 'undefined' ? 'undefined' : _typeof(autoActivate)) === 'object') {
    context = autoActivate;
    autoActivate = false;
  }

  this._dragging.init(event, 'hand.move', {
    autoActivate: autoActivate,
    cursor: HAND_CURSOR,
    data: {
      context: context || {}
    }
  });
};

HandTool.prototype.activateHand = function (event, autoActivate, reactivate) {
  this._dragging.init(event, 'hand', {
    trapClick: false,
    autoActivate: autoActivate,
    cursor: HAND_CURSOR,
    data: {
      context: {
        reactivate: reactivate
      }
    }
  });
};

HandTool.prototype.toggle = function () {
  if (this.isActive()) {
    this._dragging.cancel();
  } else {
    this.activateHand();
  }
};

HandTool.prototype.isActive = function () {
  var context = this._dragging.context();

  return context && /^hand/.test(context.prefix);
};

},{"../../util/Mouse":403}],292:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _toolManager = require('../tool-manager');

var _toolManager2 = _interopRequireDefault(_toolManager);

var _HandTool = require('./HandTool');

var _HandTool2 = _interopRequireDefault(_HandTool);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __depends__: [_toolManager2.default],
  __init__: ['handTool'],
  handTool: ['type', _HandTool2.default]
};

},{"../tool-manager":370,"./HandTool":291}],293:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = InteractionEvents;

var _minDash = require('min-dash');

var _minDom = require('min-dom');

var _Mouse = require('../../util/Mouse');

var _tinySvg = require('tiny-svg');

var _RenderUtil = require('../../util/RenderUtil');

function allowAll(e) {
  return true;
}

var LOW_PRIORITY = 500;

/**
 * A plugin that provides interaction events for diagram elements.
 *
 * It emits the following events:
 *
 *   * element.hover
 *   * element.out
 *   * element.click
 *   * element.dblclick
 *   * element.mousedown
 *   * element.contextmenu
 *
 * 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) {

  var HIT_STYLE = styles.cls('djs-hit', ['no-fill', 'no-border'], {
    stroke: 'white',
    strokeWidth: 15
  });

  /**
   * 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) {

    if (isIgnored(type, event)) {
      return;
    }

    var target, gfx, returnValue;

    if (!element) {
      target = event.delegateTarget || event.target;

      if (target) {
        gfx = target;
        element = elementRegistry.get(gfx);
      }
    } else {
      gfx = elementRegistry.getGraphics(element);
    }

    if (!gfx || !element) {
      return;
    }

    returnValue = eventBus.fire(type, {
      element: element,
      gfx: gfx,
      originalEvent: event
    });

    if (returnValue === false) {
      event.stopPropagation();
      event.preventDefault();
    }
  }

  // TODO(nikku): document this
  var handlers = {};

  function mouseHandler(localEventName) {
    return handlers[localEventName];
  }

  function isIgnored(localEventName, event) {

    var filter = ignoredFilters[localEventName] || _Mouse.isPrimaryButton;

    // only react on left mouse button interactions
    // except for interaction events that are enabled
    // for secundary mouse button
    return !filter(event);
  }

  var bindings = {
    mouseover: 'element.hover',
    mouseout: 'element.out',
    click: 'element.click',
    dblclick: 'element.dblclick',
    mousedown: 'element.mousedown',
    mouseup: 'element.mouseup',
    contextmenu: 'element.contextmenu'
  };

  var ignoredFilters = {
    'element.contextmenu': allowAll
  };

  // manual event trigger

  /**
   * 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) {

    // i.e. element.mousedown...
    var localEventName = bindings[eventName];

    if (!localEventName) {
      throw new Error('unmapped DOM event name <' + eventName + '>');
    }

    return fire(localEventName, event, targetElement);
  }

  var elementSelector = 'svg, .djs-element';

  // event registration

  function registerEvent(node, event, localEvent, ignoredFilter) {

    var handler = handlers[localEvent] = function (event) {
      fire(localEvent, event);
    };

    if (ignoredFilter) {
      ignoredFilters[localEvent] = ignoredFilter;
    }

    handler.$delegate = _minDom.delegate.bind(node, elementSelector, event, handler);
  }

  function unregisterEvent(node, event, localEvent) {

    var handler = mouseHandler(localEvent);

    if (!handler) {
      return;
    }

    _minDom.delegate.unbind(node, event, handler.$delegate);
  }

  function registerEvents(svg) {
    (0, _minDash.forEach)(bindings, function (val, key) {
      registerEvent(svg, key, val);
    });
  }

  function unregisterEvents(svg) {
    (0, _minDash.forEach)(bindings, function (val, key) {
      unregisterEvent(svg, key, val);
    });
  }

  eventBus.on('canvas.destroy', function (event) {
    unregisterEvents(event.svg);
  });

  eventBus.on('canvas.init', function (event) {
    registerEvents(event.svg);
  });

  eventBus.on(['shape.added', 'connection.added'], function (event) {
    var element = event.element,
        gfx = event.gfx,
        hit;

    if (element.waypoints) {
      hit = (0, _RenderUtil.createLine)(element.waypoints);
    } else {
      hit = (0, _tinySvg.create)('rect');
      (0, _tinySvg.attr)(hit, {
        x: 0,
        y: 0,
        width: element.width,
        height: element.height
      });
    }

    (0, _tinySvg.attr)(hit, HIT_STYLE);

    (0, _tinySvg.append)(gfx, hit);
  });

  // 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', LOW_PRIORITY, function (event) {

    var element = event.element,
        gfx = event.gfx,
        hit = (0, _minDom.query)('.djs-hit', gfx);

    (0, _tinySvg.attr)(hit, {
      width: element.width,
      height: element.height
    });
  });

  eventBus.on('connection.changed', function (event) {

    var element = event.element,
        gfx = event.gfx,
        hit = (0, _minDom.query)('.djs-hit', gfx);

    (0, _RenderUtil.updateLine)(hit, element.waypoints);
  });

  // API

  this.fire = fire;

  this.triggerMouseEvent = triggerMouseEvent;

  this.mouseHandler = mouseHandler;

  this.registerEvent = registerEvent;
  this.unregisterEvent = unregisterEvent;
}

InteractionEvents.$inject = ['eventBus', 'elementRegistry', 'styles'];

/**
 * 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
 */

/**
 * 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
 */

/**
 * 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
 */

/**
 * 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
 */

/**
 * 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
 */

/**
 * 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
 */

/**
 * 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
 */

},{"../../util/Mouse":403,"../../util/RenderUtil":407,"min-dash":505,"min-dom":506,"tiny-svg":535}],294:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _InteractionEvents = require('./InteractionEvents');

var _InteractionEvents2 = _interopRequireDefault(_InteractionEvents);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __init__: ['interactionEvents'],
  interactionEvents: ['type', _InteractionEvents2.default]
};

},{"./InteractionEvents":293}],295:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = KeyboardMoveSelection;

var _minDash = require('min-dash');

var DEFAULT_CONFIG = {
  moveSpeed: 1,
  moveSpeedAccelerated: 10
};

var HIGHER_PRIORITY = 1500;

var LEFT = 'left';
var UP = 'up';
var RIGHT = 'right';
var DOWN = 'down';

var KEY_TO_DIRECTION = {
  ArrowLeft: LEFT,
  Left: LEFT,
  ArrowUp: UP,
  Up: UP,
  ArrowRight: RIGHT,
  Right: RIGHT,
  ArrowDown: DOWN,
  Down: DOWN
};

var DIRECTIONS_DELTA = {
  left: function left(speed) {
    return {
      x: -speed,
      y: 0
    };
  },
  up: function up(speed) {
    return {
      x: 0,
      y: -speed
    };
  },
  right: function right(speed) {
    return {
      x: speed,
      y: 0
    };
  },
  down: function down(speed) {
    return {
      x: 0,
      y: speed
    };
  }
};

/**
 * 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, selection) {

  var self = this;

  this._config = (0, _minDash.assign)({}, DEFAULT_CONFIG, config || {});

  keyboard.addListener(HIGHER_PRIORITY, function (event) {

    var keyEvent = event.keyEvent;

    var direction = KEY_TO_DIRECTION[keyEvent.key];

    if (!direction) {
      return;
    }

    if (keyboard.isCmd(keyEvent)) {
      return;
    }

    var accelerated = keyboard.isShift(keyEvent);

    self.moveSelection(direction, accelerated);

    return true;
  });

  /**
   * Move selected elements in the given direction,
   * optionally specifying accelerated movement.
   *
   * @param {String} direction
   * @param {Boolean} [accelerated=false]
   */
  this.moveSelection = function (direction, accelerated) {

    var selectedElements = selection.get();

    if (!selectedElements.length) {
      return;
    }

    var speed = this._config[accelerated ? 'moveSpeedAccelerated' : 'moveSpeed'];

    var delta = DIRECTIONS_DELTA[direction](speed);

    modeling.moveElements(selectedElements, delta);
  };
}

KeyboardMoveSelection.$inject = ['config.keyboardMoveSelection', 'keyboard', 'modeling', 'selection'];

},{"min-dash":505}],296:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _keyboard = require('../keyboard');

var _keyboard2 = _interopRequireDefault(_keyboard);

var _selection = require('../selection');

var _selection2 = _interopRequireDefault(_selection);

var _KeyboardMoveSelection = require('./KeyboardMoveSelection');

var _KeyboardMoveSelection2 = _interopRequireDefault(_KeyboardMoveSelection);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __depends__: [_keyboard2.default, _selection2.default],
  __init__: ['keyboardMoveSelection'],
  keyboardMoveSelection: ['type', _KeyboardMoveSelection2.default]
};

},{"../keyboard":300,"../selection":361,"./KeyboardMoveSelection":295}],297:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = Keyboard;

var _minDash = require('min-dash');

var _minDom = require('min-dom');

var _KeyboardUtil = require('./KeyboardUtil');

var KEYDOWN_EVENT = 'keyboard.keydown';

var DEFAULT_PRIORITY = 1000;

/**
 * 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;

  this._config = config || {};
  this._eventBus = eventBus;

  this._keyHandler = this._keyHandler.bind(this);

  // properly clean dom registrations
  eventBus.on('diagram.destroy', function () {
    self._fire('destroy');

    self.unbind();
  });

  eventBus.on('diagram.init', function () {
    self._fire('init');
  });

  eventBus.on('attach', function () {
    if (config && config.bindTo) {
      self.bind(config.bindTo);
    }
  });

  eventBus.on('detach', function () {
    self.unbind();
  });
}

Keyboard.$inject = ['config.keyboard', 'eventBus'];

Keyboard.prototype._keyHandler = function (event) {

  var target = event.target,
      eventBusResult;

  if (isInput(target)) {
    return;
  }

  var context = {
    keyEvent: event
  };

  eventBusResult = this._eventBus.fire(KEYDOWN_EVENT, context);

  if (eventBusResult) {
    event.preventDefault();
  }
};

Keyboard.prototype.bind = function (node) {

  // make sure that the keyboard is only bound once to the DOM
  this.unbind();

  this._node = node;

  // bind key events
  _minDom.event.bind(node, 'keydown', this._keyHandler, true);

  this._fire('bind');
};

Keyboard.prototype.getBinding = function () {
  return this._node;
};

Keyboard.prototype.unbind = function () {
  var node = this._node;

  if (node) {
    this._fire('unbind');

    // unbind key events
    _minDom.event.unbind(node, 'keydown', this._keyHandler, true);
  }

  this._node = null;
};

Keyboard.prototype._fire = function (event) {
  this._eventBus.fire('keyboard.' + event, { node: this._node });
};

/**
 * 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
 */
Keyboard.prototype.addListener = function (priority, listener) {
  if ((0, _minDash.isFunction)(priority)) {
    listener = priority;
    priority = DEFAULT_PRIORITY;
  }

  this._eventBus.on(KEYDOWN_EVENT, priority, listener);
};

Keyboard.prototype.hasModifier = _KeyboardUtil.hasModifier;
Keyboard.prototype.isCmd = _KeyboardUtil.isCmd;
Keyboard.prototype.isShift = _KeyboardUtil.isShift;
Keyboard.prototype.isKey = _KeyboardUtil.isKey;

// helpers ///////

function isInput(target) {
  return target && ((0, _minDom.matches)(target, 'input, textarea') || target.contentEditable === 'true');
}

},{"./KeyboardUtil":299,"min-dash":505,"min-dom":506}],298:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = KeyboardBindings;

var _KeyboardUtil = require('./KeyboardUtil');

var LOW_PRIORITY = 500;

/**
 * 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) {

  var self = this;

  eventBus.on('editorActions.init', LOW_PRIORITY, function (event) {

    var editorActions = event.editorActions;

    self.registerBindings(keyboard, editorActions);
  });
}

KeyboardBindings.$inject = ['eventBus', 'keyboard'];

/**
 * Register available keyboard bindings.
 *
 * @param {Keyboard} keyboard
 * @param {EditorActions} editorActions
 */
KeyboardBindings.prototype.registerBindings = function (keyboard, editorActions) {

  /**
   * 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) {

    if (editorActions.isRegistered(action)) {
      keyboard.addListener(fn);
    }
  }

  // undo
  // (CTRL|CMD) + Z
  addListener('undo', function (context) {

    var event = context.keyEvent;

    if ((0, _KeyboardUtil.isCmd)(event) && !(0, _KeyboardUtil.isShift)(event) && (0, _KeyboardUtil.isKey)(['z', 'Z'], event)) {
      editorActions.trigger('undo');

      return true;
    }
  });

  // redo
  // CTRL + Y
  // CMD + SHIFT + Z
  addListener('redo', function (context) {

    var event = context.keyEvent;

    if ((0, _KeyboardUtil.isCmd)(event) && ((0, _KeyboardUtil.isKey)(['y', 'Y'], event) || (0, _KeyboardUtil.isKey)(['z', 'Z'], event) && (0, _KeyboardUtil.isShift)(event))) {
      editorActions.trigger('redo');

      return true;
    }
  });

  // copy
  // CTRL/CMD + C
  addListener('copy', function (context) {

    var event = context.keyEvent;

    if ((0, _KeyboardUtil.isCmd)(event) && (0, _KeyboardUtil.isKey)(['c', 'C'], event)) {
      editorActions.trigger('copy');

      return true;
    }
  });

  // paste
  // CTRL/CMD + V
  addListener('paste', function (context) {

    var event = context.keyEvent;

    if ((0, _KeyboardUtil.isCmd)(event) && (0, _KeyboardUtil.isKey)(['v', 'V'], event)) {
      editorActions.trigger('paste');

      return true;
    }
  });

  // zoom in one step
  // CTRL/CMD + +
  addListener('stepZoom', function (context) {

    var event = context.keyEvent;

    if ((0, _KeyboardUtil.isKey)(['+', 'Add'], event) && (0, _KeyboardUtil.isCmd)(event)) {
      editorActions.trigger('stepZoom', { value: 1 });

      return true;
    }
  });

  // zoom out one step
  // CTRL + -
  addListener('stepZoom', function (context) {

    var event = context.keyEvent;

    if ((0, _KeyboardUtil.isKey)(['-', 'Subtract'], event) && (0, _KeyboardUtil.isCmd)(event)) {
      editorActions.trigger('stepZoom', { value: -1 });

      return true;
    }
  });

  // zoom to the default level
  // CTRL + 0
  addListener('zoom', function (context) {

    var event = context.keyEvent;

    if ((0, _KeyboardUtil.isKey)('0', event) && (0, _KeyboardUtil.isCmd)(event)) {
      editorActions.trigger('zoom', { value: 1 });

      return true;
    }
  });

  // delete selected element
  // DEL
  addListener('removeSelection', function (context) {

    var event = context.keyEvent;

    if ((0, _KeyboardUtil.isKey)(['Delete', 'Del'], event)) {
      editorActions.trigger('removeSelection');

      return true;
    }
  });
};

},{"./KeyboardUtil":299}],299:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.hasModifier = hasModifier;
exports.isCmd = isCmd;
exports.isKey = isKey;
exports.isShift = isShift;

var _minDash = require('min-dash');

/**
 * Returns true if event was triggered with any modifier
 * @param {KeyboardEvent} event
 */
function hasModifier(event) {
  return event.ctrlKey || event.metaKey || event.shiftKey || event.altKey;
}

/**
 * @param {KeyboardEvent} event
 */
function isCmd(event) {

  // ensure we don't react to AltGr
  // (mapped to CTRL + ALT)
  if (event.altKey) {
    return false;
  }

  return event.ctrlKey || event.metaKey;
}

/**
 * Checks if key pressed is one of provided keys.
 *
 * @param {String|String[]} keys
 * @param {KeyboardEvent} event
 */
function isKey(keys, event) {
  keys = (0, _minDash.isArray)(keys) ? keys : [keys];

  return keys.indexOf(event.key) > -1;
}

/**
 * @param {KeyboardEvent} event
 */
function isShift(event) {
  return event.shiftKey;
}

},{"min-dash":505}],300:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _Keyboard = require('./Keyboard');

var _Keyboard2 = _interopRequireDefault(_Keyboard);

var _KeyboardBindings = require('./KeyboardBindings');

var _KeyboardBindings2 = _interopRequireDefault(_KeyboardBindings);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __init__: ['keyboard', 'keyboardBindings'],
  keyboard: ['type', _Keyboard2.default],
  keyboardBindings: ['type', _KeyboardBindings2.default]
};

},{"./Keyboard":297,"./KeyboardBindings":298}],301:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = LabelSupport;

var _minDash = require('min-dash');

var _inherits = require('inherits');

var _inherits2 = _interopRequireDefault(_inherits);

var _Collections = require('../../util/Collections');

var _Removal = require('../../util/Removal');

var _CommandInterceptor = require('../../command/CommandInterceptor');

var _CommandInterceptor2 = _interopRequireDefault(_CommandInterceptor);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var LOW_PRIORITY = 250,
    HIGH_PRIORITY = 1400;

/**
 * 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) {

  _CommandInterceptor2.default.call(this, eventBus);

  var movePreview = injector.get('movePreview', false);

  // remove labels from the collection that are being
  // moved with other elements anyway
  eventBus.on('shape.move.start', HIGH_PRIORITY, function (e) {

    var context = e.context,
        shapes = context.shapes,
        validatedShapes = context.validatedShapes;

    context.shapes = removeLabels(shapes);
    context.validatedShapes = removeLabels(validatedShapes);
  });

  // add labels to visual's group
  movePreview && eventBus.on('shape.move.start', LOW_PRIORITY, function (e) {

    var context = e.context,
        shapes = context.shapes;

    var labels = [];

    (0, _minDash.forEach)(shapes, function (element) {

      (0, _minDash.forEach)(element.labels, function (label) {

        if (!label.hidden && context.shapes.indexOf(label) === -1) {
          labels.push(label);
        }

        if (element.labelTarget) {
          labels.push(element);
        }
      });
    });

    (0, _minDash.forEach)(labels, function (label) {
      movePreview.makeDraggable(context, label, true);
    });
  });

  // add all labels to move closure
  this.preExecuted('elements.move', HIGH_PRIORITY, function (e) {
    var context = e.context,
        closure = context.closure,
        enclosedElements = closure.enclosedElements;

    var enclosedLabels = [];

    // find labels that are not part of
    // move closure yet and add them
    (0, _minDash.forEach)(enclosedElements, function (element) {
      (0, _minDash.forEach)(element.labels, function (label) {

        if (!enclosedElements[label.id]) {
          enclosedLabels.push(label);
        }
      });
    });

    closure.addAll(enclosedLabels);
  });

  this.preExecute(['connection.delete', 'shape.delete'], function (e) {

    var context = e.context,
        element = context.connection || context.shape;

    (0, _Removal.saveClear)(element.labels, function (label) {
      modeling.removeShape(label, { nested: true });
    });
  });

  this.execute('shape.delete', function (e) {

    var context = e.context,
        shape = context.shape,
        labelTarget = shape.labelTarget;

    // unset labelTarget
    if (labelTarget) {
      context.labelTargetIndex = (0, _Collections.indexOf)(labelTarget.labels, shape);
      context.labelTarget = labelTarget;

      shape.labelTarget = null;
    }
  });

  this.revert('shape.delete', function (e) {

    var context = e.context,
        shape = context.shape,
        labelTarget = context.labelTarget,
        labelTargetIndex = context.labelTargetIndex;

    // restore labelTarget
    if (labelTarget) {
      (0, _Collections.add)(labelTarget.labels, shape, labelTargetIndex);

      shape.labelTarget = labelTarget;
    }
  });
}

(0, _inherits2.default)(LabelSupport, _CommandInterceptor2.default);

LabelSupport.$inject = ['injector', 'eventBus', 'modeling'];

/**
 * Return a filtered list of elements that do not
 * contain attached elements with hosts being part
 * of the selection.
 *
 * @param  {Array<djs.model.Base>} elements
 *
 * @return {Array<djs.model.Base>} filtered
 */
function removeLabels(elements) {

  return (0, _minDash.filter)(elements, function (element) {

    // filter out labels that are move together
    // with their label targets
    return elements.indexOf(element.labelTarget) === -1;
  });
}

},{"../../command/CommandInterceptor":243,"../../util/Collections":393,"../../util/Removal":406,"inherits":415,"min-dash":505}],302:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _LabelSupport = require('./LabelSupport');

var _LabelSupport2 = _interopRequireDefault(_LabelSupport);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __init__: ['labelSupport'],
  labelSupport: ['type', _LabelSupport2.default]
};

},{"./LabelSupport":301}],303:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = LassoTool;

var _minDash = require('min-dash');

var _Elements = require('../../util/Elements');

var _Mouse = require('../../util/Mouse');

var _tinySvg = require('tiny-svg');

var LASSO_TOOL_CURSOR = 'crosshair';

function LassoTool(eventBus, canvas, dragging, elementRegistry, selection, toolManager) {

  this._selection = selection;
  this._dragging = dragging;

  var self = this;

  // lasso visuals implementation

  /**
  * A helper that realizes the selection box visual
  */
  var visuals = {

    create: function create(context) {
      var container = canvas.getDefaultLayer(),
          frame;

      frame = context.frame = (0, _tinySvg.create)('rect');
      (0, _tinySvg.attr)(frame, {
        class: 'djs-lasso-overlay',
        width: 1,
        height: 1,
        x: 0,
        y: 0
      });

      (0, _tinySvg.append)(container, frame);
    },

    update: function update(context) {
      var frame = context.frame,
          bbox = context.bbox;

      (0, _tinySvg.attr)(frame, {
        x: bbox.x,
        y: bbox.y,
        width: bbox.width,
        height: bbox.height
      });
    },

    remove: function remove(context) {

      if (context.frame) {
        (0, _tinySvg.remove)(context.frame);
      }
    }
  };

  toolManager.registerTool('lasso', {
    tool: 'lasso.selection',
    dragging: 'lasso'
  });

  eventBus.on('lasso.selection.end', function (event) {
    var target = event.originalEvent.target;

    // 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;
    }

    eventBus.once('lasso.selection.ended', function () {
      self.activateLasso(event.originalEvent, true);
    });
  });

  // lasso interaction implementation

  eventBus.on('lasso.end', function (event) {

    var bbox = toBBox(event);

    var elements = elementRegistry.filter(function (element) {
      return element;
    });

    self.select(elements, bbox);
  });

  eventBus.on('lasso.start', function (event) {

    var context = event.context;

    context.bbox = toBBox(event);
    visuals.create(context);
  });

  eventBus.on('lasso.move', function (event) {

    var context = event.context;

    context.bbox = toBBox(event);
    visuals.update(context);
  });

  eventBus.on('lasso.cleanup', function (event) {

    var context = event.context;

    visuals.remove(context);
  });

  // event integration

  eventBus.on('element.mousedown', 1500, function (event) {

    if ((0, _Mouse.hasSecondaryModifier)(event)) {
      self.activateLasso(event.originalEvent);

      // we've handled the event
      return true;
    }
  });
}

LassoTool.$inject = ['eventBus', 'canvas', 'dragging', 'elementRegistry', 'selection', 'toolManager'];

LassoTool.prototype.activateLasso = function (event, autoActivate) {

  this._dragging.init(event, 'lasso', {
    autoActivate: autoActivate,
    cursor: LASSO_TOOL_CURSOR,
    data: {
      context: {}
    }
  });
};

LassoTool.prototype.activateSelection = function (event) {

  this._dragging.init(event, 'lasso.selection', {
    trapClick: false,
    cursor: LASSO_TOOL_CURSOR,
    data: {
      context: {}
    }
  });
};

LassoTool.prototype.select = function (elements, bbox) {
  var selectedElements = (0, _Elements.getEnclosedElements)(elements, bbox);

  this._selection.select((0, _minDash.values)(selectedElements));
};

LassoTool.prototype.toggle = function () {
  if (this.isActive()) {
    this._dragging.cancel();
  } else {
    this.activateSelection();
  }
};

LassoTool.prototype.isActive = function () {
  var context = this._dragging.context();

  return context && /^lasso/.test(context.prefix);
};

function toBBox(event) {

  var start = {

    x: event.x - event.dx,
    y: event.y - event.dy
  };

  var end = {
    x: event.x,
    y: event.y
  };

  var bbox;

  if (start.x <= end.x && start.y < end.y || start.x < end.x && start.y <= end.y) {

    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) {

    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) {

    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) {

    bbox = {
      x: end.x,
      y: end.y,
      width: start.x - end.x,
      height: start.y - end.y
    };
  } else {

    bbox = {
      x: end.x,
      y: end.y,
      width: 0,
      height: 0
    };
  }
  return bbox;
}

},{"../../util/Elements":396,"../../util/Mouse":403,"min-dash":505,"tiny-svg":535}],304:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _toolManager = require('../tool-manager');

var _toolManager2 = _interopRequireDefault(_toolManager);

var _LassoTool = require('./LassoTool');

var _LassoTool2 = _interopRequireDefault(_LassoTool);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __depends__: [_toolManager2.default],
  __init__: ['lassoTool'],
  lassoTool: ['type', _LassoTool2.default]
};

},{"../tool-manager":370,"./LassoTool":303}],305:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

exports.default = Modeling;

var _minDash = require('min-dash');

var _model = require('../../model');

var _AppendShapeHandler = require('./cmd/AppendShapeHandler');

var _AppendShapeHandler2 = _interopRequireDefault(_AppendShapeHandler);

var _CreateShapeHandler = require('./cmd/CreateShapeHandler');

var _CreateShapeHandler2 = _interopRequireDefault(_CreateShapeHandler);

var _DeleteShapeHandler = require('./cmd/DeleteShapeHandler');

var _DeleteShapeHandler2 = _interopRequireDefault(_DeleteShapeHandler);

var _MoveShapeHandler = require('./cmd/MoveShapeHandler');

var _MoveShapeHandler2 = _interopRequireDefault(_MoveShapeHandler);

var _ResizeShapeHandler = require('./cmd/ResizeShapeHandler');

var _ResizeShapeHandler2 = _interopRequireDefault(_ResizeShapeHandler);

var _ReplaceShapeHandler = require('./cmd/ReplaceShapeHandler');

var _ReplaceShapeHandler2 = _interopRequireDefault(_ReplaceShapeHandler);

var _ToggleShapeCollapseHandler = require('./cmd/ToggleShapeCollapseHandler');

var _ToggleShapeCollapseHandler2 = _interopRequireDefault(_ToggleShapeCollapseHandler);

var _SpaceToolHandler = require('./cmd/SpaceToolHandler');

var _SpaceToolHandler2 = _interopRequireDefault(_SpaceToolHandler);

var _CreateLabelHandler = require('./cmd/CreateLabelHandler');

var _CreateLabelHandler2 = _interopRequireDefault(_CreateLabelHandler);

var _CreateConnectionHandler = require('./cmd/CreateConnectionHandler');

var _CreateConnectionHandler2 = _interopRequireDefault(_CreateConnectionHandler);

var _DeleteConnectionHandler = require('./cmd/DeleteConnectionHandler');

var _DeleteConnectionHandler2 = _interopRequireDefault(_DeleteConnectionHandler);

var _MoveConnectionHandler = require('./cmd/MoveConnectionHandler');

var _MoveConnectionHandler2 = _interopRequireDefault(_MoveConnectionHandler);

var _LayoutConnectionHandler = require('./cmd/LayoutConnectionHandler');

var _LayoutConnectionHandler2 = _interopRequireDefault(_LayoutConnectionHandler);

var _UpdateWaypointsHandler = require('./cmd/UpdateWaypointsHandler');

var _UpdateWaypointsHandler2 = _interopRequireDefault(_UpdateWaypointsHandler);

var _ReconnectConnectionHandler = require('./cmd/ReconnectConnectionHandler');

var _ReconnectConnectionHandler2 = _interopRequireDefault(_ReconnectConnectionHandler);

var _MoveElementsHandler = require('./cmd/MoveElementsHandler');

var _MoveElementsHandler2 = _interopRequireDefault(_MoveElementsHandler);

var _DeleteElementsHandler = require('./cmd/DeleteElementsHandler');

var _DeleteElementsHandler2 = _interopRequireDefault(_DeleteElementsHandler);

var _DistributeElementsHandler = require('./cmd/DistributeElementsHandler');

var _DistributeElementsHandler2 = _interopRequireDefault(_DistributeElementsHandler);

var _AlignElementsHandler = require('./cmd/AlignElementsHandler');

var _AlignElementsHandler2 = _interopRequireDefault(_AlignElementsHandler);

var _UpdateAttachmentHandler = require('./cmd/UpdateAttachmentHandler');

var _UpdateAttachmentHandler2 = _interopRequireDefault(_UpdateAttachmentHandler);

var _PasteHandler = require('./cmd/PasteHandler');

var _PasteHandler2 = _interopRequireDefault(_PasteHandler);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * The basic modeling entry point.
 *
 * @param {EventBus} eventBus
 * @param {ElementFactory} elementFactory
 * @param {CommandStack} commandStack
 */
function Modeling(eventBus, elementFactory, commandStack) {
  this._eventBus = eventBus;
  this._elementFactory = elementFactory;
  this._commandStack = commandStack;

  var self = this;

  eventBus.on('diagram.init', function () {
    // register modeling handlers
    self.registerHandlers(commandStack);
  });
}

Modeling.$inject = ['eventBus', 'elementFactory', 'commandStack'];

Modeling.prototype.getHandlers = function () {
  return {
    'shape.append': _AppendShapeHandler2.default,
    'shape.create': _CreateShapeHandler2.default,
    'shape.delete': _DeleteShapeHandler2.default,
    'shape.move': _MoveShapeHandler2.default,
    'shape.resize': _ResizeShapeHandler2.default,
    'shape.replace': _ReplaceShapeHandler2.default,
    'shape.toggleCollapse': _ToggleShapeCollapseHandler2.default,

    'spaceTool': _SpaceToolHandler2.default,

    'label.create': _CreateLabelHandler2.default,

    'connection.create': _CreateConnectionHandler2.default,
    'connection.delete': _DeleteConnectionHandler2.default,
    'connection.move': _MoveConnectionHandler2.default,
    'connection.layout': _LayoutConnectionHandler2.default,

    'connection.updateWaypoints': _UpdateWaypointsHandler2.default,

    'connection.reconnectStart': _ReconnectConnectionHandler2.default,
    'connection.reconnectEnd': _ReconnectConnectionHandler2.default,

    'elements.move': _MoveElementsHandler2.default,
    'elements.delete': _DeleteElementsHandler2.default,

    'elements.distribute': _DistributeElementsHandler2.default,
    'elements.align': _AlignElementsHandler2.default,

    'element.updateAttachment': _UpdateAttachmentHandler2.default,

    'elements.paste': _PasteHandler2.default
  };
};

/**
 * Register handlers with the command stack
 *
 * @param {CommandStack} commandStack
 */
Modeling.prototype.registerHandlers = function (commandStack) {
  (0, _minDash.forEach)(this.getHandlers(), function (handler, id) {
    commandStack.registerHandler(id, handler);
  });
};

// modeling helpers //////////////////////

Modeling.prototype.moveShape = function (shape, delta, newParent, newParentIndex, hints) {

  if ((typeof newParentIndex === 'undefined' ? 'undefined' : _typeof(newParentIndex)) === 'object') {
    hints = newParentIndex;
    newParentIndex = null;
  }

  var context = {
    shape: shape,
    delta: delta,
    newParent: newParent,
    newParentIndex: newParentIndex,
    hints: hints || {}
  };

  this._commandStack.execute('shape.move', context);
};

/**
 * Update the attachment of the given shape.
 *
 * @param {djs.mode.Base} shape
 * @param {djs.model.Base} [newHost]
 */
Modeling.prototype.updateAttachment = function (shape, newHost) {
  var context = {
    shape: shape,
    newHost: newHost
  };

  this._commandStack.execute('element.updateAttachment', context);
};

/**
 * 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.prototype.moveElements = function (shapes, delta, target, hints) {

  hints = hints || {};

  var attach = hints.attach;

  var newParent = target,
      newHost;

  if (attach === true) {
    newHost = target;
    newParent = target.parent;
  } else if (attach === false) {
    newHost = null;
  }

  var context = {
    shapes: shapes,
    delta: delta,
    newParent: newParent,
    newHost: newHost,
    hints: hints
  };

  this._commandStack.execute('elements.move', context);
};

Modeling.prototype.moveConnection = function (connection, delta, newParent, newParentIndex, hints) {

  if ((typeof newParentIndex === 'undefined' ? 'undefined' : _typeof(newParentIndex)) === 'object') {
    hints = newParentIndex;
    newParentIndex = undefined;
  }

  var context = {
    connection: connection,
    delta: delta,
    newParent: newParent,
    newParentIndex: newParentIndex,
    hints: hints || {}
  };

  this._commandStack.execute('connection.move', context);
};

Modeling.prototype.layoutConnection = function (connection, hints) {
  var context = {
    connection: connection,
    hints: hints || {}
  };

  this._commandStack.execute('connection.layout', context);
};

/**
 * Create connection.
 *
 * @param {djs.model.Base} source
 * @param {djs.model.Base} target
 * @param {Number} [targetIndex]
 * @param {Object|djs.model.Connection} connection
 * @param {djs.model.Base} parent
 * @param {Object} hints
 *
 * @return {djs.model.Connection} the created connection.
 */
Modeling.prototype.createConnection = function (source, target, parentIndex, connection, parent, hints) {

  if ((typeof parentIndex === 'undefined' ? 'undefined' : _typeof(parentIndex)) === 'object') {
    hints = parent;
    parent = connection;
    connection = parentIndex;
    parentIndex = undefined;
  }

  connection = this._create('connection', connection);

  var context = {
    source: source,
    target: target,
    parent: parent,
    parentIndex: parentIndex,
    connection: connection,
    hints: hints
  };

  this._commandStack.execute('connection.create', context);

  return context.connection;
};

/**
 * 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.prototype.createShape = function (shape, position, target, parentIndex, hints) {

  if (typeof parentIndex !== 'number') {
    hints = parentIndex;
    parentIndex = undefined;
  }

  hints = hints || {};

  var attach = hints.attach,
      parent,
      host;

  shape = this._create('shape', shape);

  if (attach) {
    parent = target.parent;
    host = target;
  } else {
    parent = target;
  }

  var context = {
    position: position,
    shape: shape,
    parent: parent,
    parentIndex: parentIndex,
    host: host,
    hints: hints
  };

  this._commandStack.execute('shape.create', context);

  return context.shape;
};

Modeling.prototype.createLabel = function (labelTarget, position, label, parent) {

  label = this._create('label', label);

  var context = {
    labelTarget: labelTarget,
    position: position,
    parent: parent || labelTarget.parent,
    shape: label
  };

  this._commandStack.execute('label.create', context);

  return context.shape;
};

/**
 * 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.prototype.appendShape = function (source, shape, position, target, hints) {

  hints = hints || {};

  shape = this._create('shape', shape);

  var context = {
    source: source,
    position: position,
    target: target,
    shape: shape,
    connection: hints.connection,
    connectionParent: hints.connectionParent,
    attach: hints.attach
  };

  this._commandStack.execute('shape.append', context);

  return context.shape;
};

Modeling.prototype.removeElements = function (elements) {
  var context = {
    elements: elements
  };

  this._commandStack.execute('elements.delete', context);
};

Modeling.prototype.distributeElements = function (groups, axis, dimension) {
  var context = {
    groups: groups,
    axis: axis,
    dimension: dimension
  };

  this._commandStack.execute('elements.distribute', context);
};

Modeling.prototype.removeShape = function (shape, hints) {
  var context = {
    shape: shape,
    hints: hints || {}
  };

  this._commandStack.execute('shape.delete', context);
};

Modeling.prototype.removeConnection = function (connection, hints) {
  var context = {
    connection: connection,
    hints: hints || {}
  };

  this._commandStack.execute('connection.delete', context);
};

Modeling.prototype.replaceShape = function (oldShape, newShape, hints) {
  var context = {
    oldShape: oldShape,
    newData: newShape,
    hints: hints || {}
  };

  this._commandStack.execute('shape.replace', context);

  return context.newShape;
};

Modeling.prototype.pasteElements = function (tree, topParent, position) {
  var context = {
    tree: tree,
    topParent: topParent,
    position: position
  };

  this._commandStack.execute('elements.paste', context);
};

Modeling.prototype.alignElements = function (elements, alignment) {
  var context = {
    elements: elements,
    alignment: alignment
  };

  this._commandStack.execute('elements.align', context);
};

Modeling.prototype.resizeShape = function (shape, newBounds, minBounds) {
  var context = {
    shape: shape,
    newBounds: newBounds,
    minBounds: minBounds
  };

  this._commandStack.execute('shape.resize', context);
};

Modeling.prototype.createSpace = function (movingShapes, resizingShapes, delta, direction) {
  var context = {
    movingShapes: movingShapes,
    resizingShapes: resizingShapes,
    delta: delta,
    direction: direction
  };

  this._commandStack.execute('spaceTool', context);
};

Modeling.prototype.updateWaypoints = function (connection, newWaypoints, hints) {
  var context = {
    connection: connection,
    newWaypoints: newWaypoints,
    hints: hints || {}
  };

  this._commandStack.execute('connection.updateWaypoints', context);
};

Modeling.prototype.reconnectStart = function (connection, newSource, dockingOrPoints) {
  var context = {
    connection: connection,
    newSource: newSource,
    dockingOrPoints: dockingOrPoints
  };

  this._commandStack.execute('connection.reconnectStart', context);
};

Modeling.prototype.reconnectEnd = function (connection, newTarget, dockingOrPoints) {
  var context = {
    connection: connection,
    newTarget: newTarget,
    dockingOrPoints: dockingOrPoints
  };

  this._commandStack.execute('connection.reconnectEnd', context);
};

Modeling.prototype.connect = function (source, target, attrs, hints) {
  return this.createConnection(source, target, attrs || {}, source.parent, hints);
};

Modeling.prototype._create = function (type, attrs) {
  if (attrs instanceof _model.Base) {
    return attrs;
  } else {
    return this._elementFactory.create(type, attrs);
  }
};

Modeling.prototype.toggleCollapse = function (shape, hints) {
  var context = {
    shape: shape,
    hints: hints || {}
  };

  this._commandStack.execute('shape.toggleCollapse', context);
};

},{"../../model":382,"./cmd/AlignElementsHandler":306,"./cmd/AppendShapeHandler":307,"./cmd/CreateConnectionHandler":308,"./cmd/CreateLabelHandler":309,"./cmd/CreateShapeHandler":310,"./cmd/DeleteConnectionHandler":311,"./cmd/DeleteElementsHandler":312,"./cmd/DeleteShapeHandler":313,"./cmd/DistributeElementsHandler":314,"./cmd/LayoutConnectionHandler":315,"./cmd/MoveConnectionHandler":316,"./cmd/MoveElementsHandler":317,"./cmd/MoveShapeHandler":318,"./cmd/PasteHandler":319,"./cmd/ReconnectConnectionHandler":320,"./cmd/ReplaceShapeHandler":321,"./cmd/ResizeShapeHandler":322,"./cmd/SpaceToolHandler":323,"./cmd/ToggleShapeCollapseHandler":324,"./cmd/UpdateAttachmentHandler":325,"./cmd/UpdateWaypointsHandler":326,"min-dash":505}],306:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = AlignElements;

var _minDash = require('min-dash');

/**
 * A handler that align elements in a certain way.
 *
 */
function AlignElements(modeling, canvas) {
  this._modeling = modeling;
  this._canvas = canvas;
}

AlignElements.$inject = ['modeling', 'canvas'];

AlignElements.prototype.preExecute = function (context) {
  var modeling = this._modeling;

  var elements = context.elements,
      alignment = context.alignment;

  (0, _minDash.forEach)(elements, function (element) {
    var delta = {
      x: 0,
      y: 0
    };

    if (alignment.left) {
      delta.x = alignment.left - element.x;
    } else if (alignment.right) {
      delta.x = alignment.right - element.width - element.x;
    } else if (alignment.center) {
      delta.x = alignment.center - Math.round(element.width / 2) - element.x;
    } else if (alignment.top) {
      delta.y = alignment.top - element.y;
    } else if (alignment.bottom) {
      delta.y = alignment.bottom - element.height - element.y;
    } else if (alignment.middle) {
      delta.y = alignment.middle - Math.round(element.height / 2) - element.y;
    }

    modeling.moveElements([element], delta, element.parent);
  });
};

AlignElements.prototype.postExecute = function (context) {};

},{"min-dash":505}],307:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = AppendShapeHandler;

var _minDash = require('min-dash');

/**
 * 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;
}

AppendShapeHandler.$inject = ['modeling'];

// api //////////////////////


/**
 * 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) {

  var source = context.source;

  if (!source) {
    throw new Error('source required');
  }

  var target = context.target || source.parent,
      shape = context.shape;

  shape = context.shape = this._modeling.createShape(shape, context.position, target, { attach: context.attach });

  context.shape = shape;
};

AppendShapeHandler.prototype.postExecute = function (context) {
  var parent = context.connectionParent || context.shape.parent;

  if (!existsConnection(context.source, context.shape)) {

    // create connection
    this._modeling.connect(context.source, context.shape, context.connection, parent);
  }
};

function existsConnection(source, target) {
  return (0, _minDash.some)(source.outgoing, function (c) {
    return c.target === target;
  });
}

},{"min-dash":505}],308:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = CreateConnectionHandler;
function CreateConnectionHandler(canvas, layouter) {
  this._canvas = canvas;
  this._layouter = layouter;
}

CreateConnectionHandler.$inject = ['canvas', 'layouter'];

// api //////////////////////


/**
 * 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) {

  var connection = context.connection,
      source = context.source,
      target = context.target,
      parent = context.parent,
      parentIndex = context.parentIndex,
      hints = context.hints;

  if (!source || !target) {
    throw new Error('source and target required');
  }

  if (!parent) {
    throw new Error('parent required');
  }

  connection.source = source;
  connection.target = target;

  if (!connection.waypoints) {
    connection.waypoints = this._layouter.layoutConnection(connection, hints);
  }

  // add connection
  this._canvas.addConnection(connection, parent, parentIndex);

  return connection;
};

CreateConnectionHandler.prototype.revert = function (context) {
  var connection = context.connection;

  this._canvas.removeConnection(connection);

  connection.source = null;
  connection.target = null;
};

},{}],309:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = CreateLabelHandler;

var _inherits = require('inherits');

var _inherits2 = _interopRequireDefault(_inherits);

var _CreateShapeHandler = require('./CreateShapeHandler');

var _CreateShapeHandler2 = _interopRequireDefault(_CreateShapeHandler);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * A handler that attaches a label to a given target shape.
 *
 * @param {Canvas} canvas
 */
function CreateLabelHandler(canvas) {
  _CreateShapeHandler2.default.call(this, canvas);
}

(0, _inherits2.default)(CreateLabelHandler, _CreateShapeHandler2.default);

CreateLabelHandler.$inject = ['canvas'];

// api //////////////////////


var originalExecute = _CreateShapeHandler2.default.prototype.execute;

/**
 * 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) {

  var label = context.shape;

  ensureValidDimensions(label);

  label.labelTarget = context.labelTarget;

  return originalExecute.call(this, context);
};

var originalRevert = _CreateShapeHandler2.default.prototype.revert;

/**
 * Undo append by removing the shape
 */
CreateLabelHandler.prototype.revert = function (context) {
  context.shape.labelTarget = null;

  return originalRevert.call(this, context);
};

// helpers //////////////////////

function ensureValidDimensions(label) {
  // make sure a label has valid { width, height } dimensions
  ['width', 'height'].forEach(function (prop) {
    if (typeof label[prop] === 'undefined') {
      label[prop] = 0;
    }
  });
}

},{"./CreateShapeHandler":310,"inherits":415}],310:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = CreateShapeHandler;

var _minDash = require('min-dash');

var round = Math.round;

/**
 * A handler that implements reversible addition of shapes.
 *
 * @param {canvas} Canvas
 */
function CreateShapeHandler(canvas) {
  this._canvas = canvas;
}

CreateShapeHandler.$inject = ['canvas'];

// api //////////////////////


/**
 * 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) {

  var shape = context.shape,
      positionOrBounds = context.position,
      parent = context.parent,
      parentIndex = context.parentIndex;

  if (!parent) {
    throw new Error('parent required');
  }

  if (!positionOrBounds) {
    throw new Error('position required');
  }

  // (1) add at event center position _or_ at given bounds
  if (positionOrBounds.width !== undefined) {
    (0, _minDash.assign)(shape, positionOrBounds);
  } else {
    (0, _minDash.assign)(shape, {
      x: positionOrBounds.x - round(shape.width / 2),
      y: positionOrBounds.y - round(shape.height / 2)
    });
  }

  // (2) add to canvas
  this._canvas.addShape(shape, parent, parentIndex);

  return shape;
};

/**
 * Undo append by removing the shape
 */
CreateShapeHandler.prototype.revert = function (context) {

  // (3) remove form canvas
  this._canvas.removeShape(context.shape);
};

},{"min-dash":505}],311:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = DeleteConnectionHandler;

var _Collections = require('../../../util/Collections');

/**
 * A handler that implements reversible deletion of Connections.
 */
function DeleteConnectionHandler(canvas, modeling) {
  this._canvas = canvas;
  this._modeling = modeling;
}

DeleteConnectionHandler.$inject = ['canvas', 'modeling'];

DeleteConnectionHandler.prototype.execute = function (context) {

  var connection = context.connection,
      parent = connection.parent;

  context.parent = parent;

  // remember containment
  context.parentIndex = (0, _Collections.indexOf)(parent.children, connection);

  context.source = connection.source;
  context.target = connection.target;

  this._canvas.removeConnection(connection);

  connection.source = null;
  connection.target = null;

  return connection;
};

/**
 * Command revert implementation.
 */
DeleteConnectionHandler.prototype.revert = function (context) {

  var connection = context.connection,
      parent = context.parent,
      parentIndex = context.parentIndex;

  connection.source = context.source;
  connection.target = context.target;

  // restore containment
  (0, _Collections.add)(parent.children, connection, parentIndex);

  this._canvas.addConnection(connection, parent);

  return connection;
};

},{"../../../util/Collections":393}],312:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = DeleteElementsHandler;

var _minDash = require('min-dash');

function DeleteElementsHandler(modeling, elementRegistry) {
  this._modeling = modeling;
  this._elementRegistry = elementRegistry;
}

DeleteElementsHandler.$inject = ['modeling', 'elementRegistry'];

DeleteElementsHandler.prototype.postExecute = function (context) {

  var modeling = this._modeling,
      elementRegistry = this._elementRegistry,
      elements = context.elements;

  (0, _minDash.forEach)(elements, function (element) {

    // element may have been removed with previous
    // remove operations already (e.g. in case of nesting)
    if (!elementRegistry.get(element.id)) {
      return;
    }

    if (element.waypoints) {
      modeling.removeConnection(element);
    } else {
      modeling.removeShape(element);
    }
  });
};

},{"min-dash":505}],313:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = DeleteShapeHandler;

var _Collections = require('../../../util/Collections');

var _Removal = require('../../../util/Removal');

/**
 * A handler that implements reversible deletion of shapes.
 *
 */
function DeleteShapeHandler(canvas, modeling) {
  this._canvas = canvas;
  this._modeling = modeling;
}

DeleteShapeHandler.$inject = ['canvas', 'modeling'];

/**
 * - Remove connections
 * - Remove all direct children
 */
DeleteShapeHandler.prototype.preExecute = function (context) {

  var modeling = this._modeling;

  var shape = context.shape;

  // remove connections
  (0, _Removal.saveClear)(shape.incoming, function (connection) {
    // To make sure that the connection isn't removed twice
    // For example if a container is removed
    modeling.removeConnection(connection, { nested: true });
  });

  (0, _Removal.saveClear)(shape.outgoing, function (connection) {
    modeling.removeConnection(connection, { nested: true });
  });

  // remove child shapes and connections
  (0, _Removal.saveClear)(shape.children, function (child) {
    if (isConnection(child)) {
      modeling.removeConnection(child, { nested: true });
    } else {
      modeling.removeShape(child, { nested: true });
    }
  });
};

/**
 * Remove shape and remember the parent
 */
DeleteShapeHandler.prototype.execute = function (context) {
  var canvas = this._canvas;

  var shape = context.shape,
      oldParent = shape.parent;

  context.oldParent = oldParent;

  // remove containment
  context.oldParentIndex = (0, _Collections.indexOf)(oldParent.children, shape);

  // remove shape
  canvas.removeShape(shape);

  return shape;
};

/**
 * Command revert implementation
 */
DeleteShapeHandler.prototype.revert = function (context) {

  var canvas = this._canvas;

  var shape = context.shape,
      oldParent = context.oldParent,
      oldParentIndex = context.oldParentIndex;

  // restore containment
  (0, _Collections.add)(oldParent.children, shape, oldParentIndex);

  canvas.addShape(shape, oldParent);

  return shape;
};

function isConnection(element) {
  return element.waypoints;
}

},{"../../../util/Collections":393,"../../../util/Removal":406}],314:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = DistributeElements;

var _minDash = require('min-dash');

/**
 * A handler that distributes elements evenly.
 */
function DistributeElements(modeling) {
  this._modeling = modeling;
}

DistributeElements.$inject = ['modeling'];

var OFF_AXIS = {
  x: 'y',
  y: 'x'
};

DistributeElements.prototype.preExecute = function (context) {
  var modeling = this._modeling;

  var groups = context.groups,
      axis = context.axis,
      dimension = context.dimension;

  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);
  }

  function center(element) {
    return element[axis] + element[dimension] / 2;
  }

  function lastIdx(arr) {
    return arr.length - 1;
  }

  function rangeDiff(range) {
    return range.max - range.min;
  }

  function centerElement(refCenter, element) {
    var delta = { y: 0 };

    delta[axis] = refCenter - center(element);

    if (delta[axis]) {

      delta[OFF_AXIS[axis]] = 0;

      modeling.moveElements([element], delta, element.parent);
    }
  }

  var firstGroup = groups[0],
      lastGroupIdx = lastIdx(groups),
      lastGroup = groups[lastGroupIdx];

  var margin,
      spaceInBetween,
      groupsSize = 0; // the size of each range

  (0, _minDash.forEach)(groups, function (group, idx) {
    var sortedElements, refElem, refCenter;

    if (group.elements.length < 2) {
      if (idx && idx !== groups.length - 1) {
        updateRange(group, group.elements[0]);

        groupsSize += rangeDiff(group.range);
      }
      return;
    }

    sortedElements = (0, _minDash.sortBy)(group.elements, axis);

    refElem = sortedElements[0];

    if (idx === lastGroupIdx) {
      refElem = sortedElements[lastIdx(sortedElements)];
    }

    refCenter = center(refElem);

    // wanna update the ranges after the shapes have been centered
    group.range = null;

    (0, _minDash.forEach)(sortedElements, function (element) {

      centerElement(refCenter, element);

      if (group.range === null) {
        group.range = {
          min: element[axis],
          max: element[axis] + element[dimension]
        };

        return;
      }

      // update group's range after centering the range elements
      updateRange(group, element);
    });

    if (idx && idx !== groups.length - 1) {
      groupsSize += rangeDiff(group.range);
    }
  });

  spaceInBetween = Math.abs(lastGroup.range.min - firstGroup.range.max);

  margin = Math.round((spaceInBetween - groupsSize) / (groups.length - 1));

  if (margin < groups.length - 1) {
    return;
  }

  (0, _minDash.forEach)(groups, function (group, groupIdx) {
    var delta = {},
        prevGroup;

    if (group === firstGroup || group === lastGroup) {
      return;
    }

    prevGroup = groups[groupIdx - 1];

    group.range.max = 0;

    (0, _minDash.forEach)(group.elements, function (element, idx) {
      delta[OFF_AXIS[axis]] = 0;
      delta[axis] = prevGroup.range.max - element[axis] + margin;

      if (group.range.min !== element[axis]) {
        delta[axis] += element[axis] - group.range.min;
      }

      if (delta[axis]) {
        modeling.moveElements([element], delta, element.parent);
      }

      group.range.max = Math.max(element[axis] + element[dimension], idx ? group.range.max : 0);
    });
  });
};

DistributeElements.prototype.postExecute = function (context) {};

},{"min-dash":505}],315:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = LayoutConnectionHandler;

var _minDash = require('min-dash');

/**
 * A handler that implements reversible moving of shapes.
 */
function LayoutConnectionHandler(layouter, canvas) {
  this._layouter = layouter;
  this._canvas = canvas;
}

LayoutConnectionHandler.$inject = ['layouter', 'canvas'];

LayoutConnectionHandler.prototype.execute = function (context) {

  var connection = context.connection;

  var oldWaypoints = connection.waypoints;

  (0, _minDash.assign)(context, {
    oldWaypoints: oldWaypoints
  });

  connection.waypoints = this._layouter.layoutConnection(connection, context.hints);

  return connection;
};

LayoutConnectionHandler.prototype.revert = function (context) {

  var connection = context.connection;

  connection.waypoints = context.oldWaypoints;

  return connection;
};

},{"min-dash":505}],316:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = MoveConnectionHandler;

var _minDash = require('min-dash');

var _Collections = require('../../../util/Collections');

/**
 * 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() {}

MoveConnectionHandler.prototype.execute = function (context) {

  var connection = context.connection,
      delta = context.delta;

  var newParent = context.newParent || connection.parent,
      newParentIndex = context.newParentIndex,
      oldParent = connection.parent;

  // save old parent in context
  context.oldParent = oldParent;
  context.oldParentIndex = (0, _Collections.remove)(oldParent.children, connection);

  // add to new parent at position
  (0, _Collections.add)(newParent.children, connection, newParentIndex);

  // update parent
  connection.parent = newParent;

  // update waypoint positions
  (0, _minDash.forEach)(connection.waypoints, function (p) {
    p.x += delta.x;
    p.y += delta.y;

    if (p.original) {
      p.original.x += delta.x;
      p.original.y += delta.y;
    }
  });

  return connection;
};

MoveConnectionHandler.prototype.revert = function (context) {

  var connection = context.connection,
      newParent = connection.parent,
      oldParent = context.oldParent,
      oldParentIndex = context.oldParentIndex,
      delta = context.delta;

  // remove from newParent
  (0, _Collections.remove)(newParent.children, connection);

  // restore previous location in old parent
  (0, _Collections.add)(oldParent.children, connection, oldParentIndex);

  // restore parent
  connection.parent = oldParent;

  // revert to old waypoint positions
  (0, _minDash.forEach)(connection.waypoints, function (p) {
    p.x -= delta.x;
    p.y -= delta.y;

    if (p.original) {
      p.original.x -= delta.x;
      p.original.y -= delta.y;
    }
  });

  return connection;
};

},{"../../../util/Collections":393,"min-dash":505}],317:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = MoveElementsHandler;

var _MoveHelper = require('./helper/MoveHelper');

var _MoveHelper2 = _interopRequireDefault(_MoveHelper);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * A handler that implements reversible moving of shapes.
 */
function MoveElementsHandler(modeling) {
  this._helper = new _MoveHelper2.default(modeling);
}

MoveElementsHandler.$inject = ['modeling'];

MoveElementsHandler.prototype.preExecute = function (context) {
  context.closure = this._helper.getClosure(context.shapes);
};

MoveElementsHandler.prototype.postExecute = function (context) {

  var hints = context.hints,
      primaryShape;

  if (hints && hints.primaryShape) {
    primaryShape = hints.primaryShape;
    hints.oldParent = primaryShape.parent;
  }

  this._helper.moveClosure(context.closure, context.delta, context.newParent, context.newHost, primaryShape);
};

},{"./helper/MoveHelper":329}],318:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = MoveShapeHandler;

var _minDash = require('min-dash');

var _MoveHelper = require('./helper/MoveHelper');

var _MoveHelper2 = _interopRequireDefault(_MoveHelper);

var _Collections = require('../../../util/Collections');

var _AnchorsHelper = require('./helper/AnchorsHelper');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * A handler that implements reversible moving of shapes.
 */
function MoveShapeHandler(modeling) {
  this._modeling = modeling;

  this._helper = new _MoveHelper2.default(modeling);
}

MoveShapeHandler.$inject = ['modeling'];

MoveShapeHandler.prototype.execute = function (context) {

  var shape = context.shape,
      delta = context.delta,
      newParent = context.newParent || shape.parent,
      newParentIndex = context.newParentIndex,
      oldParent = shape.parent;

  context.oldBounds = (0, _minDash.pick)(shape, ['x', 'y', 'width', 'height']);

  // save old parent in context
  context.oldParent = oldParent;
  context.oldParentIndex = (0, _Collections.remove)(oldParent.children, shape);

  // add to new parent at position
  (0, _Collections.add)(newParent.children, shape, newParentIndex);

  // update shape parent + position
  (0, _minDash.assign)(shape, {
    parent: newParent,
    x: shape.x + delta.x,
    y: shape.y + delta.y
  });

  return shape;
};

MoveShapeHandler.prototype.postExecute = function (context) {

  var shape = context.shape,
      delta = context.delta,
      hints = context.hints;

  var modeling = this._modeling;

  if (hints.layout !== false) {

    (0, _minDash.forEach)(shape.incoming, function (c) {
      modeling.layoutConnection(c, {
        connectionEnd: (0, _AnchorsHelper.getMovedTargetAnchor)(c, shape, delta)
      });
    });

    (0, _minDash.forEach)(shape.outgoing, function (c) {
      modeling.layoutConnection(c, {
        connectionStart: (0, _AnchorsHelper.getMovedSourceAnchor)(c, shape, delta)
      });
    });
  }

  if (hints.recurse !== false) {
    this.moveChildren(context);
  }
};

MoveShapeHandler.prototype.revert = function (context) {

  var shape = context.shape,
      oldParent = context.oldParent,
      oldParentIndex = context.oldParentIndex,
      delta = context.delta;

  // restore previous location in old parent
  (0, _Collections.add)(oldParent.children, shape, oldParentIndex);

  // revert to old position and parent
  (0, _minDash.assign)(shape, {
    parent: oldParent,
    x: shape.x - delta.x,
    y: shape.y - delta.y
  });

  return shape;
};

MoveShapeHandler.prototype.moveChildren = function (context) {

  var delta = context.delta,
      shape = context.shape;

  this._helper.moveRecursive(shape.children, delta, null);
};

MoveShapeHandler.prototype.getNewParent = function (context) {
  return context.newParent || context.shape.parent;
};

},{"../../../util/Collections":393,"./helper/AnchorsHelper":327,"./helper/MoveHelper":329,"min-dash":505}],319:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = PasteHandler;

var _minDash = require('min-dash');

function removeProperties(element, properties) {
  (0, _minDash.forEach)(properties, function (prop) {
    if (element[prop]) {
      delete element[prop];
    }
  });
}

/**
 * A handler that implements pasting of elements onto the diagram.
 *
 * @param {eventBus} EventBus
 * @param {canvas} Canvas
 * @param {selection} Selection
 * @param {elementFactory} ElementFactory
 * @param {modeling} Modeling
 * @param {rules} Rules
 */
function PasteHandler(eventBus, canvas, selection, elementFactory, modeling, rules) {

  this._eventBus = eventBus;
  this._canvas = canvas;
  this._selection = selection;
  this._elementFactory = elementFactory;
  this._modeling = modeling;
  this._rules = rules;
}

PasteHandler.$inject = ['eventBus', 'canvas', 'selection', 'elementFactory', 'modeling', 'rules'];

// api //////////////////////

/**
 * Creates a new shape
 *
 * @param {Object} context
 * @param {Object} context.tree the new shape
 * @param {Element} context.topParent the paste target
 */
PasteHandler.prototype.preExecute = function (context) {
  var eventBus = this._eventBus,
      self = this;

  var tree = context.tree,
      topParent = context.topParent,
      position = context.position;

  tree.createdElements = {};

  tree.labels = [];

  (0, _minDash.forEach)(tree, function (elements, depthStr) {
    var depth = parseInt(depthStr, 10);

    if (isNaN(depth)) {
      return;
    }

    // set the parent on the top level elements
    if (!depth) {
      elements = (0, _minDash.map)(elements, function (descriptor) {
        descriptor.parent = topParent;

        return descriptor;
      });
    }

    // Order by priority for element creation
    elements = (0, _minDash.sortBy)(elements, 'priority');

    (0, _minDash.forEach)(elements, function (descriptor) {
      var id = descriptor.id,
          parent = descriptor.parent,
          hints = {},
          newPosition;

      var element = (0, _minDash.assign)({}, descriptor);

      if (depth) {
        element.parent = self._getCreatedElement(parent, tree);
      }

      // this happens when shapes have not been created due to rules
      if (!parent) {
        return;
      }

      eventBus.fire('element.paste', {
        createdElements: tree.createdElements,
        descriptor: element
      });

      // in case the parent changed during 'element.paste'
      parent = element.parent;

      if (element.waypoints) {
        element = self._createConnection(element, parent, position, tree);

        if (element) {
          tree.createdElements[id] = {
            element: element,
            descriptor: descriptor
          };
        }

        return;
      }

      // supply not-root information as hint
      if (element.parent !== topParent) {
        hints.root = false;
      }

      // set host
      if (element.host) {
        hints.attach = true;

        parent = self._getCreatedElement(element.host, tree);
      }

      // handle labels
      if (element.labelTarget) {
        return tree.labels.push(element);
      }

      newPosition = {
        x: Math.round(position.x + element.delta.x + element.width / 2),
        y: Math.round(position.y + element.delta.y + element.height / 2)
      };

      removeProperties(element, ['id', 'parent', 'delta', 'host', 'priority']);

      element = self._createShape(element, parent, newPosition, hints);

      if (element) {
        tree.createdElements[id] = {
          element: element,
          descriptor: descriptor
        };
      }
    });
  });
};

// move label's to their relative position
PasteHandler.prototype.postExecute = function (context) {
  var modeling = this._modeling,
      selection = this._selection,
      self = this;

  var tree = context.tree,
      labels = tree.labels,
      topLevelElements = [];

  (0, _minDash.forEach)(labels, function (labelDescriptor) {
    var labelTarget = self._getCreatedElement(labelDescriptor.labelTarget, tree),
        labels,
        labelTargetPos,
        newPosition;

    if (!labelTarget) {
      return;
    }

    labels = labelTarget.labels;

    if (!labels || !labels.length) {
      return;
    }

    labelTargetPos = {
      x: labelTarget.x,
      y: labelTarget.y
    };

    if (labelTarget.waypoints) {
      labelTargetPos = labelTarget.waypoints[0];
    }

    (0, _minDash.forEach)(labels, function (label) {
      newPosition = {
        x: Math.round(labelTargetPos.x - label.x + labelDescriptor.delta.x),
        y: Math.round(labelTargetPos.y - label.y + labelDescriptor.delta.y)
      };

      modeling.moveShape(label, newPosition, labelTarget.parent);
    });
  });

  (0, _minDash.forEach)(tree[0], function (descriptor) {
    var id = descriptor.id,
        toplevel = tree.createdElements[id];

    if (toplevel) {
      topLevelElements.push(toplevel.element);
    }
  });

  selection.select(topLevelElements);
};

PasteHandler.prototype._createConnection = function (element, parent, parentCenter, tree) {
  var modeling = this._modeling,
      rules = this._rules;

  var connection, source, target, canPaste;

  element.waypoints = (0, _minDash.map)(element.waypoints, function (waypoint, idx) {
    return {
      x: Math.round(parentCenter.x + element.delta[idx].x),
      y: Math.round(parentCenter.y + element.delta[idx].y)
    };
  });

  source = this._getCreatedElement(element.source, tree);
  target = this._getCreatedElement(element.target, tree);

  if (!source || !target) {
    return null;
  }

  canPaste = rules.allowed('element.paste', {
    source: source,
    target: target
  });

  if (!canPaste) {
    return null;
  }

  removeProperties(element, ['id', 'parent', 'delta', 'source', 'target', 'width', 'height', 'priority']);

  connection = modeling.createConnection(source, target, element, parent);

  return connection;
};

PasteHandler.prototype._createShape = function (element, parent, position, isAttach, hints) {
  var modeling = this._modeling,
      elementFactory = this._elementFactory,
      rules = this._rules;

  var canPaste = rules.allowed('element.paste', {
    element: element,
    position: position,
    parent: parent
  });

  if (!canPaste) {
    return null;
  }

  var shape = elementFactory.createShape(element);

  modeling.createShape(shape, position, parent, isAttach, hints);

  return shape;
};

PasteHandler.prototype._getCreatedElement = function (id, tree) {
  return tree.createdElements[id] && tree.createdElements[id].element;
};

},{"min-dash":505}],320:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = ReconnectConnectionHandler;

var _minDash = require('min-dash');

/**
 * Reconnect connection handler
 */
function ReconnectConnectionHandler() {}

ReconnectConnectionHandler.$inject = [];

ReconnectConnectionHandler.prototype.execute = function (context) {

  var newSource = context.newSource,
      newTarget = context.newTarget,
      connection = context.connection,
      dockingOrPoints = context.dockingOrPoints,
      oldWaypoints = connection.waypoints,
      newWaypoints;

  if (!newSource && !newTarget) {
    throw new Error('newSource or newTarget are required');
  }

  if (newSource && newTarget) {
    throw new Error('must specify either newSource or newTarget');
  }

  context.oldWaypoints = oldWaypoints;

  if ((0, _minDash.isArray)(dockingOrPoints)) {
    newWaypoints = dockingOrPoints;
  } else {
    newWaypoints = oldWaypoints.slice();

    newWaypoints.splice(newSource ? 0 : -1, 1, dockingOrPoints);
  }

  if (newSource) {
    context.oldSource = connection.source;
    connection.source = newSource;
  }

  if (newTarget) {
    context.oldTarget = connection.target;
    connection.target = newTarget;
  }

  connection.waypoints = newWaypoints;

  return connection;
};

ReconnectConnectionHandler.prototype.revert = function (context) {

  var newSource = context.newSource,
      newTarget = context.newTarget,
      connection = context.connection;

  if (newSource) {
    connection.source = context.oldSource;
  }

  if (newTarget) {
    connection.target = context.oldTarget;
  }

  connection.waypoints = context.oldWaypoints;

  return connection;
};

},{"min-dash":505}],321:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = ReplaceShapeHandler;

var _minDash = require('min-dash');

/**
 * A handler that implements reversible replacing of shapes.
 * Internally the old shape will be removed and the new shape will be added.
 *
 *
 * @class
 * @constructor
 *
 * @param {canvas} Canvas
 */
function ReplaceShapeHandler(modeling, rules) {
  this._modeling = modeling;
  this._rules = rules;
}

ReplaceShapeHandler.$inject = ['modeling', 'rules'];

// api //////////////////////


/**
 * Replaces a shape with an replacement Element.
 *
 * The newData object should contain type, x, y.
 *
 * If possible also the incoming/outgoing connection
 * will be restored.
 *
 * @param {Object} context
 */
ReplaceShapeHandler.prototype.preExecute = function (context) {

  var self = this,
      modeling = this._modeling,
      rules = this._rules;

  var oldShape = context.oldShape,
      newData = context.newData,
      hints = context.hints,
      newShape;

  function canReconnect(type, source, target, connection) {
    return rules.allowed(type, {
      source: source,
      target: target,
      connection: connection
    });
  }

  // (1) place a new shape at the given position

  var position = {
    x: newData.x,
    y: newData.y
  };

  newShape = context.newShape = context.newShape || self.createShape(newData, position, oldShape.parent, hints);

  // (2) update the host

  if (oldShape.host) {
    modeling.updateAttachment(newShape, oldShape.host);
  }

  // (3) adopt all children from the old shape

  var children;

  if (hints.moveChildren !== false) {
    children = oldShape.children.slice();

    modeling.moveElements(children, { x: 0, y: 0 }, newShape);
  }

  // (4) reconnect connections to the new shape (where allowed)

  var incoming = oldShape.incoming.slice(),
      outgoing = oldShape.outgoing.slice();

  (0, _minDash.forEach)(incoming, function (connection) {
    var waypoints = connection.waypoints,
        docking = waypoints[waypoints.length - 1],
        source = connection.source,
        allowed = canReconnect('connection.reconnectEnd', source, newShape, connection);

    if (allowed) {
      self.reconnectEnd(connection, newShape, docking);
    }
  });

  (0, _minDash.forEach)(outgoing, function (connection) {
    var waypoints = connection.waypoints,
        docking = waypoints[0],
        target = connection.target,
        allowed = canReconnect('connection.reconnectStart', newShape, target, connection);

    if (allowed) {
      self.reconnectStart(connection, newShape, docking);
    }
  });
};

ReplaceShapeHandler.prototype.postExecute = function (context) {
  var modeling = this._modeling;

  var oldShape = context.oldShape,
      newShape = context.newShape;

  // if an element gets resized on replace, layout the connection again
  (0, _minDash.forEach)(newShape.incoming, function (c) {
    modeling.layoutConnection(c, { endChanged: true });
  });

  (0, _minDash.forEach)(newShape.outgoing, function (c) {
    modeling.layoutConnection(c, { startChanged: true });
  });

  modeling.removeShape(oldShape);
};

ReplaceShapeHandler.prototype.execute = function (context) {};

ReplaceShapeHandler.prototype.revert = function (context) {};

ReplaceShapeHandler.prototype.createShape = function (shape, position, target, hints) {
  var modeling = this._modeling;
  return modeling.createShape(shape, position, target, hints);
};

ReplaceShapeHandler.prototype.reconnectStart = function (connection, newSource, dockingPoint) {
  var modeling = this._modeling;
  modeling.reconnectStart(connection, newSource, dockingPoint);
};

ReplaceShapeHandler.prototype.reconnectEnd = function (connection, newTarget, dockingPoint) {
  var modeling = this._modeling;
  modeling.reconnectEnd(connection, newTarget, dockingPoint);
};

},{"min-dash":505}],322:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = ResizeShapeHandler;

var _minDash = require('min-dash');

var _AnchorsHelper = require('./helper/AnchorsHelper');

/**
 * A handler that implements reversible resizing of shapes.
 *
 * @param {Modeling} modeling
 */
function ResizeShapeHandler(modeling) {
  this._modeling = modeling;
}

ResizeShapeHandler.$inject = ['modeling'];

/**
 * {
 *   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;

  if (newBounds.x === undefined || newBounds.y === undefined || newBounds.width === undefined || newBounds.height === undefined) {
    throw new Error('newBounds must have {x, y, width, height} properties');
  }

  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');
  }

  // save old bbox in context
  context.oldBounds = {
    width: shape.width,
    height: shape.height,
    x: shape.x,
    y: shape.y
  };

  // update shape
  (0, _minDash.assign)(shape, {
    width: newBounds.width,
    height: newBounds.height,
    x: newBounds.x,
    y: newBounds.y
  });

  return shape;
};

ResizeShapeHandler.prototype.postExecute = function (context) {

  var shape = context.shape,
      oldBounds = context.oldBounds;

  var modeling = this._modeling;

  (0, _minDash.forEach)(shape.incoming, function (c) {
    modeling.layoutConnection(c, {
      connectionEnd: (0, _AnchorsHelper.getResizedTargetAnchor)(c, shape, oldBounds)
    });
  });

  (0, _minDash.forEach)(shape.outgoing, function (c) {
    modeling.layoutConnection(c, {
      connectionStart: (0, _AnchorsHelper.getResizedSourceAnchor)(c, shape, oldBounds)
    });
  });
};

ResizeShapeHandler.prototype.revert = function (context) {

  var shape = context.shape,
      oldBounds = context.oldBounds;

  // restore previous bbox
  (0, _minDash.assign)(shape, {
    width: oldBounds.width,
    height: oldBounds.height,
    x: oldBounds.x,
    y: oldBounds.y
  });

  return shape;
};

},{"./helper/AnchorsHelper":327,"min-dash":505}],323:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = SpaceToolHandler;

var _minDash = require('min-dash');

var _SpaceUtil = require('../../space-tool/SpaceUtil');

/**
 * A handler that implements reversible creating and removing of space.
 *
 * It executes in two phases:
 *
 *  (1) resize all affected resizeShapes
 *  (2) move all affected moveElements
 */
function SpaceToolHandler(modeling) {
  this._modeling = modeling;
}

SpaceToolHandler.$inject = ['modeling'];

SpaceToolHandler.prototype.preExecute = function (context) {

  // resize
  var modeling = this._modeling,
      resizingShapes = context.resizingShapes,
      delta = context.delta,
      direction = context.direction;

  (0, _minDash.forEach)(resizingShapes, function (shape) {
    var newBounds = (0, _SpaceUtil.resizeBounds)(shape, direction, delta);

    modeling.resizeShape(shape, newBounds);
  });
};

SpaceToolHandler.prototype.postExecute = function (context) {
  // move
  var modeling = this._modeling,
      movingShapes = context.movingShapes,
      delta = context.delta;

  modeling.moveElements(movingShapes, delta, undefined, { autoResize: false, attach: false });
};

SpaceToolHandler.prototype.execute = function (context) {};
SpaceToolHandler.prototype.revert = function (context) {};

},{"../../space-tool/SpaceUtil":367,"min-dash":505}],324:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = ToggleShapeCollapseHandler;
/**
 * 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;
}

ToggleShapeCollapseHandler.$inject = ['modeling'];

ToggleShapeCollapseHandler.prototype.execute = function (context) {

  var shape = context.shape,
      children = shape.children;

  // remember previous visibility of children
  context.oldChildrenVisibility = getElementsVisibility(children);

  // toggle state
  shape.collapsed = !shape.collapsed;

  // hide/show children
  setHidden(children, shape.collapsed);

  return [shape].concat(children);
};

ToggleShapeCollapseHandler.prototype.revert = function (context) {

  var shape = context.shape,
      oldChildrenVisibility = context.oldChildrenVisibility;

  var children = shape.children;

  // set old visability of children
  restoreVisibility(children, oldChildrenVisibility);

  // retoggle state
  shape.collapsed = !shape.collapsed;

  return [shape].concat(children);
};

// helpers //////////////////////

/**
 * Return a map { elementId -> hiddenState}.
 *
 * @param {Array<djs.model.Shape>} elements
 *
 * @return {Object}
 */
function getElementsVisibility(elements) {

  var result = {};

  elements.forEach(function (e) {
    result[e.id] = e.hidden;
  });

  return result;
}

function setHidden(elements, newHidden) {
  elements.forEach(function (element) {
    element.hidden = newHidden;
  });
}

function restoreVisibility(elements, lastState) {
  elements.forEach(function (e) {
    e.hidden = lastState[e.id];
  });
}

},{}],325:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = UpdateAttachmentHandler;

var _Collections = require('../../../util/Collections');

/**
 * A handler that implements reversible attaching/detaching of shapes.
 */
function UpdateAttachmentHandler(modeling) {
  this._modeling = modeling;
}

UpdateAttachmentHandler.$inject = ['modeling'];

UpdateAttachmentHandler.prototype.execute = function (context) {
  var shape = context.shape,
      newHost = context.newHost,
      oldHost = shape.host;

  // (0) detach from old host
  context.oldHost = oldHost;
  context.attacherIdx = removeAttacher(oldHost, shape);

  // (1) attach to new host
  addAttacher(newHost, shape);

  // (2) update host
  shape.host = newHost;

  return shape;
};

UpdateAttachmentHandler.prototype.revert = function (context) {
  var shape = context.shape,
      newHost = context.newHost,
      oldHost = context.oldHost,
      attacherIdx = context.attacherIdx;

  // (2) update host
  shape.host = oldHost;

  // (1) attach to new host
  removeAttacher(newHost, shape);

  // (0) detach from old host
  addAttacher(oldHost, shape, attacherIdx);

  return shape;
};

function removeAttacher(host, attacher) {
  // remove attacher from host
  return (0, _Collections.remove)(host && host.attachers, attacher);
}

function addAttacher(host, attacher, idx) {

  if (!host) {
    return;
  }

  var attachers = host.attachers;

  if (!attachers) {
    host.attachers = attachers = [];
  }

  (0, _Collections.add)(attachers, attacher, idx);
}

},{"../../../util/Collections":393}],326:[function(require,module,exports){
"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = UpdateWaypointsHandler;
function UpdateWaypointsHandler() {}

UpdateWaypointsHandler.prototype.execute = function (context) {

  var connection = context.connection,
      newWaypoints = context.newWaypoints;

  context.oldWaypoints = connection.waypoints;

  connection.waypoints = newWaypoints;

  return connection;
};

UpdateWaypointsHandler.prototype.revert = function (context) {

  var connection = context.connection,
      oldWaypoints = context.oldWaypoints;

  connection.waypoints = oldWaypoints;

  return connection;
};

},{}],327:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.getResizedSourceAnchor = getResizedSourceAnchor;
exports.getResizedTargetAnchor = getResizedTargetAnchor;
exports.getMovedSourceAnchor = getMovedSourceAnchor;
exports.getMovedTargetAnchor = getMovedTargetAnchor;

var _AttachUtil = require('../../../../util/AttachUtil');

function getResizedSourceAnchor(connection, shape, oldBounds) {

  var waypoints = safeGetWaypoints(connection),
      oldAnchor = waypoints[0];

  return (0, _AttachUtil.getNewAttachPoint)(oldAnchor.original || oldAnchor, oldBounds, shape);
}

function getResizedTargetAnchor(connection, shape, oldBounds) {

  var waypoints = safeGetWaypoints(connection),
      oldAnchor = waypoints[waypoints.length - 1];

  return (0, _AttachUtil.getNewAttachPoint)(oldAnchor.original || oldAnchor, oldBounds, shape);
}

function getMovedSourceAnchor(connection, source, moveDelta) {
  return getResizedSourceAnchor(connection, source, substractPosition(source, moveDelta));
}

function getMovedTargetAnchor(connection, target, moveDelta) {
  return getResizedTargetAnchor(connection, target, substractPosition(target, moveDelta));
}

// helpers //////////////////////

function substractPosition(bounds, delta) {
  return {
    x: bounds.x - delta.x,
    y: bounds.y - delta.y,
    width: bounds.width,
    height: bounds.height
  };
}

/**
 * Return waypoints of given connection; throw if non exists (should not happen!!).
 *
 * @param {Connection} connection
 *
 * @return {Array<Point>}
 */
function safeGetWaypoints(connection) {

  var waypoints = connection.waypoints;

  if (!waypoints.length) {
    throw new Error('connection#' + connection.id + ': no waypoints');
  }

  return waypoints;
}

},{"../../../../util/AttachUtil":391}],328:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = MoveClosure;

var _minDash = require('min-dash');

var _Elements = require('../../../../util/Elements');

function MoveClosure() {

  this.allShapes = {};
  this.allConnections = {};

  this.enclosedElements = {};
  this.enclosedConnections = {};

  this.topLevel = {};
}

MoveClosure.prototype.add = function (element, isTopLevel) {
  return this.addAll([element], isTopLevel);
};

MoveClosure.prototype.addAll = function (elements, isTopLevel) {

  var newClosure = (0, _Elements.getClosure)(elements, !!isTopLevel, this);

  (0, _minDash.assign)(this, newClosure);

  return this;
};

},{"../../../../util/Elements":396,"min-dash":505}],329:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = MoveHelper;

var _minDash = require('min-dash');

var _AnchorsHelper = require('./AnchorsHelper');

var _MoveClosure = require('./MoveClosure');

var _MoveClosure2 = _interopRequireDefault(_MoveClosure);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * A helper that is able to carry out serialized move
 * operations on multiple elements.
 *
 * @param {Modeling} modeling
 */
function MoveHelper(modeling) {
  this._modeling = modeling;
}

/**
 * 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);
  }
};

/**
 * 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;

  var allShapes = closure.allShapes,
      allConnections = closure.allConnections,
      enclosedConnections = closure.enclosedConnections,
      topLevel = closure.topLevel,
      keepParent = false;

  if (primaryShape && primaryShape.parent === newParent) {
    keepParent = true;
  }

  // move all shapes
  (0, _minDash.forEach)(allShapes, function (shape) {

    // move the element according to the given delta
    modeling.moveShape(shape, delta, topLevel[shape.id] && !keepParent && newParent, {
      recurse: false,
      layout: false
    });
  });

  // move all child connections / layout external connections
  (0, _minDash.forEach)(allConnections, function (c) {

    var sourceMoved = !!allShapes[c.source.id],
        targetMoved = !!allShapes[c.target.id];

    if (enclosedConnections[c.id] && sourceMoved && targetMoved) {
      modeling.moveConnection(c, delta, topLevel[c.id] && !keepParent && newParent);
    } else {
      modeling.layoutConnection(c, {
        connectionStart: sourceMoved && (0, _AnchorsHelper.getMovedSourceAnchor)(c, c.source, delta),
        connectionEnd: targetMoved && (0, _AnchorsHelper.getMovedTargetAnchor)(c, c.target, delta)
      });
    }
  });
};

/**
 * Returns the closure for the selected elements
 *
 * @param  {Array<djs.model.Base>} elements
 * @return {MoveClosure} closure
 */
MoveHelper.prototype.getClosure = function (elements) {
  return new _MoveClosure2.default().addAll(elements, true);
};

},{"./AnchorsHelper":327,"./MoveClosure":328,"min-dash":505}],330:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = MouseTracking;

var _minDash = require('min-dash');

function MouseTracking(eventBus, canvas) {
  this._eventBus = eventBus;
  this._canvas = canvas;

  this._init();
}

MouseTracking.$inject = ['eventBus', 'canvas'];

MouseTracking.prototype.getHoverContext = function () {
  var viewbox = this._canvas.viewbox();

  return {
    element: this._hoverElement,
    point: {
      x: viewbox.x + Math.round(this._mouseX / viewbox.scale),
      y: viewbox.y + Math.round(this._mouseY / viewbox.scale)
    }
  };
};

MouseTracking.prototype._init = function () {
  var eventBus = this._eventBus,
      canvas = this._canvas;

  var container = canvas.getContainer();

  this._setMousePosition = (0, _minDash.bind)(this._setMousePosition, this);

  container.addEventListener('mousemove', this._setMousePosition);

  eventBus.on('diagram.destroy', function () {
    container.removeEventListener('mousemove', this._setMousePosition);
  }, this);

  eventBus.on('element.hover', this._setHoverElement, this);
};

MouseTracking.prototype._setHoverElement = function (event) {
  this._hoverElement = event.element;
};

MouseTracking.prototype._setMousePosition = function (event) {
  this._mouseX = event.layerX;
  this._mouseY = event.layerY;
};

},{"min-dash":505}],331:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _MouseTracking = require('./MouseTracking');

var _MouseTracking2 = _interopRequireDefault(_MouseTracking);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __init__: ['mouseTracking'],
  mouseTracking: ['type', _MouseTracking2.default]
};

},{"./MouseTracking":330}],332:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = MoveEvents;

var _minDash = require('min-dash');

var _Event = require('../../util/Event');

var LOW_PRIORITY = 500,
    MEDIUM_PRIORITY = 1250,
    HIGH_PRIORITY = 1500;

var round = Math.round;

function mid(element) {
  return {
    x: element.x + round(element.width / 2),
    y: element.y + round(element.height / 2)
  };
}

/**
 * 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) {

  // rules

  function canMove(shapes, delta, position, target) {

    return rules.allowed('elements.move', {
      shapes: shapes,
      delta: delta,
      position: position,
      target: target
    });
  }

  // move events

  // 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, function (event) {

    var context = event.context,
        shape = event.shape,
        shapes = selection.get().slice();

    // move only single shape if the dragged element
    // is not part of the current selection
    if (shapes.indexOf(shape) === -1) {
      shapes = [shape];
    }

    // ensure we remove nested elements in the collection
    // and add attachers for a proper dragger
    shapes = removeNested(shapes);

    // attach shapes to drag context
    (0, _minDash.assign)(context, {
      shapes: shapes,
      validatedShapes: shapes,
      shape: shape
    });
  });

  // 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) {

    var context = event.context,
        validatedShapes = context.validatedShapes,
        canExecute;

    canExecute = context.canExecute = canMove(validatedShapes);

    // check if we can move the elements
    if (!canExecute) {
      return false;
    }
  });

  // 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, function (event) {

    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;

    // check if we can move the elements
    canExecute = canMove(validatedShapes, delta, position, hover);

    context.delta = delta;
    context.canExecute = canExecute;

    // simply ignore move over
    if (canExecute === null) {
      context.target = null;

      return;
    }

    context.target = hover;
  });

  eventBus.on('shape.move.end', function (event) {

    var context = event.context;

    var delta = context.delta,
        canExecute = context.canExecute,
        isAttach = canExecute === 'attach',
        shapes = context.shapes;

    if (!canExecute) {
      return false;
    }

    // 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);

    modeling.moveElements(shapes, delta, context.target, {
      primaryShape: context.shape,
      attach: isAttach
    });
  });

  // move activation

  eventBus.on('element.mousedown', function (event) {

    var originalEvent = (0, _Event.getOriginal)(event);

    if (!originalEvent) {
      throw new Error('must supply DOM mousedown event');
    }

    return start(originalEvent, event.element);
  });

  function start(event, element, activate) {

    // do not move connections or the root element
    if (element.waypoints || !element.parent) {
      return;
    }

    var referencePoint = mid(element);

    dragging.init(event, referencePoint, 'shape.move', {
      cursor: 'grabbing',
      autoActivate: activate,
      data: {
        shape: element,
        context: {}
      }
    });

    // we've handled the event
    return true;
  }

  // API

  this.start = start;
}

MoveEvents.$inject = ['eventBus', 'dragging', 'modeling', 'selection', 'rules'];

/**
 * 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) {

  var ids = (0, _minDash.groupBy)(elements, 'id');

  return (0, _minDash.filter)(elements, function (element) {
    while (element = element.parent) {

      // parent in selection
      if (ids[element.id]) {
        return false;
      }
    }

    return true;
  });
}

},{"../../util/Event":397,"min-dash":505}],333:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = MovePreview;

var _minDash = require('min-dash');

var _Elements = require('../../util/Elements');

var _tinySvg = require('tiny-svg');

var _SvgTransformUtil = require('../../util/SvgTransformUtil');

var LOW_PRIORITY = 499;

var MARKER_DRAGGING = 'djs-dragging',
    MARKER_OK = 'drop-ok',
    MARKER_NOT_OK = 'drop-not-ok',
    MARKER_NEW_PARENT = 'new-parent',
    MARKER_ATTACH = 'attach-ok';

/**
 * Provides previews for moving shapes when moving.
 *
 * @param {EventBus} eventBus
 * @param {ElementRegistry} elementRegistry
 * @param {Canvas} canvas
 * @param {Styles} styles
 */
function MovePreview(eventBus, elementRegistry, canvas, styles, previewSupport) {

  function getVisualDragShapes(shapes) {
    var elements = getAllDraggedElements(shapes);

    var filteredElements = removeEdges(elements);

    return filteredElements;
  }

  function getAllDraggedElements(shapes) {
    var allShapes = (0, _Elements.selfAndAllChildren)(shapes, true);

    var allConnections = (0, _minDash.map)(allShapes, function (shape) {
      return (shape.incoming || []).concat(shape.outgoing || []);
    });

    return (0, _minDash.flatten)(allShapes.concat(allConnections));
  }

  /**
   * Sets drop marker on an element.
   */
  function setMarker(element, marker) {

    [MARKER_ATTACH, MARKER_OK, MARKER_NOT_OK, MARKER_NEW_PARENT].forEach(function (m) {

      if (m === marker) {
        canvas.addMarker(element, m);
      } else {
        canvas.removeMarker(element, m);
      }
    });
  }

  /**
   * Make an element draggable.
   *
   * @param {Object} context
   * @param {djs.model.Base} element
   * @param {Boolean} addMarker
   */
  function makeDraggable(context, element, addMarker) {

    previewSupport.addDragger(element, context.dragGroup);

    if (addMarker) {
      canvas.addMarker(element, MARKER_DRAGGING);
    }

    if (context.allDraggedElements) {
      context.allDraggedElements.push(element);
    } else {
      context.allDraggedElements = [element];
    }
  }

  // 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, function (event) {

    var context = event.context,
        dragShapes = context.shapes,
        allDraggedElements = context.allDraggedElements;

    var visuallyDraggedShapes = getVisualDragShapes(dragShapes);

    if (!context.dragGroup) {
      var dragGroup = (0, _tinySvg.create)('g');
      (0, _tinySvg.attr)(dragGroup, styles.cls('djs-drag-group', ['no-events']));

      var defaultLayer = canvas.getDefaultLayer();

      (0, _tinySvg.append)(defaultLayer, dragGroup);

      context.dragGroup = dragGroup;
    }

    // add previews
    visuallyDraggedShapes.forEach(function (shape) {
      previewSupport.addDragger(shape, context.dragGroup);
    });

    // cache all dragged elements / gfx
    // so that we can quickly undo their state changes later
    if (!allDraggedElements) {
      allDraggedElements = getAllDraggedElements(dragShapes);
    } else {
      allDraggedElements = (0, _minDash.flatten)([allDraggedElements, getAllDraggedElements(dragShapes)]);
    }

    // add dragging marker
    (0, _minDash.forEach)(allDraggedElements, function (e) {
      canvas.addMarker(e, MARKER_DRAGGING);
    });

    context.allDraggedElements = allDraggedElements;

    // determine, if any of the dragged elements have different parents
    context.differentParents = haveDifferentParents(dragShapes);
  });

  // update previews
  eventBus.on('shape.move.move', LOW_PRIORITY, function (event) {

    var context = event.context,
        dragGroup = context.dragGroup,
        target = context.target,
        parent = context.shape.parent,
        canExecute = context.canExecute;

    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 : MARKER_NOT_OK);
      }
    }

    (0, _SvgTransformUtil.translate)(dragGroup, event.dx, event.dy);
  });

  eventBus.on(['shape.move.out', 'shape.move.cleanup'], function (event) {
    var context = event.context,
        target = context.target;

    if (target) {
      setMarker(target, null);
    }
  });

  // remove previews
  eventBus.on('shape.move.cleanup', function (event) {

    var context = event.context,
        allDraggedElements = context.allDraggedElements,
        dragGroup = context.dragGroup;

    // remove dragging marker
    (0, _minDash.forEach)(allDraggedElements, function (e) {
      canvas.removeMarker(e, MARKER_DRAGGING);
    });

    if (dragGroup) {
      (0, _tinySvg.clear)(dragGroup);
    }
  });

  // API //////////////////////

  /**
   * Make an element draggable.
   *
   * @param {Object} context
   * @param {djs.model.Base} element
   * @param {Boolean} addMarker
   */
  this.makeDraggable = makeDraggable;
}

MovePreview.$inject = ['eventBus', 'elementRegistry', 'canvas', 'styles', 'previewSupport'];

// helpers //////////////////////

/**
 * returns elements minus all connections
 * where source or target is not elements
 */
function removeEdges(elements) {

  var filteredElements = (0, _minDash.filter)(elements, function (element) {

    if (!isConnection(element)) {
      return true;
    } else {

      return (0, _minDash.find)(elements, (0, _minDash.matchPattern)({ id: element.source.id })) && (0, _minDash.find)(elements, (0, _minDash.matchPattern)({ id: element.target.id }));
    }
  });

  return filteredElements;
}

function haveDifferentParents(elements) {
  return (0, _minDash.size)((0, _minDash.groupBy)(elements, function (e) {
    return e.parent && e.parent.id;
  })) !== 1;
}

/**
 * Checks if an element is a connection.
 */
function isConnection(element) {
  return element.waypoints;
}

},{"../../util/Elements":396,"../../util/SvgTransformUtil":408,"min-dash":505,"tiny-svg":535}],334:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _interactionEvents = require('../interaction-events');

var _interactionEvents2 = _interopRequireDefault(_interactionEvents);

var _selection = require('../selection');

var _selection2 = _interopRequireDefault(_selection);

var _outline = require('../outline');

var _outline2 = _interopRequireDefault(_outline);

var _rules = require('../rules');

var _rules2 = _interopRequireDefault(_rules);

var _dragging = require('../dragging');

var _dragging2 = _interopRequireDefault(_dragging);

var _previewSupport = require('../preview-support');

var _previewSupport2 = _interopRequireDefault(_previewSupport);

var _Move = require('./Move');

var _Move2 = _interopRequireDefault(_Move);

var _MovePreview = require('./MovePreview');

var _MovePreview2 = _interopRequireDefault(_MovePreview);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __depends__: [_interactionEvents2.default, _selection2.default, _outline2.default, _rules2.default, _dragging2.default, _previewSupport2.default],
  __init__: ['move', 'movePreview'],
  move: ['type', _Move2.default],
  movePreview: ['type', _MovePreview2.default]
};

},{"../dragging":286,"../interaction-events":294,"../outline":337,"../preview-support":345,"../rules":355,"../selection":361,"./Move":332,"./MovePreview":333}],335:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = OrderingProvider;

var _inherits = require('inherits');

var _inherits2 = _interopRequireDefault(_inherits);

var _CommandInterceptor = require('../../command/CommandInterceptor');

var _CommandInterceptor2 = _interopRequireDefault(_CommandInterceptor);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * 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) {

  _CommandInterceptor2.default.call(this, eventBus);

  var self = this;

  this.preExecute(['shape.create', 'connection.create'], function (event) {

    var context = event.context,
        element = context.shape || context.connection,
        parent = context.parent;

    var ordering = self.getOrdering(element, parent);

    if (ordering) {

      if (ordering.parent !== undefined) {
        context.parent = ordering.parent;
      }

      context.parentIndex = ordering.index;
    }
  });

  this.preExecute(['shape.move', 'connection.move'], function (event) {

    var context = event.context,
        element = context.shape || context.connection,
        parent = context.newParent || element.parent;

    var ordering = self.getOrdering(element, parent);

    if (ordering) {

      if (ordering.parent !== undefined) {
        context.newParent = ordering.parent;
      }

      context.newParentIndex = ordering.index;
    }
  });
}

/**
 * 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;
};

(0, _inherits2.default)(OrderingProvider, _CommandInterceptor2.default);

},{"../../command/CommandInterceptor":243,"inherits":415}],336:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = Outline;

var _Elements = require('../../util/Elements');

var _tinySvg = require('tiny-svg');

var _minDom = require('min-dom');

var _minDash = require('min-dash');

var LOW_PRIORITY = 500;

/**
 * @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) {

  this.offset = 6;

  var OUTLINE_STYLE = styles.cls('djs-outline', ['no-fill']);

  var self = this;

  function createOutline(gfx, bounds) {
    var outline = (0, _tinySvg.create)('rect');

    (0, _tinySvg.attr)(outline, (0, _minDash.assign)({
      x: 10,
      y: 10,
      width: 100,
      height: 100
    }, OUTLINE_STYLE));

    (0, _tinySvg.append)(gfx, outline);

    return outline;
  }

  // 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, function (event) {
    var element = event.element,
        gfx = event.gfx;

    var outline = (0, _minDom.query)('.djs-outline', gfx);

    if (!outline) {
      outline = createOutline(gfx, element);
    }

    self.updateShapeOutline(outline, element);
  });

  eventBus.on(['connection.added', 'connection.changed'], function (event) {
    var element = event.element,
        gfx = event.gfx;

    var outline = (0, _minDom.query)('.djs-outline', gfx);

    if (!outline) {
      outline = createOutline(gfx, element);
    }

    self.updateConnectionOutline(outline, element);
  });
}

/**
 * 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) {

  (0, _tinySvg.attr)(outline, {
    x: -this.offset,
    y: -this.offset,
    width: element.width + this.offset * 2,
    height: element.height + this.offset * 2
  });
};

/**
 * 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) {

  var bbox = (0, _Elements.getBBox)(connection);

  (0, _tinySvg.attr)(outline, {
    x: bbox.x - this.offset,
    y: bbox.y - this.offset,
    width: bbox.width + this.offset * 2,
    height: bbox.height + this.offset * 2
  });
};

Outline.$inject = ['eventBus', 'styles', 'elementRegistry'];

},{"../../util/Elements":396,"min-dash":505,"min-dom":506,"tiny-svg":535}],337:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _Outline = require('./Outline');

var _Outline2 = _interopRequireDefault(_Outline);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __init__: ['outline'],
  outline: ['type', _Outline2.default]
};

},{"./Outline":336}],338:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = Overlays;

var _minDash = require('min-dash');

var _minDom = require('min-dom');

var _Elements = require('../../util/Elements');

var _IdGenerator = require('../../util/IdGenerator');

var _IdGenerator2 = _interopRequireDefault(_IdGenerator);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

// document wide unique overlay ids
var ids = new _IdGenerator2.default('ov');

var LOW_PRIORITY = 500;

/**
 * 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) {

  this._eventBus = eventBus;
  this._canvas = canvas;
  this._elementRegistry = elementRegistry;

  this._ids = ids;

  this._overlayDefaults = (0, _minDash.assign)({
    // no show constraints
    show: null,

    // always scale
    scale: true
  }, config && config.defaults);

  /**
   * Mapping overlayId -> overlay
   */
  this._overlays = {};

  /**
   * Mapping elementId -> overlay container
   */
  this._overlayContainers = [];

  // root html element for all overlays
  this._overlayRoot = createRoot(canvas.getContainer());

  this._init();
}

Overlays.$inject = ['config.overlays', 'eventBus', 'canvas', 'elementRegistry'];

/**
 * 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) {

  if ((0, _minDash.isString)(search)) {
    search = { id: search };
  }

  if ((0, _minDash.isString)(search.element)) {
    search.element = this._elementRegistry.get(search.element);
  }

  if (search.element) {
    var container = this._getOverlayContainer(search.element, true);

    // return a list of overlays when searching by element (+type)
    if (container) {
      return search.type ? (0, _minDash.filter)(container.overlays, (0, _minDash.matchPattern)({ type: search.type })) : container.overlays.slice();
    } else {
      return [];
    }
  } else if (search.type) {
    return (0, _minDash.filter)(this._overlays, (0, _minDash.matchPattern)({ type: search.type }));
  } else {
    // return single element when searching by id
    return search.id ? this._overlays[search.id] : null;
  }
};

/**
 * 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) {

  if ((0, _minDash.isObject)(type)) {
    overlay = type;
    type = null;
  }

  if (!element.id) {
    element = this._elementRegistry.get(element);
  }

  if (!overlay.position) {
    throw new Error('must specifiy overlay position');
  }

  if (!overlay.html) {
    throw new Error('must specifiy overlay html');
  }

  if (!element) {
    throw new Error('invalid element specified');
  }

  var id = this._ids.next();

  overlay = (0, _minDash.assign)({}, this._overlayDefaults, overlay, {
    id: id,
    type: type,
    element: element,
    html: overlay.html
  });

  this._addOverlay(overlay);

  return id;
};

/**
 * Remove an overlay with the given id or all overlays matching the given filter.
 *
 * @see Overlays#get for filter options.
 *
 * @param {String} [id]
 * @param {Object} [filter]
 */
Overlays.prototype.remove = function (filter) {

  var overlays = this.get(filter) || [];

  if (!(0, _minDash.isArray)(overlays)) {
    overlays = [overlays];
  }

  var self = this;

  (0, _minDash.forEach)(overlays, function (overlay) {

    var container = self._getOverlayContainer(overlay.element, true);

    if (overlay) {
      (0, _minDom.remove)(overlay.html);
      (0, _minDom.remove)(overlay.htmlContainer);

      delete overlay.htmlContainer;
      delete overlay.element;

      delete self._overlays[overlay.id];
    }

    if (container) {
      var idx = container.overlays.indexOf(overlay);
      if (idx !== -1) {
        container.overlays.splice(idx, 1);
      }
    }
  });
};

Overlays.prototype.show = function () {
  setVisible(this._overlayRoot);
};

Overlays.prototype.hide = function () {
  setVisible(this._overlayRoot, false);
};

Overlays.prototype.clear = function () {
  this._overlays = {};

  this._overlayContainers = [];

  (0, _minDom.clear)(this._overlayRoot);
};

Overlays.prototype._updateOverlayContainer = function (container) {
  var element = container.element,
      html = container.html;

  // update container left,top according to the elements x,y coordinates
  // this ensures we can attach child elements relative to this container

  var x = element.x,
      y = element.y;

  if (element.waypoints) {
    var bbox = (0, _Elements.getBBox)(element);
    x = bbox.x;
    y = bbox.y;
  }

  setPosition(html, x, y);

  (0, _minDom.attr)(container.html, 'data-container-id', element.id);
};

Overlays.prototype._updateOverlay = function (overlay) {

  var position = overlay.position,
      htmlContainer = overlay.htmlContainer,
      element = overlay.element;

  // update overlay html relative to shape because
  // it is already positioned on the element

  // update relative
  var left = position.left,
      top = position.top;

  if (position.right !== undefined) {

    var width;

    if (element.waypoints) {
      width = (0, _Elements.getBBox)(element).width;
    } else {
      width = element.width;
    }

    left = position.right * -1 + width;
  }

  if (position.bottom !== undefined) {

    var height;

    if (element.waypoints) {
      height = (0, _Elements.getBBox)(element).height;
    } else {
      height = element.height;
    }

    top = position.bottom * -1 + height;
  }

  setPosition(htmlContainer, left || 0, top || 0);
};

Overlays.prototype._createOverlayContainer = function (element) {
  var html = (0, _minDom.domify)('<div class="djs-overlays" style="position: absolute" />');

  this._overlayRoot.appendChild(html);

  var container = {
    html: html,
    element: element,
    overlays: []
  };

  this._updateOverlayContainer(container);

  this._overlayContainers.push(container);

  return container;
};

Overlays.prototype._updateRoot = function (viewbox) {
  var scale = viewbox.scale || 1;

  var matrix = 'matrix(' + [scale, 0, 0, scale, -1 * viewbox.x * scale, -1 * viewbox.y * scale].join(',') + ')';

  setTransform(this._overlayRoot, matrix);
};

Overlays.prototype._getOverlayContainer = function (element, raw) {
  var container = (0, _minDash.find)(this._overlayContainers, function (c) {
    return c.element === element;
  });

  if (!container && !raw) {
    return this._createOverlayContainer(element);
  }

  return container;
};

Overlays.prototype._addOverlay = function (overlay) {

  var id = overlay.id,
      element = overlay.element,
      html = overlay.html,
      htmlContainer,
      overlayContainer;

  // unwrap jquery (for those who need it)
  if (html.get && html.constructor.prototype.jquery) {
    html = html.get(0);
  }

  // create proper html elements from
  // overlay HTML strings
  if ((0, _minDash.isString)(html)) {
    html = (0, _minDom.domify)(html);
  }

  overlayContainer = this._getOverlayContainer(element);

  htmlContainer = (0, _minDom.domify)('<div class="djs-overlay" data-overlay-id="' + id + '" style="position: absolute">');

  htmlContainer.appendChild(html);

  if (overlay.type) {
    (0, _minDom.classes)(htmlContainer).add('djs-overlay-' + overlay.type);
  }

  overlay.htmlContainer = htmlContainer;

  overlayContainer.overlays.push(overlay);
  overlayContainer.html.appendChild(htmlContainer);

  this._overlays[id] = overlay;

  this._updateOverlay(overlay);
  this._updateOverlayVisibilty(overlay, this._canvas.viewbox());
};

Overlays.prototype._updateOverlayVisibilty = function (overlay, viewbox) {
  var show = overlay.show,
      minZoom = show && show.minZoom,
      maxZoom = show && show.maxZoom,
      htmlContainer = overlay.htmlContainer,
      visible = true;

  if (show) {
    if ((0, _minDash.isDefined)(minZoom) && minZoom > viewbox.scale || (0, _minDash.isDefined)(maxZoom) && maxZoom < viewbox.scale) {
      visible = false;
    }

    setVisible(htmlContainer, visible);
  }

  this._updateOverlayScale(overlay, viewbox);
};

Overlays.prototype._updateOverlayScale = function (overlay, viewbox) {
  var shouldScale = overlay.scale,
      minScale,
      maxScale,
      htmlContainer = overlay.htmlContainer;

  var scale,
      transform = '';

  if (shouldScale !== true) {

    if (shouldScale === false) {
      minScale = 1;
      maxScale = 1;
    } else {
      minScale = shouldScale.min;
      maxScale = shouldScale.max;
    }

    if ((0, _minDash.isDefined)(minScale) && viewbox.scale < minScale) {
      scale = (1 / viewbox.scale || 1) * minScale;
    }

    if ((0, _minDash.isDefined)(maxScale) && viewbox.scale > maxScale) {
      scale = (1 / viewbox.scale || 1) * maxScale;
    }
  }

  if ((0, _minDash.isDefined)(scale)) {
    transform = 'scale(' + scale + ',' + scale + ')';
  }

  setTransform(htmlContainer, transform);
};

Overlays.prototype._updateOverlaysVisibilty = function (viewbox) {

  var self = this;

  (0, _minDash.forEach)(this._overlays, function (overlay) {
    self._updateOverlayVisibilty(overlay, viewbox);
  });
};

Overlays.prototype._init = function () {

  var eventBus = this._eventBus;

  var self = this;

  // scroll/zoom integration

  function updateViewbox(viewbox) {
    self._updateRoot(viewbox);
    self._updateOverlaysVisibilty(viewbox);

    self.show();
  }

  eventBus.on('canvas.viewbox.changing', function (event) {
    self.hide();
  });

  eventBus.on('canvas.viewbox.changed', function (event) {
    updateViewbox(event.viewbox);
  });

  // remove integration

  eventBus.on(['shape.remove', 'connection.remove'], function (e) {
    var element = e.element;
    var overlays = self.get({ element: element });

    (0, _minDash.forEach)(overlays, function (o) {
      self.remove(o.id);
    });

    var container = self._getOverlayContainer(element);

    if (container) {
      (0, _minDom.remove)(container.html);
      var i = self._overlayContainers.indexOf(container);
      if (i !== -1) {
        self._overlayContainers.splice(i, 1);
      }
    }
  });

  // move integration

  eventBus.on('element.changed', LOW_PRIORITY, function (e) {
    var element = e.element;

    var container = self._getOverlayContainer(element, true);

    if (container) {
      (0, _minDash.forEach)(container.overlays, function (overlay) {
        self._updateOverlay(overlay);
      });

      self._updateOverlayContainer(container);
    }
  });

  // marker integration, simply add them on the overlays as classes, too.

  eventBus.on('element.marker.update', function (e) {
    var container = self._getOverlayContainer(e.element, true);
    if (container) {
      (0, _minDom.classes)(container.html)[e.add ? 'add' : 'remove'](e.marker);
    }
  });

  // clear overlays with diagram

  eventBus.on('diagram.clear', this.clear, this);
};

// helpers /////////////////////////////

function createRoot(parentNode) {
  var root = (0, _minDom.domify)('<div class="djs-overlay-container" style="position: absolute; width: 0; height: 0;" />');

  parentNode.insertBefore(root, parentNode.firstChild);

  return root;
}

function setPosition(el, x, y) {
  (0, _minDash.assign)(el.style, { left: x + 'px', top: y + 'px' });
}

function setVisible(el, visible) {
  el.style.display = visible === false ? 'none' : '';
}

function setTransform(el, transform) {

  el.style['transform-origin'] = 'top left';

  ['', '-ms-', '-webkit-'].forEach(function (prefix) {
    el.style[prefix + 'transform'] = transform;
  });
}

},{"../../util/Elements":396,"../../util/IdGenerator":400,"min-dash":505,"min-dom":506}],339:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _Overlays = require('./Overlays');

var _Overlays2 = _interopRequireDefault(_Overlays);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __init__: ['overlays'],
  overlays: ['type', _Overlays2.default]
};

},{"./Overlays":338}],340:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = Palette;

var _minDash = require('min-dash');

var _minDom = require('min-dom');

var TOGGLE_SELECTOR = '.djs-palette-toggle',
    ENTRY_SELECTOR = '.entry',
    ELEMENT_SELECTOR = TOGGLE_SELECTOR + ', ' + ENTRY_SELECTOR;

var PALETTE_OPEN_CLS = 'open',
    PALETTE_TWO_COLUMN_CLS = 'two-column';

/**
 * A palette containing modeling elements.
 */
function Palette(eventBus, canvas) {

  this._eventBus = eventBus;
  this._canvas = canvas;

  this._providers = [];

  var self = this;

  eventBus.on('tool-manager.update', function (event) {
    var tool = event.tool;

    self.updateToolHighlight(tool);
  });

  eventBus.on('i18n.changed', function () {
    self._update();
  });

  eventBus.on('diagram.init', function () {

    self._diagramInitialized = true;

    // initialize + update once diagram is ready
    if (self._providers.length) {
      self._init();

      self._update();
    }
  });
}

Palette.$inject = ['eventBus', 'canvas'];

/**
 * Register a provider with the palette
 *
 * @param  {PaletteProvider} provider
 */
Palette.prototype.registerProvider = function (provider) {
  this._providers.push(provider);

  // postpone init / update until diagram is initialized
  if (!this._diagramInitialized) {
    return;
  }

  if (!this._container) {
    this._init();
  }

  this._update();
};

/**
 * Returns the palette entries for a given element
 *
 * @return {Array<PaletteEntryDescriptor>} list of entries
 */
Palette.prototype.getEntries = function () {

  var entries = {};

  // loop through all providers and their entries.
  // group entries by id so that overriding an entry is possible
  (0, _minDash.forEach)(this._providers, function (provider) {
    var e = provider.getPaletteEntries();

    (0, _minDash.forEach)(e, function (entry, id) {
      entries[id] = entry;
    });
  });

  return entries;
};

/**
 * Initialize
 */
Palette.prototype._init = function () {
  var canvas = this._canvas,
      eventBus = this._eventBus;

  var parent = canvas.getContainer(),
      container = this._container = (0, _minDom.domify)(Palette.HTML_MARKUP),
      self = this;

  parent.appendChild(container);

  _minDom.delegate.bind(container, ELEMENT_SELECTOR, 'click', function (event) {

    var target = event.delegateTarget;

    if ((0, _minDom.matches)(target, TOGGLE_SELECTOR)) {
      return self.toggle();
    }

    self.trigger('click', event);
  });

  // prevent drag propagation
  _minDom.event.bind(container, 'mousedown', function (event) {
    event.stopPropagation();
  });

  // prevent drag propagation
  _minDom.delegate.bind(container, ENTRY_SELECTOR, 'dragstart', function (event) {
    self.trigger('dragstart', event);
  });

  eventBus.on('canvas.resized', this._layoutChanged, this);

  eventBus.fire('palette.create', {
    container: container
  });
};

/**
 * Update palette state.
 *
 * @param  {Object} [state] { open, twoColumn }
 */
Palette.prototype._toggleState = function (state) {

  state = state || {};

  var parent = this._getParentContainer(),
      container = this._container;

  var eventBus = this._eventBus;

  var twoColumn;

  var cls = (0, _minDom.classes)(container);

  if ('twoColumn' in state) {
    twoColumn = state.twoColumn;
  } else {
    twoColumn = this._needsCollapse(parent.clientHeight, this._entries || {});
  }

  // always update two column
  cls.toggle(PALETTE_TWO_COLUMN_CLS, twoColumn);

  if ('open' in state) {
    cls.toggle(PALETTE_OPEN_CLS, state.open);
  }

  eventBus.fire('palette.changed', {
    twoColumn: twoColumn,
    open: this.isOpen()
  });
};

Palette.prototype._update = function () {

  var entriesContainer = (0, _minDom.query)('.djs-palette-entries', this._container),
      entries = this._entries = this.getEntries();

  (0, _minDom.clear)(entriesContainer);

  (0, _minDash.forEach)(entries, function (entry, id) {

    var grouping = entry.group || 'default';

    var container = (0, _minDom.query)('[data-group=' + grouping + ']', entriesContainer);
    if (!container) {
      container = (0, _minDom.domify)('<div class="group" data-group="' + grouping + '"></div>');
      entriesContainer.appendChild(container);
    }

    var html = entry.html || (entry.separator ? '<hr class="separator" />' : '<div class="entry" draggable="true"></div>');

    var control = (0, _minDom.domify)(html);
    container.appendChild(control);

    if (!entry.separator) {
      (0, _minDom.attr)(control, 'data-action', id);

      if (entry.title) {
        (0, _minDom.attr)(control, 'title', entry.title);
      }

      if (entry.className) {
        addClasses(control, entry.className);
      }

      if (entry.imageUrl) {
        control.appendChild((0, _minDom.domify)('<img src="' + entry.imageUrl + '">'));
      }
    }
  });

  // open after update
  this.open();
};

/**
 * 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;

  if (!button) {
    return event.preventDefault();
  }

  entry = entries[(0, _minDom.attr)(button, 'data-action')];

  // when user clicks on the palette and not on an action
  if (!entry) {
    return;
  }

  handler = entry.action;

  originalEvent = event.originalEvent || event;

  // simple action (via callback function)
  if ((0, _minDash.isFunction)(handler)) {
    if (action === 'click') {
      handler(originalEvent, autoActivate);
    }
  } else {
    if (handler[action]) {
      handler[action](originalEvent, autoActivate);
    }
  }

  // silence other actions
  event.preventDefault();
};

Palette.prototype._layoutChanged = function () {
  this._toggleState({});
};

/**
 * Do we need to collapse to two columns?
 *
 * @param {Number} availableHeight
 * @param {Object} entries
 *
 * @return {Boolean}
 */
Palette.prototype._needsCollapse = function (availableHeight, entries) {

  // top margin + bottom toggle + bottom margin
  // implementors must override this method if they
  // change the palette styles
  var margin = 20 + 10 + 20;

  var entriesHeight = Object.keys(entries).length * 46;

  return availableHeight < entriesHeight + margin;
};

/**
 * Close the palette
 */
Palette.prototype.close = function () {

  this._toggleState({
    open: false,
    twoColumn: false
  });
};

/**
 * Open the palette
 */
Palette.prototype.open = function () {
  this._toggleState({ open: true });
};

Palette.prototype.toggle = function (open) {
  if (this.isOpen()) {
    this.close();
  } else {
    this.open();
  }
};

Palette.prototype.isActiveTool = function (tool) {
  return tool && this._activeTool === tool;
};

Palette.prototype.updateToolHighlight = function (name) {
  var entriesContainer, toolsContainer;

  if (!this._toolsContainer) {
    entriesContainer = (0, _minDom.query)('.djs-palette-entries', this._container);

    this._toolsContainer = (0, _minDom.query)('[data-group=tools]', entriesContainer);
  }

  toolsContainer = this._toolsContainer;

  (0, _minDash.forEach)(toolsContainer.children, function (tool) {
    var actionName = tool.getAttribute('data-action');

    if (!actionName) {
      return;
    }

    var toolClasses = (0, _minDom.classes)(tool);

    actionName = actionName.replace('-tool', '');

    if (toolClasses.contains('entry') && actionName === name) {
      toolClasses.add('highlighted-entry');
    } else {
      toolClasses.remove('highlighted-entry');
    }
  });
};

/**
 * 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 (0, _minDom.classes)(this._container).has(PALETTE_OPEN_CLS);
};

/**
 * Get container the palette lives in.
 *
 * @return {Element}
 */
Palette.prototype._getParentContainer = function () {
  return this._canvas.getContainer();
};

/* markup definition */

Palette.HTML_MARKUP = '<div class="djs-palette">' + '<div class="djs-palette-entries"></div>' + '<div class="djs-palette-toggle"></div>' + '</div>';

// helpers //////////////////////

function addClasses(element, classNames) {

  var classes = (0, _minDom.classes)(element);

  var actualClassNames = (0, _minDash.isArray)(classNames) ? classNames : classNames.split(/\s+/g);
  actualClassNames.forEach(function (cls) {
    classes.add(cls);
  });
}

},{"min-dash":505,"min-dom":506}],341:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _Palette = require('./Palette');

var _Palette2 = _interopRequireDefault(_Palette);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __init__: ['palette'],
  palette: ['type', _Palette2.default]
};

},{"./Palette":340}],342:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = PopupMenu;

var _minDash = require('min-dash');

var _minDom = require('min-dom');

var DATA_REF = 'data-id';

/**
 * 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) {

  var scale = (0, _minDash.isDefined)(config && config.scale) ? config.scale : {
    min: 1,
    max: 1.5
  };

  this._config = {
    scale: scale
  };

  this._eventBus = eventBus;
  this._canvas = canvas;
  this._providers = {};
  this._current = {};
}

PopupMenu.$inject = ['config.popupMenu', 'eventBus', 'canvas'];

/**
 * Registers a popup menu provider
 *
 * @param  {String} id
 * @param  {Object} provider
 *
 * @example
 *
 * popupMenu.registerProvider('myMenuID', {
 *   getEntries: function(element) {
 *     return [
 *       {
 *         id: 'entry-1',
 *         label: 'My Entry',
 *         action: 'alert("I have been clicked!")'
 *       }
 *     ];
 *   }
 * });
 */
PopupMenu.prototype.registerProvider = function (id, provider) {
  this._providers[id] = provider;
};

/**
 * 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');
  }

  if (!providerId) {
    throw new Error('providerId parameter is missing');
  }

  var provider = this._providers[providerId];

  var entries = provider.getEntries(element),
      headerEntries = provider.getHeaderEntries && provider.getHeaderEntries(element);

  var hasEntries = entries.length > 0,
      hasHeaderEntries = headerEntries && headerEntries.length > 0;

  return !hasEntries && !hasHeaderEntries;
};

/**
 * 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) {

  var provider = this._providers[id];

  if (!element) {
    throw new Error('Element is missing');
  }

  if (!provider) {
    throw new Error('Provider is not registered: ' + id);
  }

  if (!position) {
    throw new Error('the position argument is missing');
  }

  if (this.isOpen()) {
    this.close();
  }

  this._emit('open');

  var current = this._current = {
    provider: provider,
    className: id,
    element: element,
    position: position
  };

  if (provider.getHeaderEntries) {
    current.headerEntries = provider.getHeaderEntries(element);
  }

  current.entries = provider.getEntries(element);

  current.container = this._createContainer();

  var headerEntries = current.headerEntries || [],
      entries = current.entries || [];

  if (headerEntries.length) {
    current.container.appendChild(this._createEntries(current.headerEntries, 'djs-popup-header'));
  }

  if (entries.length) {
    current.container.appendChild(this._createEntries(current.entries, 'djs-popup-body'));
  }

  var canvas = this._canvas,
      parent = canvas.getContainer();

  this._attachContainer(current.container, parent, position.cursor);
};

/**
 * Removes the popup menu and unbinds the event handlers.
 */
PopupMenu.prototype.close = function () {

  if (!this.isOpen()) {
    return;
  }

  this._emit('close');

  this._unbindHandlers();
  (0, _minDom.remove)(this._current.container);
  this._current.container = null;
};

/**
 * Determine if an open popup menu exist.
 *
 * @return {Boolean} true if open
 */
PopupMenu.prototype.isOpen = function () {
  return !!this._current.container;
};

/**
 * Trigger an action associated with an entry.
 *
 * @param {Object} event
 *
 * @return the result of the action callback, if any
 */
PopupMenu.prototype.trigger = function (event) {

  // silence other actions
  event.preventDefault();

  var element = event.delegateTarget || event.target,
      entryId = (0, _minDom.attr)(element, DATA_REF);

  var entry = this._getEntry(entryId);

  if (entry.action) {
    return entry.action.call(null, event, entry);
  }
};

/**
 * Gets an entry instance (either entry or headerEntry) by id.
 *
 * @param  {String} entryId
 *
 * @return {Object} entry instance
 */
PopupMenu.prototype._getEntry = function (entryId) {

  var search = (0, _minDash.matchPattern)({ id: entryId });

  var entry = (0, _minDash.find)(this._current.entries, search) || (0, _minDash.find)(this._current.headerEntries, search);

  if (!entry) {
    throw new Error('entry not found');
  }

  return entry;
};

PopupMenu.prototype._emit = function (eventName) {
  this._eventBus.fire('popupMenu.' + eventName);
};

/**
 * Creates the popup menu container.
 *
 * @return {Object} a DOM container
 */
PopupMenu.prototype._createContainer = function () {
  var container = (0, _minDom.domify)('<div class="djs-popup">'),
      position = this._current.position,
      className = this._current.className;

  (0, _minDash.assign)(container.style, {
    position: 'absolute',
    left: position.x + 'px',
    top: position.y + 'px',
    visibility: 'hidden'
  });

  (0, _minDom.classes)(container).add(className);

  return container;
};

/**
 * Attaches the container to the DOM and binds the event handlers.
 *
 * @param {Object} container
 * @param {Object} parent
 */
PopupMenu.prototype._attachContainer = function (container, parent, cursor) {
  var self = this;

  // Event handler
  _minDom.delegate.bind(container, '.entry', 'click', function (event) {
    self.trigger(event);
  });

  this._updateScale(container);

  // Attach to DOM
  parent.appendChild(container);

  if (cursor) {
    this._assureIsInbounds(container, cursor);
  }

  // Add Handler
  this._bindHandlers();
};

/**
 * 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();

  var scaleConfig = this._config.scale,
      minScale,
      maxScale,
      scale = zoom;

  if (scaleConfig !== true) {

    if (scaleConfig === false) {
      minScale = 1;
      maxScale = 1;
    } else {
      minScale = scaleConfig.min;
      maxScale = scaleConfig.max;
    }

    if ((0, _minDash.isDefined)(minScale) && zoom < minScale) {
      scale = minScale;
    }

    if ((0, _minDash.isDefined)(maxScale) && zoom > maxScale) {
      scale = maxScale;
    }
  }

  setTransform(container, 'scale(' + scale + ')');
};

/**
 * 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();

  var containerX = container.offsetLeft,
      containerY = container.offsetTop,
      containerWidth = container.scrollWidth,
      containerHeight = container.scrollHeight,
      overAxis = {},
      left,
      top;

  var cursorPosition = {
    x: cursor.x - clientRect.left,
    y: cursor.y - clientRect.top
  };

  if (containerX + containerWidth > clientRect.width) {
    overAxis.x = true;
  }

  if (containerY + containerHeight > clientRect.height) {
    overAxis.y = true;
  }

  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';
  }

  (0, _minDash.assign)(container.style, { left: left, top: top }, { visibility: 'visible', 'z-index': 1000 });
};

/**
 * 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) {

  var entriesContainer = (0, _minDom.domify)('<div>'),
      self = this;

  (0, _minDom.classes)(entriesContainer).add(className);

  (0, _minDash.forEach)(entries, function (entry) {
    var entryContainer = self._createEntry(entry, entriesContainer);
    entriesContainer.appendChild(entryContainer);
  });

  return entriesContainer;
};

/**
 * Creates a single entry and returns it as a DOM container.
 *
 * @param  {Object} entry
 *
 * @return {Object} a DOM container
 */
PopupMenu.prototype._createEntry = function (entry) {

  if (!entry.id) {
    throw new Error('every entry must have the id property set');
  }

  var entryContainer = (0, _minDom.domify)('<div>'),
      entryClasses = (0, _minDom.classes)(entryContainer);

  entryClasses.add('entry');

  if (entry.className) {
    entry.className.split(' ').forEach(function (className) {
      entryClasses.add(className);
    });
  }

  (0, _minDom.attr)(entryContainer, DATA_REF, entry.id);

  if (entry.label) {
    var label = (0, _minDom.domify)('<span>');
    label.textContent = entry.label;
    entryContainer.appendChild(label);
  }

  if (entry.imageUrl) {
    entryContainer.appendChild((0, _minDom.domify)('<img src="' + entry.imageUrl + '" />'));
  }

  if (entry.active === true) {
    entryClasses.add('active');
  }

  if (entry.disabled === true) {
    entryClasses.add('disabled');
  }

  if (entry.title) {
    entryContainer.title = entry.title;
  }

  return entryContainer;
};

/**
 * Binds the `close` method to 'contextPad.close' & 'canvas.viewbox.changed'.
 */
PopupMenu.prototype._bindHandlers = function () {

  var eventBus = this._eventBus,
      self = this;

  function close() {
    self.close();
  }

  eventBus.once('contextPad.close', close);
  eventBus.once('canvas.viewbox.changing', close);
  eventBus.once('commandStack.changed', close);
};

/**
 * Unbinds the `close` method to 'contextPad.close' & 'canvas.viewbox.changing'.
 */
PopupMenu.prototype._unbindHandlers = function () {

  var eventBus = this._eventBus,
      self = this;

  function close() {
    self.close();
  }

  eventBus.off('contextPad.close', close);
  eventBus.off('canvas.viewbox.changed', close);
  eventBus.off('commandStack.changed', close);
};

// helpers /////////////////////////////

function setTransform(element, transform) {
  element.style['transform-origin'] = 'top left';

  ['', '-ms-', '-webkit-'].forEach(function (prefix) {
    element.style[prefix + 'transform'] = transform;
  });
}

},{"min-dash":505,"min-dom":506}],343:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _PopupMenu = require('./PopupMenu');

var _PopupMenu2 = _interopRequireDefault(_PopupMenu);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __init__: ['popupMenu'],
  popupMenu: ['type', _PopupMenu2.default]
};

},{"./PopupMenu":342}],344:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = PreviewSupport;

var _minDash = require('min-dash');

var _tinySvg = require('tiny-svg');

/**
 * Adds support for previews of moving/resizing elements.
 */
function PreviewSupport(elementRegistry, canvas, styles) {
  this._elementRegistry = elementRegistry;
  this._canvas = canvas;
  this._styles = styles;
}

PreviewSupport.$inject = ['elementRegistry', 'canvas', 'styles'];

/**
 * Returns graphics of an element.
 *
 * @param {djs.model.Base} element
 *
 * @return {SVGElement}
 */
PreviewSupport.prototype.getGfx = function (element) {
  return this._elementRegistry.getGraphics(element);
};

/**
 * Adds a move preview of a given shape to a given svg group.
 *
 * @param {djs.model.Base} element
 * @param {SVGElement} group
 *
 * @return {SVGElement} dragger
 */
PreviewSupport.prototype.addDragger = function (shape, group) {
  var gfx = this.getGfx(shape);

  // clone is not included in tsvg for some reason
  var dragger = (0, _tinySvg.clone)(gfx);
  var bbox = gfx.getBoundingClientRect();

  // remove markers from connections
  if (isConnection(shape)) {
    removeMarkers(dragger);
  }

  (0, _tinySvg.attr)(dragger, this._styles.cls('djs-dragger', [], {
    x: bbox.top,
    y: bbox.left
  }));

  (0, _tinySvg.append)(group, dragger);

  return dragger;
};

/**
 * 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) {

  var frame = (0, _tinySvg.create)('rect', {
    class: 'djs-resize-overlay',
    width: shape.width,
    height: shape.height,
    x: shape.x,
    y: shape.y
  });

  (0, _tinySvg.append)(group, frame);

  return frame;
};

// helpers //////////////////////

/**
 * Removes all svg marker references from an SVG.
 *
 * @param {SVGElement} gfx
 */
function removeMarkers(gfx) {

  if (gfx.children) {

    (0, _minDash.forEach)(gfx.children, function (child) {

      // recursion
      removeMarkers(child);
    });
  }

  gfx.style.markerStart = '';
  gfx.style.markerEnd = '';
}

/**
 * Checks if an element is a connection.
 */
function isConnection(element) {
  return element.waypoints;
}

},{"min-dash":505,"tiny-svg":535}],345:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _PreviewSupport = require('./PreviewSupport');

var _PreviewSupport2 = _interopRequireDefault(_PreviewSupport);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __init__: ['previewSupport'],
  previewSupport: ['type', _PreviewSupport2.default]
};

},{"./PreviewSupport":344}],346:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = Replace;
var round = Math.round;

/**
 * Service that allow replacing of elements.
 */
function Replace(modeling) {

  this._modeling = modeling;
}

Replace.$inject = ['modeling'];

/**
 * @param {Element} oldElement - Element to be replaced
 * @param {Object}  newElementData - Containing information about the new Element, for example height, width, 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) {

  var modeling = this._modeling;

  var newElement = null;

  if (oldElement.waypoints) {
    // TODO
    // modeling.replaceConnection
  } else {
    // set center of element for modeling API
    // if no new width / height is given use old elements size
    newElementData.x = round(oldElement.x + (newElementData.width || oldElement.width) / 2);
    newElementData.y = round(oldElement.y + (newElementData.height || oldElement.height) / 2);

    newElement = modeling.replaceShape(oldElement, newElementData, options);
  }

  return newElement;
};

},{}],347:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _Replace = require('./Replace');

var _Replace2 = _interopRequireDefault(_Replace);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __init__: ['replace'],
  replace: ['type', _Replace2.default]
};

},{"./Replace":346}],348:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = Resize;

var _minDash = require('min-dash');

var _ResizeUtil = require('./ResizeUtil');

var _LayoutUtil = require('../../layout/LayoutUtil');

var DEFAULT_MIN_WIDTH = 10;

/**
 * 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) {

  this._dragging = dragging;
  this._rules = rules;

  var self = this;

  /**
   * Handle resize move by specified delta.
   *
   * @param {Object} context
   * @param {Point delta
   */
  function handleMove(context, delta) {

    var shape = context.shape,
        direction = context.direction,
        resizeConstraints = context.resizeConstraints,
        newBounds;

    context.delta = delta;

    newBounds = (0, _ResizeUtil.resizeBounds)(shape, direction, delta);

    // ensure constraints during resize
    context.newBounds = (0, _ResizeUtil.ensureConstraints)(newBounds, resizeConstraints);

    // update + cache executable state
    context.canExecute = self.canResize(context);
  }

  /**
   * Handle resize start.
   *
   * @param  {Object} context
   */
  function handleStart(context) {

    var resizeConstraints = context.resizeConstraints,

    // evaluate minBounds for backwards compatibility
    minBounds = context.minBounds;

    if (resizeConstraints !== undefined) {
      return;
    }

    if (minBounds === undefined) {
      minBounds = self.computeMinResizeBox(context);
    }

    context.resizeConstraints = {
      min: (0, _LayoutUtil.asTRBL)(minBounds)
    };
  }

  /**
   * Handle resize end.
   *
   * @param  {Object} context
   */
  function handleEnd(context) {
    var shape = context.shape,
        canExecute = context.canExecute,
        newBounds = context.newBounds;

    if (canExecute) {
      // ensure we have actual pixel values for new bounds
      // (important when zoom level was > 1 during move)
      newBounds = (0, _LayoutUtil.roundBounds)(newBounds);

      // perform the actual resize
      modeling.resizeShape(shape, newBounds);
    }
  }

  eventBus.on('resize.start', function (event) {
    handleStart(event.context);
  });

  eventBus.on('resize.move', function (event) {
    var delta = {
      x: event.dx,
      y: event.dy
    };

    handleMove(event.context, delta);
  });

  eventBus.on('resize.end', function (event) {
    handleEnd(event.context);
  });
}

Resize.prototype.canResize = function (context) {
  var rules = this._rules;

  var ctx = (0, _minDash.pick)(context, ['newBounds', 'shape', 'delta', 'direction']);

  return rules.allowed('shape.resize', ctx);
};

/**
 * 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;

  if (typeof contextOrDirection === 'string') {
    contextOrDirection = {
      direction: contextOrDirection
    };
  }

  context = (0, _minDash.assign)({ shape: shape }, contextOrDirection);

  direction = context.direction;

  if (!direction) {
    throw new Error('must provide a direction (nw|se|ne|sw)');
  }

  dragging.init(event, 'resize', {
    autoActivate: true,
    cursor: 'resize-' + (/nw|se/.test(direction) ? 'nwse' : 'nesw'),
    data: {
      shape: shape,
      context: context
    }
  });
};

Resize.prototype.computeMinResizeBox = function (context) {
  var shape = context.shape,
      direction = context.direction,
      minDimensions,
      childrenBounds;

  minDimensions = context.minDimensions || {
    width: DEFAULT_MIN_WIDTH,
    height: DEFAULT_MIN_WIDTH
  };

  // get children bounds
  childrenBounds = (0, _ResizeUtil.computeChildrenBBox)(shape, context.childrenBoxPadding);

  // get correct minimum bounds from given resize direction
  // basically ensures that the minBounds is max(childrenBounds, minDimensions)
  return (0, _ResizeUtil.getMinResizeBounds)(direction, shape, minDimensions, childrenBounds);
};

Resize.$inject = ['eventBus', 'rules', 'modeling', 'dragging'];

},{"../../layout/LayoutUtil":380,"./ResizeUtil":351,"min-dash":505}],349:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = ResizeHandles;

var _minDash = require('min-dash');

var _tinySvg = require('tiny-svg');

var _minDom = require('min-dom');

var _Mouse = require('../../util/Mouse');

var _LayoutUtil = require('../../layout/LayoutUtil');

var _SvgTransformUtil = require('../../util/SvgTransformUtil');

var HANDLE_OFFSET = -2,
    HANDLE_SIZE = 5,
    HANDLE_HIT_SIZE = 20;

var CLS_RESIZER = 'djs-resizer';

/**
 * 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) {

  this._resize = resize;
  this._canvas = canvas;

  var self = this;

  eventBus.on('selection.changed', function (e) {
    var newSelection = e.newSelection;

    // remove old selection markers
    self.removeResizers();

    // add new selection markers ONLY if single selection
    if (newSelection.length === 1) {
      (0, _minDash.forEach)(newSelection, (0, _minDash.bind)(self.addResizer, self));
    }
  });

  eventBus.on('shape.changed', function (e) {
    var shape = e.element;

    if (selection.isSelected(shape)) {
      self.removeResizers();

      self.addResizer(shape);
    }
  });
}

ResizeHandles.prototype.makeDraggable = function (element, gfx, direction) {
  var resize = this._resize;

  function startResize(event) {
    // only trigger on left mouse button
    if ((0, _Mouse.isPrimaryButton)(event)) {
      resize.activate(event, element, direction);
    }
  }

  _minDom.event.bind(gfx, 'mousedown', startResize);
  _minDom.event.bind(gfx, 'touchstart', startResize);
};

ResizeHandles.prototype._createResizer = function (element, x, y, rotation, direction) {
  var resizersParent = this._getResizersParent();

  var group = (0, _tinySvg.create)('g');
  (0, _tinySvg.classes)(group).add(CLS_RESIZER);
  (0, _tinySvg.classes)(group).add(CLS_RESIZER + '-' + element.id);
  (0, _tinySvg.classes)(group).add(CLS_RESIZER + '-' + direction);

  (0, _tinySvg.append)(resizersParent, group);

  var origin = -HANDLE_SIZE + HANDLE_OFFSET;

  // Create four drag indicators on the outline
  var visual = (0, _tinySvg.create)('rect');
  (0, _tinySvg.attr)(visual, {
    x: origin,
    y: origin,
    width: HANDLE_SIZE,
    height: HANDLE_SIZE
  });
  (0, _tinySvg.classes)(visual).add(CLS_RESIZER + '-visual');

  (0, _tinySvg.append)(group, visual);

  var hit = (0, _tinySvg.create)('rect');
  (0, _tinySvg.attr)(hit, {
    x: origin,
    y: origin,
    width: HANDLE_HIT_SIZE,
    height: HANDLE_HIT_SIZE
  });
  (0, _tinySvg.classes)(hit).add(CLS_RESIZER + '-hit');

  (0, _tinySvg.append)(group, hit);

  (0, _SvgTransformUtil.transform)(group, x, y, rotation);

  return group;
};

ResizeHandles.prototype.createResizer = function (element, direction) {
  var resizer;

  var trbl = (0, _LayoutUtil.asTRBL)(element);

  if (direction === 'nw') {
    resizer = this._createResizer(element, trbl.left, trbl.top, 0, direction);
  } else if (direction === 'ne') {
    resizer = this._createResizer(element, trbl.right, trbl.top, 90, direction);
  } else if (direction === 'se') {
    resizer = this._createResizer(element, trbl.right, trbl.bottom, 180, direction);
  } else {
    resizer = this._createResizer(element, trbl.left, trbl.bottom, 270, direction);
  }

  this.makeDraggable(element, resizer, direction);
};

// resize handles implementation ///////////////////////////////

/**
 * Add resizers for a given element.
 *
 * @param {djs.model.Shape} shape
 */
ResizeHandles.prototype.addResizer = function (shape) {
  var resize = this._resize;

  if (!resize.canResize({ shape: shape })) {
    return;
  }

  this.createResizer(shape, 'nw');
  this.createResizer(shape, 'ne');
  this.createResizer(shape, 'se');
  this.createResizer(shape, 'sw');
};

/**
 * Remove all resizers
 */
ResizeHandles.prototype.removeResizers = function () {
  var resizersParent = this._getResizersParent();

  (0, _tinySvg.clear)(resizersParent);
};

ResizeHandles.prototype._getResizersParent = function () {
  return this._canvas.getLayer('resizers');
};

ResizeHandles.$inject = ['eventBus', 'canvas', 'selection', 'resize'];

},{"../../layout/LayoutUtil":380,"../../util/Mouse":403,"../../util/SvgTransformUtil":408,"min-dash":505,"min-dom":506,"tiny-svg":535}],350:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = ResizePreview;

var _tinySvg = require('tiny-svg');

var MARKER_RESIZING = 'djs-resizing',
    MARKER_RESIZE_NOT_OK = 'resize-not-ok';

var LOW_PRIORITY = 500;

/**
 * Provides previews for resizing shapes when resizing.
 *
 * @param {EventBus} eventBus
 * @param {Canvas} canvas
 * @param {PreviewSupport} previewSupport
 */
function ResizePreview(eventBus, canvas, previewSupport) {

  /**
   * Update resizer frame.
   *
   * @param {Object} context
   */
  function updateFrame(context) {

    var shape = context.shape,
        bounds = context.newBounds,
        frame = context.frame;

    if (!frame) {
      frame = context.frame = previewSupport.addFrame(shape, canvas.getDefaultLayer());

      canvas.addMarker(shape, MARKER_RESIZING);
    }

    if (bounds.width > 5) {
      (0, _tinySvg.attr)(frame, { x: bounds.x, width: bounds.width });
    }

    if (bounds.height > 5) {
      (0, _tinySvg.attr)(frame, { y: bounds.y, height: bounds.height });
    }

    if (context.canExecute) {
      (0, _tinySvg.classes)(frame).remove(MARKER_RESIZE_NOT_OK);
    } else {
      (0, _tinySvg.classes)(frame).add(MARKER_RESIZE_NOT_OK);
    }
  }

  /**
   * Remove resizer frame.
   *
   * @param {Object} context
   */
  function removeFrame(context) {
    var shape = context.shape,
        frame = context.frame;

    if (frame) {
      (0, _tinySvg.remove)(context.frame);
    }

    canvas.removeMarker(shape, MARKER_RESIZING);
  }

  // add and update previews
  eventBus.on('resize.move', LOW_PRIORITY, function (event) {
    updateFrame(event.context);
  });

  // remove previews
  eventBus.on('resize.cleanup', function (event) {
    removeFrame(event.context);
  });
}

ResizePreview.$inject = ['eventBus', 'canvas', 'previewSupport'];

},{"tiny-svg":535}],351:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

exports.substractTRBL = substractTRBL;
exports.resizeBounds = resizeBounds;
exports.resizeTRBL = resizeTRBL;
exports.reattachPoint = reattachPoint;
exports.ensureConstraints = ensureConstraints;
exports.getMinResizeBounds = getMinResizeBounds;
exports.addPadding = addPadding;
exports.computeChildrenBBox = computeChildrenBBox;

var _minDash = require('min-dash');

var _Elements = require('../../util/Elements');

var _LayoutUtil = require('../../layout/LayoutUtil');

var max = Math.max,
    min = Math.min;

var DEFAULT_CHILD_BOX_PADDING = 20;

/**
 * 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
  };
}

/**
 * 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(bounds, direction, delta) {

  var dx = delta.x,
      dy = delta.y;

  switch (direction) {

    case 'nw':
      return {
        x: bounds.x + dx,
        y: bounds.y + dy,
        width: bounds.width - dx,
        height: bounds.height - dy
      };

    case 'sw':
      return {
        x: bounds.x + dx,
        y: bounds.y,
        width: bounds.width - dx,
        height: bounds.height + dy
      };

    case 'ne':
      return {
        x: bounds.x,
        y: bounds.y + dy,
        width: bounds.width + dx,
        height: bounds.height - dy
      };

    case 'se':
      return {
        x: bounds.x,
        y: bounds.y,
        width: bounds.width + dx,
        height: bounds.height + dy
      };

    default:
      throw new Error('unrecognized direction: ' + direction);
  }
}

/**
 * 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)
  };
}

function reattachPoint(bounds, newBounds, point) {

  var sx = bounds.width / newBounds.width,
      sy = bounds.height / newBounds.height;

  return {
    x: Math.round(newBounds.x + newBounds.width / 2) - Math.floor((bounds.x + bounds.width / 2 - point.x) / sx),
    y: Math.round(newBounds.y + newBounds.height / 2) - Math.floor((bounds.y + bounds.height / 2 - point.y) / sy)
  };
}

function applyConstraints(attr, trbl, resizeConstraints) {

  var value = trbl[attr],
      minValue = resizeConstraints.min && resizeConstraints.min[attr],
      maxValue = resizeConstraints.max && resizeConstraints.max[attr];

  if ((0, _minDash.isNumber)(minValue)) {
    value = (/top|left/.test(attr) ? min : max)(value, minValue);
  }

  if ((0, _minDash.isNumber)(maxValue)) {
    value = (/top|left/.test(attr) ? max : min)(value, maxValue);
  }

  return value;
}

function ensureConstraints(currentBounds, resizeConstraints) {

  if (!resizeConstraints) {
    return currentBounds;
  }

  var currentTrbl = (0, _LayoutUtil.asTRBL)(currentBounds);

  return (0, _LayoutUtil.asBounds)({
    top: applyConstraints('top', currentTrbl, resizeConstraints),
    right: applyConstraints('right', currentTrbl, resizeConstraints),
    bottom: applyConstraints('bottom', currentTrbl, resizeConstraints),
    left: applyConstraints('left', currentTrbl, resizeConstraints)
  });
}

function getMinResizeBounds(direction, currentBounds, minDimensions, childrenBounds) {

  var currentBox = (0, _LayoutUtil.asTRBL)(currentBounds);

  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
  };

  var childrenBox = childrenBounds ? (0, _LayoutUtil.asTRBL)(childrenBounds) : minBox;

  var combinedBox = {
    top: min(minBox.top, childrenBox.top),
    left: min(minBox.left, childrenBox.left),
    bottom: max(minBox.bottom, childrenBox.bottom),
    right: max(minBox.right, childrenBox.right)
  };

  return (0, _LayoutUtil.asBounds)(combinedBox);
}

function asPadding(mayBePadding, defaultValue) {
  if (typeof mayBePadding !== 'undefined') {
    return mayBePadding;
  } else {
    return DEFAULT_CHILD_BOX_PADDING;
  }
}

function addPadding(bbox, padding) {
  var left, right, top, bottom;

  if ((typeof padding === 'undefined' ? 'undefined' : _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);
  }

  return {
    x: bbox.x - left,
    y: bbox.y - top,
    width: bbox.width + left + right,
    height: bbox.height + top + bottom
  };
}

/**
 * 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) {

  // exclude connections
  if (element.waypoints) {
    return false;
  }

  // exclude labels
  if (element.type === 'label') {
    return false;
  }

  return true;
}

/**
 * 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) {

  var elements;

  // compute based on shape
  if (shapeOrChildren.length === undefined) {
    // grab all the children that are part of the
    // parents children box
    elements = (0, _minDash.filter)(shapeOrChildren.children, isBBoxChild);
  } else {
    elements = shapeOrChildren;
  }

  if (elements.length) {
    return addPadding((0, _Elements.getBBox)(elements), padding);
  }
}

},{"../../layout/LayoutUtil":380,"../../util/Elements":396,"min-dash":505}],352:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _rules = require('../rules');

var _rules2 = _interopRequireDefault(_rules);

var _dragging = require('../dragging');

var _dragging2 = _interopRequireDefault(_dragging);

var _previewSupport = require('../preview-support');

var _previewSupport2 = _interopRequireDefault(_previewSupport);

var _Resize = require('./Resize');

var _Resize2 = _interopRequireDefault(_Resize);

var _ResizePreview = require('./ResizePreview');

var _ResizePreview2 = _interopRequireDefault(_ResizePreview);

var _ResizeHandles = require('./ResizeHandles');

var _ResizeHandles2 = _interopRequireDefault(_ResizeHandles);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __depends__: [_rules2.default, _dragging2.default, _previewSupport2.default],
  __init__: ['resize', 'resizePreview', 'resizeHandles'],
  resize: ['type', _Resize2.default],
  resizePreview: ['type', _ResizePreview2.default],
  resizeHandles: ['type', _ResizeHandles2.default]
};

},{"../dragging":286,"../preview-support":345,"../rules":355,"./Resize":348,"./ResizeHandles":349,"./ResizePreview":350}],353:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = RuleProvider;

var _inherits = require('inherits');

var _inherits2 = _interopRequireDefault(_inherits);

var _CommandInterceptor = require('../../command/CommandInterceptor');

var _CommandInterceptor2 = _interopRequireDefault(_CommandInterceptor);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * 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) {
  _CommandInterceptor2.default.call(this, eventBus);

  this.init();
}

RuleProvider.$inject = ['eventBus'];

(0, _inherits2.default)(RuleProvider, _CommandInterceptor2.default);

/**
 * 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) {

  var self = this;

  if (typeof actions === 'string') {
    actions = [actions];
  }

  actions.forEach(function (action) {

    self.canExecute(action, priority, function (context, action, event) {
      return fn(context);
    }, true);
  });
};

/**
 * Implement this method to add new rules during provider initialization.
 */
RuleProvider.prototype.init = function () {};

},{"../../command/CommandInterceptor":243,"inherits":415}],354:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = Rules;
/**
 * 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);
}

Rules.$inject = ['injector'];

/**
 * 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;

  var commandStack = this._commandStack;

  if (commandStack) {
    allowed = commandStack.canExecute(action, context);
  }

  // map undefined to true, i.e. no rules
  return allowed === undefined ? true : allowed;
};

},{}],355:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _Rules = require('./Rules');

var _Rules2 = _interopRequireDefault(_Rules);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __init__: ['rules'],
  rules: ['type', _Rules2.default]
};

},{"./Rules":354}],356:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = SearchPad;

var _minDom = require('min-dom');

var _Elements = require('../../util/Elements');

/**
 * Provides searching infrastructure
 */
function SearchPad(canvas, eventBus, overlays, selection) {
  this._open = false;
  this._results = [];
  this._eventMaps = [];

  this._canvas = canvas;
  this._eventBus = eventBus;
  this._overlays = overlays;
  this._selection = selection;

  // setup elements
  this._container = (0, _minDom.domify)(SearchPad.BOX_HTML);
  this._searchInput = (0, _minDom.query)(SearchPad.INPUT_SELECTOR, this._container);
  this._resultsContainer = (0, _minDom.query)(SearchPad.RESULTS_CONTAINER_SELECTOR, this._container);

  // attach search pad
  this._canvas.getContainer().appendChild(this._container);

  // cleanup on destroy
  eventBus.on(['canvas.destroy', 'diagram.destroy'], this.close, this);
}

SearchPad.$inject = ['canvas', 'eventBus', 'overlays', 'selection'];

/**
 * Binds and keeps track of all event listereners
 */
SearchPad.prototype._bindEvents = function () {
  var self = this;

  function listen(el, selector, type, fn) {
    self._eventMaps.push({
      el: el,
      type: type,
      listener: _minDom.delegate.bind(el, selector, type, fn)
    });
  }

  // close search on clicking anywhere outside
  listen(document, 'html', 'click', function (e) {
    self.close();
  }, true);

  // stop event from propagating and closing search
  // focus on input
  listen(this._container, SearchPad.INPUT_SELECTOR, 'click', function (e) {
    e.stopPropagation();
    e.delegateTarget.focus();
  });

  // preselect result on hover
  listen(this._container, SearchPad.RESULT_SELECTOR, 'mouseover', function (e) {
    e.stopPropagation();
    self._scrollToNode(e.delegateTarget);
    self._preselect(e.delegateTarget);
  });

  // selects desired result on mouse click
  listen(this._container, SearchPad.RESULT_SELECTOR, 'click', function (e) {
    e.stopPropagation();
    self._select(e.delegateTarget);
  });

  // 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) {
    // up
    if (e.keyCode === 38) {
      e.preventDefault();
    }

    // down
    if (e.keyCode === 40) {
      e.preventDefault();
    }
  });

  // handle keyboard input
  listen(this._container, SearchPad.INPUT_SELECTOR, 'keyup', function (e) {
    // escape
    if (e.keyCode === 27) {
      return self.close();
    }

    // enter
    if (e.keyCode === 13) {
      var selected = self._getCurrentResult();

      return selected ? self._select(selected) : self.close();
    }

    // up
    if (e.keyCode === 38) {
      return self._scrollToDirection(true);
    }

    // down
    if (e.keyCode === 40) {
      return self._scrollToDirection();
    }

    // left && right
    // do not search while navigating text input
    if (e.keyCode === 37 || e.keyCode === 39) {
      return;
    }

    // anything else
    self._search(e.delegateTarget.value);
  });
};

/**
 * Unbinds all previously established listeners
 */
SearchPad.prototype._unbindEvents = function () {
  this._eventMaps.forEach(function (m) {
    _minDom.delegate.unbind(m.el, m.type, m.listener);
  });
};

/**
 * Performs a search for the given pattern.
 *
 * @param  {String} pattern
 */
SearchPad.prototype._search = function (pattern) {
  var self = this;

  this._clearResults();

  // do not search on empty query
  if (!pattern || pattern === '') {
    return;
  }

  var searchResults = this._searchProvider.find(pattern);

  if (!searchResults.length) {
    return;
  }

  // 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
    };
  });

  // preselect first result
  var node = (0, _minDom.query)(SearchPad.RESULT_SELECTOR, this._resultsContainer);
  this._scrollToNode(node);
  this._preselect(node);
};

/**
 * 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;
  }

  var node = previous ? selected.previousElementSibling : selected.nextElementSibling;
  if (node) {
    this._scrollToNode(node);
    this._preselect(node);
  }
};

/**
 * Scroll to the node if it is not visible.
 *
 * @param  {Element} node
 */
SearchPad.prototype._scrollToNode = function (node) {
  if (!node || node === this._getCurrentResult()) {
    return;
  }

  var nodeOffset = node.offsetTop;
  var containerScroll = this._resultsContainer.scrollTop;

  var bottomScroll = nodeOffset - this._resultsContainer.clientHeight + node.clientHeight;

  if (nodeOffset < containerScroll) {
    this._resultsContainer.scrollTop = nodeOffset;
  } else if (containerScroll < bottomScroll) {
    this._resultsContainer.scrollTop = bottomScroll;
  }
};

/**
 * Clears all results data.
 */
SearchPad.prototype._clearResults = function () {
  (0, _minDom.clear)(this._resultsContainer);

  this._results = [];

  this._resetOverlay();

  this._eventBus.fire('searchPad.cleared');
};

/**
 * Get currently selected result.
 *
 * @return {Element}
 */
SearchPad.prototype._getCurrentResult = function () {
  return (0, _minDom.query)(SearchPad.RESULT_SELECTED_SELECTOR, this._resultsContainer);
};

/**
 * 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 = (0, _minDom.domify)(SearchPad.RESULT_HTML);

  // create only if available
  if (result.primaryTokens.length > 0) {
    createInnerTextNode(node, result.primaryTokens, SearchPad.RESULT_PRIMARY_HTML);
  }

  // secondary tokens (represent element ID) are allways available
  createInnerTextNode(node, result.secondaryTokens, SearchPad.RESULT_SECONDARY_HTML);

  (0, _minDom.attr)(node, SearchPad.RESULT_ID_ATTRIBUTE, id);

  this._resultsContainer.appendChild(node);

  return node;
};

/**
 * 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;
};

/**
 * Open search pad.
 */
SearchPad.prototype.open = function () {
  if (!this._searchProvider) {
    throw new Error('no search provider registered');
  }

  if (this.isOpen()) {
    return;
  }

  this._bindEvents();

  this._open = true;

  (0, _minDom.classes)(this._container).add('open');

  this._searchInput.focus();

  this._eventBus.fire('searchPad.opened');
};

/**
 * Close search pad.
 */
SearchPad.prototype.close = function () {
  if (!this.isOpen()) {
    return;
  }

  this._unbindEvents();

  this._open = false;

  (0, _minDom.classes)(this._container).remove('open');

  this._clearResults();

  this._searchInput.value = '';
  this._searchInput.blur();

  this._resetOverlay();

  this._eventBus.fire('searchPad.closed');
};

/**
 * Toggles search pad on/off.
 */
SearchPad.prototype.toggle = function () {
  this.isOpen() ? this.close() : this.open();
};

/**
 * Report state of search pad.
 */
SearchPad.prototype.isOpen = function () {
  return this._open;
};

/**
 * Preselect result entry.
 *
 * @param  {Element} element
 */
SearchPad.prototype._preselect = function (node) {
  var selectedNode = this._getCurrentResult();

  // already selected
  if (node === selectedNode) {
    return;
  }

  // removing preselection from current node
  if (selectedNode) {
    (0, _minDom.classes)(selectedNode).remove(SearchPad.RESULT_SELECTED_CLASS);
  }

  var id = (0, _minDom.attr)(node, SearchPad.RESULT_ID_ATTRIBUTE);
  var element = this._results[id].element;

  (0, _minDom.classes)(node).add(SearchPad.RESULT_SELECTED_CLASS);

  this._resetOverlay(element);

  this._centerViewbox(element);

  this._selection.select(element);

  this._eventBus.fire('searchPad.preselected', element);
};

/**
 * Select result node.
 *
 * @param  {Element} element
 */
SearchPad.prototype._select = function (node) {
  var id = (0, _minDom.attr)(node, SearchPad.RESULT_ID_ATTRIBUTE);
  var element = this._results[id].element;

  this.close();

  this._resetOverlay();

  this._centerViewbox(element);

  this._selection.select(element);

  this._eventBus.fire('searchPad.selected', element);
};

/**
 * Center viewbox on the element middle point.
 *
 * @param  {Element} element
 */
SearchPad.prototype._centerViewbox = function (element) {
  var viewbox = this._canvas.viewbox();

  var box = (0, _Elements.getBBox)(element);

  var newViewbox = {
    x: box.x + box.width / 2 - viewbox.outer.width / 2,
    y: box.y + box.height / 2 - viewbox.outer.height / 2,
    width: viewbox.outer.width,
    height: viewbox.outer.height
  };

  this._canvas.viewbox(newViewbox);

  this._canvas.zoom(viewbox.scale);
};

/**
 * 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);
  }

  if (element) {
    var box = (0, _Elements.getBBox)(element);
    var overlay = constructOverlay(box);
    this._overlayId = this._overlays.add(element, overlay);
  }
};

/**
 * Construct overlay object for the given bounding box.
 *
 * @param  {BoundingBox} box
 * @return {Object}
 */
function constructOverlay(box) {

  var offset = 6;
  var w = box.width + offset * 2;
  var h = box.height + offset * 2;

  var styles = ['width: ' + w + 'px', 'height: ' + h + 'px'].join('; ');

  return {
    position: {
      bottom: h - offset,
      right: w - offset
    },
    show: true,
    html: '<div style="' + styles + '" class="' + SearchPad.OVERLAY_CLASS + '"></div>'
  };
}

/**
 * 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 = (0, _minDom.domify)(template);
  childNode.innerHTML = text;
  parentNode.appendChild(childNode);
}

/**
 * Create internal HTML markup from result tokens.
 * Caters for highlighting pattern matched tokens.
 *
 * @param  {Array<Object>} tokens
 * @return {String}
 */
function createHtmlText(tokens) {
  var htmlText = '';

  tokens.forEach(function (t) {
    if (t.matched) {
      htmlText += '<strong class="' + SearchPad.RESULT_HIGHLIGHT_CLASS + '">' + t.matched + '</strong>';
    } else {
      htmlText += t.normal;
    }
  });

  return htmlText !== '' ? htmlText : null;
}

/**
 * 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';

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>';

SearchPad.RESULT_HTML = '<div class="djs-search-result"></div>';

SearchPad.RESULT_PRIMARY_HTML = '<div class="djs-search-result-primary"></div>';

SearchPad.RESULT_SECONDARY_HTML = '<p class="djs-search-result-secondary"></p>';

},{"../../util/Elements":396,"min-dom":506}],357:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _overlays = require('../overlays');

var _overlays2 = _interopRequireDefault(_overlays);

var _selection = require('../selection');

var _selection2 = _interopRequireDefault(_selection);

var _SearchPad = require('./SearchPad');

var _SearchPad2 = _interopRequireDefault(_SearchPad);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __depends__: [_overlays2.default, _selection2.default],
  searchPad: ['type', _SearchPad2.default]
};

},{"../overlays":339,"../selection":361,"./SearchPad":356}],358:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = Selection;

var _minDash = require('min-dash');

/**
 * 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) {

  this._eventBus = eventBus;

  this._selectedElements = [];

  var self = this;

  eventBus.on(['shape.remove', 'connection.remove'], function (e) {
    var element = e.element;
    self.deselect(element);
  });

  eventBus.on(['diagram.clear'], function (e) {
    self.select(null);
  });
}

Selection.$inject = ['eventBus'];

Selection.prototype.deselect = function (element) {
  var selectedElements = this._selectedElements;

  var idx = selectedElements.indexOf(element);

  if (idx !== -1) {
    var oldSelection = selectedElements.slice();

    selectedElements.splice(idx, 1);

    this._eventBus.fire('selection.changed', { oldSelection: oldSelection, newSelection: selectedElements });
  }
};

Selection.prototype.get = function () {
  return this._selectedElements;
};

Selection.prototype.isSelected = function (element) {
  return this._selectedElements.indexOf(element) !== -1;
};

/**
 * 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();

  if (!(0, _minDash.isArray)(elements)) {
    elements = elements ? [elements] : [];
  }

  // selection may be cleared by passing an empty array or null
  // to the method
  if (add) {
    (0, _minDash.forEach)(elements, function (element) {
      if (selectedElements.indexOf(element) !== -1) {
        // already selected
        return;
      } else {
        selectedElements.push(element);
      }
    });
  } else {
    this._selectedElements = selectedElements = elements.slice();
  }

  this._eventBus.fire('selection.changed', { oldSelection: oldSelection, newSelection: selectedElements });
};

},{"min-dash":505}],359:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = SelectionBehavior;

var _Mouse = require('../../util/Mouse');

var _minDash = require('min-dash');

function SelectionBehavior(eventBus, selection, canvas, elementRegistry) {

  eventBus.on('create.end', 500, function (e) {

    // select the created shape after a
    // successful create operation
    if (e.context.canExecute) {
      selection.select(e.context.shape);
    }
  });

  eventBus.on('connect.end', 500, function (e) {

    // select the connect end target
    // after a connect operation
    if (e.context.canExecute && e.context.target) {
      selection.select(e.context.target);
    }
  });

  eventBus.on('shape.move.end', 500, function (e) {
    var previousSelection = e.previousSelection || [];

    var shape = elementRegistry.get(e.context.shape.id);

    // make sure at least the main moved element is being
    // selected after a move operation
    var inSelection = (0, _minDash.find)(previousSelection, function (selectedShape) {
      return shape.id === selectedShape.id;
    });

    if (!inSelection) {
      selection.select(shape);
    }
  });

  // Shift + click selection
  eventBus.on('element.click', function (event) {

    var element = event.element;

    // do not select the root element
    // or connections
    if (element === canvas.getRootElement()) {
      element = null;
    }

    var isSelected = selection.isSelected(element),
        isMultiSelect = selection.get().length > 1;

    // mouse-event: SELECTION_KEY
    var add = (0, _Mouse.hasPrimaryModifier)(event);

    // select OR deselect element in multi selection
    if (isSelected && isMultiSelect) {
      if (add) {
        return selection.deselect(element);
      } else {
        return selection.select(element);
      }
    } else if (!isSelected) {
      selection.select(element, add);
    } else {
      selection.deselect(element);
    }
  });
}

SelectionBehavior.$inject = ['eventBus', 'selection', 'canvas', 'elementRegistry'];

},{"../../util/Mouse":403,"min-dash":505}],360:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = SelectionVisuals;

var _minDash = require('min-dash');

var MARKER_HOVER = 'hover',
    MARKER_SELECTED = 'selected';

/**
 * 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) {

  this._multiSelectionBox = null;

  function addMarker(e, cls) {
    canvas.addMarker(e, cls);
  }

  function removeMarker(e, cls) {
    canvas.removeMarker(e, cls);
  }

  events.on('element.hover', function (event) {
    addMarker(event.element, MARKER_HOVER);
  });

  events.on('element.out', function (event) {
    removeMarker(event.element, MARKER_HOVER);
  });

  events.on('selection.changed', function (event) {

    function deselect(s) {
      removeMarker(s, MARKER_SELECTED);
    }

    function select(s) {
      addMarker(s, MARKER_SELECTED);
    }

    var oldSelection = event.oldSelection,
        newSelection = event.newSelection;

    (0, _minDash.forEach)(oldSelection, function (e) {
      if (newSelection.indexOf(e) === -1) {
        deselect(e);
      }
    });

    (0, _minDash.forEach)(newSelection, function (e) {
      if (oldSelection.indexOf(e) === -1) {
        select(e);
      }
    });
  });
}

SelectionVisuals.$inject = ['eventBus', 'canvas', 'selection', 'styles'];

},{"min-dash":505}],361:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _interactionEvents = require('../interaction-events');

var _interactionEvents2 = _interopRequireDefault(_interactionEvents);

var _outline = require('../outline');

var _outline2 = _interopRequireDefault(_outline);

var _Selection = require('./Selection');

var _Selection2 = _interopRequireDefault(_Selection);

var _SelectionVisuals = require('./SelectionVisuals');

var _SelectionVisuals2 = _interopRequireDefault(_SelectionVisuals);

var _SelectionBehavior = require('./SelectionBehavior');

var _SelectionBehavior2 = _interopRequireDefault(_SelectionBehavior);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __init__: ['selectionVisuals', 'selectionBehavior'],
  __depends__: [_interactionEvents2.default, _outline2.default],
  selection: ['type', _Selection2.default],
  selectionVisuals: ['type', _SelectionVisuals2.default],
  selectionBehavior: ['type', _SelectionBehavior2.default]
};

},{"../interaction-events":294,"../outline":337,"./Selection":358,"./SelectionBehavior":359,"./SelectionVisuals":360}],362:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = SnapContext;

var _minDash = require('min-dash');

var _SnapUtil = require('./SnapUtil');

/**
 * A snap context, containing the (possibly incomplete)
 * mappings of drop targets (to identify the snapping)
 * to computed snap points.
 */
function SnapContext() {

  /**
   * Map<String, SnapPoints> mapping drop targets to
   * a list of possible snappings.
   *
   * @type {Object}
   */
  this._targets = {};

  /**
   * Map<String, Point> initial positioning of element
   * regarding various snap directions.
   *
   * @type {Object}
   */
  this._snapOrigins = {};

  /**
   * List of snap locations
   *
   * @type {Array<String>}
   */
  this._snapLocations = [];

  /**
   * Map<String, Array<Point>> of default snapping locations
   *
   * @type {Object}
   */
  this._defaultSnaps = {};
}

SnapContext.prototype.getSnapOrigin = function (snapLocation) {
  return this._snapOrigins[snapLocation];
};

SnapContext.prototype.setSnapOrigin = function (snapLocation, initialValue) {
  this._snapOrigins[snapLocation] = initialValue;

  if (this._snapLocations.indexOf(snapLocation) === -1) {
    this._snapLocations.push(snapLocation);
  }
};

SnapContext.prototype.addDefaultSnap = function (type, point) {

  var snapValues = this._defaultSnaps[type];

  if (!snapValues) {
    snapValues = this._defaultSnaps[type] = [];
  }

  snapValues.push(point);
};

/**
 * 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;
};

/**
 * 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;
};

/**
 * Get snap points for a given target
 *
 * @param {Element|String} target
 */
SnapContext.prototype.pointsForTarget = function (target) {

  var targetId = target.id || target;

  var snapPoints = this._targets[targetId];

  if (!snapPoints) {
    snapPoints = this._targets[targetId] = new SnapPoints();
    snapPoints.initDefaults(this._defaultSnaps);
  }

  return snapPoints;
};

/**
 * Creates the snap points and initializes them with the
 * given default values.
 *
 * @param {Object<String, Array<Point>>} [defaultPoints]
 */
function SnapPoints(defaultSnaps) {

  /**
   * 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 = {};
}

SnapPoints.prototype.add = function (snapLocation, point) {

  var snapValues = this._snapValues[snapLocation];

  if (!snapValues) {
    snapValues = this._snapValues[snapLocation] = { x: [], y: [] };
  }

  if (snapValues.x.indexOf(point.x) === -1) {
    snapValues.x.push(point.x);
  }

  if (snapValues.y.indexOf(point.y) === -1) {
    snapValues.y.push(point.y);
  }
};

SnapPoints.prototype.snap = function (point, snapLocation, axis, tolerance) {
  var snappingValues = this._snapValues[snapLocation];

  return snappingValues && (0, _SnapUtil.snapTo)(point[axis], snappingValues[axis], tolerance);
};

/**
 * Initialize a number of default snapping points.
 *
 * @param  {Object} defaultSnaps
 */
SnapPoints.prototype.initDefaults = function (defaultSnaps) {

  var self = this;

  (0, _minDash.forEach)(defaultSnaps || {}, function (snapPoints, snapLocation) {
    (0, _minDash.forEach)(snapPoints, function (point) {
      self.add(snapLocation, point);
    });
  });
};

},{"./SnapUtil":363,"min-dash":505}],363:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.snapTo = snapTo;
exports.topLeft = topLeft;
exports.mid = mid;
exports.bottomRight = bottomRight;
exports.isSnapped = isSnapped;
exports.setSnapped = setSnapped;
var abs = Math.abs,
    round = Math.round;

/**
 * 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;

  var idx, snapValue;

  for (idx = 0; idx < values.length; idx++) {
    snapValue = values[idx];

    if (abs(snapValue - value) <= tolerance) {
      return snapValue;
    }
  }
}

function topLeft(bounds) {
  return {
    x: bounds.x,
    y: bounds.y
  };
}

function mid(bounds, defaultValue) {

  if (!bounds || isNaN(bounds.x) || isNaN(bounds.y)) {
    return defaultValue;
  }

  return {
    x: round(bounds.x + bounds.width / 2),
    y: round(bounds.y + bounds.height / 2)
  };
}

function bottomRight(bounds) {
  return {
    x: bounds.x + bounds.width,
    y: bounds.y + bounds.height
  };
}

/**
 * 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;

  if (!snapped) {
    return false;
  }

  if (typeof axis === 'string') {
    return snapped[axis];
  }

  return snapped.x && snapped.y;
}

/**
 * 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]');
  }

  if (typeof value !== 'number' && value !== false) {
    throw new Error('value must be Number or false');
  }

  var delta,
      previousValue = event[axis];

  var snapped = event.snapped = event.snapped || {};

  if (value === false) {
    snapped[axis] = false;
  } else {
    snapped[axis] = true;

    delta = value - previousValue;

    event[axis] += delta;
    event['d' + axis] += delta;
  }

  return previousValue;
}

},{}],364:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

exports.default = Snapping;

var _minDash = require('min-dash');

var _SnapContext = require('./SnapContext');

var _SnapContext2 = _interopRequireDefault(_SnapContext);

var _SnapUtil = require('./SnapUtil');

var _tinySvg = require('tiny-svg');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var HIGHER_PRIORITY = 1250;

/**
 * A general purpose snapping component for diagram elements.
 *
 * @param {EventBus} eventBus
 * @param {Canvas} canvas
 */
function Snapping(eventBus, canvas) {

  this._canvas = canvas;

  var self = this;

  eventBus.on(['shape.move.start', 'create.start'], function (event) {
    self.initSnap(event);
  });

  eventBus.on(['shape.move.move', 'shape.move.end', 'create.move', 'create.end'], HIGHER_PRIORITY, function (event) {

    if (event.originalEvent && event.originalEvent.ctrlKey) {
      return;
    }

    if ((0, _SnapUtil.isSnapped)(event)) {
      return;
    }

    self.snap(event);
  });

  eventBus.on(['shape.move.cleanup', 'create.cleanup'], function (event) {
    self.hide();
  });

  // delay hide by 1000 seconds since last match
  this._asyncHide = (0, _minDash.debounce)((0, _minDash.bind)(this.hide, this), 1000);
}

Snapping.$inject = ['eventBus', 'canvas'];

Snapping.prototype.initSnap = function (event) {

  var context = event.context,
      shape = context.shape,
      snapContext = context.snapContext;

  if (!snapContext) {
    snapContext = context.snapContext = new _SnapContext2.default();
  }

  var snapMid = (0, _SnapUtil.mid)(shape, event);

  snapContext.setSnapOrigin('mid', {
    x: snapMid.x - event.x,
    y: snapMid.y - event.y
  });

  return snapContext;
};

Snapping.prototype.snap = function (event) {

  var context = event.context,
      snapContext = context.snapContext,
      shape = context.shape,
      target = context.target,
      snapLocations = snapContext.getSnapLocations();

  if (!target) {
    return;
  }

  var snapPoints = snapContext.pointsForTarget(target);

  if (!snapPoints.initialized) {
    this.addTargetSnaps(snapPoints, shape, target);

    snapPoints.initialized = true;
  }

  var snapping = {
    x: (0, _SnapUtil.isSnapped)(event, 'x'),
    y: (0, _SnapUtil.isSnapped)(event, 'y')
  };

  (0, _minDash.forEach)(snapLocations, function (location) {

    var snapOrigin = snapContext.getSnapOrigin(location);

    var snapCurrent = {
      x: event.x + snapOrigin.x,
      y: event.y + snapOrigin.y
    };

    // snap on both axis, if not snapped already
    (0, _minDash.forEach)(['x', 'y'], function (axis) {
      var locationSnapping;

      if (!snapping[axis]) {
        locationSnapping = snapPoints.snap(snapCurrent, location, axis, 7);

        if (locationSnapping !== undefined) {
          snapping[axis] = {
            value: locationSnapping,
            originValue: locationSnapping - snapOrigin[axis]
          };
        }
      }
    });

    // no more need to snap, drop out of interation
    if (snapping.x && snapping.y) {
      return false;
    }
  });

  // show snap visuals

  this.showSnapLine('vertical', snapping.x && snapping.x.value);
  this.showSnapLine('horizontal', snapping.y && snapping.y.value);

  // adjust event { x, y, dx, dy } and mark as snapping
  (0, _minDash.forEach)(['x', 'y'], function (axis) {

    var axisSnapping = snapping[axis];

    if ((typeof axisSnapping === 'undefined' ? 'undefined' : _typeof(axisSnapping)) === 'object') {
      // set as snapped and adjust the x and/or y position of the event
      (0, _SnapUtil.setSnapped)(event, axis, axisSnapping.originValue);
    }
  });
};

Snapping.prototype._createLine = function (orientation) {

  var root = this._canvas.getLayer('snap');

  // var line = root.path('M0,0 L0,0').addClass('djs-snap-line');

  var line = (0, _tinySvg.create)('path');
  (0, _tinySvg.attr)(line, { d: 'M0,0 L0,0' });
  (0, _tinySvg.classes)(line).add('djs-snap-line');

  (0, _tinySvg.append)(root, line);

  return {
    update: function update(position) {

      if (typeof position !== 'number') {
        (0, _tinySvg.attr)(line, { display: 'none' });
      } else {
        if (orientation === 'horizontal') {
          (0, _tinySvg.attr)(line, {
            d: 'M-100000,' + position + ' L+100000,' + position,
            display: ''
          });
        } else {
          (0, _tinySvg.attr)(line, {
            d: 'M ' + position + ',-100000 L ' + position + ', +100000',
            display: ''
          });
        }
      }
    }
  };
};

Snapping.prototype._createSnapLines = function () {

  this._snapLines = {
    horizontal: this._createLine('horizontal'),
    vertical: this._createLine('vertical')
  };
};

Snapping.prototype.showSnapLine = function (orientation, position) {

  var line = this.getSnapLine(orientation);

  if (line) {
    line.update(position);
  }

  this._asyncHide();
};

Snapping.prototype.getSnapLine = function (orientation) {
  if (!this._snapLines) {
    this._createSnapLines();
  }

  return this._snapLines[orientation];
};

Snapping.prototype.hide = function () {
  (0, _minDash.forEach)(this._snapLines, function (l) {
    l.update();
  });
};

Snapping.prototype.addTargetSnaps = function (snapPoints, shape, target) {

  var siblings = this.getSiblings(shape, target);

  (0, _minDash.forEach)(siblings, function (s) {
    snapPoints.add('mid', (0, _SnapUtil.mid)(s));
  });
};

Snapping.prototype.getSiblings = function (element, target) {

  // snap to all siblings that are not hidden, labels, attached to element or element itself
  return target && (0, _minDash.filter)(target.children, function (e) {
    return !e.hidden && !e.labelTarget && e.host !== element && e !== element;
  });
};

},{"./SnapContext":362,"./SnapUtil":363,"min-dash":505,"tiny-svg":535}],365:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = SpaceTool;

var _SpaceUtil = require('./SpaceUtil');

var _Cursor = require('../../util/Cursor');

var _Mouse = require('../../util/Mouse');

var _Elements = require('../../util/Elements');

var _minDash = require('min-dash');

var abs = Math.abs,
    round = Math.round;

var HIGH_PRIORITY = 1500,
    SPACE_TOOL_CURSOR = 'crosshair';

var AXIS_TO_DIMENSION = { x: 'width', y: 'height' },
    AXIS_INVERTED = { x: 'y', y: 'x' };

/**
 * A tool that allows users to create and remove space in a diagram.
 *
 * The tool needs to be activated manually via {@link SpaceTool#activate(MouseEvent)}.
 */
function SpaceTool(eventBus, dragging, canvas, modeling, rules, toolManager) {

  this._canvas = canvas;
  this._dragging = dragging;
  this._modeling = modeling;
  this._rules = rules;
  this._toolManager = toolManager;

  var self = this;

  toolManager.registerTool('space', {
    tool: 'spaceTool.selection',
    dragging: 'spaceTool'
  });

  eventBus.on('spaceTool.selection.end', function (event) {
    var target = event.originalEvent.target;

    // 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;
    }

    eventBus.once('spaceTool.selection.ended', function () {
      self.activateMakeSpace(event.originalEvent);
    });
  });

  eventBus.on('spaceTool.move', HIGH_PRIORITY, function (event) {

    var context = event.context;

    if (!context.initialized) {
      context.initialized = self.initializeMakeSpace(event, context);
    }
  });

  eventBus.on('spaceTool.end', function (event) {

    var context = event.context,
        axis = context.axis,
        direction = context.direction,
        movingShapes = context.movingShapes,
        resizingShapes = context.resizingShapes;

    // skip if create space has not been initialized yet
    if (!context.initialized) {
      return;
    }

    var delta = { x: round(event.dx), y: round(event.dy) };
    delta[AXIS_INVERTED[axis]] = 0;

    var insideBounds = true;

    // check if the space tool cursor is inside of bounds of
    // any of the shapes that would be resized.
    (0, _minDash.forEach)(resizingShapes, function (shape) {

      if (direction === 'w' && event.x > shape.x + shape.width || direction === 'e' && event.x < shape.x || direction === 'n' && event.y > shape.y + shape.height || direction === 's' && event.y < shape.y) {

        insideBounds = false;
        return;
      }
    });

    if (insideBounds) {
      // make space only if the cursor is inside bounds
      self.makeSpace(movingShapes, resizingShapes, delta, direction);
    }

    eventBus.once('spaceTool.ended', function (event) {
      // reactivate space tool after usage
      self.activateSelection(event.originalEvent, true, true);
    });
  });
}

SpaceTool.$inject = ['eventBus', 'dragging', 'canvas', 'modeling', 'rules', 'toolManager'];

/**
 * Activate space tool selection
 *
 * @param  {MouseEvent} event
 * @param  {Boolean} autoActivate
 */
SpaceTool.prototype.activateSelection = function (event, autoActivate, reactivate) {
  this._dragging.init(event, 'spaceTool.selection', {
    trapClick: false,
    cursor: SPACE_TOOL_CURSOR,
    autoActivate: autoActivate,
    data: {
      context: {
        reactivate: reactivate
      }
    }
  });
};

/**
 * Activate make space
 *
 * @param  {MouseEvent} event
 */
SpaceTool.prototype.activateMakeSpace = function (event) {
  this._dragging.init(event, 'spaceTool', {
    autoActivate: true,
    cursor: SPACE_TOOL_CURSOR,
    data: {
      context: {}
    }
  });
};

/**
 * Actually make space on the diagram
 *
 * @param  {Array<djs.model.Shape>} movingShapes
 * @param  {Array<djs.model.Shape>} resizingShapes
 * @param  {Point} delta
 * @param  {String} direction
 */
SpaceTool.prototype.makeSpace = function (movingShapes, resizingShapes, delta, direction) {
  return this._modeling.createSpace(movingShapes, resizingShapes, delta, direction);
};

/**
 * Initialize make space and return true if that was successful.
 *
 * @param {Event} event
 * @param {Object} context
 *
 * @return {Boolean} true, if successful
 */
SpaceTool.prototype.initializeMakeSpace = function (event, context) {

  var axis = abs(event.dx) > abs(event.dy) ? 'x' : 'y',
      offset = event['d' + axis],

  // start point of create space operation
  spacePos = event[axis] - offset;

  if (abs(offset) < 5) {
    return false;
  }

  // invert the offset in order to remove space when moving left
  if (offset < 0) {
    offset *= -1;
  }

  // inverts the offset to choose the shapes
  // on the opposite side of the resizer if
  // a key modifier is pressed
  if ((0, _Mouse.hasPrimaryModifier)(event)) {
    offset *= -1;
  }

  var rootShape = this._canvas.getRootElement();

  var allShapes = (0, _Elements.selfAndAllChildren)(rootShape, true);

  var adjustments = this.calculateAdjustments(allShapes, axis, offset, spacePos);

  // store data in context
  (0, _minDash.assign)(context, adjustments, {
    axis: axis,
    direction: (0, _SpaceUtil.getDirection)(axis, offset)
  });

  (0, _Cursor.set)('resize-' + (axis === 'x' ? 'ew' : 'ns'));

  return true;
};

/**
 * Calculate adjustments needed when making space
 *
 * @param  {Array<djs.model.Shape>} elements
 * @param  {String} axis
 * @param  {Number} offset
 * @param  {Number} spacePos
 *
 * @return {Object}
 */
SpaceTool.prototype.calculateAdjustments = function (elements, axis, offset, spacePos) {

  var movingShapes = [],
      resizingShapes = [];

  var rules = this._rules;

  // collect all elements that need to be moved _AND_
  // resized given on the initial create space position
  elements.forEach(function (shape) {

    var shapeStart = shape[axis],
        shapeEnd = shapeStart + shape[AXIS_TO_DIMENSION[axis]];

    // checking if it's root
    if (!shape.parent) {
      return;
    }

    // checking if it's a shape
    if (shape.waypoints) {
      return;
    }

    // shape after spacePos
    if (offset > 0 && shapeStart > spacePos) {
      return movingShapes.push(shape);
    }

    // shape before spacePos
    if (offset < 0 && shapeEnd < spacePos) {
      return movingShapes.push(shape);
    }

    // shape on top of spacePos, resize only if allowed
    if (shapeStart < spacePos && shapeEnd > spacePos && rules.allowed('shape.resize', { shape: shape })) {

      return resizingShapes.push(shape);
    }
  });

  return {
    movingShapes: movingShapes,
    resizingShapes: resizingShapes
  };
};

SpaceTool.prototype.toggle = function () {
  if (this.isActive()) {
    this._dragging.cancel();
  } else {
    this.activateSelection();
  }
};

SpaceTool.prototype.isActive = function () {
  var context = this._dragging.context();

  return context && /^spaceTool/.test(context.prefix);
};

},{"../../util/Cursor":395,"../../util/Elements":396,"../../util/Mouse":403,"./SpaceUtil":367,"min-dash":505}],366:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = SpaceToolPreview;

var _minDash = require('min-dash');

var _tinySvg = require('tiny-svg');

var _SvgTransformUtil = require('../../util/SvgTransformUtil');

var MARKER_DRAGGING = 'djs-dragging',
    MARKER_RESIZING = 'djs-resizing';

var LOW_PRIORITY = 250;

/**
 * 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) {

  function addPreviewGfx(collection, dragGroup) {
    (0, _minDash.forEach)(collection, function (element) {
      previewSupport.addDragger(element, dragGroup);

      canvas.addMarker(element, MARKER_DRAGGING);
    });
  }

  // add crosshair
  eventBus.on('spaceTool.selection.start', function (event) {
    var space = canvas.getLayer('space'),
        context = event.context;

    var orientation = {
      x: 'M 0,-10000 L 0,10000',
      y: 'M -10000,0 L 10000,0'
    };

    var crosshairGroup = (0, _tinySvg.create)('g');
    (0, _tinySvg.attr)(crosshairGroup, styles.cls('djs-crosshair-group', ['no-events']));

    (0, _tinySvg.append)(space, crosshairGroup);

    // horizontal path
    var pathX = (0, _tinySvg.create)('path');
    (0, _tinySvg.attr)(pathX, 'd', orientation.x);
    (0, _tinySvg.classes)(pathX).add('djs-crosshair');

    (0, _tinySvg.append)(crosshairGroup, pathX);

    // vertical path
    var pathY = (0, _tinySvg.create)('path');
    (0, _tinySvg.attr)(pathY, 'd', orientation.y);
    (0, _tinySvg.classes)(pathY).add('djs-crosshair');

    (0, _tinySvg.append)(crosshairGroup, pathY);

    context.crosshairGroup = crosshairGroup;
  });

  // update crosshair
  eventBus.on('spaceTool.selection.move', function (event) {
    var crosshairGroup = event.context.crosshairGroup;

    (0, _SvgTransformUtil.translate)(crosshairGroup, event.x, event.y);
  });

  // remove crosshair
  eventBus.on('spaceTool.selection.cleanup', function (event) {
    var context = event.context,
        crosshairGroup = context.crosshairGroup;

    if (crosshairGroup) {
      (0, _tinySvg.remove)(crosshairGroup);
    }
  });

  // add and update move/resize previews
  eventBus.on('spaceTool.move', LOW_PRIORITY, function (event) {

    var context = event.context,
        line = context.line,
        axis = context.axis,
        movingShapes = context.movingShapes,
        resizingShapes = context.resizingShapes;

    if (!context.initialized) {
      return;
    }

    if (!context.dragGroup) {
      var spaceLayer = canvas.getLayer('space');

      line = (0, _tinySvg.create)('path');
      (0, _tinySvg.attr)(line, 'd', 'M0,0 L0,0');
      (0, _tinySvg.classes)(line).add('djs-crosshair');

      (0, _tinySvg.append)(spaceLayer, line);

      context.line = line;

      var dragGroup = (0, _tinySvg.create)('g');
      (0, _tinySvg.attr)(dragGroup, styles.cls('djs-drag-group', ['no-events']));

      (0, _tinySvg.append)(canvas.getDefaultLayer(), dragGroup);

      // shapes
      addPreviewGfx(movingShapes, dragGroup);

      // connections
      var movingConnections = context.movingConnections = elementRegistry.filter(function (element) {
        var sourceIsMoving = false;

        (0, _minDash.forEach)(movingShapes, function (shape) {
          (0, _minDash.forEach)(shape.outgoing, function (connection) {
            if (element === connection) {
              sourceIsMoving = true;
            }
          });
        });

        var targetIsMoving = false;

        (0, _minDash.forEach)(movingShapes, function (shape) {
          (0, _minDash.forEach)(shape.incoming, function (connection) {
            if (element === connection) {
              targetIsMoving = true;
            }
          });
        });

        var sourceIsResizing = false;

        (0, _minDash.forEach)(resizingShapes, function (shape) {
          (0, _minDash.forEach)(shape.outgoing, function (connection) {
            if (element === connection) {
              sourceIsResizing = true;
            }
          });
        });

        var targetIsResizing = false;

        (0, _minDash.forEach)(resizingShapes, function (shape) {
          (0, _minDash.forEach)(shape.incoming, function (connection) {
            if (element === connection) {
              targetIsResizing = true;
            }
          });
        });

        return isConnection(element) && (sourceIsMoving || sourceIsResizing) && (targetIsMoving || targetIsResizing);
      });

      addPreviewGfx(movingConnections, dragGroup);

      context.dragGroup = dragGroup;
    }

    if (!context.frameGroup) {
      var frameGroup = (0, _tinySvg.create)('g');
      (0, _tinySvg.attr)(frameGroup, styles.cls('djs-frame-group', ['no-events']));

      (0, _tinySvg.append)(canvas.getDefaultLayer(), frameGroup);

      var frames = [];

      (0, _minDash.forEach)(resizingShapes, function (shape) {
        var frame = previewSupport.addFrame(shape, frameGroup);

        frames.push({
          element: frame,
          initialWidth: frame.getBBox().width,
          initialHeight: frame.getBBox().height
        });

        canvas.addMarker(shape, MARKER_RESIZING);
      });

      context.frameGroup = frameGroup;
      context.frames = frames;
    }

    var orientation = {
      x: 'M' + event.x + ', -10000 L' + event.x + ', 10000',
      y: 'M -10000, ' + event.y + ' L 10000, ' + event.y
    };

    (0, _tinySvg.attr)(line, { path: orientation[axis], display: '' });

    var opposite = { x: 'y', y: 'x' };
    var delta = { x: event.dx, y: event.dy };
    delta[opposite[context.axis]] = 0;

    // update move previews
    (0, _SvgTransformUtil.translate)(context.dragGroup, delta.x, delta.y);

    // update resize previews
    (0, _minDash.forEach)(context.frames, function (frame) {
      if (frame.initialWidth + delta.x > 5) {
        (0, _tinySvg.attr)(frame.element, { width: frame.initialWidth + delta.x });
      }

      if (frame.initialHeight + delta.y > 5) {
        (0, _tinySvg.attr)(frame.element, { height: frame.initialHeight + delta.y });
      }
    });
  });

  // remove move/resize previews
  eventBus.on('spaceTool.cleanup', function (event) {

    var context = event.context,
        movingShapes = context.movingShapes,
        movingConnections = context.movingConnections,
        resizingShapes = context.resizingShapes,
        line = context.line,
        dragGroup = context.dragGroup,
        frameGroup = context.frameGroup;

    // moving shapes
    (0, _minDash.forEach)(movingShapes, function (shape) {
      canvas.removeMarker(shape, MARKER_DRAGGING);
    });

    // moving connections
    (0, _minDash.forEach)(movingConnections, function (connection) {
      canvas.removeMarker(connection, MARKER_DRAGGING);
    });

    if (dragGroup) {
      (0, _tinySvg.remove)(line);
      (0, _tinySvg.remove)(dragGroup);
    }

    (0, _minDash.forEach)(resizingShapes, function (shape) {
      canvas.removeMarker(shape, MARKER_RESIZING);
    });

    if (frameGroup) {
      (0, _tinySvg.remove)(frameGroup);
    }
  });
}

SpaceToolPreview.$inject = ['eventBus', 'elementRegistry', 'canvas', 'styles', 'previewSupport'];

// helpers //////////////////////

/**
 * Checks if an element is a connection.
 */
function isConnection(element) {
  return element.waypoints;
}

},{"../../util/SvgTransformUtil":408,"min-dash":505,"tiny-svg":535}],367:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.getDirection = getDirection;
exports.resizeBounds = resizeBounds;
/**
 * Get Resize direction given axis + offset
 *
 * @param {String} axis (x|y)
 * @param {Number} offset
 *
 * @return {String} (e|w|n|s)
 */
function getDirection(axis, offset) {

  if (axis === 'x') {
    if (offset > 0) {
      return 'e';
    }

    if (offset < 0) {
      return 'w';
    }
  }

  if (axis === 'y') {
    if (offset > 0) {
      return 's';
    }

    if (offset < 0) {
      return 'n';
    }
  }

  return null;
}

/**
 * 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 (n, s, e, w)
 * @param {Point} delta of the resize operation
 *
 * @return {Bounds} resized bounding box
 */
function resizeBounds(bounds, direction, delta) {

  var dx = delta.x,
      dy = delta.y;

  switch (direction) {

    case 'n':
      return {
        x: bounds.x,
        y: bounds.y + dy,
        width: bounds.width,
        height: bounds.height - dy
      };

    case 's':
      return {
        x: bounds.x,
        y: bounds.y,
        width: bounds.width,
        height: bounds.height + dy
      };

    case 'w':
      return {
        x: bounds.x + dx,
        y: bounds.y,
        width: bounds.width - dx,
        height: bounds.height
      };

    case 'e':
      return {
        x: bounds.x,
        y: bounds.y,
        width: bounds.width + dx,
        height: bounds.height
      };

    default:
      throw new Error('unrecognized direction: ' + direction);
  }
}

},{}],368:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _dragging = require('../dragging');

var _dragging2 = _interopRequireDefault(_dragging);

var _rules = require('../rules');

var _rules2 = _interopRequireDefault(_rules);

var _toolManager = require('../tool-manager');

var _toolManager2 = _interopRequireDefault(_toolManager);

var _previewSupport = require('../preview-support');

var _previewSupport2 = _interopRequireDefault(_previewSupport);

var _SpaceTool = require('./SpaceTool');

var _SpaceTool2 = _interopRequireDefault(_SpaceTool);

var _SpaceToolPreview = require('./SpaceToolPreview');

var _SpaceToolPreview2 = _interopRequireDefault(_SpaceToolPreview);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __init__: ['spaceToolPreview'],
  __depends__: [_dragging2.default, _rules2.default, _toolManager2.default, _previewSupport2.default],
  spaceTool: ['type', _SpaceTool2.default],
  spaceToolPreview: ['type', _SpaceToolPreview2.default]
};

},{"../dragging":286,"../preview-support":345,"../rules":355,"../tool-manager":370,"./SpaceTool":365,"./SpaceToolPreview":366}],369:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = ToolManager;

var _minDash = require('min-dash');

var _minDom = require('min-dom');

var LOW_PRIORITY = 250;

/**
 * The tool manager acts as middle-man between the available tool's and the Palette,
 * it takes care of making sure that the correct active state is set.
 *
 * @param  {Object}    eventBus
 * @param  {Object}    dragging
 */
function ToolManager(eventBus, dragging) {
  this._eventBus = eventBus;
  this._dragging = dragging;

  this._tools = [];
  this._active = null;
}

ToolManager.$inject = ['eventBus', 'dragging'];

ToolManager.prototype.registerTool = function (name, events) {
  var tools = this._tools;

  if (!events) {
    throw new Error('A tool has to be registered with it\'s "events"');
  }

  tools.push(name);

  this.bindEvents(name, events);
};

ToolManager.prototype.isActive = function (tool) {
  return tool && this._active === tool;
};

ToolManager.prototype.length = function (tool) {
  return this._tools.length;
};

ToolManager.prototype.setActive = function (tool) {
  var eventBus = this._eventBus;

  if (this._active !== tool) {
    this._active = tool;

    eventBus.fire('tool-manager.update', { tool: tool });
  }
};

ToolManager.prototype.bindEvents = function (name, events) {
  var eventBus = this._eventBus,
      dragging = this._dragging;

  var eventsToRegister = [];

  eventBus.on(events.tool + '.init', function (event) {
    var context = event.context;

    // Active tools that want to reactivate themselves must do this explicitly
    if (!context.reactivate && this.isActive(name)) {
      this.setActive(null);

      dragging.cancel();
      return;
    }

    this.setActive(name);
  }, this);

  // Todo[ricardo]: add test cases
  (0, _minDash.forEach)(events, function (event) {
    eventsToRegister.push(event + '.ended');
    eventsToRegister.push(event + '.canceled');
  });

  eventBus.on(eventsToRegister, LOW_PRIORITY, function (event) {
    var originalEvent = event.originalEvent;

    // We defer the de-activation of the tool to the .activate phase,
    // so we're able to check if we want to toggle off the current
    // active tool or switch to a new one
    if (!this._active) {
      return;
    }

    if (originalEvent && (0, _minDom.closest)(originalEvent.target, '.group[data-group="tools"]')) {
      return;
    }

    this.setActive(null);
  }, this);
};

},{"min-dash":505,"min-dom":506}],370:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _dragging = require('../dragging');

var _dragging2 = _interopRequireDefault(_dragging);

var _ToolManager = require('./ToolManager');

var _ToolManager2 = _interopRequireDefault(_ToolManager);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __depends__: [_dragging2.default],
  __init__: ['toolManager'],
  toolManager: ['type', _ToolManager2.default]
};

},{"../dragging":286,"./ToolManager":369}],371:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = Tooltips;

var _minDash = require('min-dash');

var _minDom = require('min-dom');

var _IdGenerator = require('../../util/IdGenerator');

var _IdGenerator2 = _interopRequireDefault(_IdGenerator);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

// document wide unique tooltip ids
var ids = new _IdGenerator2.default('tt');

function createRoot(parentNode) {
  var root = (0, _minDom.domify)('<div class="djs-tooltip-container" style="position: absolute; width: 0; height: 0;" />');

  parentNode.insertBefore(root, parentNode.firstChild);

  return root;
}

function setPosition(el, x, y) {
  (0, _minDash.assign)(el.style, { left: x + 'px', top: y + 'px' });
}

function setVisible(el, visible) {
  el.style.display = visible === false ? 'none' : '';
}

var tooltipClass = 'djs-tooltip',
    tooltipSelector = '.' + tooltipClass;

/**
 * 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) {

  this._eventBus = eventBus;
  this._canvas = canvas;

  this._ids = ids;

  this._tooltipDefaults = {
    show: {
      minZoom: 0.7,
      maxZoom: 5.0
    }
  };

  /**
   * Mapping tooltipId -> tooltip
   */
  this._tooltips = {};

  // root html element for all tooltips
  this._tooltipRoot = createRoot(canvas.getContainer());

  var self = this;

  _minDom.delegate.bind(this._tooltipRoot, tooltipSelector, 'mousedown', function (event) {
    event.stopPropagation();
  });

  _minDom.delegate.bind(this._tooltipRoot, tooltipSelector, 'mouseover', function (event) {
    self.trigger('mouseover', event);
  });

  _minDom.delegate.bind(this._tooltipRoot, tooltipSelector, 'mouseout', function (event) {
    self.trigger('mouseout', event);
  });

  this._init();
}

Tooltips.$inject = ['eventBus', 'canvas'];

/**
 * Adds a HTML tooltip to the diagram
 *
 * @param {Object}               tooltip   the tooltip configuration
 *
 * @param {String|DOMElement}    tooltip.html                 html element to use as an tooltip
 * @param {Object}               [tooltip.show]               show configuration
 * @param {Number}               [tooltip.show.minZoom]       minimal zoom level to show the tooltip
 * @param {Number}               [tooltip.show.maxZoom]       maximum zoom level to show the tooltip
 * @param {Object}               tooltip.position             where to attach the tooltip
 * @param {Number}               [tooltip.position.left]      relative to element bbox left attachment
 * @param {Number}               [tooltip.position.top]       relative to element bbox top attachment
 * @param {Number}               [tooltip.position.bottom]    relative to element bbox bottom attachment
 * @param {Number}               [tooltip.position.right]     relative to element bbox right attachment
 * @param {Number}               [tooltip.timeout=-1]
 *
 * @return {String}              id that may be used to reference the tooltip for update or removal
 */
Tooltips.prototype.add = function (tooltip) {

  if (!tooltip.position) {
    throw new Error('must specifiy tooltip position');
  }

  if (!tooltip.html) {
    throw new Error('must specifiy tooltip html');
  }

  var id = this._ids.next();

  tooltip = (0, _minDash.assign)({}, this._tooltipDefaults, tooltip, {
    id: id
  });

  this._addTooltip(tooltip);

  if (tooltip.timeout) {
    this.setTimeout(tooltip);
  }

  return id;
};

Tooltips.prototype.trigger = function (action, event) {

  var node = event.delegateTarget || event.target;

  var tooltip = this.get((0, _minDom.attr)(node, 'data-tooltip-id'));

  if (!tooltip) {
    return;
  }

  if (action === 'mouseover' && tooltip.timeout) {
    this.clearTimeout(tooltip);
  }

  if (action === 'mouseout' && tooltip.timeout) {
    // cut timeout after mouse out
    tooltip.timeout = 1000;

    this.setTimeout(tooltip);
  }
};

/**
 * Get a tooltip with the given id
 *
 * @param {String} id
 */
Tooltips.prototype.get = function (id) {

  if (typeof id !== 'string') {
    id = id.id;
  }

  return this._tooltips[id];
};

Tooltips.prototype.clearTimeout = function (tooltip) {

  tooltip = this.get(tooltip);

  if (!tooltip) {
    return;
  }

  var removeTimer = tooltip.removeTimer;

  if (removeTimer) {
    clearTimeout(removeTimer);
    tooltip.removeTimer = null;
  }
};

Tooltips.prototype.setTimeout = function (tooltip) {

  tooltip = this.get(tooltip);

  if (!tooltip) {
    return;
  }

  this.clearTimeout(tooltip);

  var self = this;

  tooltip.removeTimer = setTimeout(function () {
    self.remove(tooltip);
  }, tooltip.timeout);
};

/**
 * Remove an tooltip with the given id
 *
 * @param {String} id
 */
Tooltips.prototype.remove = function (id) {

  var tooltip = this.get(id);

  if (tooltip) {
    (0, _minDom.remove)(tooltip.html);
    (0, _minDom.remove)(tooltip.htmlContainer);

    delete tooltip.htmlContainer;

    delete this._tooltips[tooltip.id];
  }
};

Tooltips.prototype.show = function () {
  setVisible(this._tooltipRoot);
};

Tooltips.prototype.hide = function () {
  setVisible(this._tooltipRoot, false);
};

Tooltips.prototype._updateRoot = function (viewbox) {
  var a = viewbox.scale || 1;
  var d = viewbox.scale || 1;

  var matrix = 'matrix(' + a + ',0,0,' + d + ',' + -1 * viewbox.x * a + ',' + -1 * viewbox.y * d + ')';

  this._tooltipRoot.style.transform = matrix;
  this._tooltipRoot.style['-ms-transform'] = matrix;
};

Tooltips.prototype._addTooltip = function (tooltip) {

  var id = tooltip.id,
      html = tooltip.html,
      htmlContainer,
      tooltipRoot = this._tooltipRoot;

  // unwrap jquery (for those who need it)
  if (html.get && html.constructor.prototype.jquery) {
    html = html.get(0);
  }

  // create proper html elements from
  // tooltip HTML strings
  if ((0, _minDash.isString)(html)) {
    html = (0, _minDom.domify)(html);
  }

  htmlContainer = (0, _minDom.domify)('<div data-tooltip-id="' + id + '" class="' + tooltipClass + '" style="position: absolute">');

  htmlContainer.appendChild(html);

  if (tooltip.type) {
    (0, _minDom.classes)(htmlContainer).add('djs-tooltip-' + tooltip.type);
  }

  if (tooltip.className) {
    (0, _minDom.classes)(htmlContainer).add(tooltip.className);
  }

  tooltip.htmlContainer = htmlContainer;

  tooltipRoot.appendChild(htmlContainer);

  this._tooltips[id] = tooltip;

  this._updateTooltip(tooltip);
};

Tooltips.prototype._updateTooltip = function (tooltip) {

  var position = tooltip.position,
      htmlContainer = tooltip.htmlContainer;

  // update overlay html based on tooltip x, y

  setPosition(htmlContainer, position.x, position.y);
};

Tooltips.prototype._updateTooltipVisibilty = function (viewbox) {

  (0, _minDash.forEach)(this._tooltips, function (tooltip) {
    var show = tooltip.show,
        htmlContainer = tooltip.htmlContainer,
        visible = true;

    if (show) {
      if (show.minZoom > viewbox.scale || show.maxZoom < viewbox.scale) {
        visible = false;
      }

      setVisible(htmlContainer, visible);
    }
  });
};

Tooltips.prototype._init = function () {

  var self = this;

  // scroll/zoom integration

  function updateViewbox(viewbox) {
    self._updateRoot(viewbox);
    self._updateTooltipVisibilty(viewbox);

    self.show();
  }

  this._eventBus.on('canvas.viewbox.changing', function (event) {
    self.hide();
  });

  this._eventBus.on('canvas.viewbox.changed', function (event) {
    updateViewbox(event.viewbox);
  });
};

},{"../../util/IdGenerator":400,"min-dash":505,"min-dom":506}],372:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _Tooltips = require('./Tooltips');

var _Tooltips2 = _interopRequireDefault(_Tooltips);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __init__: ['tooltips'],
  tooltips: ['type', _Tooltips2.default]
};

},{"./Tooltips":371}],373:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = TouchFix;

var _tinySvg = require('tiny-svg');

function TouchFix(canvas, eventBus) {

  var self = this;

  eventBus.on('canvas.init', function (e) {
    self.addBBoxMarker(e.svg);
  });
}

TouchFix.$inject = ['canvas', 'eventBus'];

/**
 * 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) {

  var markerStyle = {
    fill: 'none',
    class: 'outer-bound-marker'
  };

  var rect1 = (0, _tinySvg.create)('rect');
  (0, _tinySvg.attr)(rect1, {
    x: -10000,
    y: 10000,
    width: 10,
    height: 10
  });
  (0, _tinySvg.attr)(rect1, markerStyle);

  (0, _tinySvg.append)(svg, rect1);

  var rect2 = (0, _tinySvg.create)('rect');
  (0, _tinySvg.attr)(rect2, {
    x: 10000,
    y: 10000,
    width: 10,
    height: 10
  });
  (0, _tinySvg.attr)(rect2, markerStyle);

  (0, _tinySvg.append)(svg, rect2);
};

},{"tiny-svg":535}],374:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = TouchInteractionEvents;

var _minDash = require('min-dash');

var _minDom = require('min-dom');

var _hammerjs = require('hammerjs');

var _hammerjs2 = _interopRequireDefault(_hammerjs);

var _Event = require('../../util/Event');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var MIN_ZOOM = 0.2,
    MAX_ZOOM = 4;

var mouseEvents = ['mousedown', 'mouseup', 'mouseover', 'mouseout', 'click', 'dblclick'];

function log() {
  // console.log.apply(console, arguments);
}

function get(service, injector) {
  return injector.get(service, false);
}

function stopEvent(event) {

  event.preventDefault();
  event.stopPropagation();

  if (typeof event.stopImmediatePropagation === 'function') {
    event.stopImmediatePropagation();
  }
}

function createTouchRecognizer(node) {

  function stopMouse(event) {

    (0, _minDash.forEach)(mouseEvents, function (e) {
      _minDom.event.bind(node, e, stopEvent, true);
    });
  }

  function allowMouse(event) {
    setTimeout(function () {
      (0, _minDash.forEach)(mouseEvents, function (e) {
        _minDom.event.unbind(node, e, stopEvent, true);
      });
    }, 500);
  }

  _minDom.event.bind(node, 'touchstart', stopMouse, true);
  _minDom.event.bind(node, 'touchend', allowMouse, true);
  _minDom.event.bind(node, 'touchcancel', allowMouse, true);

  // A touch event recognizer that handles
  // touch events only (we know, we can already handle
  // mouse events out of the box)

  var recognizer = new _hammerjs2.default.Manager(node, {
    inputClass: _hammerjs2.default.TouchInput,
    recognizers: []
  });

  var tap = new _hammerjs2.default.Tap();
  var pan = new _hammerjs2.default.Pan({ threshold: 10 });
  var press = new _hammerjs2.default.Press();
  var pinch = new _hammerjs2.default.Pinch();

  var doubleTap = new _hammerjs2.default.Tap({ event: 'doubletap', taps: 2 });

  pinch.requireFailure(pan);
  pinch.requireFailure(press);

  recognizer.add([pan, press, pinch, doubleTap, tap]);

  recognizer.reset = function (force) {
    var recognizers = this.recognizers,
        session = this.session;

    if (session.stopped) {
      return;
    }

    log('recognizer', 'stop');

    recognizer.stop(force);

    setTimeout(function () {
      var i, r;

      log('recognizer', 'reset');
      for (i = 0; r = recognizers[i]; i++) {
        r.reset();
        r.state = 8; // FAILED STATE
      }

      session.curRecognizer = null;
    }, 0);
  };

  recognizer.on('hammer.input', function (event) {
    if (event.srcEvent.defaultPrevented) {
      recognizer.reset(true);
    }
  });

  return recognizer;
}

/**
 * A plugin that provides touch events for elements.
 *
 * @param {EventBus} eventBus
 * @param {InteractionEvents} interactionEvents
 */
function TouchInteractionEvents(injector, canvas, eventBus, elementRegistry, interactionEvents) {

  // optional integrations
  var dragging = get('dragging', injector),
      move = get('move', injector),
      contextPad = get('contextPad', injector),
      palette = get('palette', injector);

  // the touch recognizer
  var recognizer;

  function handler(type) {

    return function (event) {
      log('element', type, event);

      interactionEvents.fire(type, event);
    };
  }

  function getGfx(target) {
    var node = (0, _minDom.closest)(target, 'svg, .djs-element', true);
    return node;
  }

  function initEvents(svg) {

    // touch recognizer
    recognizer = createTouchRecognizer(svg);

    recognizer.on('doubletap', handler('element.dblclick'));

    recognizer.on('tap', handler('element.click'));

    function startGrabCanvas(event) {

      log('canvas', 'grab start');

      var lx = 0,
          ly = 0;

      function update(e) {

        var dx = e.deltaX - lx,
            dy = e.deltaY - ly;

        canvas.scroll({ dx: dx, dy: dy });

        lx = e.deltaX;
        ly = e.deltaY;
      }

      function end(e) {
        recognizer.off('panmove', update);
        recognizer.off('panend', end);
        recognizer.off('pancancel', end);

        log('canvas', 'grab end');
      }

      recognizer.on('panmove', update);
      recognizer.on('panend', end);
      recognizer.on('pancancel', end);
    }

    function startGrab(event) {

      var gfx = getGfx(event.target),
          element = gfx && elementRegistry.get(gfx);

      // recognizer
      if (move && canvas.getRootElement() !== element) {
        log('element', 'move start', element, event, true);
        return move.start(event, element, true);
      } else {
        startGrabCanvas(event);
      }
    }

    function startZoom(e) {

      log('canvas', 'zoom start');

      var zoom = canvas.zoom(),
          mid = e.center;

      function update(e) {

        var ratio = 1 - (1 - e.scale) / 1.50,
            newZoom = Math.max(MIN_ZOOM, Math.min(MAX_ZOOM, ratio * zoom));

        canvas.zoom(newZoom, mid);

        stopEvent(e);
      }

      function end(e) {
        recognizer.off('pinchmove', update);
        recognizer.off('pinchend', end);
        recognizer.off('pinchcancel', end);

        recognizer.reset(true);

        log('canvas', 'zoom end');
      }

      recognizer.on('pinchmove', update);
      recognizer.on('pinchend', end);
      recognizer.on('pinchcancel', end);
    }

    recognizer.on('panstart', startGrab);
    recognizer.on('press', startGrab);

    recognizer.on('pinchstart', startZoom);
  }

  if (dragging) {

    // simulate hover during dragging
    eventBus.on('drag.move', function (event) {

      var originalEvent = event.originalEvent;

      if (!originalEvent || originalEvent instanceof MouseEvent) {
        return;
      }

      var position = (0, _Event.toPoint)(originalEvent);

      // this gets really expensive ...
      var node = document.elementFromPoint(position.x, position.y),
          gfx = getGfx(node),
          element = gfx && elementRegistry.get(gfx);

      if (element !== event.hover) {
        if (event.hover) {
          dragging.out(event);
        }

        if (element) {
          dragging.hover({ element: element, gfx: gfx });

          event.hover = element;
          event.hoverGfx = gfx;
        }
      }
    });
  }

  if (contextPad) {

    eventBus.on('contextPad.create', function (event) {
      var node = event.pad.html;

      // touch recognizer
      var padRecognizer = createTouchRecognizer(node);

      padRecognizer.on('panstart', function (event) {
        log('context-pad', 'panstart', event);
        contextPad.trigger('dragstart', event, true);
      });

      padRecognizer.on('press', function (event) {
        log('context-pad', 'press', event);
        contextPad.trigger('dragstart', event, true);
      });

      padRecognizer.on('tap', function (event) {
        log('context-pad', 'tap', event);
        contextPad.trigger('click', event);
      });
    });
  }

  if (palette) {
    eventBus.on('palette.create', function (event) {
      var node = event.container;

      // touch recognizer
      var padRecognizer = createTouchRecognizer(node);

      padRecognizer.on('panstart', function (event) {
        log('palette', 'panstart', event);
        palette.trigger('dragstart', event, true);
      });

      padRecognizer.on('press', function (event) {
        log('palette', 'press', event);
        palette.trigger('dragstart', event, true);
      });

      padRecognizer.on('tap', function (event) {
        log('palette', 'tap', event);
        palette.trigger('click', event);
      });
    });
  }

  eventBus.on('canvas.init', function (event) {
    initEvents(event.svg);
  });
}

TouchInteractionEvents.$inject = ['injector', 'canvas', 'eventBus', 'elementRegistry', 'interactionEvents', 'touchFix'];

},{"../../util/Event":397,"hammerjs":412,"min-dash":505,"min-dom":506}],375:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _interactionEvents = require('../interaction-events');

var _interactionEvents2 = _interopRequireDefault(_interactionEvents);

var _TouchInteractionEvents = require('./TouchInteractionEvents');

var _TouchInteractionEvents2 = _interopRequireDefault(_TouchInteractionEvents);

var _TouchFix = require('./TouchFix');

var _TouchFix2 = _interopRequireDefault(_TouchFix);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __depends__: [_interactionEvents2.default],
  __init__: ['touchInteractionEvents'],
  touchInteractionEvents: ['type', _TouchInteractionEvents2.default],
  touchFix: ['type', _TouchFix2.default]
};

},{"../interaction-events":294,"./TouchFix":373,"./TouchInteractionEvents":374}],376:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _translate = require('./translate');

var _translate2 = _interopRequireDefault(_translate);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  translate: ['value', _translate2.default]
};

},{"./translate":377}],377:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = translate;
/**
 * 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(template, replacements) {

  replacements = replacements || {};

  return template.replace(/{([^}]+)}/g, function (_, key) {
    return replacements[key] || '{' + key + '}';
  });
}

},{}],378:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = BaseLayouter;

var _LayoutUtil = require('./LayoutUtil');

/**
 * A base connection layouter implementation
 * that layouts the connection by directly connecting
 * mid(source) + mid(target).
 */
function BaseLayouter() {}

/**
 * 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]
 *
 * @return {Array<Point>} the layouted connection waypoints
 */
BaseLayouter.prototype.layoutConnection = function (connection, hints) {

  hints = hints || {};

  return [hints.connectionStart || (0, _LayoutUtil.getMid)(connection.source), hints.connectionEnd || (0, _LayoutUtil.getMid)(connection.target)];
};

},{"./LayoutUtil":380}],379:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = CroppingConnectionDocking;

var _minDash = require('min-dash');

var _LayoutUtil = require('./LayoutUtil');

function dockingToPoint(docking) {
  // use the dockings actual point and
  // retain the original docking
  return (0, _minDash.assign)({ original: docking.point.original || docking.point }, docking.actual);
}

/**
 * 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;
}

CroppingConnectionDocking.$inject = ['elementRegistry', 'graphicsFactory'];

/**
 * @inheritDoc ConnectionDocking#getCroppedWaypoints
 */
CroppingConnectionDocking.prototype.getCroppedWaypoints = function (connection, source, target) {

  source = source || connection.source;
  target = target || connection.target;

  var sourceDocking = this.getDockingPoint(connection, source, true),
      targetDocking = this.getDockingPoint(connection, target);

  var croppedWaypoints = connection.waypoints.slice(sourceDocking.idx + 1, targetDocking.idx);

  croppedWaypoints.unshift(dockingToPoint(sourceDocking));
  croppedWaypoints.push(dockingToPoint(targetDocking));

  return croppedWaypoints;
};

/**
 * Return the connection docking point on the specified shape
 *
 * @inheritDoc ConnectionDocking#getDockingPoint
 */
CroppingConnectionDocking.prototype.getDockingPoint = function (connection, shape, dockStart) {

  var waypoints = connection.waypoints,
      dockingIdx,
      dockingPoint,
      croppedPoint;

  dockingIdx = dockStart ? 0 : waypoints.length - 1;
  dockingPoint = waypoints[dockingIdx];

  croppedPoint = this._getIntersection(shape, connection, dockStart);

  return {
    point: dockingPoint,
    actual: croppedPoint || dockingPoint,
    idx: dockingIdx
  };
};

// helpers //////////////////////

CroppingConnectionDocking.prototype._getIntersection = function (shape, connection, takeFirst) {

  var shapePath = this._getShapePath(shape),
      connectionPath = this._getConnectionPath(connection);

  return (0, _LayoutUtil.getElementLineIntersection)(shapePath, connectionPath, takeFirst);
};

CroppingConnectionDocking.prototype._getConnectionPath = function (connection) {
  return this._graphicsFactory.getConnectionPath(connection);
};

CroppingConnectionDocking.prototype._getShapePath = function (shape) {
  return this._graphicsFactory.getShapePath(shape);
};

CroppingConnectionDocking.prototype._getGfx = function (element) {
  return this._elementRegistry.getGraphics(element);
};

},{"./LayoutUtil":380,"min-dash":505}],380:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.roundBounds = roundBounds;
exports.roundPoint = roundPoint;
exports.asTRBL = asTRBL;
exports.asBounds = asBounds;
exports.getMid = getMid;
exports.getOrientation = getOrientation;
exports.getElementLineIntersection = getElementLineIntersection;
exports.getIntersections = getIntersections;

var _minDash = require('min-dash');

var _Geometry = require('../util/Geometry');

var _pathIntersection = require('path-intersection');

var _pathIntersection2 = _interopRequireDefault(_pathIntersection);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function roundBounds(bounds) {
  return {
    x: Math.round(bounds.x),
    y: Math.round(bounds.y),
    width: Math.round(bounds.width),
    height: Math.round(bounds.height)
  };
}

function roundPoint(point) {

  return {
    x: Math.round(point.x),
    y: Math.round(point.y)
  };
}

/**
 * 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
  };
}

/**
 * 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
  };
}

/**
 * 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
  });
}

// orientation utils //////////////////////

/**
 * 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) {

  padding = padding || 0;

  // make sure we can use an object, too
  // for individual { x, y } padding
  if (!(0, _minDash.isObject)(padding)) {
    padding = { x: padding, y: padding };
  }

  var rectOrientation = asTRBL(rect),
      referenceOrientation = asTRBL(reference);

  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;

  var vertical = top ? 'top' : bottom ? 'bottom' : null,
      horizontal = left ? 'left' : right ? 'right' : null;

  if (horizontal && vertical) {
    return vertical + '-' + horizontal;
  } else {
    return horizontal || vertical || 'intersect';
  }
}

// intersection utils //////////////////////

/**
 * 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) {

  var intersections = getIntersections(elementPath, linePath);

  // 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 && (0, _Geometry.pointDistance)(intersections[0], intersections[1]) < 1) {
    return roundPoint(intersections[0]);
  } else if (intersections.length > 1) {

    // sort by intersections based on connection segment +
    // distance from start
    intersections = (0, _minDash.sortBy)(intersections, function (i) {
      var distance = Math.floor(i.t2 * 100) || 1;

      distance = 100 - distance;

      distance = (distance < 10 ? '0' : '') + distance;

      // 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;
    });

    return roundPoint(intersections[cropStart ? 0 : intersections.length - 1]);
  }

  return null;
}

function getIntersections(a, b) {
  return (0, _pathIntersection2.default)(a, b);
}

},{"../util/Geometry":398,"min-dash":505,"path-intersection":523}],381:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.connectPoints = connectPoints;
exports.connectRectangles = connectRectangles;
exports.repairConnection = repairConnection;
exports.layoutStraight = layoutStraight;
exports._repairConnectionSide = _repairConnectionSide;
exports.withoutRedundantPoints = withoutRedundantPoints;

var _minDash = require('min-dash');

var _LayoutUtil = require('./LayoutUtil');

var _Geometry = require('../util/Geometry');

var MIN_SEGMENT_LENGTH = 20,
    POINT_ORIENTATION_PADDING = 5;

var round = Math.round;

var INTERSECTION_THRESHOLD = 20,
    ORIENTATION_THRESHOLD = {
  'h:h': 20,
  'v:v': 20,
  'h:v': -10,
  'v:h': -10
};

function needsTurn(orientation, startDirection) {
  return !{
    t: /top/,
    r: /right/,
    b: /bottom/,
    l: /left/,
    h: /./,
    v: /./
  }[startDirection].test(orientation);
}

function canLayoutStraight(direction, targetOrientation) {
  return {
    t: /top/,
    r: /right/,
    b: /bottom/,
    l: /left/,
    h: /left|right/,
    v: /top|bottom/
  }[direction].test(targetOrientation);
}

function getSegmentBendpoints(a, b, directions) {
  var orientation = (0, _LayoutUtil.getOrientation)(b, a, POINT_ORIENTATION_PADDING);

  var startDirection = directions.split(':')[0];

  var xmid = round((b.x - a.x) / 2 + a.x),
      ymid = round((b.y - a.y) / 2 + a.y);

  var segmentEnd, segmentDirections;

  var layoutStraight = canLayoutStraight(startDirection, orientation),
      layoutHorizontal = /h|r|l/.test(startDirection),
      layoutTurn = false;

  var turnNextDirections = false;

  if (layoutStraight) {
    segmentEnd = layoutHorizontal ? { x: xmid, y: a.y } : { x: a.x, y: ymid };

    segmentDirections = layoutHorizontal ? 'h:h' : 'v:v';
  } else {
    layoutTurn = needsTurn(orientation, startDirection);

    segmentDirections = layoutHorizontal ? 'h:v' : 'v:h';

    if (layoutTurn) {

      if (layoutHorizontal) {
        turnNextDirections = ymid === a.y;

        segmentEnd = {
          x: a.x + MIN_SEGMENT_LENGTH * (/l/.test(startDirection) ? -1 : 1),
          y: turnNextDirections ? ymid + MIN_SEGMENT_LENGTH : ymid
        };
      } else {
        turnNextDirections = xmid === a.x;

        segmentEnd = {
          x: turnNextDirections ? xmid + MIN_SEGMENT_LENGTH : xmid,
          y: a.y + MIN_SEGMENT_LENGTH * (/t/.test(startDirection) ? -1 : 1)
        };
      }
    } else {
      segmentEnd = {
        x: xmid,
        y: ymid
      };
    }
  }

  return {
    waypoints: getBendpoints(a, segmentEnd, segmentDirections).concat(segmentEnd),
    directions: segmentDirections,
    turnNextDirections: turnNextDirections
  };
}

function getStartSegment(a, b, directions) {
  return getSegmentBendpoints(a, b, directions);
}

function getEndSegment(a, b, directions) {
  var invertedSegment = getSegmentBendpoints(b, a, invertDirections(directions));

  return {
    waypoints: invertedSegment.waypoints.slice().reverse(),
    directions: invertDirections(invertedSegment.directions),
    turnNextDirections: invertedSegment.turnNextDirections
  };
}

function getMidSegment(startSegment, endSegment) {

  var startDirection = startSegment.directions.split(':')[1],
      endDirection = endSegment.directions.split(':')[0];

  if (startSegment.turnNextDirections) {
    startDirection = startDirection == 'h' ? 'v' : 'h';
  }

  if (endSegment.turnNextDirections) {
    endDirection = endDirection == 'h' ? 'v' : 'h';
  }

  var directions = startDirection + ':' + endDirection;

  var bendpoints = getBendpoints(startSegment.waypoints[startSegment.waypoints.length - 1], endSegment.waypoints[0], directions);

  return {
    waypoints: bendpoints,
    directions: directions
  };
}

function invertDirections(directions) {
  return directions.split(':').reverse().join(':');
}

/**
 * Handle simple layouts with maximum two bendpoints.
 */
function getSimpleBendpoints(a, b, directions) {

  var xmid = round((b.x - a.x) / 2 + a.x),
      ymid = round((b.y - a.y) / 2 + a.y);

  // one point, right or left from a
  if (directions === 'h:v') {
    return [{ x: b.x, y: a.y }];
  }

  // one point, above or below a
  if (directions === 'v:h') {
    return [{ x: a.x, y: b.y }];
  }

  // vertical segment between a and b
  if (directions === 'h:h') {
    return [{ x: xmid, y: a.y }, { x: xmid, y: b.y }];
  }

  // horizontal segment between a and b
  if (directions === 'v:v') {
    return [{ x: a.x, y: ymid }, { x: b.x, y: ymid }];
  }

  throw new Error('invalid directions: can only handle varians of [hv]:[hv]');
}

/**
 * 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';

  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 }');
  }

  // 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);

    return [].concat(startSegment.waypoints, midSegment.waypoints, endSegment.waypoints);
  }

  // handle simple [hv]:[hv] cases that can be easily computed
  return getSimpleBendpoints(a, b, directions);
}

/**
 * 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) {

  var points = getBendpoints(a, b, directions);

  points.unshift(a);
  points.push(b);

  return withoutRedundantPoints(points);
}

/**
 * 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) {

  var preferredLayouts = hints && hints.preferredLayouts || [];

  var preferredLayout = (0, _minDash.without)(preferredLayouts, 'straight')[0] || 'h:h';

  var threshold = ORIENTATION_THRESHOLD[preferredLayout] || 0;

  var orientation = (0, _LayoutUtil.getOrientation)(source, target, threshold);

  var directions = getDirections(orientation, preferredLayout);

  start = start || (0, _LayoutUtil.getMid)(source);
  end = end || (0, _LayoutUtil.getMid)(target);

  var directionSplit = directions.split(':');

  // 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);

  return connectPoints(startDocking, endDocking, directions);
}

/**
 * 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) {

  if ((0, _minDash.isArray)(start)) {
    waypoints = start;
    hints = end;

    start = (0, _LayoutUtil.getMid)(source);
    end = (0, _LayoutUtil.getMid)(target);
  }

  hints = (0, _minDash.assign)({ preferredLayouts: [] }, hints);
  waypoints = waypoints || [];

  var preferredLayouts = hints.preferredLayouts,
      preferStraight = preferredLayouts.indexOf('straight') !== -1,
      repairedWaypoints;

  // just layout non-existing or simple connections
  // attempt to render straight lines, if required

  if (preferStraight) {
    // attempt to layout a straight line
    repairedWaypoints = layoutStraight(source, target, start, end, hints);
  }

  if (!repairedWaypoints) {
    // check if we layout from start or end
    if (hints.connectionEnd) {
      repairedWaypoints = _repairConnectionSide(target, source, end, waypoints.slice().reverse());
      repairedWaypoints = repairedWaypoints && repairedWaypoints.reverse();
    } else if (hints.connectionStart) {
      repairedWaypoints = _repairConnectionSide(source, target, start, waypoints);
    } else
      // or whether nothing seems to have changed
      if (waypoints && waypoints.length) {
        repairedWaypoints = waypoints;
      }
  }

  // simply reconnect if nothing else worked
  if (!repairedWaypoints) {
    repairedWaypoints = connectRectangles(source, target, start, end, hints);
  }

  return repairedWaypoints;
}

function inRange(a, start, end) {
  return a >= start && a <= end;
}

function isInRange(axis, a, b) {
  var size = {
    x: 'width',
    y: 'height'
  };

  return inRange(a[axis], b[axis], b[axis] + b[size[axis]]);
}

/**
 * Layout a straight connection
 *
 * @param {Bounds} source
 * @param {Bounds} target
 * @param {Point} start
 * @param {Point} end
 * @param {Object} [hints]
 *
 * @return {Array<Point>} waypoints if straight layout worked
 */
function layoutStraight(source, target, start, end, hints) {
  var axis = {},
      primaryAxis,
      orientation;

  orientation = (0, _LayoutUtil.getOrientation)(source, target);

  // only layout a straight connection if shapes are
  // horizontally or vertically aligned
  if (!/^(top|bottom|left|right)$/.test(orientation)) {
    return null;
  }

  if (/top|bottom/.test(orientation)) {
    primaryAxis = 'x';
  }

  if (/left|right/.test(orientation)) {
    primaryAxis = 'y';
  }

  if (hints.preserveDocking === 'target') {

    if (!isInRange(primaryAxis, end, source)) {
      return null;
    }

    axis[primaryAxis] = end[primaryAxis];

    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
    }];
  } else {

    if (!isInRange(primaryAxis, start, target)) {
      return null;
    }

    axis[primaryAxis] = start[primaryAxis];

    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
      }
    }];
  }
}

/**
 * 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 _repairConnectionSide(moved, other, newDocking, points) {

  function needsRelayout(moved, other, points) {

    if (points.length < 3) {
      return true;
    }

    if (points.length > 4) {
      return false;
    }

    // relayout if two points overlap
    // this is most likely due to
    return !!(0, _minDash.find)(points, function (p, idx) {
      var q = points[idx - 1];

      return q && (0, _Geometry.pointDistance)(p, q) < 3;
    });
  }

  function repairBendpoint(candidate, oldPeer, newPeer) {

    var alignment = (0, _Geometry.pointsAligned)(oldPeer, candidate);

    switch (alignment) {
      case 'v':
        // repair vertical alignment
        return { x: candidate.x, y: newPeer.y };
      case 'h':
        // repair horizontal alignment
        return { x: newPeer.x, y: candidate.y };
    }

    return { x: candidate.x, y: candidate.y };
  }

  function removeOverlapping(points, a, b) {
    var i;

    for (i = points.length - 2; i !== 0; i--) {

      // intersects (?) break, remove all bendpoints up to this one and relayout
      if ((0, _Geometry.pointInRect)(points[i], a, INTERSECTION_THRESHOLD) || (0, _Geometry.pointInRect)(points[i], b, INTERSECTION_THRESHOLD)) {

        // return sliced old connection
        return points.slice(i);
      }
    }

    return points;
  }

  // (0) only repair what has layoutable bendpoints

  // (1) if only one bendpoint and on shape moved onto other shapes axis
  //     (horizontally / vertically), relayout

  if (needsRelayout(moved, other, points)) {
    return null;
  }

  var oldDocking = points[0],
      newPoints = points.slice(),
      slicedPoints;

  // (2) repair only last line segment and only if it was layouted before

  newPoints[0] = newDocking;
  newPoints[1] = repairBendpoint(newPoints[1], oldDocking, newDocking);

  // (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);

  if (slicedPoints !== newPoints) {
    return _repairConnectionSide(moved, other, newDocking, slicedPoints);
  }

  return newPoints;
}

/**
 * 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) {

  // don't override specific trbl directions
  if (isExplicitDirections(defaultLayout)) {
    return defaultLayout;
  }

  switch (orientation) {
    case 'intersect':
      return 't:t';

    case 'top':
    case 'bottom':
      return 'v:v';

    case 'left':
    case 'right':
      return 'h:h';

    // 'top-left'
    // 'top-right'
    // 'bottom-left'
    // 'bottom-right'
    default:
      return defaultLayout;
  }
}

function isValidDirections(directions) {
  return directions && /^h|v|t|r|b|l:h|v|t|r|b|l$/.test(directions);
}

function isExplicitDirections(directions) {
  return directions && /t|r|b|l/.test(directions);
}

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];
}

function getDockingPoint(point, rectangle, dockingDirection, targetOrientation) {

  // ensure we end up with a specific docking direction
  // based on the targetOrientation, if <h|v> is being passed

  if (dockingDirection === 'h') {
    dockingDirection = /left/.test(targetOrientation) ? 'l' : 'r';
  }

  if (dockingDirection === 'v') {
    dockingDirection = /top/.test(targetOrientation) ? 't' : 'b';
  }

  if (dockingDirection === 't') {
    return { original: point, x: point.x, y: rectangle.y };
  }

  if (dockingDirection === 'r') {
    return { original: point, x: rectangle.x + rectangle.width, y: point.y };
  }

  if (dockingDirection === 'b') {
    return { original: point, x: point.x, y: rectangle.y + rectangle.height };
  }

  if (dockingDirection === 'l') {
    return { original: point, x: rectangle.x, y: point.y };
  }

  throw new Error('unexpected dockingDirection: <' + dockingDirection + '>');
}

/**
 * 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) {

    var previous = points[points.length - 1],
        next = waypoints[idx + 1];

    if (!(0, _Geometry.pointsOnLine)(previous, next, p, 0)) {
      points.push(p);
    }

    return points;
  }, []);
}

},{"../util/Geometry":398,"./LayoutUtil":380,"min-dash":505}],382:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.Base = Base;
exports.Shape = Shape;
exports.Root = Root;
exports.Label = Label;
exports.Connection = Connection;
exports.create = create;

var _minDash = require('min-dash');

var _inherits = require('inherits');

var _inherits2 = _interopRequireDefault(_inherits);

var _objectRefs = require('object-refs');

var _objectRefs2 = _interopRequireDefault(_objectRefs);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var parentRefs = new _objectRefs2.default({ name: 'children', enumerable: true, collection: true }, { name: 'parent' }),
    labelRefs = new _objectRefs2.default({ name: 'labels', enumerable: true, collection: true }, { name: 'labelTarget' }),
    attacherRefs = new _objectRefs2.default({ name: 'attachers', collection: true }, { name: 'host' }),
    outgoingRefs = new _objectRefs2.default({ name: 'outgoing', collection: true }, { name: 'source' }),
    incomingRefs = new _objectRefs2.default({ name: 'incoming', collection: true }, { name: 'target' });

/**
 * @namespace djs.model
 */

/**
 * @memberOf djs.model
 */

/**
 * The basic graphical representation
 *
 * @class
 *
 * @abstract
 */
function Base() {

  /**
   * The object that backs up the shape
   *
   * @name Base#businessObject
   * @type Object
   */
  Object.defineProperty(this, 'businessObject', {
    writable: true
  });

  /**
   * Single label support, will mapped to multi label array
   *
   * @name Base#label
   * @type Object
   */
  Object.defineProperty(this, 'label', {
    get: function get() {
      return this.labels[0];
    },
    set: function set(newLabel) {

      var label = this.label,
          labels = this.labels;

      if (!newLabel && label) {
        labels.remove(label);
      } else {
        labels.add(newLabel, 0);
      }
    }
  });

  /**
   * The parent shape
   *
   * @name Base#parent
   * @type Shape
   */
  parentRefs.bind(this, 'parent');

  /**
   * The list of labels
   *
   * @name Base#labels
   * @type Label
   */
  labelRefs.bind(this, 'labels');

  /**
   * The list of outgoing connections
   *
   * @name Base#outgoing
   * @type Array<Connection>
   */
  outgoingRefs.bind(this, 'outgoing');

  /**
   * The list of incoming connections
   *
   * @name Base#incoming
   * @type Array<Connection>
   */
  incomingRefs.bind(this, 'incoming');
}

/**
 * A graphical object
 *
 * @class
 * @constructor
 *
 * @extends Base
 */
function Shape() {
  Base.call(this);

  /**
   * The list of children
   *
   * @name Shape#children
   * @type Array<Base>
   */
  parentRefs.bind(this, 'children');

  /**
   * @name Shape#host
   * @type Shape
   */
  attacherRefs.bind(this, 'host');

  /**
   * @name Shape#attachers
   * @type Shape
   */
  attacherRefs.bind(this, 'attachers');
}

(0, _inherits2.default)(Shape, Base);

/**
 * A root graphical object
 *
 * @class
 * @constructor
 *
 * @extends Shape
 */
function Root() {
  Shape.call(this);
}

(0, _inherits2.default)(Root, Shape);

/**
 * A label for an element
 *
 * @class
 * @constructor
 *
 * @extends Shape
 */
function Label() {
  Shape.call(this);

  /**
   * The labeled element
   *
   * @name Label#labelTarget
   * @type Base
   */
  labelRefs.bind(this, 'labelTarget');
}

(0, _inherits2.default)(Label, Shape);

/**
 * A connection between two elements
 *
 * @class
 * @constructor
 *
 * @extends Base
 */
function Connection() {
  Base.call(this);

  /**
   * The element this connection originates from
   *
   * @name Connection#source
   * @type Base
   */
  outgoingRefs.bind(this, 'source');

  /**
   * The element this connection points to
   *
   * @name Connection#target
   * @type Base
   */
  incomingRefs.bind(this, 'target');
}

(0, _inherits2.default)(Connection, Base);

var types = {
  connection: Connection,
  shape: Shape,
  label: Label,
  root: Root
};

/**
 * 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[type];
  if (!Type) {
    throw new Error('unknown type: <' + type + '>');
  }
  return (0, _minDash.assign)(new Type(), attrs);
}

},{"inherits":415,"min-dash":505,"object-refs":520}],383:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = KeyboardMove;

var _minDash = require('min-dash');

var DEFAULT_CONFIG = {
  moveSpeed: 50,
  moveSpeedAccelerated: 200
};

/**
 * 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) {

  var self = this;

  this._config = (0, _minDash.assign)({}, DEFAULT_CONFIG, config || {});

  keyboard.addListener(arrowsListener);

  function arrowsListener(context) {

    var event = context.keyEvent,
        config = self._config;

    if (!keyboard.isCmd(event)) {
      return;
    }

    if (keyboard.isKey(['ArrowLeft', 'Left', 'ArrowUp', 'Up', 'ArrowDown', 'Down', 'ArrowRight', 'Right'], event)) {

      var speed = keyboard.isShift(event) ? config.moveSpeedAccelerated : config.moveSpeed;

      var direction;

      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;
      }

      self.moveCanvas({
        speed: speed,
        direction: direction
      });

      return true;
    }
  }

  this.moveCanvas = function (opts) {

    var dx = 0,
        dy = 0,
        speed = opts.speed;

    var actualSpeed = speed / Math.min(Math.sqrt(canvas.viewbox().scale), 1);

    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;
    }

    canvas.scroll({
      dx: dx,
      dy: dy
    });
  };
}

KeyboardMove.$inject = ['config.keyboardMove', 'keyboard', 'canvas'];

},{"min-dash":505}],384:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _keyboard = require('../../features/keyboard');

var _keyboard2 = _interopRequireDefault(_keyboard);

var _KeyboardMove = require('./KeyboardMove');

var _KeyboardMove2 = _interopRequireDefault(_KeyboardMove);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __depends__: [_keyboard2.default],
  __init__: ['keyboardMove'],
  keyboardMove: ['type', _KeyboardMove2.default]
};

},{"../../features/keyboard":300,"./KeyboardMove":383}],385:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = MoveCanvas;

var _Cursor = require('../../util/Cursor');

var _ClickTrap = require('../../util/ClickTrap');

var _PositionUtil = require('../../util/PositionUtil');

var _minDom = require('min-dom');

var _Event = require('../../util/Event');

var THRESHOLD = 15;

/**
 * Move the canvas via mouse.
 *
 * @param {EventBus} eventBus
 * @param {Canvas} canvas
 */
function MoveCanvas(eventBus, canvas) {

  var context;

  // 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);
  });

  function handleMove(event) {

    var start = context.start,
        position = (0, _Event.toPoint)(event),
        delta = (0, _PositionUtil.delta)(position, start);

    if (!context.dragging && length(delta) > THRESHOLD) {
      context.dragging = true;

      (0, _ClickTrap.install)(eventBus);

      (0, _Cursor.set)('grab');
    }

    if (context.dragging) {

      var lastPosition = context.last || context.start;

      delta = (0, _PositionUtil.delta)(position, lastPosition);

      canvas.scroll({
        dx: delta.x,
        dy: delta.y
      });

      context.last = position;
    }

    // prevent select
    event.preventDefault();
  }

  function handleEnd(event) {
    _minDom.event.unbind(document, 'mousemove', handleMove);
    _minDom.event.unbind(document, 'mouseup', handleEnd);

    context = null;

    (0, _Cursor.unset)();
  }

  function handleStart(event) {
    // event is already handled by '.djs-draggable'
    if ((0, _minDom.closest)(event.target, '.djs-draggable')) {
      return;
    }

    // reject non-left left mouse button or modifier key
    if (event.button || event.ctrlKey || event.shiftKey || event.altKey) {
      return;
    }

    context = {
      start: (0, _Event.toPoint)(event)
    };

    _minDom.event.bind(document, 'mousemove', handleMove);
    _minDom.event.bind(document, 'mouseup', handleEnd);

    // we've handled the event
    return true;
  }
}

MoveCanvas.$inject = ['eventBus', 'canvas'];

// helpers ///////

function length(point) {
  return Math.sqrt(Math.pow(point.x, 2) + Math.pow(point.y, 2));
}

},{"../../util/ClickTrap":392,"../../util/Cursor":395,"../../util/Event":397,"../../util/PositionUtil":405,"min-dom":506}],386:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _MoveCanvas = require('./MoveCanvas');

var _MoveCanvas2 = _interopRequireDefault(_MoveCanvas);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __init__: ['moveCanvas'],
  moveCanvas: ['type', _MoveCanvas2.default]
};

},{"./MoveCanvas":385}],387:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _touch = require('../../features/touch');

var _touch2 = _interopRequireDefault(_touch);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __depends__: [_touch2.default]
};

},{"../../features/touch":375}],388:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = ZoomScroll;

var _minDom = require('min-dom');

var _ZoomUtil = require('./ZoomUtil');

var _Math = require('../../util/Math');

var _minDash = require('min-dash');

var sign = Math.sign || function (n) {
  return n >= 0 ? 1 : -1;
};

var RANGE = { min: 0.2, max: 4 },
    NUM_STEPS = 10;

var DELTA_THRESHOLD = 0.1;

var DEFAULT_SCALE = 0.75;

/**
 * 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) {

  config = config || {};

  this._enabled = false;

  this._canvas = canvas;
  this._container = canvas._container;

  this._handleWheel = (0, _minDash.bind)(this._handleWheel, this);

  this._totalDelta = 0;
  this._scale = config.scale || DEFAULT_SCALE;

  var self = this;

  eventBus.on('canvas.init', function (e) {
    self._init(config.enabled !== false);
  });
}

ZoomScroll.$inject = ['config.zoomScroll', 'eventBus', 'canvas'];

ZoomScroll.prototype.scroll = function scroll(delta) {
  this._canvas.scroll(delta);
};

ZoomScroll.prototype.reset = function reset() {
  this._canvas.zoom('fit-viewport');
};

/**
 * Zoom depending on delta.
 *
 * @param {number} delta - Zoom delta.
 * @param {Object} position - Zoom position.
 */
ZoomScroll.prototype.zoom = function zoom(delta, position) {

  // zoom with half the step size of stepZoom
  var stepSize = (0, _ZoomUtil.getStepSize)(RANGE, NUM_STEPS * 2);

  // add until threshold reached
  this._totalDelta += delta;

  if (Math.abs(this._totalDelta) > DELTA_THRESHOLD) {
    this._zoom(delta, position, stepSize);

    // reset
    this._totalDelta = 0;
  }
};

ZoomScroll.prototype._handleWheel = function handleWheel(event) {
  // event is already handled by '.djs-scrollable'
  if ((0, _minDom.closest)(event.target, '.djs-scrollable', true)) {
    return;
  }

  var element = this._container;

  event.preventDefault();

  // pinch to zoom is mapped to wheel + ctrlKey = true
  // in modern browsers (!)

  var isZoom = event.ctrlKey;

  var isHorizontalScroll = event.shiftKey;

  var factor = -1 * this._scale,
      delta;

  if (isZoom) {
    factor *= event.deltaMode === 0 ? 0.020 : 0.32;
  } else {
    factor *= event.deltaMode === 0 ? 1.0 : 16.0;
  }

  if (isZoom) {
    var elementRect = element.getBoundingClientRect();

    var offset = {
      x: event.clientX - elementRect.left,
      y: event.clientY - elementRect.top
    };

    delta = Math.sqrt(Math.pow(event.deltaY, 2) + Math.pow(event.deltaX, 2)) * sign(event.deltaY) * factor;

    // zoom in relative to diagram {x,y} coordinates
    this.zoom(delta, offset);
  } else {

    if (isHorizontalScroll) {
      delta = {
        dx: factor * event.deltaY,
        dy: 0
      };
    } else {
      delta = {
        dx: factor * event.deltaX,
        dy: factor * event.deltaY
      };
    }

    this.scroll(delta);
  }
};

/**
 * Zoom with fixed step size.
 *
 * @param {number} delta - Zoom delta (1 for zooming in, -1 for out).
 * @param {Object} position - Zoom position.
 */
ZoomScroll.prototype.stepZoom = function stepZoom(delta, position) {

  var stepSize = (0, _ZoomUtil.getStepSize)(RANGE, NUM_STEPS);

  this._zoom(delta, position, stepSize);
};

/**
 * Zoom in/out given a step size.
 *
 * @param {number} delta - Zoom delta. Can be positive or negative.
 * @param {Object} position - Zoom position.
 * @param {number} stepSize - Step size.
 */
ZoomScroll.prototype._zoom = function (delta, position, stepSize) {
  var canvas = this._canvas;

  var direction = delta > 0 ? 1 : -1;

  var currentLinearZoomLevel = (0, _Math.log10)(canvas.zoom());

  // snap to a proximate zoom step
  var newLinearZoomLevel = Math.round(currentLinearZoomLevel / stepSize) * stepSize;

  // increase or decrease one zoom step in the given direction
  newLinearZoomLevel += stepSize * direction;

  // 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);

  canvas.zoom((0, _ZoomUtil.cap)(RANGE, newLogZoomLevel), position);
};

/**
 * Toggle the zoom scroll ability via mouse wheel.
 *
 * @param  {Boolean} [newEnabled] new enabled state
 */
ZoomScroll.prototype.toggle = function toggle(newEnabled) {

  var element = this._container;
  var handleWheel = this._handleWheel;

  var oldEnabled = this._enabled;

  if (typeof newEnabled === 'undefined') {
    newEnabled = !oldEnabled;
  }

  // only react on actual changes
  if (oldEnabled !== newEnabled) {

    // add or remove wheel listener based on
    // changed enabled state
    _minDom.event[newEnabled ? 'bind' : 'unbind'](element, 'wheel', handleWheel, false);
  }

  this._enabled = newEnabled;

  return newEnabled;
};

ZoomScroll.prototype._init = function (newEnabled) {
  this.toggle(newEnabled);
};

},{"../../util/Math":402,"./ZoomUtil":389,"min-dash":505,"min-dom":506}],389:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.getStepSize = getStepSize;
exports.cap = cap;

var _Math = require('../../util/Math');

/**
 * Get step size for given range and number of steps.
 *
 * @param {Object} range - Range.
 * @param {number} range.min - Range minimum.
 * @param {number} range.max - Range maximum.
 */
function getStepSize(range, steps) {

  var minLinearRange = (0, _Math.log10)(range.min),
      maxLinearRange = (0, _Math.log10)(range.max);

  var absoluteLinearRange = Math.abs(minLinearRange) + Math.abs(maxLinearRange);

  return absoluteLinearRange / steps;
}

function cap(range, scale) {
  return Math.max(range.min, Math.min(range.max, scale));
}

},{"../../util/Math":402}],390:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _ZoomScroll = require('./ZoomScroll');

var _ZoomScroll2 = _interopRequireDefault(_ZoomScroll);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  __init__: ['zoomScroll'],
  zoomScroll: ['type', _ZoomScroll2.default]
};

},{"./ZoomScroll":388}],391:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.getNewAttachPoint = getNewAttachPoint;
exports.getNewAttachShapeDelta = getNewAttachShapeDelta;

var _LayoutUtil = require('../layout/LayoutUtil');

var _PositionUtil = require('./PositionUtil');

/**
 * 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 = (0, _PositionUtil.center)(oldBounds),
      newCenter = (0, _PositionUtil.center)(newBounds),
      oldDelta = (0, _PositionUtil.delta)(point, oldCenter);

  var newDelta = {
    x: oldDelta.x * (newBounds.width / oldBounds.width),
    y: oldDelta.y * (newBounds.height / oldBounds.height)
  };

  return (0, _LayoutUtil.roundPoint)({
    x: newCenter.x + newDelta.x,
    y: newCenter.y + newDelta.y
  });
}

/**
 * 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 = (0, _PositionUtil.center)(shape),
      oldCenter = (0, _PositionUtil.center)(oldBounds),
      newCenter = (0, _PositionUtil.center)(newBounds),
      shapeDelta = (0, _PositionUtil.delta)(shape, shapeCenter),
      oldCenterDelta = (0, _PositionUtil.delta)(shapeCenter, oldCenter);

  var newCenterDelta = {
    x: oldCenterDelta.x * (newBounds.width / oldBounds.width),
    y: oldCenterDelta.y * (newBounds.height / oldBounds.height)
  };

  var newShapeCenter = {
    x: newCenter.x + newCenterDelta.x,
    y: newCenter.y + newCenterDelta.y
  };

  return (0, _LayoutUtil.roundPoint)({
    x: newShapeCenter.x + shapeDelta.x - shape.x,
    y: newShapeCenter.y + shapeDelta.y - shape.y
  });
}

},{"../layout/LayoutUtil":380,"./PositionUtil":405}],392:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.install = install;
var TRAP_PRIORITY = 5000;

/**
 * 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) {

  eventName = eventName || 'element.click';

  function trap() {
    return false;
  }

  eventBus.once(eventName, TRAP_PRIORITY, trap);

  return function () {
    eventBus.off(eventName, trap);
  };
}

},{}],393:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.remove = remove;
exports.add = add;
exports.indexOf = indexOf;
/**
 * 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) {

  if (!collection || !element) {
    return -1;
  }

  var idx = collection.indexOf(element);

  if (idx !== -1) {
    collection.splice(idx, 1);
  }

  return idx;
}

/**
 * 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) {

  if (!collection || !element) {
    return;
  }

  if (typeof idx !== 'number') {
    idx = -1;
  }

  var currentIdx = collection.indexOf(element);

  if (currentIdx !== -1) {

    if (currentIdx === idx) {
      // nothing to do, position has not changed
      return;
    } else {

      if (idx !== -1) {
        // remove from current position
        collection.splice(currentIdx, 1);
      } else {
        // already exists in collection
        return;
      }
    }
  }

  if (idx !== -1) {
    // insert at specified position
    collection.splice(idx, 0, element);
  } else {
    // push to end
    collection.push(element);
  }
}

/**
 * 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) {

  if (!collection || !element) {
    return -1;
  }

  return collection.indexOf(element);
}

},{}],394:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.getTopLevel = getTopLevel;

var _minDash = require('min-dash');

function getTopLevel(elements) {
  var topLevel = {},
      parents = [],
      result = [],
      clearedParents = [];

  (0, _minDash.forEach)(elements, function (element) {
    var parent = element.parent;

    if (!topLevel[parent.id]) {
      topLevel[parent.id] = [];
    }

    if (parents.indexOf(parent.id) === -1) {
      parents.push(parent.id);
    }

    topLevel[parent.id].push(element);
  });

  (0, _minDash.forEach)(parents, function (parent) {
    (0, _minDash.forEach)(topLevel[parent], function (element) {
      if (topLevel[element.id]) {
        clearedParents.push(element.id);
      }
    });
  });

  (0, _minDash.forEach)(parents, function (parent) {
    var idx = clearedParents.indexOf(parent);

    if (idx === -1) {
      result = result.concat(topLevel[parent]);
    }
  });

  return result;
}

},{"min-dash":505}],395:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.set = set;
exports.unset = unset;
exports.has = has;

var _minDom = require('min-dom');

var CURSOR_CLS_PATTERN = /^djs-cursor-.*$/;

function set(mode) {
  var classes = (0, _minDom.classes)(document.body);

  classes.removeMatching(CURSOR_CLS_PATTERN);

  if (mode) {
    classes.add('djs-cursor-' + mode);
  }
}

function unset() {
  set(null);
}

function has(mode) {
  var classes = (0, _minDom.classes)(document.body);

  return classes.has('djs-cursor-' + mode);
}

},{"min-dom":506}],396:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.add = add;
exports.eachElement = eachElement;
exports.selfAndChildren = selfAndChildren;
exports.selfAndDirectChildren = selfAndDirectChildren;
exports.selfAndAllChildren = selfAndAllChildren;
exports.getClosure = getClosure;
exports.getBBox = getBBox;
exports.getEnclosedElements = getEnclosedElements;
exports.getType = getType;

var _minDash = require('min-dash');

/**
 * 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(elements, e, unique) {
  var canAdd = !unique || elements.indexOf(e) === -1;

  if (canAdd) {
    elements.push(e);
  }

  return canAdd;
}

/**
 * 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) {

  depth = depth || 0;

  if (!(0, _minDash.isArray)(elements)) {
    elements = [elements];
  }

  (0, _minDash.forEach)(elements, function (s, i) {
    var filter = fn(s, i, depth);

    if ((0, _minDash.isArray)(filter) && filter.length) {
      eachElement(filter, fn, depth + 1);
    }
  });
}

/**
 * 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 = [];

  eachElement(elements, function (element, i, depth) {
    add(result, element, unique);

    var children = element.children;

    // max traversal depth not reached yet
    if (maxDepth === -1 || depth < maxDepth) {

      // children exist && children not yet processed
      if (children && add(processedChildren, children, unique)) {
        return children;
      }
    }
  });

  return result;
}

/**
 * Return self + direct 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 selfAndDirectChildren(elements, allowDuplicates) {
  return selfAndChildren(elements, !allowDuplicates, 1);
}

/**
 * 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);
}

/**
 * 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) {

  if ((0, _minDash.isUndefined)(isTopLevel)) {
    isTopLevel = true;
  }

  if ((0, _minDash.isObject)(isTopLevel)) {
    closure = isTopLevel;
    isTopLevel = true;
  }

  closure = closure || {};

  var allShapes = copyObject(closure.allShapes),
      allConnections = copyObject(closure.allConnections),
      enclosedElements = copyObject(closure.enclosedElements),
      enclosedConnections = copyObject(closure.enclosedConnections);

  var topLevel = copyObject(closure.topLevel, isTopLevel && (0, _minDash.groupBy)(elements, function (e) {
    return e.id;
  }));

  function handleConnection(c) {
    if (topLevel[c.source.id] && topLevel[c.target.id]) {
      topLevel[c.id] = [c];
    }

    // 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;
    }

    allConnections[c.id] = c;
  }

  function handleElement(element) {

    enclosedElements[element.id] = element;

    if (element.waypoints) {
      // remember connection
      enclosedConnections[element.id] = allConnections[element.id] = element;
    } else {
      // remember shape
      allShapes[element.id] = element;

      // remember all connections
      (0, _minDash.forEach)(element.incoming, handleConnection);

      (0, _minDash.forEach)(element.outgoing, handleConnection);

      // recurse into children
      return element.children;
    }
  }

  eachElement(elements, handleElement);

  return {
    allShapes: allShapes,
    allConnections: allConnections,
    topLevel: topLevel,
    enclosedConnections: enclosedConnections,
    enclosedElements: enclosedElements
  };
}

/**
 * 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) {

  stopRecursion = !!stopRecursion;
  if (!(0, _minDash.isArray)(elements)) {
    elements = [elements];
  }

  var minX, minY, maxX, maxY;

  (0, _minDash.forEach)(elements, function (element) {

    // If element is a connection the bbox must be computed first
    var bbox = element;
    if (element.waypoints && !stopRecursion) {
      bbox = getBBox(element.waypoints, true);
    }

    var x = bbox.x,
        y = bbox.y,
        height = bbox.height || 0,
        width = bbox.width || 0;

    if (x < minX || minX === undefined) {
      minX = x;
    }
    if (y < minY || minY === undefined) {
      minY = y;
    }

    if (x + width > maxX || maxX === undefined) {
      maxX = x + width;
    }
    if (y + height > maxY || maxY === undefined) {
      maxY = y + height;
    }
  });

  return {
    x: minX,
    y: minY,
    height: maxY - minY,
    width: maxX - minX
  };
}

/**
 * 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) {

  var filteredElements = {};

  (0, _minDash.forEach)(elements, function (element) {

    var e = element;

    if (e.waypoints) {
      e = getBBox(e);
    }

    if (!(0, _minDash.isNumber)(bbox.y) && e.x > bbox.x) {
      filteredElements[element.id] = element;
    }
    if (!(0, _minDash.isNumber)(bbox.x) && e.y > bbox.y) {
      filteredElements[element.id] = element;
    }
    if (e.x > bbox.x && e.y > bbox.y) {
      if ((0, _minDash.isNumber)(bbox.width) && (0, _minDash.isNumber)(bbox.height) && e.width + e.x < bbox.width + bbox.x && e.height + e.y < bbox.height + bbox.y) {

        filteredElements[element.id] = element;
      } else if (!(0, _minDash.isNumber)(bbox.width) || !(0, _minDash.isNumber)(bbox.height)) {
        filteredElements[element.id] = element;
      }
    }
  });

  return filteredElements;
}

function getType(element) {

  if ('waypoints' in element) {
    return 'connection';
  }

  if ('x' in element) {
    return 'shape';
  }

  return 'root';
}

// helpers ///////////////////////////////

function copyObject(src1, src2) {
  return (0, _minDash.assign)({}, src1 || {}, src2 || {});
}

},{"min-dash":505}],397:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.getOriginal = getOriginal;
exports.stopPropagation = stopPropagation;
exports.toPoint = toPoint;
function __stopPropagation(event) {
  if (!event || typeof event.stopPropagation !== 'function') {
    return;
  }

  event.stopPropagation();
}

function getOriginal(event) {
  return event.originalEvent || event.srcEvent;
}

function stopPropagation(event, immediate) {
  __stopPropagation(event, immediate);
  __stopPropagation(getOriginal(event), immediate);
}

function toPoint(event) {

  if (event.pointers && event.pointers.length) {
    event = event.pointers[0];
  }

  if (event.touches && event.touches.length) {
    event = event.touches[0];
  }

  return event ? {
    x: event.clientX,
    y: event.clientY
  } : null;
}

},{}],398:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.pointDistance = pointDistance;
exports.pointsOnLine = pointsOnLine;
exports.pointsAligned = pointsAligned;
exports.pointInRect = pointInRect;
exports.getMidPoint = getMidPoint;
/**
 * Computes the distance between two points
 *
 * @param  {Point}  p
 * @param  {Point}  q
 *
 * @return {Number}  distance
 */
function pointDistance(a, b) {
  if (!a || !b) {
    return -1;
  }

  return Math.sqrt(Math.pow(a.x - b.x, 2) + Math.pow(a.y - b.y, 2));
}

/**
 * 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) {

  if (typeof accuracy === 'undefined') {
    accuracy = 5;
  }

  if (!p || !q || !r) {
    return false;
  }

  var val = (q.x - p.x) * (r.y - p.y) - (q.y - p.y) * (r.x - p.x),
      dist = pointDistance(p, q);

  // @see http://stackoverflow.com/a/907491/412190
  return Math.abs(val / dist) <= accuracy;
}

var ALIGNED_THRESHOLD = 2;

/**
 * Returns whether two points are in a horizontal or vertical line.
 *
 * @param {Point} a
 * @param {Point} b
 *
 * @return {String|Boolean} returns false if the points are not
 *                          aligned or 'h|v' if they are aligned
 *                          horizontally / vertically.
 */
function pointsAligned(a, b) {
  if (Math.abs(a.x - b.x) <= ALIGNED_THRESHOLD) {
    return 'h';
  }

  if (Math.abs(a.y - b.y) <= ALIGNED_THRESHOLD) {
    return 'v';
  }

  return false;
}

/**
 * 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;

  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;
}

/**
 * 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)
  };
}

},{}],399:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.getVisual = getVisual;
exports.getChildren = getChildren;

var _minDom = require('min-dom');

/**
 * SVGs for elements are generated by the {@link GraphicsFactory}.
 *
 * This utility gives quick access to the important semantic
 * parts of an element.
 */

/**
 * Returns the visual part of a diagram element
 *
 * @param {Snap<SVGElement>} gfx
 *
 * @return {Snap<SVGElement>}
 */
function getVisual(gfx) {
  return (0, _minDom.query)('.djs-visual', gfx);
}

/**
 * Returns the children for a given diagram element.
 *
 * @param {Snap<SVGElement>} gfx
 * @return {Snap<SVGElement>}
 */
function getChildren(gfx) {
  return gfx.parentNode.childNodes[1];
}

},{"min-dom":506}],400:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = IdGenerator;
/**
 * 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) {

  this._counter = 0;
  this._prefix = (prefix ? prefix + '-' : '') + Math.floor(Math.random() * 1000000000) + '-';
}

/**
 * Returns a next unique ID.
 *
 * @method djs.util.IdGenerator#next
 *
 * @returns {String} the id
 */
IdGenerator.prototype.next = function () {
  return this._prefix + ++this._counter;
};

},{}],401:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.getApproxIntersection = getApproxIntersection;

var _Geometry = require('./Geometry');

var _pathIntersection = require('path-intersection');

var _pathIntersection2 = _interopRequireDefault(_pathIntersection);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var round = Math.round,
    max = Math.max;

function circlePath(center, r) {
  var x = center.x,
      y = center.y;

  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']];
}

function linePath(points) {
  var segments = [];

  points.forEach(function (p, idx) {
    segments.push([idx === 0 ? 'M' : 'L', p.x, p.y]);
  });

  return segments;
}

var INTERSECTION_THRESHOLD = 10;

function getBendpointIntersection(waypoints, reference) {

  var i, w;

  for (i = 0; w = waypoints[i]; i++) {

    if ((0, _Geometry.pointDistance)(w, reference) <= INTERSECTION_THRESHOLD) {
      return {
        point: waypoints[i],
        bendpoint: true,
        index: i
      };
    }
  }

  return null;
}

function getPathIntersection(waypoints, reference) {

  var intersections = (0, _pathIntersection2.default)(circlePath(reference, INTERSECTION_THRESHOLD), linePath(waypoints));

  var a = intersections[0],
      b = intersections[intersections.length - 1],
      idx;

  if (!a) {
    // no intersection
    return null;
  }

  if (a !== b) {

    if (a.segment2 !== b.segment2) {
      // we use the bendpoint in between both segments
      // as the intersection point

      idx = max(a.segment2, b.segment2) - 1;

      return {
        point: waypoints[idx],
        bendpoint: true,
        index: idx
      };
    }

    return {
      point: {
        x: round(a.x + b.x) / 2,
        y: round(a.y + b.y) / 2
      },
      index: a.segment2
    };
  }

  return {
    point: {
      x: round(a.x),
      y: round(a.y)
    },
    index: a.segment2
  };
}

/**
 * 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);
}

},{"./Geometry":398,"path-intersection":523}],402:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.log10 = log10;

var _PositionUtil = require('./PositionUtil');

Object.defineProperty(exports, 'substract', {
  enumerable: true,
  get: function get() {
    return _PositionUtil.delta;
  }
});
/**
 * Get the logarithm of x with base 10
 * @param  {Integer} value
 */
function log10(x) {
  return Math.log(x) / Math.log(10);
}

},{"./PositionUtil":405}],403:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.isMac = undefined;

var _Platform = require('./Platform');

Object.defineProperty(exports, 'isMac', {
  enumerable: true,
  get: function get() {
    return _Platform.isMac;
  }
});
exports.isPrimaryButton = isPrimaryButton;
exports.hasPrimaryModifier = hasPrimaryModifier;
exports.hasSecondaryModifier = hasSecondaryModifier;

var _Event = require('./Event');

function isPrimaryButton(event) {
  // button === 0 -> left áka primary mouse button
  return !((0, _Event.getOriginal)(event) || event).button;
}

function hasPrimaryModifier(event) {
  var originalEvent = (0, _Event.getOriginal)(event) || event;

  if (!isPrimaryButton(event)) {
    return false;
  }

  // Use alt as primary modifier key for mac OS
  if ((0, _Platform.isMac)()) {
    return originalEvent.metaKey;
  } else {
    return originalEvent.ctrlKey;
  }
}

function hasSecondaryModifier(event) {
  var originalEvent = (0, _Event.getOriginal)(event) || event;

  return isPrimaryButton(event) && originalEvent.shiftKey;
}

},{"./Event":397,"./Platform":404}],404:[function(require,module,exports){
"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.isMac = isMac;
function isMac() {
  return (/mac/i.test(navigator.platform)
  );
}

},{}],405:[function(require,module,exports){
"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.center = center;
exports.delta = delta;
function center(bounds) {
  return {
    x: bounds.x + bounds.width / 2,
    y: bounds.y + bounds.height / 2
  };
}

function delta(a, b) {
  return {
    x: a.x - b.x,
    y: a.y - b.y
  };
}

},{}],406:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.saveClear = saveClear;
/**
 * 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) {

  if (typeof removeFn !== 'function') {
    throw new Error('removeFn iterator must be a function');
  }

  if (!collection) {
    return;
  }

  var e;

  while (e = collection[0]) {
    removeFn(e);
  }

  return collection;
}

},{}],407:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.componentsToPath = componentsToPath;
exports.toSVGPoints = toSVGPoints;
exports.createLine = createLine;
exports.updateLine = updateLine;

var _tinySvg = require('tiny-svg');

function componentsToPath(elements) {
  return elements.join(',').replace(/,?([A-z]),?/g, '$1');
}

function toSVGPoints(points) {
  var result = '';

  for (var i = 0, p; p = points[i]; i++) {
    result += p.x + ',' + p.y + ' ';
  }

  return result;
}

function createLine(points, attrs) {

  var line = (0, _tinySvg.create)('polyline');
  (0, _tinySvg.attr)(line, { points: toSVGPoints(points) });

  if (attrs) {
    (0, _tinySvg.attr)(line, attrs);
  }

  return line;
}

function updateLine(gfx, points) {
  (0, _tinySvg.attr)(gfx, { points: toSVGPoints(points) });

  return gfx;
}

},{"tiny-svg":535}],408:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.transform = transform;
exports.translate = translate;
exports.rotate = rotate;
exports.scale = scale;

var _tinySvg = require('tiny-svg');

/**
 * @param {<SVGElement>} element
 * @param {Number} x
 * @param {Number} y
 * @param {Number} angle
 * @param {Number} amount
 */
function transform(gfx, x, y, angle, amount) {
  var translate = (0, _tinySvg.createTransform)();
  translate.setTranslate(x, y);

  var rotate = (0, _tinySvg.createTransform)();
  rotate.setRotate(angle, 0, 0);

  var scale = (0, _tinySvg.createTransform)();
  scale.setScale(amount || 1, amount || 1);

  (0, _tinySvg.transform)(gfx, [translate, rotate, scale]);
}

/**
 * @param {SVGElement} element
 * @param {Number} x
 * @param {Number} y
 */
function translate(gfx, x, y) {
  var translate = (0, _tinySvg.createTransform)();
  translate.setTranslate(x, y);

  (0, _tinySvg.transform)(gfx, translate);
}

/**
 * @param {SVGElement} element
 * @param {Number} angle
 */
function rotate(gfx, angle) {
  var rotate = (0, _tinySvg.createTransform)();
  rotate.setRotate(angle, 0, 0);

  (0, _tinySvg.transform)(gfx, rotate);
}

/**
 * @param {SVGElement} element
 * @param {Number} amount
 */
function scale(gfx, amount) {
  var scale = (0, _tinySvg.createTransform)();
  scale.setScale(amount, amount);

  (0, _tinySvg.transform)(gfx, scale);
}

},{"tiny-svg":535}],409:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = Text;

var _minDash = require('min-dash');

var _tinySvg = require('tiny-svg');

var DEFAULT_BOX_PADDING = 0;

var DEFAULT_LABEL_SIZE = {
  width: 150,
  height: 50
};

function parseAlign(align) {

  var parts = align.split('-');

  return {
    horizontal: parts[0] || 'center',
    vertical: parts[1] || 'top'
  };
}

function parsePadding(padding) {

  if ((0, _minDash.isObject)(padding)) {
    return (0, _minDash.assign)({ top: 0, left: 0, right: 0, bottom: 0 }, padding);
  } else {
    return {
      top: padding,
      left: padding,
      right: padding,
      bottom: padding
    };
  }
}

function getTextBBox(text, fakeText) {

  fakeText.textContent = text;

  var textBBox;

  try {
    var bbox,
        emptyLine = text === '';

    // add dummy text, when line is empty to
    // determine correct height
    fakeText.textContent = emptyLine ? 'dummy' : text;

    textBBox = fakeText.getBBox();

    // take text rendering related horizontal
    // padding into account
    bbox = {
      width: textBBox.width + textBBox.x * 2,
      height: textBBox.height
    };

    if (emptyLine) {
      // correct width
      bbox.width = 0;
    }

    return bbox;
  } catch (e) {
    return { width: 0, height: 0 };
  }
}

/**
 * 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) {

  var originalLine = lines.shift(),
      fitLine = originalLine;

  var textBBox;

  for (;;) {
    textBBox = getTextBBox(fitLine, fakeText);

    textBBox.width = fitLine ? textBBox.width : 0;

    // try to fit
    if (fitLine === ' ' || fitLine === '' || textBBox.width < Math.round(maxWidth) || fitLine.length < 2) {
      return fit(lines, fitLine, originalLine, textBBox);
    }

    fitLine = shortenLine(fitLine, textBBox.width, maxWidth);
  }
}

function fit(lines, fitLine, originalLine, textBBox) {
  if (fitLine.length < originalLine.length) {
    var remainder = originalLine.slice(fitLine.length).trim();

    lines.unshift(remainder);
  }

  return {
    width: textBBox.width,
    height: textBBox.height,
    text: fitLine
  };
}

/**
 * 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) {
  var parts = line.split(/(\s|-)/g),
      part,
      shortenedParts = [],
      length = 0;

  // try to shorten via spaces + hyphens
  if (parts.length > 1) {
    while (part = parts.shift()) {
      if (part.length + length < maxLength) {
        shortenedParts.push(part);
        length += part.length;
      } else {
        // remove previous part, too if hyphen does not fit anymore
        if (part === '-') {
          shortenedParts.pop();
        }

        break;
      }
    }
  }

  return shortenedParts.join('');
}

function shortenLine(line, width, maxWidth) {
  var length = Math.max(line.length * (maxWidth / width), 1);

  // try to shorten semantically (i.e. based on spaces and hyphens)
  var shortenedLine = semanticShorten(line, length);

  if (!shortenedLine) {

    // force shorten by cutting the long word
    shortenedLine = line.slice(0, Math.max(Math.round(length - 1), 1));
  }

  return shortenedLine;
}

function getHelperSvg() {
  var helperSvg = document.getElementById('helper-svg');

  if (!helperSvg) {
    helperSvg = (0, _tinySvg.create)('svg');

    (0, _tinySvg.attr)(helperSvg, {
      id: 'helper-svg',
      width: 0,
      height: 0,
      style: 'visibility: hidden; position: fixed'
    });

    document.body.appendChild(helperSvg);
  }

  return helperSvg;
}

/**
 * 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) {

  this._config = (0, _minDash.assign)({}, {
    size: DEFAULT_LABEL_SIZE,
    padding: DEFAULT_BOX_PADDING,
    style: {},
    align: 'center-top'
  }, config || {});
}

/**
 * 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;
};

/**
 * 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;
};

/**
 * 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 = (0, _minDash.assign)({}, this._config.size, options.box),
      style = (0, _minDash.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;

  var lineHeight = getLineHeight(style);

  var lines = text.split(/\r?\n/g),
      layouted = [];

  var maxWidth = box.width - padding.left - padding.right;

  // ensure correct rendering by attaching helper text node to invisible SVG
  var helperText = (0, _tinySvg.create)('text');
  (0, _tinySvg.attr)(helperText, { x: 0, y: 0 });
  (0, _tinySvg.attr)(helperText, style);

  var helperSvg = getHelperSvg();

  (0, _tinySvg.append)(helperSvg, helperText);

  while (lines.length) {
    layouted.push(layoutNext(lines, maxWidth, helperText));
  }

  if (align.vertical === 'middle') {
    padding.top = padding.bottom = 0;
  }

  var totalHeight = (0, _minDash.reduce)(layouted, function (sum, line, idx) {
    return sum + (lineHeight || line.height);
  }, 0) + padding.top + padding.bottom;

  var maxLineWidth = (0, _minDash.reduce)(layouted, function (sum, line, idx) {
    return line.width > sum ? line.width : sum;
  }, 0);

  // the y position of the next line
  var y = padding.top;

  if (align.vertical === 'middle') {
    y += (box.height - totalHeight) / 2;
  }

  // magic number initial offset
  y -= (lineHeight || layouted[0].height) / 4;

  var textElement = (0, _tinySvg.create)('text');

  (0, _tinySvg.attr)(textElement, style);

  // layout each line taking into account that parent
  // shape might resize to fit text size
  (0, _minDash.forEach)(layouted, function (line) {

    var x;

    y += lineHeight || line.height;

    switch (align.horizontal) {
      case 'left':
        x = padding.left;
        break;

      case 'right':
        x = (fitBox ? maxLineWidth : maxWidth) - padding.right - line.width;
        break;

      default:
        // aka center
        x = Math.max(((fitBox ? maxLineWidth : maxWidth) - line.width) / 2 + padding.left, 0);
    }

    var tspan = (0, _tinySvg.create)('tspan');
    (0, _tinySvg.attr)(tspan, { x: x, y: y });

    tspan.textContent = line.text;

    (0, _tinySvg.append)(textElement, tspan);
  });

  (0, _tinySvg.remove)(helperText);

  var dimensions = {
    width: maxLineWidth,
    height: totalHeight
  };

  return {
    dimensions: dimensions,
    element: textElement
  };
};

function getLineHeight(style) {
  if ('fontSize' in style && 'lineHeight' in style) {
    return style.lineHeight * parseInt(style.fontSize, 10);
  }
}

},{"min-dash":505,"tiny-svg":535}],410:[function(require,module,exports){
'use strict';

var _typeof2 = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

Object.defineProperty(exports, '__esModule', { value: true });

var CLASS_PATTERN = /^class /;

function isClass(fn) {
  return CLASS_PATTERN.test(fn.toString());
}

function isArray(obj) {
  return Object.prototype.toString.call(obj) === '[object Array]';
}

function annotate() {
  var args = Array.prototype.slice.call(arguments);

  if (args.length === 1 && isArray(args[0])) {
    args = args[0];
  }

  var fn = args.pop();

  fn.$inject = args;

  return fn;
}

// 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.

var CONSTRUCTOR_ARGS = /constructor\s*[^(]*\(\s*([^)]*)\)/m;
var FN_ARGS = /^function\s*[^(]*\(\s*([^)]*)\)/m;
var FN_ARG = /\/\*([^*]*)\*\//m;

function parse(fn) {

  if (typeof fn !== 'function') {
    throw new Error('Cannot annotate "' + fn + '". Expected a function!');
  }

  var match = fn.toString().match(isClass(fn) ? CONSTRUCTOR_ARGS : FN_ARGS);

  // may parse class without constructor
  if (!match) {
    return [];
  }

  return match[1] && match[1].split(',').map(function (arg) {
    match = arg.match(FN_ARG);
    return match ? match[1].trim() : arg.trim();
  }) || [];
}

function Module() {
  var providers = [];

  this.factory = function (name, factory) {
    providers.push([name, 'factory', factory]);
    return this;
  };

  this.value = function (name, value) {
    providers.push([name, 'value', value]);
    return this;
  };

  this.type = function (name, type) {
    providers.push([name, 'type', type]);
    return this;
  };

  this.forEach = function (iterator) {
    providers.forEach(iterator);
  };
}

var _typeof = typeof Symbol === "function" && _typeof2(Symbol.iterator) === "symbol" ? function (obj) {
  return typeof obj === 'undefined' ? 'undefined' : _typeof2(obj);
} : function (obj) {
  return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj === 'undefined' ? 'undefined' : _typeof2(obj);
};

function _toConsumableArray(arr) {
  if (Array.isArray(arr)) {
    for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) {
      arr2[i] = arr[i];
    }return arr2;
  } else {
    return Array.from(arr);
  }
}

function Injector(modules, parent) {
  parent = parent || {
    get: function get(name, strict) {
      currentlyResolving.push(name);

      if (strict === false) {
        return null;
      } else {
        throw error('No provider for "' + name + '"!');
      }
    }
  };

  var currentlyResolving = [];
  var providers = this._providers = Object.create(parent._providers || null);
  var instances = this._instances = Object.create(null);

  var self = instances.injector = this;

  var error = function error(msg) {
    var stack = currentlyResolving.join(' -> ');
    currentlyResolving.length = 0;
    return new Error(stack ? msg + ' (Resolving: ' + stack + ')' : msg);
  };

  /**
   * Return a named service.
   *
   * @param {String} name
   * @param {Boolean} [strict=true] if false, resolve missing services to null
   *
   * @return {Object}
   */
  var get = function get(name, strict) {
    if (!providers[name] && name.indexOf('.') !== -1) {
      var parts = name.split('.');
      var pivot = get(parts.shift());

      while (parts.length) {
        pivot = pivot[parts.shift()];
      }

      return pivot;
    }

    if (hasProp(instances, name)) {
      return instances[name];
    }

    if (hasProp(providers, name)) {
      if (currentlyResolving.indexOf(name) !== -1) {
        currentlyResolving.push(name);
        throw error('Cannot resolve circular dependency!');
      }

      currentlyResolving.push(name);
      instances[name] = providers[name][0](providers[name][1]);
      currentlyResolving.pop();

      return instances[name];
    }

    return parent.get(name, strict);
  };

  var fnDef = function fnDef(fn) {
    var locals = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

    if (typeof fn !== 'function') {
      if (isArray(fn)) {
        fn = annotate(fn.slice());
      } else {
        throw new Error('Cannot invoke "' + fn + '". Expected a function!');
      }
    }

    var inject = fn.$inject || parse(fn);
    var dependencies = inject.map(function (dep) {
      if (hasProp(locals, dep)) {
        return locals[dep];
      } else {
        return get(dep);
      }
    });

    return {
      fn: fn,
      dependencies: dependencies
    };
  };

  var instantiate = function instantiate(Type) {
    var _fnDef = fnDef(Type),
        dependencies = _fnDef.dependencies,
        fn = _fnDef.fn;

    return new (Function.prototype.bind.apply(fn, [null].concat(_toConsumableArray(dependencies))))();
  };

  var invoke = function invoke(func, context, locals) {
    var _fnDef2 = fnDef(func, locals),
        dependencies = _fnDef2.dependencies,
        fn = _fnDef2.fn;

    return fn.call.apply(fn, [context].concat(_toConsumableArray(dependencies)));
  };

  var createPrivateInjectorFactory = function createPrivateInjectorFactory(privateChildInjector) {
    return annotate(function (key) {
      return privateChildInjector.get(key);
    });
  };

  var createChild = function createChild(modules, forceNewInstances) {
    if (forceNewInstances && forceNewInstances.length) {
      var fromParentModule = Object.create(null);
      var matchedScopes = Object.create(null);

      var privateInjectorsCache = [];
      var privateChildInjectors = [];
      var privateChildFactories = [];

      var provider;
      var cacheIdx;
      var privateChildInjector;
      var privateChildInjectorFactory;
      for (var name in providers) {
        provider = providers[name];

        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;
        }

        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;
            }
          });
        }
      }

      forceNewInstances.forEach(function (scope) {
        if (!matchedScopes[scope]) {
          throw new Error('No provider for "' + scope + '". Cannot use provider from the parent!');
        }
      });

      modules.unshift(fromParentModule);
    }

    return new Injector(modules, self);
  };

  var factoryMap = {
    factory: invoke,
    type: instantiate,
    value: function value(_value) {
      return _value;
    }
  };

  modules.forEach(function (module) {

    function arrayUnwrap(type, value) {
      if (type !== 'value' && isArray(value)) {
        value = annotate(value.slice());
      }

      return value;
    }

    // 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];

        providers[name] = [factoryMap[type], arrayUnwrap(type, value), type];
      });
    } else if ((typeof module === 'undefined' ? 'undefined' : _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));

        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;
          }

          var type = module[name][0];
          var value = module[name][1];

          providers[name] = [factoryMap[type], arrayUnwrap(type, value), type];
        });
      }
    }
  });

  // public API
  this.get = get;
  this.invoke = invoke;
  this.instantiate = instantiate;
  this.createChild = createChild;
}

// helpers /////////////////

function hasProp(obj, prop) {
  return Object.hasOwnProperty.call(obj, prop);
}

exports.annotate = annotate;
exports.Module = Module;
exports.Injector = Injector;

},{}],411:[function(require,module,exports){
'use strict';

/**
 * Expose `parse`.
 */

module.exports = parse;

/**
 * Tests for browser support.
 */

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;
}

/**
 * Wrap map from jquery.
 */

var map = {
  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, '', '']
};

map.td = map.th = [3, '<table><tbody><tr>', '</tr></tbody></table>'];

map.option = map.optgroup = [1, '<select multiple="multiple">', '</select>'];

map.thead = map.tbody = map.colgroup = map.caption = map.tfoot = [1, '<table>', '</table>'];

map.polyline = map.ellipse = map.polygon = map.circle = map.text = map.line = map.path = map.rect = map.g = [1, '<svg xmlns="http://www.w3.org/2000/svg" version="1.1">', '</svg>'];

/**
 * 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
 */

function parse(html, doc) {
  if ('string' != typeof html) throw new TypeError('String expected');

  // default to the global `document` object
  if (!doc) doc = document;

  // tag name
  var m = /<([\w:]+)/.exec(html);
  if (!m) return doc.createTextNode(html);

  html = html.replace(/^\s+|\s+$/g, ''); // Remove leading/trailing whitespace

  var tag = m[1];

  // body support
  if (tag == 'body') {
    var el = doc.createElement('html');
    el.innerHTML = html;
    return el.removeChild(el.lastChild);
  }

  // wrap map
  var wrap = map[tag] || map._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;
  } // one element
  if (el.firstChild == el.lastChild) {
    return el.removeChild(el.firstChild);
  }

  // several elements
  var fragment = doc.createDocumentFragment();
  while (el.firstChild) {
    fragment.appendChild(el.removeChild(el.firstChild));
  }

  return fragment;
}

},{}],412:[function(require,module,exports){
'use strict';

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

/*! Hammer.JS - v2.0.7 - 2016-04-22
 * http://hammerjs.github.io/
 *
 * Copyright (c) 2016 Jorik Tangelder;
 * Licensed under the MIT license */
(function (window, document, exportName, undefined) {
    'use strict';

    var VENDOR_PREFIXES = ['', 'webkit', 'Moz', 'MS', 'ms', 'o'];
    var TEST_ELEMENT = document.createElement('div');

    var TYPE_FUNCTION = 'function';

    var round = Math.round;
    var abs = Math.abs;
    var now = Date.now;

    /**
     * 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);
    }

    /**
     * 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;
    }

    /**
     * walk objects and arrays
     * @param {Object} obj
     * @param {Function} iterator
     * @param {Object} context
     */
    function each(obj, iterator, context) {
        var i;

        if (!obj) {
            return;
        }

        if (obj.forEach) {
            obj.forEach(iterator, context);
        } else if (obj.length !== undefined) {
            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);
            }
        }
    }

    /**
     * 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';

            var log = window.console && (window.console.warn || window.console.log);
            if (log) {
                log.call(window.console, deprecationMessage, stack);
            }
            return method.apply(this, arguments);
        };
    }

    /**
     * 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 || target === null) {
                throw new TypeError('Cannot convert undefined or null to object');
            }

            var output = Object(target);
            for (var index = 1; index < arguments.length; index++) {
                var source = arguments[index];
                if (source !== undefined && source !== null) {
                    for (var nextKey in source) {
                        if (source.hasOwnProperty(nextKey)) {
                            output[nextKey] = source[nextKey];
                        }
                    }
                }
            }
            return output;
        };
    } else {
        assign = Object.assign;
    }

    /**
     * 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) {
                dest[keys[i]] = src[keys[i]];
            }
            i++;
        }
        return dest;
    }, 'extend', 'Use `assign`.');

    /**
     * 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`.');

    /**
     * simple class inheritance
     * @param {Function} child
     * @param {Function} base
     * @param {Object} [properties]
     */
    function inherit(child, base, properties) {
        var baseP = base.prototype,
            childP;

        childP = child.prototype = Object.create(baseP);
        childP.constructor = child;
        childP._super = baseP;

        if (properties) {
            assign(childP, properties);
        }
    }

    /**
     * simple function bind
     * @param {Function} fn
     * @param {Object} context
     * @returns {Function}
     */
    function bindFn(fn, context) {
        return function boundFn() {
            return fn.apply(context, arguments);
        };
    }

    /**
     * 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 === 'undefined' ? 'undefined' : _typeof(val)) == TYPE_FUNCTION) {
            return val.apply(args ? args[0] || undefined : undefined, args);
        }
        return val;
    }

    /**
     * use the val2 when val1 is undefined
     * @param {*} val1
     * @param {*} val2
     * @returns {*}
     */
    function ifUndefined(val1, val2) {
        return val1 === undefined ? val2 : val1;
    }

    /**
     * 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);
        });
    }

    /**
     * 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);
        });
    }

    /**
     * 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;
    }

    /**
     * small indexOf wrapper
     * @param {String} str
     * @param {String} find
     * @returns {Boolean} found
     */
    function inStr(str, find) {
        return str.indexOf(find) > -1;
    }

    /**
     * split string on whitespace
     * @param {String} str
     * @returns {Array} words
     */
    function splitStr(str) {
        return str.trim().split(/\s+/g);
    }

    /**
     * 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;
        }
    }

    /**
     * convert array-like objects to real arrays
     * @param {Object} obj
     * @returns {Array}
     */
    function toArray(obj) {
        return Array.prototype.slice.call(obj, 0);
    }

    /**
     * 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;

        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++;
        }

        if (sort) {
            if (!key) {
                results = results.sort();
            } else {
                results = results.sort(function sortUniqueArray(a, b) {
                    return a[key] > b[key];
                });
            }
        }

        return results;
    }

    /**
     * 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);

        var i = 0;
        while (i < VENDOR_PREFIXES.length) {
            prefix = VENDOR_PREFIXES[i];
            prop = prefix ? prefix + camelProp : property;

            if (prop in obj) {
                return prop;
            }
            i++;
        }
        return undefined;
    }

    /**
     * get a unique id
     * @returns {number} uniqueId
     */
    var _uniqueId = 1;
    function uniqueId() {
        return _uniqueId++;
    }

    /**
     * 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;
    }

    var MOBILE_REGEX = /mobile|tablet|ip(ad|hone|od)|android/i;

    var SUPPORT_TOUCH = 'ontouchstart' in window;
    var SUPPORT_POINTER_EVENTS = prefixed(window, 'PointerEvent') !== undefined;
    var SUPPORT_ONLY_TOUCH = SUPPORT_TOUCH && MOBILE_REGEX.test(navigator.userAgent);

    var INPUT_TYPE_TOUCH = 'touch';
    var INPUT_TYPE_PEN = 'pen';
    var INPUT_TYPE_MOUSE = 'mouse';
    var INPUT_TYPE_KINECT = 'kinect';

    var COMPUTE_INTERVAL = 25;

    var INPUT_START = 1;
    var INPUT_MOVE = 2;
    var INPUT_END = 4;
    var INPUT_CANCEL = 8;

    var DIRECTION_NONE = 1;
    var DIRECTION_LEFT = 2;
    var DIRECTION_RIGHT = 4;
    var DIRECTION_UP = 8;
    var DIRECTION_DOWN = 16;

    var DIRECTION_HORIZONTAL = DIRECTION_LEFT | DIRECTION_RIGHT;
    var DIRECTION_VERTICAL = DIRECTION_UP | DIRECTION_DOWN;
    var DIRECTION_ALL = DIRECTION_HORIZONTAL | DIRECTION_VERTICAL;

    var PROPS_XY = ['x', 'y'];
    var PROPS_CLIENT_XY = ['clientX', 'clientY'];

    /**
     * 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;

        // 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);
            }
        };

        this.init();
    }

    Input.prototype = {
        /**
         * should handle the inputEvent data and trigger the callback
         * @virtual
         */
        handler: function handler() {},

        /**
         * bind the events
         */
        init: function init() {
            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);
        },

        /**
         * unbind the events
         */
        destroy: function destroy() {
            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);
        }
    };

    /**
     * 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;

        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);
    }

    /**
     * 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;

        input.isFirst = !!isFirst;
        input.isFinal = !!isFinal;

        if (isFirst) {
            manager.session = {};
        }

        // source event is the normalized value of the domEvents
        // like 'touchstart, mouseup, pointerdown'
        input.eventType = eventType;

        // compute scale, rotation etc
        computeInputData(manager, input);

        // emit secret event
        manager.emit('hammer.input', input);

        manager.recognize(input);
        manager.session.prevInput = input;
    }

    /**
     * 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;

        // store the first input to calculate the distance and direction
        if (!session.firstInput) {
            session.firstInput = simpleCloneInputData(input);
        }

        // 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;
        }

        var firstInput = session.firstInput;
        var firstMultiple = session.firstMultiple;
        var offsetCenter = firstMultiple ? firstMultiple.center : firstInput.center;

        var center = input.center = getCenter(pointers);
        input.timeStamp = now();
        input.deltaTime = input.timeStamp - firstInput.timeStamp;

        input.angle = getAngle(offsetCenter, center);
        input.distance = getDistance(offsetCenter, center);

        computeDeltaXY(session, input);
        input.offsetDirection = getDirection(input.deltaX, input.deltaY);

        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;

        input.scale = firstMultiple ? getScale(firstMultiple.pointers, pointers) : 1;
        input.rotation = firstMultiple ? getRotation(firstMultiple.pointers, pointers) : 0;

        input.maxPointers = !session.prevInput ? input.pointers.length : input.pointers.length > session.prevInput.maxPointers ? input.pointers.length : session.prevInput.maxPointers;

        computeIntervalInputData(session, input);

        // find the correct target
        var target = manager.element;
        if (hasParent(input.srcEvent.target, target)) {
            target = input.srcEvent.target;
        }
        input.target = target;
    }

    function computeDeltaXY(session, input) {
        var center = input.center;
        var offset = session.offsetDelta || {};
        var prevDelta = session.prevDelta || {};
        var prevInput = session.prevInput || {};

        if (input.eventType === INPUT_START || prevInput.eventType === INPUT_END) {
            prevDelta = session.prevDelta = {
                x: prevInput.deltaX || 0,
                y: prevInput.deltaY || 0
            };

            offset = session.offsetDelta = {
                x: center.x,
                y: center.y
            };
        }

        input.deltaX = prevDelta.x + (center.x - offset.x);
        input.deltaY = prevDelta.y + (center.y - offset.y);
    }

    /**
     * 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;

        if (input.eventType != INPUT_CANCEL && (deltaTime > COMPUTE_INTERVAL || last.velocity === undefined)) {
            var deltaX = input.deltaX - last.deltaX;
            var deltaY = input.deltaY - last.deltaY;

            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);

            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;
        }

        input.velocity = velocity;
        input.velocityX = velocityX;
        input.velocityY = velocityY;
        input.direction = direction;
    }

    /**
     * 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++;
        }

        return {
            timeStamp: now(),
            pointers: pointers,
            center: getCenter(pointers),
            deltaX: input.deltaX,
            deltaY: input.deltaY
        };
    }

    /**
     * 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;

        // no need to loop when only one touch
        if (pointersLength === 1) {
            return {
                x: round(pointers[0].clientX),
                y: round(pointers[0].clientY)
            };
        }

        var x = 0,
            y = 0,
            i = 0;
        while (i < pointersLength) {
            x += pointers[i].clientX;
            y += pointers[i].clientY;
            i++;
        }

        return {
            x: round(x / pointersLength),
            y: round(y / pointersLength)
        };
    }

    /**
     * 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
        };
    }

    /**
     * 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;
        }

        if (abs(x) >= abs(y)) {
            return x < 0 ? DIRECTION_LEFT : DIRECTION_RIGHT;
        }
        return y < 0 ? DIRECTION_UP : DIRECTION_DOWN;
    }

    /**
     * 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]];

        return Math.sqrt(x * x + y * y);
    }

    /**
     * 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;
    }

    /**
     * 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);
    }

    /**
     * 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);
    }

    var MOUSE_INPUT_MAP = {
        mousedown: INPUT_START,
        mousemove: INPUT_MOVE,
        mouseup: INPUT_END
    };

    var MOUSE_ELEMENT_EVENTS = 'mousedown';
    var MOUSE_WINDOW_EVENTS = 'mousemove mouseup';

    /**
     * Mouse events input
     * @constructor
     * @extends Input
     */
    function MouseInput() {
        this.evEl = MOUSE_ELEMENT_EVENTS;
        this.evWin = MOUSE_WINDOW_EVENTS;

        this.pressed = false; // mousedown state

        Input.apply(this, arguments);
    }

    inherit(MouseInput, Input, {
        /**
         * handle mouse events
         * @param {Object} ev
         */
        handler: function MEhandler(ev) {
            var eventType = MOUSE_INPUT_MAP[ev.type];

            // on start we want to have the left mouse button down
            if (eventType & INPUT_START && ev.button === 0) {
                this.pressed = true;
            }

            if (eventType & INPUT_MOVE && ev.which !== 1) {
                eventType = INPUT_END;
            }

            // mouse must be down
            if (!this.pressed) {
                return;
            }

            if (eventType & INPUT_END) {
                this.pressed = false;
            }

            this.callback(this.manager, eventType, {
                pointers: [ev],
                changedPointers: [ev],
                pointerType: INPUT_TYPE_MOUSE,
                srcEvent: ev
            });
        }
    });

    var POINTER_INPUT_MAP = {
        pointerdown: INPUT_START,
        pointermove: INPUT_MOVE,
        pointerup: INPUT_END,
        pointercancel: INPUT_CANCEL,
        pointerout: INPUT_CANCEL
    };

    // 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
    };

    var POINTER_ELEMENT_EVENTS = 'pointerdown';
    var POINTER_WINDOW_EVENTS = 'pointermove pointerup pointercancel';

    // IE10 has prefixed support, and case-sensitive
    if (window.MSPointerEvent && !window.PointerEvent) {
        POINTER_ELEMENT_EVENTS = 'MSPointerDown';
        POINTER_WINDOW_EVENTS = 'MSPointerMove MSPointerUp MSPointerCancel';
    }

    /**
     * Pointer events input
     * @constructor
     * @extends Input
     */
    function PointerEventInput() {
        this.evEl = POINTER_ELEMENT_EVENTS;
        this.evWin = POINTER_WINDOW_EVENTS;

        Input.apply(this, arguments);

        this.store = this.manager.session.pointerEvents = [];
    }

    inherit(PointerEventInput, Input, {
        /**
         * handle mouse events
         * @param {Object} ev
         */
        handler: function PEhandler(ev) {
            var store = this.store;
            var removePointer = false;

            var eventTypeNormalized = ev.type.toLowerCase().replace('ms', '');
            var eventType = POINTER_INPUT_MAP[eventTypeNormalized];
            var pointerType = IE10_POINTER_TYPE_ENUM[ev.pointerType] || ev.pointerType;

            var isTouch = pointerType == INPUT_TYPE_TOUCH;

            // get index of the event in the store
            var storeIndex = inArray(store, ev.pointerId, 'pointerId');

            // 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;
            }

            // it not found, so the pointer hasn't been down (so it's probably a hover)
            if (storeIndex < 0) {
                return;
            }

            // update the event in the store
            store[storeIndex] = ev;

            this.callback(this.manager, eventType, {
                pointers: store,
                changedPointers: [ev],
                pointerType: pointerType,
                srcEvent: ev
            });

            if (removePointer) {
                // remove from the store
                store.splice(storeIndex, 1);
            }
        }
    });

    var SINGLE_TOUCH_INPUT_MAP = {
        touchstart: INPUT_START,
        touchmove: INPUT_MOVE,
        touchend: INPUT_END,
        touchcancel: INPUT_CANCEL
    };

    var SINGLE_TOUCH_TARGET_EVENTS = 'touchstart';
    var SINGLE_TOUCH_WINDOW_EVENTS = 'touchstart touchmove touchend touchcancel';

    /**
     * Touch events input
     * @constructor
     * @extends Input
     */
    function SingleTouchInput() {
        this.evTarget = SINGLE_TOUCH_TARGET_EVENTS;
        this.evWin = SINGLE_TOUCH_WINDOW_EVENTS;
        this.started = false;

        Input.apply(this, arguments);
    }

    inherit(SingleTouchInput, Input, {
        handler: function TEhandler(ev) {
            var type = SINGLE_TOUCH_INPUT_MAP[ev.type];

            // should we handle the touch events?
            if (type === INPUT_START) {
                this.started = true;
            }

            if (!this.started) {
                return;
            }

            var touches = normalizeSingleTouches.call(this, ev, type);

            // when done, reset the started state
            if (type & (INPUT_END | INPUT_CANCEL) && touches[0].length - touches[1].length === 0) {
                this.started = false;
            }

            this.callback(this.manager, type, {
                pointers: touches[0],
                changedPointers: touches[1],
                pointerType: INPUT_TYPE_TOUCH,
                srcEvent: ev
            });
        }
    });

    /**
     * @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);

        if (type & (INPUT_END | INPUT_CANCEL)) {
            all = uniqueArray(all.concat(changed), 'identifier', true);
        }

        return [all, changed];
    }

    var TOUCH_INPUT_MAP = {
        touchstart: INPUT_START,
        touchmove: INPUT_MOVE,
        touchend: INPUT_END,
        touchcancel: INPUT_CANCEL
    };

    var TOUCH_TARGET_EVENTS = 'touchstart touchmove touchend touchcancel';

    /**
     * Multi-user touch events input
     * @constructor
     * @extends Input
     */
    function TouchInput() {
        this.evTarget = TOUCH_TARGET_EVENTS;
        this.targetIds = {};

        Input.apply(this, arguments);
    }

    inherit(TouchInput, Input, {
        handler: function MTEhandler(ev) {
            var type = TOUCH_INPUT_MAP[ev.type];
            var touches = getTouches.call(this, ev, type);
            if (!touches) {
                return;
            }

            this.callback(this.manager, type, {
                pointers: touches[0],
                changedPointers: touches[1],
                pointerType: INPUT_TYPE_TOUCH,
                srcEvent: ev
            });
        }
    });

    /**
     * @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;

        // 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];
        }

        var i,
            targetTouches,
            changedTouches = toArray(ev.changedTouches),
            changedTargetTouches = [],
            target = this.target;

        // get target touches from touches
        targetTouches = allTouches.filter(function (touch) {
            return hasParent(touch.target, target);
        });

        // collect touches
        if (type === INPUT_START) {
            i = 0;
            while (i < targetTouches.length) {
                targetIds[targetTouches[i].identifier] = true;
                i++;
            }
        }

        // 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]);
            }

            // cleanup removed touches
            if (type & (INPUT_END | INPUT_CANCEL)) {
                delete targetIds[changedTouches[i].identifier];
            }
            i++;
        }

        if (!changedTargetTouches.length) {
            return;
        }

        return [
        // merge targetTouches with changedTargetTouches so it contains ALL touches, including 'end' and 'cancel'
        uniqueArray(targetTouches.concat(changedTargetTouches), 'identifier', true), changedTargetTouches];
    }

    /**
     * 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
     */

    var DEDUP_TIMEOUT = 2500;
    var DEDUP_DISTANCE = 25;

    function TouchMouseInput() {
        Input.apply(this, arguments);

        var handler = bindFn(this.handler, this);
        this.touch = new TouchInput(this.manager, handler);
        this.mouse = new MouseInput(this.manager, handler);

        this.primaryTouch = null;
        this.lastTouches = [];
    }

    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;

            if (isMouse && inputData.sourceCapabilities && inputData.sourceCapabilities.firesTouchEvents) {
                return;
            }

            // 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;
            }

            this.callback(manager, inputEvent, inputData);
        },

        /**
         * remove the event listeners
         */
        destroy: function destroy() {
            this.touch.destroy();
            this.mouse.destroy();
        }
    });

    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);
        }
    }

    function setLastTouch(eventData) {
        var touch = eventData.changedPointers[0];

        if (touch.identifier === this.primaryTouch) {
            var lastTouch = { x: touch.clientX, y: touch.clientY };
            this.lastTouches.push(lastTouch);
            var lts = this.lastTouches;
            var removeLastTouch = function removeLastTouch() {
                var i = lts.indexOf(lastTouch);
                if (i > -1) {
                    lts.splice(i, 1);
                }
            };
            setTimeout(removeLastTouch, DEDUP_TIMEOUT);
        }
    }

    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;
    }

    var PREFIXED_TOUCH_ACTION = prefixed(TEST_ELEMENT.style, 'touchAction');
    var NATIVE_TOUCH_ACTION = PREFIXED_TOUCH_ACTION !== undefined;

    // 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();

    /**
     * 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);
    }

    TouchAction.prototype = {
        /**
         * set the touchAction value on the element or enable the polyfill
         * @param {String} value
         */
        set: function set(value) {
            // find out the touch-action by the event handlers
            if (value == TOUCH_ACTION_COMPUTE) {
                value = this.compute();
            }

            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();
        },

        /**
         * just re-set the touchAction value
         */
        update: function update() {
            this.set(this.manager.options.touchAction);
        },

        /**
         * compute the value for the touchAction property based on the recognizer's settings
         * @returns {String} value
         */
        compute: function compute() {
            var actions = [];
            each(this.manager.recognizers, function (recognizer) {
                if (boolOrFn(recognizer.options.enable, [recognizer])) {
                    actions = actions.concat(recognizer.getTouchAction());
                }
            });
            return cleanTouchActions(actions.join(' '));
        },

        /**
         * this method is called on each input cycle and provides the preventing of the browser behavior
         * @param {Object} input
         */
        preventDefaults: function preventDefaults(input) {
            var srcEvent = input.srcEvent;
            var direction = input.offsetDirection;

            // if the touch action did prevented once this session
            if (this.manager.session.prevented) {
                srcEvent.preventDefault();
                return;
            }

            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];

            if (hasNone) {
                //do not prevent defaults if this is a tap gesture

                var isTapPointer = input.pointers.length === 1;
                var isTapMovement = input.distance < 2;
                var isTapTouchTime = input.deltaTime < 250;

                if (isTapPointer && isTapMovement && isTapTouchTime) {
                    return;
                }
            }

            if (hasPanX && hasPanY) {
                // `pan-x pan-y` means browser handles all scrolling/panning, do not prevent
                return;
            }

            if (hasNone || hasPanY && direction & DIRECTION_HORIZONTAL || hasPanX && direction & DIRECTION_VERTICAL) {
                return this.preventSrc(srcEvent);
            }
        },

        /**
         * call preventDefault to prevent the browser's default behavior (scrolling in most cases)
         * @param {Object} srcEvent
         */
        preventSrc: function preventSrc(srcEvent) {
            this.manager.session.prevented = true;
            srcEvent.preventDefault();
        }
    };

    /**
     * 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;
        }

        var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X);
        var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y);

        // 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;
        }

        // pan-x OR pan-y
        if (hasPanX || hasPanY) {
            return hasPanX ? TOUCH_ACTION_PAN_X : TOUCH_ACTION_PAN_Y;
        }

        // manipulation
        if (inStr(actions, TOUCH_ACTION_MANIPULATION)) {
            return TOUCH_ACTION_MANIPULATION;
        }

        return TOUCH_ACTION_AUTO;
    }

    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) {

            // 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;
    }

    /**
     * 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;

    /**
     * Recognizer
     * Every recognizer needs to extend from this class.
     * @constructor
     * @param {Object} options
     */
    function Recognizer(options) {
        this.options = assign({}, this.defaults, options || {});

        this.id = uniqueId();

        this.manager = null;

        // default is enable true
        this.options.enable = ifUndefined(this.options.enable, true);

        this.state = STATE_POSSIBLE;

        this.simultaneous = {};
        this.requireFail = [];
    }

    Recognizer.prototype = {
        /**
         * @virtual
         * @type {Object}
         */
        defaults: {},

        /**
         * set options
         * @param {Object} options
         * @return {Recognizer}
         */
        set: function set(options) {
            assign(this.options, options);

            // also update the touchAction, in case something changed about the directions/enabled state
            this.manager && this.manager.touchAction.update();
            return this;
        },

        /**
         * recognize simultaneous with an other recognizer.
         * @param {Recognizer} otherRecognizer
         * @returns {Recognizer} this
         */
        recognizeWith: function recognizeWith(otherRecognizer) {
            if (invokeArrayArg(otherRecognizer, 'recognizeWith', this)) {
                return this;
            }

            var simultaneous = this.simultaneous;
            otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
            if (!simultaneous[otherRecognizer.id]) {
                simultaneous[otherRecognizer.id] = otherRecognizer;
                otherRecognizer.recognizeWith(this);
            }
            return this;
        },

        /**
         * drop the simultaneous link. it doesnt remove the link on the other recognizer.
         * @param {Recognizer} otherRecognizer
         * @returns {Recognizer} this
         */
        dropRecognizeWith: function dropRecognizeWith(otherRecognizer) {
            if (invokeArrayArg(otherRecognizer, 'dropRecognizeWith', this)) {
                return this;
            }

            otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
            delete this.simultaneous[otherRecognizer.id];
            return this;
        },

        /**
         * recognizer can only run when an other is failing
         * @param {Recognizer} otherRecognizer
         * @returns {Recognizer} this
         */
        requireFailure: function requireFailure(otherRecognizer) {
            if (invokeArrayArg(otherRecognizer, 'requireFailure', this)) {
                return this;
            }

            var requireFail = this.requireFail;
            otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
            if (inArray(requireFail, otherRecognizer) === -1) {
                requireFail.push(otherRecognizer);
                otherRecognizer.requireFailure(this);
            }
            return this;
        },

        /**
         * drop the requireFailure link. it does not remove the link on the other recognizer.
         * @param {Recognizer} otherRecognizer
         * @returns {Recognizer} this
         */
        dropRequireFailure: function dropRequireFailure(otherRecognizer) {
            if (invokeArrayArg(otherRecognizer, 'dropRequireFailure', this)) {
                return this;
            }

            otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
            var index = inArray(this.requireFail, otherRecognizer);
            if (index > -1) {
                this.requireFail.splice(index, 1);
            }
            return this;
        },

        /**
         * has require failures boolean
         * @returns {boolean}
         */
        hasRequireFailures: function hasRequireFailures() {
            return this.requireFail.length > 0;
        },

        /**
         * if the recognizer can recognize simultaneous with an other recognizer
         * @param {Recognizer} otherRecognizer
         * @returns {Boolean}
         */
        canRecognizeWith: function canRecognizeWith(otherRecognizer) {
            return !!this.simultaneous[otherRecognizer.id];
        },

        /**
         * You should use `tryEmit` instead of `emit` directly to check
         * that all the needed recognizers has failed before emitting.
         * @param {Object} input
         */
        emit: function emit(input) {
            var self = this;
            var state = this.state;

            function emit(event) {
                self.manager.emit(event, input);
            }

            // 'panstart' and 'panmove'
            if (state < STATE_ENDED) {
                emit(self.options.event + stateStr(state));
            }

            emit(self.options.event); // simple 'eventName' events

            if (input.additionalEvent) {
                // additional event(panleft, panright, pinchin, pinchout...)
                emit(input.additionalEvent);
            }

            // panend and pancancel
            if (state >= STATE_ENDED) {
                emit(self.options.event + stateStr(state));
            }
        },

        /**
         * 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 tryEmit(input) {
            if (this.canEmit()) {
                return this.emit(input);
            }
            // it's failing anyway
            this.state = STATE_FAILED;
        },

        /**
         * can we emit?
         * @returns {boolean}
         */
        canEmit: function canEmit() {
            var i = 0;
            while (i < this.requireFail.length) {
                if (!(this.requireFail[i].state & (STATE_FAILED | STATE_POSSIBLE))) {
                    return false;
                }
                i++;
            }
            return true;
        },

        /**
         * update the recognizer
         * @param {Object} inputData
         */
        recognize: function recognize(inputData) {
            // make a new copy of the inputData
            // so we can change the inputData without messing up the other recognizers
            var inputDataClone = assign({}, inputData);

            // is is enabled and allow recognizing?
            if (!boolOrFn(this.options.enable, [this, inputDataClone])) {
                this.reset();
                this.state = STATE_FAILED;
                return;
            }

            // reset when we've reached the end
            if (this.state & (STATE_RECOGNIZED | STATE_CANCELLED | STATE_FAILED)) {
                this.state = STATE_POSSIBLE;
            }

            this.state = this.process(inputDataClone);

            // the recognizer has recognized a gesture
            // so trigger an event
            if (this.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED | STATE_CANCELLED)) {
                this.tryEmit(inputDataClone);
            }
        },

        /**
         * return the state of the recognizer
         * the actual recognizing happens in this method
         * @virtual
         * @param {Object} inputData
         * @returns {Const} STATE
         */
        process: function process(inputData) {}, // jshint ignore:line

        /**
         * return the preferred touch-action
         * @virtual
         * @returns {Array}
         */
        getTouchAction: function getTouchAction() {},

        /**
         * called when the gesture isn't allowed to recognize
         * like when another is being recognized or it is disabled
         * @virtual
         */
        reset: function reset() {}
    };

    /**
     * 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 '';
    }

    /**
     * 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 '';
    }

    /**
     * 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;
    }

    /**
     * This recognizer is just used as a base for the simple attribute recognizers.
     * @constructor
     * @extends Recognizer
     */
    function AttrRecognizer() {
        Recognizer.apply(this, arguments);
    }

    inherit(AttrRecognizer, Recognizer, {
        /**
         * @namespace
         * @memberof AttrRecognizer
         */
        defaults: {
            /**
             * @type {Number}
             * @default 1
             */
            pointers: 1
        },

        /**
         * Used to check if it the recognizer receives valid input, like input.distance > 10.
         * @memberof AttrRecognizer
         * @param {Object} input
         * @returns {Boolean} recognized
         */
        attrTest: function attrTest(input) {
            var optionPointers = this.options.pointers;
            return optionPointers === 0 || input.pointers.length === optionPointers;
        },

        /**
         * Process the input and return the state for the recognizer
         * @memberof AttrRecognizer
         * @param {Object} input
         * @returns {*} State
         */
        process: function process(input) {
            var state = this.state;
            var eventType = input.eventType;

            var isRecognized = state & (STATE_BEGAN | STATE_CHANGED);
            var isValid = this.attrTest(input);

            // 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;
        }
    });

    /**
     * Pan
     * Recognized when the pointer is down and moved in the allowed direction.
     * @constructor
     * @extends AttrRecognizer
     */
    function PanRecognizer() {
        AttrRecognizer.apply(this, arguments);

        this.pX = null;
        this.pY = null;
    }

    inherit(PanRecognizer, AttrRecognizer, {
        /**
         * @namespace
         * @memberof PanRecognizer
         */
        defaults: {
            event: 'pan',
            threshold: 10,
            pointers: 1,
            direction: DIRECTION_ALL
        },

        getTouchAction: function getTouchAction() {
            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;
        },

        directionTest: function directionTest(input) {
            var options = this.options;
            var hasMoved = true;
            var distance = input.distance;
            var direction = input.direction;
            var x = input.deltaX;
            var y = input.deltaY;

            // 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;
        },

        attrTest: function attrTest(input) {
            return AttrRecognizer.prototype.attrTest.call(this, input) && (this.state & STATE_BEGAN || !(this.state & STATE_BEGAN) && this.directionTest(input));
        },

        emit: function emit(input) {

            this.pX = input.deltaX;
            this.pY = input.deltaY;

            var direction = directionStr(input.direction);

            if (direction) {
                input.additionalEvent = this.options.event + direction;
            }
            this._super.emit.call(this, input);
        }
    });

    /**
     * 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);
    }

    inherit(PinchRecognizer, AttrRecognizer, {
        /**
         * @namespace
         * @memberof PinchRecognizer
         */
        defaults: {
            event: 'pinch',
            threshold: 0,
            pointers: 2
        },

        getTouchAction: function getTouchAction() {
            return [TOUCH_ACTION_NONE];
        },

        attrTest: function attrTest(input) {
            return this._super.attrTest.call(this, input) && (Math.abs(input.scale - 1) > this.options.threshold || this.state & STATE_BEGAN);
        },

        emit: function emit(input) {
            if (input.scale !== 1) {
                var inOut = input.scale < 1 ? 'in' : 'out';
                input.additionalEvent = this.options.event + inOut;
            }
            this._super.emit.call(this, input);
        }
    });

    /**
     * Press
     * Recognized when the pointer is down for x ms without any movement.
     * @constructor
     * @extends Recognizer
     */
    function PressRecognizer() {
        Recognizer.apply(this, arguments);

        this._timer = null;
        this._input = null;
    }

    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
        },

        getTouchAction: function getTouchAction() {
            return [TOUCH_ACTION_AUTO];
        },

        process: function process(input) {
            var options = this.options;
            var validPointers = input.pointers.length === options.pointers;
            var validMovement = input.distance < options.threshold;
            var validTime = input.deltaTime > options.time;

            this._input = input;

            // 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;
        },

        reset: function reset() {
            clearTimeout(this._timer);
        },

        emit: function emit(input) {
            if (this.state !== STATE_RECOGNIZED) {
                return;
            }

            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);
            }
        }
    });

    /**
     * Rotate
     * Recognized when two or more pointer are moving in a circular motion.
     * @constructor
     * @extends AttrRecognizer
     */
    function RotateRecognizer() {
        AttrRecognizer.apply(this, arguments);
    }

    inherit(RotateRecognizer, AttrRecognizer, {
        /**
         * @namespace
         * @memberof RotateRecognizer
         */
        defaults: {
            event: 'rotate',
            threshold: 0,
            pointers: 2
        },

        getTouchAction: function getTouchAction() {
            return [TOUCH_ACTION_NONE];
        },

        attrTest: function attrTest(input) {
            return this._super.attrTest.call(this, input) && (Math.abs(input.rotation) > this.options.threshold || this.state & STATE_BEGAN);
        }
    });

    /**
     * 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);
    }

    inherit(SwipeRecognizer, AttrRecognizer, {
        /**
         * @namespace
         * @memberof SwipeRecognizer
         */
        defaults: {
            event: 'swipe',
            threshold: 10,
            velocity: 0.3,
            direction: DIRECTION_HORIZONTAL | DIRECTION_VERTICAL,
            pointers: 1
        },

        getTouchAction: function getTouchAction() {
            return PanRecognizer.prototype.getTouchAction.call(this);
        },

        attrTest: function attrTest(input) {
            var direction = this.options.direction;
            var velocity;

            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;
            }

            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;
        },

        emit: function emit(input) {
            var direction = directionStr(input.offsetDirection);
            if (direction) {
                this.manager.emit(this.options.event + direction, input);
            }

            this.manager.emit(this.options.event, input);
        }
    });

    /**
     * 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);

        // previous time and center,
        // used for tap counting
        this.pTime = false;
        this.pCenter = false;

        this._timer = null;
        this._input = null;
        this.count = 0;
    }

    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
        },

        getTouchAction: function getTouchAction() {
            return [TOUCH_ACTION_MANIPULATION];
        },

        process: function process(input) {
            var options = this.options;

            var validPointers = input.pointers.length === options.pointers;
            var validMovement = input.distance < options.threshold;
            var validTouchTime = input.deltaTime < options.time;

            this.reset();

            if (input.eventType & INPUT_START && this.count === 0) {
                return this.failTimeout();
            }

            // 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();
                }

                var validInterval = this.pTime ? input.timeStamp - this.pTime < options.interval : true;
                var validMultiTap = !this.pCenter || getDistance(this.pCenter, input.center) < options.posThreshold;

                this.pTime = input.timeStamp;
                this.pCenter = input.center;

                if (!validMultiTap || !validInterval) {
                    this.count = 1;
                } else {
                    this.count += 1;
                }

                this._input = input;

                // 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;
        },

        failTimeout: function failTimeout() {
            this._timer = setTimeoutContext(function () {
                this.state = STATE_FAILED;
            }, this.options.interval, this);
            return STATE_FAILED;
        },

        reset: function reset() {
            clearTimeout(this._timer);
        },

        emit: function emit() {
            if (this.state == STATE_RECOGNIZED) {
                this._input.tapCount = this.count;
                this.manager.emit(this.options.event, this._input);
            }
        }
    });

    /**
     * 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);
    }

    /**
     * @const {string}
     */
    Hammer.VERSION = '2.0.7';

    /**
     * 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,

        /**
         * 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,

        /**
         * @type {Boolean}
         * @default true
         */
        enable: true,

        /**
         * 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,

        /**
         * force an input class
         * @type {Null|Function}
         * @default null
         */
        inputClass: null,

        /**
         * 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]],

        /**
         * 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',

            /**
             * Disable the Windows Phone grippers when pressing an element.
             * @type {String}
             * @default 'none'
             */
            touchSelect: 'none',

            /**
             * 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',

            /**
             * Specifies whether zooming is enabled. Used by IE10>
             * @type {String}
             * @default 'none'
             */
            contentZooming: 'none',

            /**
             * Specifies that an entire element should be draggable instead of its contents. Mainly for desktop browsers.
             * @type {String}
             * @default 'none'
             */
            userDrag: 'none',

            /**
             * 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)'
        }
    };

    var STOP = 1;
    var FORCED_STOP = 2;

    /**
     * Manager
     * @param {HTMLElement} element
     * @param {Object} [options]
     * @constructor
     */
    function Manager(element, options) {
        this.options = assign({}, Hammer.defaults, options || {});

        this.options.inputTarget = this.options.inputTarget || element;

        this.handlers = {};
        this.session = {};
        this.recognizers = [];
        this.oldCssProps = {};

        this.element = element;
        this.input = createInputInstance(this);
        this.touchAction = new TouchAction(this, this.options.touchAction);

        toggleCssProps(this, true);

        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);
    }

    Manager.prototype = {
        /**
         * set options
         * @param {Object} options
         * @returns {Manager}
         */
        set: function set(options) {
            assign(this.options, options);

            // 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;
        },

        /**
         * 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 stop(force) {
            this.session.stopped = force ? FORCED_STOP : STOP;
        },

        /**
         * 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 recognize(inputData) {
            var session = this.session;
            if (session.stopped) {
                return;
            }

            // run the touch-action polyfill
            this.touchAction.preventDefaults(inputData);

            var recognizer;
            var recognizers = this.recognizers;

            // 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;

            // 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;
            }

            var i = 0;
            while (i < recognizers.length) {
                recognizer = recognizers[i];

                // 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();
                }

                // 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++;
            }
        },

        /**
         * get a recognizer by its event name.
         * @param {Recognizer|String} recognizer
         * @returns {Recognizer|Null}
         */
        get: function get(recognizer) {
            if (recognizer instanceof Recognizer) {
                return recognizer;
            }

            var recognizers = this.recognizers;
            for (var i = 0; i < recognizers.length; i++) {
                if (recognizers[i].options.event == recognizer) {
                    return recognizers[i];
                }
            }
            return null;
        },

        /**
         * add a recognizer to the manager
         * existing recognizers with the same event name will be removed
         * @param {Recognizer} recognizer
         * @returns {Recognizer|Manager}
         */
        add: function add(recognizer) {
            if (invokeArrayArg(recognizer, 'add', this)) {
                return this;
            }

            // remove existing
            var existing = this.get(recognizer.options.event);
            if (existing) {
                this.remove(existing);
            }

            this.recognizers.push(recognizer);
            recognizer.manager = this;

            this.touchAction.update();
            return recognizer;
        },

        /**
         * remove a recognizer by name or instance
         * @param {Recognizer|String} recognizer
         * @returns {Manager}
         */
        remove: function remove(recognizer) {
            if (invokeArrayArg(recognizer, 'remove', this)) {
                return this;
            }

            recognizer = this.get(recognizer);

            // let's make sure this recognizer exists
            if (recognizer) {
                var recognizers = this.recognizers;
                var index = inArray(recognizers, recognizer);

                if (index !== -1) {
                    recognizers.splice(index, 1);
                    this.touchAction.update();
                }
            }

            return this;
        },

        /**
         * bind event
         * @param {String} events
         * @param {Function} handler
         * @returns {EventEmitter} this
         */
        on: function on(events, handler) {
            if (events === undefined) {
                return;
            }
            if (handler === undefined) {
                return;
            }

            var handlers = this.handlers;
            each(splitStr(events), function (event) {
                handlers[event] = handlers[event] || [];
                handlers[event].push(handler);
            });
            return this;
        },

        /**
         * unbind event, leave emit blank to remove all handlers
         * @param {String} events
         * @param {Function} [handler]
         * @returns {EventEmitter} this
         */
        off: function off(events, handler) {
            if (events === undefined) {
                return;
            }

            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;
        },

        /**
         * emit event to the listeners
         * @param {String} event
         * @param {Object} data
         */
        emit: function emit(event, data) {
            // we also want to trigger dom events
            if (this.options.domEvents) {
                triggerDomEvent(event, data);
            }

            // no handlers, so skip it all
            var handlers = this.handlers[event] && this.handlers[event].slice();
            if (!handlers || !handlers.length) {
                return;
            }

            data.type = event;
            data.preventDefault = function () {
                data.srcEvent.preventDefault();
            };

            var i = 0;
            while (i < handlers.length) {
                handlers[i](data);
                i++;
            }
        },

        /**
         * destroy the manager and unbinds all events
         * it doesn't unbind dom events, that is the user own responsibility
         */
        destroy: function destroy() {
            this.element && toggleCssProps(this, false);

            this.handlers = {};
            this.session = {};
            this.input.destroy();
            this.element = null;
        }
    };

    /**
     * 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 = {};
        }
    }

    /**
     * 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);
    }

    assign(Hammer, {
        INPUT_START: INPUT_START,
        INPUT_MOVE: INPUT_MOVE,
        INPUT_END: INPUT_END,
        INPUT_CANCEL: INPUT_CANCEL,

        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,

        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,

        Manager: Manager,
        Input: Input,
        TouchAction: TouchAction,

        TouchInput: TouchInput,
        MouseInput: MouseInput,
        PointerEventInput: PointerEventInput,
        TouchMouseInput: TouchMouseInput,
        SingleTouchInput: SingleTouchInput,

        Recognizer: Recognizer,
        AttrRecognizer: AttrRecognizer,
        Tap: TapRecognizer,
        Pan: PanRecognizer,
        Swipe: SwipeRecognizer,
        Pinch: PinchRecognizer,
        Rotate: RotateRecognizer,
        Press: PressRecognizer,

        on: addEventListeners,
        off: removeEventListeners,
        each: each,
        merge: merge,
        extend: extend,
        assign: assign,
        inherit: inherit,
        bindFn: bindFn,
        prefixed: prefixed
    });

    // 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;

    if (typeof define === 'function' && define.amd) {
        define(function () {
            return Hammer;
        });
    } else if (typeof module != 'undefined' && module.exports) {
        module.exports = Hammer;
    } else {
        window[exportName] = Hammer;
    }
})(window, document, 'Hammer');

},{}],413:[function(require,module,exports){
'use strict';

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;
};

hat.rack = function (bits, base, expandBy) {
    var fn = function fn(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;
};

},{}],414:[function(require,module,exports){
'use strict';

var hat = require('hat');

/**
 * Create a new id generator / cache instance.
 *
 * You may optionally provide a seed that is used internally.
 *
 * @param {Seed} seed
 */
function Ids(seed) {

  if (!(this instanceof Ids)) {
    return new Ids(seed);
  }

  seed = seed || [128, 36, 1];
  this._seed = seed.length ? hat.rack(seed[0], seed[1], seed[2]) : seed;
}

module.exports = Ids;

/**
 * Generate a next id.
 *
 * @param {Object} [element] element to bind the id to
 *
 * @return {String} id
 */
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
 */
Ids.prototype.nextPrefixed = function (prefix, element) {
  var id;

  do {
    id = prefix + this.next(true);
  } while (this.assigned(id));

  // claim {prefix}{random}
  this.claim(id, element);

  // return
  return id;
};

/**
 * Manually claim an existing id.
 *
 * @param {String} id
 * @param {String} [element] element the id is claimed by
 */
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}
 */
Ids.prototype.assigned = function (id) {
  return this._seed.get(id) || false;
};

/**
 * Unclaim an id.
 *
 * @param  {String} id the id to unclaim
 */
Ids.prototype.unclaim = function (id) {
  delete this._seed.hats[id];
};

/**
 * Clear all claimed ids.
 */
Ids.prototype.clear = function () {

  var hats = this._seed.hats,
      id;

  for (id in hats) {
    this.unclaim(id);
  }
};

},{"hat":413}],415:[function(require,module,exports){
'use strict';

if (typeof Object.create === 'function') {
  // implementation from standard node.js 'util' module
  module.exports = function inherits(ctor, 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
  module.exports = function inherits(ctor, superCtor) {
    ctor.super_ = superCtor;
    var TempCtor = function TempCtor() {};
    TempCtor.prototype = superCtor.prototype;
    ctor.prototype = new TempCtor();
    ctor.prototype.constructor = ctor;
  };
}

},{}],416:[function(require,module,exports){
"use strict";

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

/*!
 * jQuery JavaScript Library v3.3.1
 * https://jquery.com/
 *
 * Includes Sizzle.js
 * https://sizzlejs.com/
 *
 * Copyright JS Foundation and other contributors
 * Released under the MIT license
 * https://jquery.org/license
 *
 * Date: 2018-01-20T17:24Z
 */
(function (global, factory) {

	"use strict";

	if ((typeof module === "undefined" ? "undefined" : _typeof(module)) === "object" && _typeof(module.exports) === "object") {

		// For CommonJS and CommonJS-like environments where a proper `window`
		// is present, execute the factory and get jQuery.
		// For environments that do not have a `window` with a `document`
		// (such as Node.js), expose a factory as module.exports.
		// This accentuates the need for the creation of a real `window`.
		// e.g. var jQuery = require("jquery")(window);
		// See ticket #14549 for more info.
		module.exports = global.document ? factory(global, true) : function (w) {
			if (!w.document) {
				throw new Error("jQuery requires a window with a document");
			}
			return factory(w);
		};
	} else {
		factory(global);
	}

	// Pass this if window is not defined yet
})(typeof window !== "undefined" ? window : undefined, function (window, noGlobal) {

	// Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1
	// throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode
	// arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common
	// enough that all such attempts are guarded in a try block.
	"use strict";

	var arr = [];

	var document = window.document;

	var getProto = Object.getPrototypeOf;

	var _slice = arr.slice;

	var concat = arr.concat;

	var push = arr.push;

	var indexOf = arr.indexOf;

	var class2type = {};

	var toString = class2type.toString;

	var hasOwn = class2type.hasOwnProperty;

	var fnToString = hasOwn.toString;

	var ObjectFunctionString = fnToString.call(Object);

	var support = {};

	var isFunction = function isFunction(obj) {

		// Support: Chrome <=57, Firefox <=52
		// In some browsers, typeof returns "function" for HTML <object> elements
		// (i.e., `typeof document.createElement( "object" ) === "function"`).
		// We don't want to classify *any* DOM node as a function.
		return typeof obj === "function" && typeof obj.nodeType !== "number";
	};

	var isWindow = function isWindow(obj) {
		return obj != null && obj === obj.window;
	};

	var preservedScriptAttributes = {
		type: true,
		src: true,
		noModule: true
	};

	function DOMEval(code, doc, node) {
		doc = doc || document;

		var i,
		    script = doc.createElement("script");

		script.text = code;
		if (node) {
			for (i in preservedScriptAttributes) {
				if (node[i]) {
					script[i] = node[i];
				}
			}
		}
		doc.head.appendChild(script).parentNode.removeChild(script);
	}

	function toType(obj) {
		if (obj == null) {
			return obj + "";
		}

		// Support: Android <=2.3 only (functionish RegExp)
		return (typeof obj === "undefined" ? "undefined" : _typeof(obj)) === "object" || typeof obj === "function" ? class2type[toString.call(obj)] || "object" : typeof obj === "undefined" ? "undefined" : _typeof(obj);
	}
	/* global Symbol */
	// Defining this global in .eslintrc.json would create a danger of using the global
	// unguarded in another place, it seems safer to define global only for this module


	var version = "3.3.1",


	// Define a local copy of jQuery
	jQuery = function jQuery(selector, context) {

		// The jQuery object is actually just the init constructor 'enhanced'
		// Need init if jQuery is called (just allow error to be thrown if not included)
		return new jQuery.fn.init(selector, context);
	},


	// Support: Android <=4.0 only
	// Make sure we trim BOM and NBSP
	rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;

	jQuery.fn = jQuery.prototype = {

		// The current version of jQuery being used
		jquery: version,

		constructor: jQuery,

		// The default length of a jQuery object is 0
		length: 0,

		toArray: function toArray() {
			return _slice.call(this);
		},

		// Get the Nth element in the matched element set OR
		// Get the whole matched element set as a clean array
		get: function get(num) {

			// Return all the elements in a clean array
			if (num == null) {
				return _slice.call(this);
			}

			// Return just the one element from the set
			return num < 0 ? this[num + this.length] : this[num];
		},

		// Take an array of elements and push it onto the stack
		// (returning the new matched element set)
		pushStack: function pushStack(elems) {

			// Build a new jQuery matched element set
			var ret = jQuery.merge(this.constructor(), elems);

			// Add the old object onto the stack (as a reference)
			ret.prevObject = this;

			// Return the newly-formed element set
			return ret;
		},

		// Execute a callback for every element in the matched set.
		each: function each(callback) {
			return jQuery.each(this, callback);
		},

		map: function map(callback) {
			return this.pushStack(jQuery.map(this, function (elem, i) {
				return callback.call(elem, i, elem);
			}));
		},

		slice: function slice() {
			return this.pushStack(_slice.apply(this, arguments));
		},

		first: function first() {
			return this.eq(0);
		},

		last: function last() {
			return this.eq(-1);
		},

		eq: function eq(i) {
			var len = this.length,
			    j = +i + (i < 0 ? len : 0);
			return this.pushStack(j >= 0 && j < len ? [this[j]] : []);
		},

		end: function end() {
			return this.prevObject || this.constructor();
		},

		// For internal use only.
		// Behaves like an Array's method, not like a jQuery method.
		push: push,
		sort: arr.sort,
		splice: arr.splice
	};

	jQuery.extend = jQuery.fn.extend = function () {
		var options,
		    name,
		    src,
		    copy,
		    copyIsArray,
		    clone,
		    target = arguments[0] || {},
		    i = 1,
		    length = arguments.length,
		    deep = false;

		// Handle a deep copy situation
		if (typeof target === "boolean") {
			deep = target;

			// Skip the boolean and the target
			target = arguments[i] || {};
			i++;
		}

		// Handle case when target is a string or something (possible in deep copy)
		if ((typeof target === "undefined" ? "undefined" : _typeof(target)) !== "object" && !isFunction(target)) {
			target = {};
		}

		// Extend jQuery itself if only one argument is passed
		if (i === length) {
			target = this;
			i--;
		}

		for (; i < length; i++) {

			// Only deal with non-null/undefined values
			if ((options = arguments[i]) != null) {

				// Extend the base object
				for (name in options) {
					src = target[name];
					copy = options[name];

					// Prevent never-ending loop
					if (target === copy) {
						continue;
					}

					// Recurse if we're merging plain objects or arrays
					if (deep && copy && (jQuery.isPlainObject(copy) || (copyIsArray = Array.isArray(copy)))) {

						if (copyIsArray) {
							copyIsArray = false;
							clone = src && Array.isArray(src) ? src : [];
						} else {
							clone = src && jQuery.isPlainObject(src) ? src : {};
						}

						// Never move original objects, clone them
						target[name] = jQuery.extend(deep, clone, copy);

						// Don't bring in undefined values
					} else if (copy !== undefined) {
						target[name] = copy;
					}
				}
			}
		}

		// Return the modified object
		return target;
	};

	jQuery.extend({

		// Unique for each copy of jQuery on the page
		expando: "jQuery" + (version + Math.random()).replace(/\D/g, ""),

		// Assume jQuery is ready without the ready module
		isReady: true,

		error: function error(msg) {
			throw new Error(msg);
		},

		noop: function noop() {},

		isPlainObject: function isPlainObject(obj) {
			var proto, Ctor;

			// Detect obvious negatives
			// Use toString instead of jQuery.type to catch host objects
			if (!obj || toString.call(obj) !== "[object Object]") {
				return false;
			}

			proto = getProto(obj);

			// Objects with no prototype (e.g., `Object.create( null )`) are plain
			if (!proto) {
				return true;
			}

			// Objects with prototype are plain iff they were constructed by a global Object function
			Ctor = hasOwn.call(proto, "constructor") && proto.constructor;
			return typeof Ctor === "function" && fnToString.call(Ctor) === ObjectFunctionString;
		},

		isEmptyObject: function isEmptyObject(obj) {

			/* eslint-disable no-unused-vars */
			// See https://github.com/eslint/eslint/issues/6125
			var name;

			for (name in obj) {
				return false;
			}
			return true;
		},

		// Evaluates a script in a global context
		globalEval: function globalEval(code) {
			DOMEval(code);
		},

		each: function each(obj, callback) {
			var length,
			    i = 0;

			if (isArrayLike(obj)) {
				length = obj.length;
				for (; i < length; i++) {
					if (callback.call(obj[i], i, obj[i]) === false) {
						break;
					}
				}
			} else {
				for (i in obj) {
					if (callback.call(obj[i], i, obj[i]) === false) {
						break;
					}
				}
			}

			return obj;
		},

		// Support: Android <=4.0 only
		trim: function trim(text) {
			return text == null ? "" : (text + "").replace(rtrim, "");
		},

		// results is for internal usage only
		makeArray: function makeArray(arr, results) {
			var ret = results || [];

			if (arr != null) {
				if (isArrayLike(Object(arr))) {
					jQuery.merge(ret, typeof arr === "string" ? [arr] : arr);
				} else {
					push.call(ret, arr);
				}
			}

			return ret;
		},

		inArray: function inArray(elem, arr, i) {
			return arr == null ? -1 : indexOf.call(arr, elem, i);
		},

		// Support: Android <=4.0 only, PhantomJS 1 only
		// push.apply(_, arraylike) throws on ancient WebKit
		merge: function merge(first, second) {
			var len = +second.length,
			    j = 0,
			    i = first.length;

			for (; j < len; j++) {
				first[i++] = second[j];
			}

			first.length = i;

			return first;
		},

		grep: function grep(elems, callback, invert) {
			var callbackInverse,
			    matches = [],
			    i = 0,
			    length = elems.length,
			    callbackExpect = !invert;

			// Go through the array, only saving the items
			// that pass the validator function
			for (; i < length; i++) {
				callbackInverse = !callback(elems[i], i);
				if (callbackInverse !== callbackExpect) {
					matches.push(elems[i]);
				}
			}

			return matches;
		},

		// arg is for internal usage only
		map: function map(elems, callback, arg) {
			var length,
			    value,
			    i = 0,
			    ret = [];

			// Go through the array, translating each of the items to their new values
			if (isArrayLike(elems)) {
				length = elems.length;
				for (; i < length; i++) {
					value = callback(elems[i], i, arg);

					if (value != null) {
						ret.push(value);
					}
				}

				// Go through every key on the object,
			} else {
				for (i in elems) {
					value = callback(elems[i], i, arg);

					if (value != null) {
						ret.push(value);
					}
				}
			}

			// Flatten any nested arrays
			return concat.apply([], ret);
		},

		// A global GUID counter for objects
		guid: 1,

		// jQuery.support is not used in Core but other projects attach their
		// properties to it so it needs to exist.
		support: support
	});

	if (typeof Symbol === "function") {
		jQuery.fn[Symbol.iterator] = arr[Symbol.iterator];
	}

	// Populate the class2type map
	jQuery.each("Boolean Number String Function Array Date RegExp Object Error Symbol".split(" "), function (i, name) {
		class2type["[object " + name + "]"] = name.toLowerCase();
	});

	function isArrayLike(obj) {

		// Support: real iOS 8.2 only (not reproducible in simulator)
		// `in` check used to prevent JIT error (gh-2145)
		// hasOwn isn't used here due to false negatives
		// regarding Nodelist length in IE
		var length = !!obj && "length" in obj && obj.length,
		    type = toType(obj);

		if (isFunction(obj) || isWindow(obj)) {
			return false;
		}

		return type === "array" || length === 0 || typeof length === "number" && length > 0 && length - 1 in obj;
	}
	var Sizzle =
	/*!
  * Sizzle CSS Selector Engine v2.3.3
  * https://sizzlejs.com/
  *
  * Copyright jQuery Foundation and other contributors
  * Released under the MIT license
  * http://jquery.org/license
  *
  * Date: 2016-08-08
  */
	function (window) {

		var i,
		    support,
		    Expr,
		    getText,
		    isXML,
		    tokenize,
		    compile,
		    select,
		    outermostContext,
		    sortInput,
		    hasDuplicate,


		// Local document vars
		setDocument,
		    document,
		    docElem,
		    documentIsHTML,
		    rbuggyQSA,
		    rbuggyMatches,
		    matches,
		    contains,


		// Instance-specific data
		expando = "sizzle" + 1 * new Date(),
		    preferredDoc = window.document,
		    dirruns = 0,
		    done = 0,
		    classCache = createCache(),
		    tokenCache = createCache(),
		    compilerCache = createCache(),
		    sortOrder = function sortOrder(a, b) {
			if (a === b) {
				hasDuplicate = true;
			}
			return 0;
		},


		// Instance methods
		hasOwn = {}.hasOwnProperty,
		    arr = [],
		    pop = arr.pop,
		    push_native = arr.push,
		    push = arr.push,
		    slice = arr.slice,

		// Use a stripped-down indexOf as it's faster than native
		// https://jsperf.com/thor-indexof-vs-for/5
		indexOf = function indexOf(list, elem) {
			var i = 0,
			    len = list.length;
			for (; i < len; i++) {
				if (list[i] === elem) {
					return i;
				}
			}
			return -1;
		},
		    booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",


		// Regular expressions

		// http://www.w3.org/TR/css3-selectors/#whitespace
		whitespace = "[\\x20\\t\\r\\n\\f]",


		// http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
		identifier = "(?:\\\\.|[\\w-]|[^\0-\\xa0])+",


		// Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors
		attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace +
		// Operator (capture 2)
		"*([*^$|!~]?=)" + whitespace +
		// "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]"
		"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace + "*\\]",
		    pseudos = ":(" + identifier + ")(?:\\((" +
		// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
		// 1. quoted (capture 3; capture 4 or capture 5)
		"('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +
		// 2. simple (capture 6)
		"((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +
		// 3. anything else (capture 2)
		".*" + ")\\)|)",


		// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
		rwhitespace = new RegExp(whitespace + "+", "g"),
		    rtrim = new RegExp("^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g"),
		    rcomma = new RegExp("^" + whitespace + "*," + whitespace + "*"),
		    rcombinators = new RegExp("^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*"),
		    rattributeQuotes = new RegExp("=" + whitespace + "*([^\\]'\"]*?)" + whitespace + "*\\]", "g"),
		    rpseudo = new RegExp(pseudos),
		    ridentifier = new RegExp("^" + identifier + "$"),
		    matchExpr = {
			"ID": new RegExp("^#(" + identifier + ")"),
			"CLASS": new RegExp("^\\.(" + identifier + ")"),
			"TAG": new RegExp("^(" + identifier + "|[*])"),
			"ATTR": new RegExp("^" + attributes),
			"PSEUDO": new RegExp("^" + pseudos),
			"CHILD": new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace + "*(\\d+)|))" + whitespace + "*\\)|)", "i"),
			"bool": new RegExp("^(?:" + booleans + ")$", "i"),
			// For use in libraries implementing .is()
			// We use this for POS matching in `select`
			"needsContext": new RegExp("^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i")
		},
		    rinputs = /^(?:input|select|textarea|button)$/i,
		    rheader = /^h\d$/i,
		    rnative = /^[^{]+\{\s*\[native \w/,


		// Easily-parseable/retrievable ID or TAG or CLASS selectors
		rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
		    rsibling = /[+~]/,


		// CSS escapes
		// http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
		runescape = new RegExp("\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig"),
		    funescape = function funescape(_, escaped, escapedWhitespace) {
			var high = "0x" + escaped - 0x10000;
			// NaN means non-codepoint
			// Support: Firefox<24
			// Workaround erroneous numeric interpretation of +"0x"
			return high !== high || escapedWhitespace ? escaped : high < 0 ?
			// BMP codepoint
			String.fromCharCode(high + 0x10000) :
			// Supplemental Plane codepoint (surrogate pair)
			String.fromCharCode(high >> 10 | 0xD800, high & 0x3FF | 0xDC00);
		},


		// CSS string/identifier serialization
		// https://drafts.csswg.org/cssom/#common-serializing-idioms
		rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,
		    fcssescape = function fcssescape(ch, asCodePoint) {
			if (asCodePoint) {

				// U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER
				if (ch === "\0") {
					return "\uFFFD";
				}

				// Control characters and (dependent upon position) numbers get escaped as code points
				return ch.slice(0, -1) + "\\" + ch.charCodeAt(ch.length - 1).toString(16) + " ";
			}

			// Other potentially-special ASCII characters get backslash-escaped
			return "\\" + ch;
		},


		// Used for iframes
		// See setDocument()
		// Removing the function wrapper causes a "Permission Denied"
		// error in IE
		unloadHandler = function unloadHandler() {
			setDocument();
		},
		    disabledAncestor = addCombinator(function (elem) {
			return elem.disabled === true && ("form" in elem || "label" in elem);
		}, { dir: "parentNode", next: "legend" });

		// Optimize for push.apply( _, NodeList )
		try {
			push.apply(arr = slice.call(preferredDoc.childNodes), preferredDoc.childNodes);
			// Support: Android<4.0
			// Detect silently failing push.apply
			arr[preferredDoc.childNodes.length].nodeType;
		} catch (e) {
			push = { apply: arr.length ?

				// Leverage slice if possible
				function (target, els) {
					push_native.apply(target, slice.call(els));
				} :

				// Support: IE<9
				// Otherwise append directly
				function (target, els) {
					var j = target.length,
					    i = 0;
					// Can't trust NodeList.length
					while (target[j++] = els[i++]) {}
					target.length = j - 1;
				}
			};
		}

		function Sizzle(selector, context, results, seed) {
			var m,
			    i,
			    elem,
			    nid,
			    match,
			    groups,
			    newSelector,
			    newContext = context && context.ownerDocument,


			// nodeType defaults to 9, since context defaults to document
			nodeType = context ? context.nodeType : 9;

			results = results || [];

			// Return early from calls with invalid selector or context
			if (typeof selector !== "string" || !selector || nodeType !== 1 && nodeType !== 9 && nodeType !== 11) {

				return results;
			}

			// Try to shortcut find operations (as opposed to filters) in HTML documents
			if (!seed) {

				if ((context ? context.ownerDocument || context : preferredDoc) !== document) {
					setDocument(context);
				}
				context = context || document;

				if (documentIsHTML) {

					// If the selector is sufficiently simple, try using a "get*By*" DOM method
					// (excepting DocumentFragment context, where the methods don't exist)
					if (nodeType !== 11 && (match = rquickExpr.exec(selector))) {

						// ID selector
						if (m = match[1]) {

							// Document context
							if (nodeType === 9) {
								if (elem = context.getElementById(m)) {

									// Support: IE, Opera, Webkit
									// TODO: identify versions
									// getElementById can match elements by name instead of ID
									if (elem.id === m) {
										results.push(elem);
										return results;
									}
								} else {
									return results;
								}

								// Element context
							} else {

								// Support: IE, Opera, Webkit
								// TODO: identify versions
								// getElementById can match elements by name instead of ID
								if (newContext && (elem = newContext.getElementById(m)) && contains(context, elem) && elem.id === m) {

									results.push(elem);
									return results;
								}
							}

							// Type selector
						} else if (match[2]) {
							push.apply(results, context.getElementsByTagName(selector));
							return results;

							// Class selector
						} else if ((m = match[3]) && support.getElementsByClassName && context.getElementsByClassName) {

							push.apply(results, context.getElementsByClassName(m));
							return results;
						}
					}

					// Take advantage of querySelectorAll
					if (support.qsa && !compilerCache[selector + " "] && (!rbuggyQSA || !rbuggyQSA.test(selector))) {

						if (nodeType !== 1) {
							newContext = context;
							newSelector = selector;

							// qSA looks outside Element context, which is not what we want
							// Thanks to Andrew Dupont for this workaround technique
							// Support: IE <=8
							// Exclude object elements
						} else if (context.nodeName.toLowerCase() !== "object") {

							// Capture the context ID, setting it first if necessary
							if (nid = context.getAttribute("id")) {
								nid = nid.replace(rcssescape, fcssescape);
							} else {
								context.setAttribute("id", nid = expando);
							}

							// Prefix every selector in the list
							groups = tokenize(selector);
							i = groups.length;
							while (i--) {
								groups[i] = "#" + nid + " " + toSelector(groups[i]);
							}
							newSelector = groups.join(",");

							// Expand context for sibling selectors
							newContext = rsibling.test(selector) && testContext(context.parentNode) || context;
						}

						if (newSelector) {
							try {
								push.apply(results, newContext.querySelectorAll(newSelector));
								return results;
							} catch (qsaError) {} finally {
								if (nid === expando) {
									context.removeAttribute("id");
								}
							}
						}
					}
				}
			}

			// All others
			return select(selector.replace(rtrim, "$1"), context, results, seed);
		}

		/**
   * Create key-value caches of limited size
   * @returns {function(string, object)} Returns the Object data after storing it on itself with
   *	property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
   *	deleting the oldest entry
   */
		function createCache() {
			var keys = [];

			function cache(key, value) {
				// Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
				if (keys.push(key + " ") > Expr.cacheLength) {
					// Only keep the most recent entries
					delete cache[keys.shift()];
				}
				return cache[key + " "] = value;
			}
			return cache;
		}

		/**
   * Mark a function for special use by Sizzle
   * @param {Function} fn The function to mark
   */
		function markFunction(fn) {
			fn[expando] = true;
			return fn;
		}

		/**
   * Support testing using an element
   * @param {Function} fn Passed the created element and returns a boolean result
   */
		function assert(fn) {
			var el = document.createElement("fieldset");

			try {
				return !!fn(el);
			} catch (e) {
				return false;
			} finally {
				// Remove from its parent by default
				if (el.parentNode) {
					el.parentNode.removeChild(el);
				}
				// release memory in IE
				el = null;
			}
		}

		/**
   * Adds the same handler for all of the specified attrs
   * @param {String} attrs Pipe-separated list of attributes
   * @param {Function} handler The method that will be applied
   */
		function addHandle(attrs, handler) {
			var arr = attrs.split("|"),
			    i = arr.length;

			while (i--) {
				Expr.attrHandle[arr[i]] = handler;
			}
		}

		/**
   * Checks document order of two siblings
   * @param {Element} a
   * @param {Element} b
   * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
   */
		function siblingCheck(a, b) {
			var cur = b && a,
			    diff = cur && a.nodeType === 1 && b.nodeType === 1 && a.sourceIndex - b.sourceIndex;

			// Use IE sourceIndex if available on both nodes
			if (diff) {
				return diff;
			}

			// Check if b follows a
			if (cur) {
				while (cur = cur.nextSibling) {
					if (cur === b) {
						return -1;
					}
				}
			}

			return a ? 1 : -1;
		}

		/**
   * Returns a function to use in pseudos for input types
   * @param {String} type
   */
		function createInputPseudo(type) {
			return function (elem) {
				var name = elem.nodeName.toLowerCase();
				return name === "input" && elem.type === type;
			};
		}

		/**
   * Returns a function to use in pseudos for buttons
   * @param {String} type
   */
		function createButtonPseudo(type) {
			return function (elem) {
				var name = elem.nodeName.toLowerCase();
				return (name === "input" || name === "button") && elem.type === type;
			};
		}

		/**
   * Returns a function to use in pseudos for :enabled/:disabled
   * @param {Boolean} disabled true for :disabled; false for :enabled
   */
		function createDisabledPseudo(disabled) {

			// Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable
			return function (elem) {

				// Only certain elements can match :enabled or :disabled
				// https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled
				// https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled
				if ("form" in elem) {

					// Check for inherited disabledness on relevant non-disabled elements:
					// * listed form-associated elements in a disabled fieldset
					//   https://html.spec.whatwg.org/multipage/forms.html#category-listed
					//   https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled
					// * option elements in a disabled optgroup
					//   https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled
					// All such elements have a "form" property.
					if (elem.parentNode && elem.disabled === false) {

						// Option elements defer to a parent optgroup if present
						if ("label" in elem) {
							if ("label" in elem.parentNode) {
								return elem.parentNode.disabled === disabled;
							} else {
								return elem.disabled === disabled;
							}
						}

						// Support: IE 6 - 11
						// Use the isDisabled shortcut property to check for disabled fieldset ancestors
						return elem.isDisabled === disabled ||

						// Where there is no isDisabled, check manually
						/* jshint -W018 */
						elem.isDisabled !== !disabled && disabledAncestor(elem) === disabled;
					}

					return elem.disabled === disabled;

					// Try to winnow out elements that can't be disabled before trusting the disabled property.
					// Some victims get caught in our net (label, legend, menu, track), but it shouldn't
					// even exist on them, let alone have a boolean value.
				} else if ("label" in elem) {
					return elem.disabled === disabled;
				}

				// Remaining elements are neither :enabled nor :disabled
				return false;
			};
		}

		/**
   * Returns a function to use in pseudos for positionals
   * @param {Function} fn
   */
		function createPositionalPseudo(fn) {
			return markFunction(function (argument) {
				argument = +argument;
				return markFunction(function (seed, matches) {
					var j,
					    matchIndexes = fn([], seed.length, argument),
					    i = matchIndexes.length;

					// Match elements found at the specified indexes
					while (i--) {
						if (seed[j = matchIndexes[i]]) {
							seed[j] = !(matches[j] = seed[j]);
						}
					}
				});
			});
		}

		/**
   * Checks a node for validity as a Sizzle context
   * @param {Element|Object=} context
   * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
   */
		function testContext(context) {
			return context && typeof context.getElementsByTagName !== "undefined" && context;
		}

		// Expose support vars for convenience
		support = Sizzle.support = {};

		/**
   * Detects XML nodes
   * @param {Element|Object} elem An element or a document
   * @returns {Boolean} True iff elem is a non-HTML XML node
   */
		isXML = Sizzle.isXML = function (elem) {
			// documentElement is verified for cases where it doesn't yet exist
			// (such as loading iframes in IE - #4833)
			var documentElement = elem && (elem.ownerDocument || elem).documentElement;
			return documentElement ? documentElement.nodeName !== "HTML" : false;
		};

		/**
   * Sets document-related variables once based on the current document
   * @param {Element|Object} [doc] An element or document object to use to set the document
   * @returns {Object} Returns the current document
   */
		setDocument = Sizzle.setDocument = function (node) {
			var hasCompare,
			    subWindow,
			    doc = node ? node.ownerDocument || node : preferredDoc;

			// Return early if doc is invalid or already selected
			if (doc === document || doc.nodeType !== 9 || !doc.documentElement) {
				return document;
			}

			// Update global variables
			document = doc;
			docElem = document.documentElement;
			documentIsHTML = !isXML(document);

			// Support: IE 9-11, Edge
			// Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936)
			if (preferredDoc !== document && (subWindow = document.defaultView) && subWindow.top !== subWindow) {

				// Support: IE 11, Edge
				if (subWindow.addEventListener) {
					subWindow.addEventListener("unload", unloadHandler, false);

					// Support: IE 9 - 10 only
				} else if (subWindow.attachEvent) {
					subWindow.attachEvent("onunload", unloadHandler);
				}
			}

			/* Attributes
   ---------------------------------------------------------------------- */

			// Support: IE<8
			// Verify that getAttribute really returns attributes and not properties
			// (excepting IE8 booleans)
			support.attributes = assert(function (el) {
				el.className = "i";
				return !el.getAttribute("className");
			});

			/* getElement(s)By*
   ---------------------------------------------------------------------- */

			// Check if getElementsByTagName("*") returns only elements
			support.getElementsByTagName = assert(function (el) {
				el.appendChild(document.createComment(""));
				return !el.getElementsByTagName("*").length;
			});

			// Support: IE<9
			support.getElementsByClassName = rnative.test(document.getElementsByClassName);

			// Support: IE<10
			// Check if getElementById returns elements by name
			// The broken getElementById methods don't pick up programmatically-set names,
			// so use a roundabout getElementsByName test
			support.getById = assert(function (el) {
				docElem.appendChild(el).id = expando;
				return !document.getElementsByName || !document.getElementsByName(expando).length;
			});

			// ID filter and find
			if (support.getById) {
				Expr.filter["ID"] = function (id) {
					var attrId = id.replace(runescape, funescape);
					return function (elem) {
						return elem.getAttribute("id") === attrId;
					};
				};
				Expr.find["ID"] = function (id, context) {
					if (typeof context.getElementById !== "undefined" && documentIsHTML) {
						var elem = context.getElementById(id);
						return elem ? [elem] : [];
					}
				};
			} else {
				Expr.filter["ID"] = function (id) {
					var attrId = id.replace(runescape, funescape);
					return function (elem) {
						var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
						return node && node.value === attrId;
					};
				};

				// Support: IE 6 - 7 only
				// getElementById is not reliable as a find shortcut
				Expr.find["ID"] = function (id, context) {
					if (typeof context.getElementById !== "undefined" && documentIsHTML) {
						var node,
						    i,
						    elems,
						    elem = context.getElementById(id);

						if (elem) {

							// Verify the id attribute
							node = elem.getAttributeNode("id");
							if (node && node.value === id) {
								return [elem];
							}

							// Fall back on getElementsByName
							elems = context.getElementsByName(id);
							i = 0;
							while (elem = elems[i++]) {
								node = elem.getAttributeNode("id");
								if (node && node.value === id) {
									return [elem];
								}
							}
						}

						return [];
					}
				};
			}

			// Tag
			Expr.find["TAG"] = support.getElementsByTagName ? function (tag, context) {
				if (typeof context.getElementsByTagName !== "undefined") {
					return context.getElementsByTagName(tag);

					// DocumentFragment nodes don't have gEBTN
				} else if (support.qsa) {
					return context.querySelectorAll(tag);
				}
			} : function (tag, context) {
				var elem,
				    tmp = [],
				    i = 0,

				// By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too
				results = context.getElementsByTagName(tag);

				// Filter out possible comments
				if (tag === "*") {
					while (elem = results[i++]) {
						if (elem.nodeType === 1) {
							tmp.push(elem);
						}
					}

					return tmp;
				}
				return results;
			};

			// Class
			Expr.find["CLASS"] = support.getElementsByClassName && function (className, context) {
				if (typeof context.getElementsByClassName !== "undefined" && documentIsHTML) {
					return context.getElementsByClassName(className);
				}
			};

			/* QSA/matchesSelector
   ---------------------------------------------------------------------- */

			// QSA and matchesSelector support

			// matchesSelector(:active) reports false when true (IE9/Opera 11.5)
			rbuggyMatches = [];

			// qSa(:focus) reports false when true (Chrome 21)
			// We allow this because of a bug in IE8/9 that throws an error
			// whenever `document.activeElement` is accessed on an iframe
			// So, we allow :focus to pass through QSA all the time to avoid the IE error
			// See https://bugs.jquery.com/ticket/13378
			rbuggyQSA = [];

			if (support.qsa = rnative.test(document.querySelectorAll)) {
				// Build QSA regex
				// Regex strategy adopted from Diego Perini
				assert(function (el) {
					// Select is set to empty string on purpose
					// This is to test IE's treatment of not explicitly
					// setting a boolean content attribute,
					// since its presence should be enough
					// https://bugs.jquery.com/ticket/12359
					docElem.appendChild(el).innerHTML = "<a id='" + expando + "'></a>" + "<select id='" + expando + "-\r\\' msallowcapture=''>" + "<option selected=''></option></select>";

					// Support: IE8, Opera 11-12.16
					// Nothing should be selected when empty strings follow ^= or $= or *=
					// The test attribute must be unknown in Opera but "safe" for WinRT
					// https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
					if (el.querySelectorAll("[msallowcapture^='']").length) {
						rbuggyQSA.push("[*^$]=" + whitespace + "*(?:''|\"\")");
					}

					// Support: IE8
					// Boolean attributes and "value" are not treated correctly
					if (!el.querySelectorAll("[selected]").length) {
						rbuggyQSA.push("\\[" + whitespace + "*(?:value|" + booleans + ")");
					}

					// Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+
					if (!el.querySelectorAll("[id~=" + expando + "-]").length) {
						rbuggyQSA.push("~=");
					}

					// Webkit/Opera - :checked should return selected option elements
					// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
					// IE8 throws error here and will not see later tests
					if (!el.querySelectorAll(":checked").length) {
						rbuggyQSA.push(":checked");
					}

					// Support: Safari 8+, iOS 8+
					// https://bugs.webkit.org/show_bug.cgi?id=136851
					// In-page `selector#id sibling-combinator selector` fails
					if (!el.querySelectorAll("a#" + expando + "+*").length) {
						rbuggyQSA.push(".#.+[+~]");
					}
				});

				assert(function (el) {
					el.innerHTML = "<a href='' disabled='disabled'></a>" + "<select disabled='disabled'><option/></select>";

					// Support: Windows 8 Native Apps
					// The type and name attributes are restricted during .innerHTML assignment
					var input = document.createElement("input");
					input.setAttribute("type", "hidden");
					el.appendChild(input).setAttribute("name", "D");

					// Support: IE8
					// Enforce case-sensitivity of name attribute
					if (el.querySelectorAll("[name=d]").length) {
						rbuggyQSA.push("name" + whitespace + "*[*^$|!~]?=");
					}

					// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
					// IE8 throws error here and will not see later tests
					if (el.querySelectorAll(":enabled").length !== 2) {
						rbuggyQSA.push(":enabled", ":disabled");
					}

					// Support: IE9-11+
					// IE's :disabled selector does not pick up the children of disabled fieldsets
					docElem.appendChild(el).disabled = true;
					if (el.querySelectorAll(":disabled").length !== 2) {
						rbuggyQSA.push(":enabled", ":disabled");
					}

					// Opera 10-11 does not throw on post-comma invalid pseudos
					el.querySelectorAll("*,:x");
					rbuggyQSA.push(",.*:");
				});
			}

			if (support.matchesSelector = rnative.test(matches = docElem.matches || docElem.webkitMatchesSelector || docElem.mozMatchesSelector || docElem.oMatchesSelector || docElem.msMatchesSelector)) {

				assert(function (el) {
					// Check to see if it's possible to do matchesSelector
					// on a disconnected node (IE 9)
					support.disconnectedMatch = matches.call(el, "*");

					// This should fail with an exception
					// Gecko does not error, returns false instead
					matches.call(el, "[s!='']:x");
					rbuggyMatches.push("!=", pseudos);
				});
			}

			rbuggyQSA = rbuggyQSA.length && new RegExp(rbuggyQSA.join("|"));
			rbuggyMatches = rbuggyMatches.length && new RegExp(rbuggyMatches.join("|"));

			/* Contains
   ---------------------------------------------------------------------- */
			hasCompare = rnative.test(docElem.compareDocumentPosition);

			// Element contains another
			// Purposefully self-exclusive
			// As in, an element does not contain itself
			contains = hasCompare || rnative.test(docElem.contains) ? function (a, b) {
				var adown = a.nodeType === 9 ? a.documentElement : a,
				    bup = b && b.parentNode;
				return a === bup || !!(bup && bup.nodeType === 1 && (adown.contains ? adown.contains(bup) : a.compareDocumentPosition && a.compareDocumentPosition(bup) & 16));
			} : function (a, b) {
				if (b) {
					while (b = b.parentNode) {
						if (b === a) {
							return true;
						}
					}
				}
				return false;
			};

			/* Sorting
   ---------------------------------------------------------------------- */

			// Document order sorting
			sortOrder = hasCompare ? function (a, b) {

				// Flag for duplicate removal
				if (a === b) {
					hasDuplicate = true;
					return 0;
				}

				// Sort on method existence if only one input has compareDocumentPosition
				var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
				if (compare) {
					return compare;
				}

				// Calculate position if both inputs belong to the same document
				compare = (a.ownerDocument || a) === (b.ownerDocument || b) ? a.compareDocumentPosition(b) :

				// Otherwise we know they are disconnected
				1;

				// Disconnected nodes
				if (compare & 1 || !support.sortDetached && b.compareDocumentPosition(a) === compare) {

					// Choose the first element that is related to our preferred document
					if (a === document || a.ownerDocument === preferredDoc && contains(preferredDoc, a)) {
						return -1;
					}
					if (b === document || b.ownerDocument === preferredDoc && contains(preferredDoc, b)) {
						return 1;
					}

					// Maintain original order
					return sortInput ? indexOf(sortInput, a) - indexOf(sortInput, b) : 0;
				}

				return compare & 4 ? -1 : 1;
			} : function (a, b) {
				// Exit early if the nodes are identical
				if (a === b) {
					hasDuplicate = true;
					return 0;
				}

				var cur,
				    i = 0,
				    aup = a.parentNode,
				    bup = b.parentNode,
				    ap = [a],
				    bp = [b];

				// Parentless nodes are either documents or disconnected
				if (!aup || !bup) {
					return a === document ? -1 : b === document ? 1 : aup ? -1 : bup ? 1 : sortInput ? indexOf(sortInput, a) - indexOf(sortInput, b) : 0;

					// If the nodes are siblings, we can do a quick check
				} else if (aup === bup) {
					return siblingCheck(a, b);
				}

				// Otherwise we need full lists of their ancestors for comparison
				cur = a;
				while (cur = cur.parentNode) {
					ap.unshift(cur);
				}
				cur = b;
				while (cur = cur.parentNode) {
					bp.unshift(cur);
				}

				// Walk down the tree looking for a discrepancy
				while (ap[i] === bp[i]) {
					i++;
				}

				return i ?
				// Do a sibling check if the nodes have a common ancestor
				siblingCheck(ap[i], bp[i]) :

				// Otherwise nodes in our document sort first
				ap[i] === preferredDoc ? -1 : bp[i] === preferredDoc ? 1 : 0;
			};

			return document;
		};

		Sizzle.matches = function (expr, elements) {
			return Sizzle(expr, null, null, elements);
		};

		Sizzle.matchesSelector = function (elem, expr) {
			// Set document vars if needed
			if ((elem.ownerDocument || elem) !== document) {
				setDocument(elem);
			}

			// Make sure that attribute selectors are quoted
			expr = expr.replace(rattributeQuotes, "='$1']");

			if (support.matchesSelector && documentIsHTML && !compilerCache[expr + " "] && (!rbuggyMatches || !rbuggyMatches.test(expr)) && (!rbuggyQSA || !rbuggyQSA.test(expr))) {

				try {
					var ret = matches.call(elem, expr);

					// IE 9's matchesSelector returns false on disconnected nodes
					if (ret || support.disconnectedMatch ||
					// As well, disconnected nodes are said to be in a document
					// fragment in IE 9
					elem.document && elem.document.nodeType !== 11) {
						return ret;
					}
				} catch (e) {}
			}

			return Sizzle(expr, document, null, [elem]).length > 0;
		};

		Sizzle.contains = function (context, elem) {
			// Set document vars if needed
			if ((context.ownerDocument || context) !== document) {
				setDocument(context);
			}
			return contains(context, elem);
		};

		Sizzle.attr = function (elem, name) {
			// Set document vars if needed
			if ((elem.ownerDocument || elem) !== document) {
				setDocument(elem);
			}

			var fn = Expr.attrHandle[name.toLowerCase()],

			// Don't get fooled by Object.prototype properties (jQuery #13807)
			val = fn && hasOwn.call(Expr.attrHandle, name.toLowerCase()) ? fn(elem, name, !documentIsHTML) : undefined;

			return val !== undefined ? val : support.attributes || !documentIsHTML ? elem.getAttribute(name) : (val = elem.getAttributeNode(name)) && val.specified ? val.value : null;
		};

		Sizzle.escape = function (sel) {
			return (sel + "").replace(rcssescape, fcssescape);
		};

		Sizzle.error = function (msg) {
			throw new Error("Syntax error, unrecognized expression: " + msg);
		};

		/**
   * Document sorting and removing duplicates
   * @param {ArrayLike} results
   */
		Sizzle.uniqueSort = function (results) {
			var elem,
			    duplicates = [],
			    j = 0,
			    i = 0;

			// Unless we *know* we can detect duplicates, assume their presence
			hasDuplicate = !support.detectDuplicates;
			sortInput = !support.sortStable && results.slice(0);
			results.sort(sortOrder);

			if (hasDuplicate) {
				while (elem = results[i++]) {
					if (elem === results[i]) {
						j = duplicates.push(i);
					}
				}
				while (j--) {
					results.splice(duplicates[j], 1);
				}
			}

			// Clear input after sorting to release objects
			// See https://github.com/jquery/sizzle/pull/225
			sortInput = null;

			return results;
		};

		/**
   * Utility function for retrieving the text value of an array of DOM nodes
   * @param {Array|Element} elem
   */
		getText = Sizzle.getText = function (elem) {
			var node,
			    ret = "",
			    i = 0,
			    nodeType = elem.nodeType;

			if (!nodeType) {
				// If no nodeType, this is expected to be an array
				while (node = elem[i++]) {
					// Do not traverse comment nodes
					ret += getText(node);
				}
			} else if (nodeType === 1 || nodeType === 9 || nodeType === 11) {
				// Use textContent for elements
				// innerText usage removed for consistency of new lines (jQuery #11153)
				if (typeof elem.textContent === "string") {
					return elem.textContent;
				} else {
					// Traverse its children
					for (elem = elem.firstChild; elem; elem = elem.nextSibling) {
						ret += getText(elem);
					}
				}
			} else if (nodeType === 3 || nodeType === 4) {
				return elem.nodeValue;
			}
			// Do not include comment or processing instruction nodes

			return ret;
		};

		Expr = Sizzle.selectors = {

			// Can be adjusted by the user
			cacheLength: 50,

			createPseudo: markFunction,

			match: matchExpr,

			attrHandle: {},

			find: {},

			relative: {
				">": { dir: "parentNode", first: true },
				" ": { dir: "parentNode" },
				"+": { dir: "previousSibling", first: true },
				"~": { dir: "previousSibling" }
			},

			preFilter: {
				"ATTR": function ATTR(match) {
					match[1] = match[1].replace(runescape, funescape);

					// Move the given value to match[3] whether quoted or unquoted
					match[3] = (match[3] || match[4] || match[5] || "").replace(runescape, funescape);

					if (match[2] === "~=") {
						match[3] = " " + match[3] + " ";
					}

					return match.slice(0, 4);
				},

				"CHILD": function CHILD(match) {
					/* matches from matchExpr["CHILD"]
     	1 type (only|nth|...)
     	2 what (child|of-type)
     	3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
     	4 xn-component of xn+y argument ([+-]?\d*n|)
     	5 sign of xn-component
     	6 x of xn-component
     	7 sign of y-component
     	8 y of y-component
     */
					match[1] = match[1].toLowerCase();

					if (match[1].slice(0, 3) === "nth") {
						// nth-* requires argument
						if (!match[3]) {
							Sizzle.error(match[0]);
						}

						// numeric x and y parameters for Expr.filter.CHILD
						// remember that false/true cast respectively to 0/1
						match[4] = +(match[4] ? match[5] + (match[6] || 1) : 2 * (match[3] === "even" || match[3] === "odd"));
						match[5] = +(match[7] + match[8] || match[3] === "odd");

						// other types prohibit arguments
					} else if (match[3]) {
						Sizzle.error(match[0]);
					}

					return match;
				},

				"PSEUDO": function PSEUDO(match) {
					var excess,
					    unquoted = !match[6] && match[2];

					if (matchExpr["CHILD"].test(match[0])) {
						return null;
					}

					// Accept quoted arguments as-is
					if (match[3]) {
						match[2] = match[4] || match[5] || "";

						// Strip excess characters from unquoted arguments
					} else if (unquoted && rpseudo.test(unquoted) && (
					// Get excess from tokenize (recursively)
					excess = tokenize(unquoted, true)) && (
					// advance to the next closing parenthesis
					excess = unquoted.indexOf(")", unquoted.length - excess) - unquoted.length)) {

						// excess is a negative index
						match[0] = match[0].slice(0, excess);
						match[2] = unquoted.slice(0, excess);
					}

					// Return only captures needed by the pseudo filter method (type and argument)
					return match.slice(0, 3);
				}
			},

			filter: {

				"TAG": function TAG(nodeNameSelector) {
					var nodeName = nodeNameSelector.replace(runescape, funescape).toLowerCase();
					return nodeNameSelector === "*" ? function () {
						return true;
					} : function (elem) {
						return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
					};
				},

				"CLASS": function CLASS(className) {
					var pattern = classCache[className + " "];

					return pattern || (pattern = new RegExp("(^|" + whitespace + ")" + className + "(" + whitespace + "|$)")) && classCache(className, function (elem) {
						return pattern.test(typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || "");
					});
				},

				"ATTR": function ATTR(name, operator, check) {
					return function (elem) {
						var result = Sizzle.attr(elem, name);

						if (result == null) {
							return operator === "!=";
						}
						if (!operator) {
							return true;
						}

						result += "";

						return operator === "=" ? result === check : operator === "!=" ? result !== check : operator === "^=" ? check && result.indexOf(check) === 0 : operator === "*=" ? check && result.indexOf(check) > -1 : operator === "$=" ? check && result.slice(-check.length) === check : operator === "~=" ? (" " + result.replace(rwhitespace, " ") + " ").indexOf(check) > -1 : operator === "|=" ? result === check || result.slice(0, check.length + 1) === check + "-" : false;
					};
				},

				"CHILD": function CHILD(type, what, argument, first, last) {
					var simple = type.slice(0, 3) !== "nth",
					    forward = type.slice(-4) !== "last",
					    ofType = what === "of-type";

					return first === 1 && last === 0 ?

					// Shortcut for :nth-*(n)
					function (elem) {
						return !!elem.parentNode;
					} : function (elem, context, xml) {
						var cache,
						    uniqueCache,
						    outerCache,
						    node,
						    nodeIndex,
						    start,
						    dir = simple !== forward ? "nextSibling" : "previousSibling",
						    parent = elem.parentNode,
						    name = ofType && elem.nodeName.toLowerCase(),
						    useCache = !xml && !ofType,
						    diff = false;

						if (parent) {

							// :(first|last|only)-(child|of-type)
							if (simple) {
								while (dir) {
									node = elem;
									while (node = node[dir]) {
										if (ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1) {

											return false;
										}
									}
									// Reverse direction for :only-* (if we haven't yet done so)
									start = dir = type === "only" && !start && "nextSibling";
								}
								return true;
							}

							start = [forward ? parent.firstChild : parent.lastChild];

							// non-xml :nth-child(...) stores cache data on `parent`
							if (forward && useCache) {

								// Seek `elem` from a previously-cached index

								// ...in a gzip-friendly way
								node = parent;
								outerCache = node[expando] || (node[expando] = {});

								// Support: IE <9 only
								// Defend against cloned attroperties (jQuery gh-1709)
								uniqueCache = outerCache[node.uniqueID] || (outerCache[node.uniqueID] = {});

								cache = uniqueCache[type] || [];
								nodeIndex = cache[0] === dirruns && cache[1];
								diff = nodeIndex && cache[2];
								node = nodeIndex && parent.childNodes[nodeIndex];

								while (node = ++nodeIndex && node && node[dir] || (

								// Fallback to seeking `elem` from the start
								diff = nodeIndex = 0) || start.pop()) {

									// When found, cache indexes on `parent` and break
									if (node.nodeType === 1 && ++diff && node === elem) {
										uniqueCache[type] = [dirruns, nodeIndex, diff];
										break;
									}
								}
							} else {
								// Use previously-cached element index if available
								if (useCache) {
									// ...in a gzip-friendly way
									node = elem;
									outerCache = node[expando] || (node[expando] = {});

									// Support: IE <9 only
									// Defend against cloned attroperties (jQuery gh-1709)
									uniqueCache = outerCache[node.uniqueID] || (outerCache[node.uniqueID] = {});

									cache = uniqueCache[type] || [];
									nodeIndex = cache[0] === dirruns && cache[1];
									diff = nodeIndex;
								}

								// xml :nth-child(...)
								// or :nth-last-child(...) or :nth(-last)?-of-type(...)
								if (diff === false) {
									// Use the same loop as above to seek `elem` from the start
									while (node = ++nodeIndex && node && node[dir] || (diff = nodeIndex = 0) || start.pop()) {

										if ((ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1) && ++diff) {

											// Cache the index of each encountered element
											if (useCache) {
												outerCache = node[expando] || (node[expando] = {});

												// Support: IE <9 only
												// Defend against cloned attroperties (jQuery gh-1709)
												uniqueCache = outerCache[node.uniqueID] || (outerCache[node.uniqueID] = {});

												uniqueCache[type] = [dirruns, diff];
											}

											if (node === elem) {
												break;
											}
										}
									}
								}
							}

							// Incorporate the offset, then check against cycle size
							diff -= last;
							return diff === first || diff % first === 0 && diff / first >= 0;
						}
					};
				},

				"PSEUDO": function PSEUDO(pseudo, argument) {
					// pseudo-class names are case-insensitive
					// http://www.w3.org/TR/selectors/#pseudo-classes
					// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
					// Remember that setFilters inherits from pseudos
					var args,
					    fn = Expr.pseudos[pseudo] || Expr.setFilters[pseudo.toLowerCase()] || Sizzle.error("unsupported pseudo: " + pseudo);

					// The user may use createPseudo to indicate that
					// arguments are needed to create the filter function
					// just as Sizzle does
					if (fn[expando]) {
						return fn(argument);
					}

					// But maintain support for old signatures
					if (fn.length > 1) {
						args = [pseudo, pseudo, "", argument];
						return Expr.setFilters.hasOwnProperty(pseudo.toLowerCase()) ? markFunction(function (seed, matches) {
							var idx,
							    matched = fn(seed, argument),
							    i = matched.length;
							while (i--) {
								idx = indexOf(seed, matched[i]);
								seed[idx] = !(matches[idx] = matched[i]);
							}
						}) : function (elem) {
							return fn(elem, 0, args);
						};
					}

					return fn;
				}
			},

			pseudos: {
				// Potentially complex pseudos
				"not": markFunction(function (selector) {
					// Trim the selector passed to compile
					// to avoid treating leading and trailing
					// spaces as combinators
					var input = [],
					    results = [],
					    matcher = compile(selector.replace(rtrim, "$1"));

					return matcher[expando] ? markFunction(function (seed, matches, context, xml) {
						var elem,
						    unmatched = matcher(seed, null, xml, []),
						    i = seed.length;

						// Match elements unmatched by `matcher`
						while (i--) {
							if (elem = unmatched[i]) {
								seed[i] = !(matches[i] = elem);
							}
						}
					}) : function (elem, context, xml) {
						input[0] = elem;
						matcher(input, null, xml, results);
						// Don't keep the element (issue #299)
						input[0] = null;
						return !results.pop();
					};
				}),

				"has": markFunction(function (selector) {
					return function (elem) {
						return Sizzle(selector, elem).length > 0;
					};
				}),

				"contains": markFunction(function (text) {
					text = text.replace(runescape, funescape);
					return function (elem) {
						return (elem.textContent || elem.innerText || getText(elem)).indexOf(text) > -1;
					};
				}),

				// "Whether an element is represented by a :lang() selector
				// is based solely on the element's language value
				// being equal to the identifier C,
				// or beginning with the identifier C immediately followed by "-".
				// The matching of C against the element's language value is performed case-insensitively.
				// The identifier C does not have to be a valid language name."
				// http://www.w3.org/TR/selectors/#lang-pseudo
				"lang": markFunction(function (lang) {
					// lang value must be a valid identifier
					if (!ridentifier.test(lang || "")) {
						Sizzle.error("unsupported lang: " + lang);
					}
					lang = lang.replace(runescape, funescape).toLowerCase();
					return function (elem) {
						var elemLang;
						do {
							if (elemLang = documentIsHTML ? elem.lang : elem.getAttribute("xml:lang") || elem.getAttribute("lang")) {

								elemLang = elemLang.toLowerCase();
								return elemLang === lang || elemLang.indexOf(lang + "-") === 0;
							}
						} while ((elem = elem.parentNode) && elem.nodeType === 1);
						return false;
					};
				}),

				// Miscellaneous
				"target": function target(elem) {
					var hash = window.location && window.location.hash;
					return hash && hash.slice(1) === elem.id;
				},

				"root": function root(elem) {
					return elem === docElem;
				},

				"focus": function focus(elem) {
					return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
				},

				// Boolean properties
				"enabled": createDisabledPseudo(false),
				"disabled": createDisabledPseudo(true),

				"checked": function checked(elem) {
					// In CSS3, :checked should return both checked and selected elements
					// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
					var nodeName = elem.nodeName.toLowerCase();
					return nodeName === "input" && !!elem.checked || nodeName === "option" && !!elem.selected;
				},

				"selected": function selected(elem) {
					// Accessing this property makes selected-by-default
					// options in Safari work properly
					if (elem.parentNode) {
						elem.parentNode.selectedIndex;
					}

					return elem.selected === true;
				},

				// Contents
				"empty": function empty(elem) {
					// http://www.w3.org/TR/selectors/#empty-pseudo
					// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
					//   but not by others (comment: 8; processing instruction: 7; etc.)
					// nodeType < 6 works because attributes (2) do not appear as children
					for (elem = elem.firstChild; elem; elem = elem.nextSibling) {
						if (elem.nodeType < 6) {
							return false;
						}
					}
					return true;
				},

				"parent": function parent(elem) {
					return !Expr.pseudos["empty"](elem);
				},

				// Element/input types
				"header": function header(elem) {
					return rheader.test(elem.nodeName);
				},

				"input": function input(elem) {
					return rinputs.test(elem.nodeName);
				},

				"button": function button(elem) {
					var name = elem.nodeName.toLowerCase();
					return name === "input" && elem.type === "button" || name === "button";
				},

				"text": function text(elem) {
					var attr;
					return elem.nodeName.toLowerCase() === "input" && elem.type === "text" && (

					// Support: IE<8
					// New HTML5 attribute values (e.g., "search") appear with elem.type === "text"
					(attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text");
				},

				// Position-in-collection
				"first": createPositionalPseudo(function () {
					return [0];
				}),

				"last": createPositionalPseudo(function (matchIndexes, length) {
					return [length - 1];
				}),

				"eq": createPositionalPseudo(function (matchIndexes, length, argument) {
					return [argument < 0 ? argument + length : argument];
				}),

				"even": createPositionalPseudo(function (matchIndexes, length) {
					var i = 0;
					for (; i < length; i += 2) {
						matchIndexes.push(i);
					}
					return matchIndexes;
				}),

				"odd": createPositionalPseudo(function (matchIndexes, length) {
					var i = 1;
					for (; i < length; i += 2) {
						matchIndexes.push(i);
					}
					return matchIndexes;
				}),

				"lt": createPositionalPseudo(function (matchIndexes, length, argument) {
					var i = argument < 0 ? argument + length : argument;
					for (; --i >= 0;) {
						matchIndexes.push(i);
					}
					return matchIndexes;
				}),

				"gt": createPositionalPseudo(function (matchIndexes, length, argument) {
					var i = argument < 0 ? argument + length : argument;
					for (; ++i < length;) {
						matchIndexes.push(i);
					}
					return matchIndexes;
				})
			}
		};

		Expr.pseudos["nth"] = Expr.pseudos["eq"];

		// Add button/input type pseudos
		for (i in { radio: true, checkbox: true, file: true, password: true, image: true }) {
			Expr.pseudos[i] = createInputPseudo(i);
		}
		for (i in { submit: true, reset: true }) {
			Expr.pseudos[i] = createButtonPseudo(i);
		}

		// Easy API for creating new setFilters
		function setFilters() {}
		setFilters.prototype = Expr.filters = Expr.pseudos;
		Expr.setFilters = new setFilters();

		tokenize = Sizzle.tokenize = function (selector, parseOnly) {
			var matched,
			    match,
			    tokens,
			    type,
			    soFar,
			    groups,
			    preFilters,
			    cached = tokenCache[selector + " "];

			if (cached) {
				return parseOnly ? 0 : cached.slice(0);
			}

			soFar = selector;
			groups = [];
			preFilters = Expr.preFilter;

			while (soFar) {

				// Comma and first run
				if (!matched || (match = rcomma.exec(soFar))) {
					if (match) {
						// Don't consume trailing commas as valid
						soFar = soFar.slice(match[0].length) || soFar;
					}
					groups.push(tokens = []);
				}

				matched = false;

				// Combinators
				if (match = rcombinators.exec(soFar)) {
					matched = match.shift();
					tokens.push({
						value: matched,
						// Cast descendant combinators to space
						type: match[0].replace(rtrim, " ")
					});
					soFar = soFar.slice(matched.length);
				}

				// Filters
				for (type in Expr.filter) {
					if ((match = matchExpr[type].exec(soFar)) && (!preFilters[type] || (match = preFilters[type](match)))) {
						matched = match.shift();
						tokens.push({
							value: matched,
							type: type,
							matches: match
						});
						soFar = soFar.slice(matched.length);
					}
				}

				if (!matched) {
					break;
				}
			}

			// Return the length of the invalid excess
			// if we're just parsing
			// Otherwise, throw an error or return tokens
			return parseOnly ? soFar.length : soFar ? Sizzle.error(selector) :
			// Cache the tokens
			tokenCache(selector, groups).slice(0);
		};

		function toSelector(tokens) {
			var i = 0,
			    len = tokens.length,
			    selector = "";
			for (; i < len; i++) {
				selector += tokens[i].value;
			}
			return selector;
		}

		function addCombinator(matcher, combinator, base) {
			var dir = combinator.dir,
			    skip = combinator.next,
			    key = skip || dir,
			    checkNonElements = base && key === "parentNode",
			    doneName = done++;

			return combinator.first ?
			// Check against closest ancestor/preceding element
			function (elem, context, xml) {
				while (elem = elem[dir]) {
					if (elem.nodeType === 1 || checkNonElements) {
						return matcher(elem, context, xml);
					}
				}
				return false;
			} :

			// Check against all ancestor/preceding elements
			function (elem, context, xml) {
				var oldCache,
				    uniqueCache,
				    outerCache,
				    newCache = [dirruns, doneName];

				// We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching
				if (xml) {
					while (elem = elem[dir]) {
						if (elem.nodeType === 1 || checkNonElements) {
							if (matcher(elem, context, xml)) {
								return true;
							}
						}
					}
				} else {
					while (elem = elem[dir]) {
						if (elem.nodeType === 1 || checkNonElements) {
							outerCache = elem[expando] || (elem[expando] = {});

							// Support: IE <9 only
							// Defend against cloned attroperties (jQuery gh-1709)
							uniqueCache = outerCache[elem.uniqueID] || (outerCache[elem.uniqueID] = {});

							if (skip && skip === elem.nodeName.toLowerCase()) {
								elem = elem[dir] || elem;
							} else if ((oldCache = uniqueCache[key]) && oldCache[0] === dirruns && oldCache[1] === doneName) {

								// Assign to newCache so results back-propagate to previous elements
								return newCache[2] = oldCache[2];
							} else {
								// Reuse newcache so results back-propagate to previous elements
								uniqueCache[key] = newCache;

								// A match means we're done; a fail means we have to keep checking
								if (newCache[2] = matcher(elem, context, xml)) {
									return true;
								}
							}
						}
					}
				}
				return false;
			};
		}

		function elementMatcher(matchers) {
			return matchers.length > 1 ? function (elem, context, xml) {
				var i = matchers.length;
				while (i--) {
					if (!matchers[i](elem, context, xml)) {
						return false;
					}
				}
				return true;
			} : matchers[0];
		}

		function multipleContexts(selector, contexts, results) {
			var i = 0,
			    len = contexts.length;
			for (; i < len; i++) {
				Sizzle(selector, contexts[i], results);
			}
			return results;
		}

		function condense(unmatched, map, filter, context, xml) {
			var elem,
			    newUnmatched = [],
			    i = 0,
			    len = unmatched.length,
			    mapped = map != null;

			for (; i < len; i++) {
				if (elem = unmatched[i]) {
					if (!filter || filter(elem, context, xml)) {
						newUnmatched.push(elem);
						if (mapped) {
							map.push(i);
						}
					}
				}
			}

			return newUnmatched;
		}

		function setMatcher(preFilter, selector, matcher, postFilter, postFinder, postSelector) {
			if (postFilter && !postFilter[expando]) {
				postFilter = setMatcher(postFilter);
			}
			if (postFinder && !postFinder[expando]) {
				postFinder = setMatcher(postFinder, postSelector);
			}
			return markFunction(function (seed, results, context, xml) {
				var temp,
				    i,
				    elem,
				    preMap = [],
				    postMap = [],
				    preexisting = results.length,


				// Get initial elements from seed or context
				elems = seed || multipleContexts(selector || "*", context.nodeType ? [context] : context, []),


				// Prefilter to get matcher input, preserving a map for seed-results synchronization
				matcherIn = preFilter && (seed || !selector) ? condense(elems, preMap, preFilter, context, xml) : elems,
				    matcherOut = matcher ?
				// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
				postFinder || (seed ? preFilter : preexisting || postFilter) ?

				// ...intermediate processing is necessary
				[] :

				// ...otherwise use results directly
				results : matcherIn;

				// Find primary matches
				if (matcher) {
					matcher(matcherIn, matcherOut, context, xml);
				}

				// Apply postFilter
				if (postFilter) {
					temp = condense(matcherOut, postMap);
					postFilter(temp, [], context, xml);

					// Un-match failing elements by moving them back to matcherIn
					i = temp.length;
					while (i--) {
						if (elem = temp[i]) {
							matcherOut[postMap[i]] = !(matcherIn[postMap[i]] = elem);
						}
					}
				}

				if (seed) {
					if (postFinder || preFilter) {
						if (postFinder) {
							// Get the final matcherOut by condensing this intermediate into postFinder contexts
							temp = [];
							i = matcherOut.length;
							while (i--) {
								if (elem = matcherOut[i]) {
									// Restore matcherIn since elem is not yet a final match
									temp.push(matcherIn[i] = elem);
								}
							}
							postFinder(null, matcherOut = [], temp, xml);
						}

						// Move matched elements from seed to results to keep them synchronized
						i = matcherOut.length;
						while (i--) {
							if ((elem = matcherOut[i]) && (temp = postFinder ? indexOf(seed, elem) : preMap[i]) > -1) {

								seed[temp] = !(results[temp] = elem);
							}
						}
					}

					// Add elements to results, through postFinder if defined
				} else {
					matcherOut = condense(matcherOut === results ? matcherOut.splice(preexisting, matcherOut.length) : matcherOut);
					if (postFinder) {
						postFinder(null, results, matcherOut, xml);
					} else {
						push.apply(results, matcherOut);
					}
				}
			});
		}

		function matcherFromTokens(tokens) {
			var checkContext,
			    matcher,
			    j,
			    len = tokens.length,
			    leadingRelative = Expr.relative[tokens[0].type],
			    implicitRelative = leadingRelative || Expr.relative[" "],
			    i = leadingRelative ? 1 : 0,


			// The foundational matcher ensures that elements are reachable from top-level context(s)
			matchContext = addCombinator(function (elem) {
				return elem === checkContext;
			}, implicitRelative, true),
			    matchAnyContext = addCombinator(function (elem) {
				return indexOf(checkContext, elem) > -1;
			}, implicitRelative, true),
			    matchers = [function (elem, context, xml) {
				var ret = !leadingRelative && (xml || context !== outermostContext) || ((checkContext = context).nodeType ? matchContext(elem, context, xml) : matchAnyContext(elem, context, xml));
				// Avoid hanging onto element (issue #299)
				checkContext = null;
				return ret;
			}];

			for (; i < len; i++) {
				if (matcher = Expr.relative[tokens[i].type]) {
					matchers = [addCombinator(elementMatcher(matchers), matcher)];
				} else {
					matcher = Expr.filter[tokens[i].type].apply(null, tokens[i].matches);

					// Return special upon seeing a positional matcher
					if (matcher[expando]) {
						// Find the next relative operator (if any) for proper handling
						j = ++i;
						for (; j < len; j++) {
							if (Expr.relative[tokens[j].type]) {
								break;
							}
						}
						return setMatcher(i > 1 && elementMatcher(matchers), i > 1 && toSelector(
						// If the preceding token was a descendant combinator, insert an implicit any-element `*`
						tokens.slice(0, i - 1).concat({ value: tokens[i - 2].type === " " ? "*" : "" })).replace(rtrim, "$1"), matcher, i < j && matcherFromTokens(tokens.slice(i, j)), j < len && matcherFromTokens(tokens = tokens.slice(j)), j < len && toSelector(tokens));
					}
					matchers.push(matcher);
				}
			}

			return elementMatcher(matchers);
		}

		function matcherFromGroupMatchers(elementMatchers, setMatchers) {
			var bySet = setMatchers.length > 0,
			    byElement = elementMatchers.length > 0,
			    superMatcher = function superMatcher(seed, context, xml, results, outermost) {
				var elem,
				    j,
				    matcher,
				    matchedCount = 0,
				    i = "0",
				    unmatched = seed && [],
				    setMatched = [],
				    contextBackup = outermostContext,

				// We must always have either seed elements or outermost context
				elems = seed || byElement && Expr.find["TAG"]("*", outermost),

				// Use integer dirruns iff this is the outermost matcher
				dirrunsUnique = dirruns += contextBackup == null ? 1 : Math.random() || 0.1,
				    len = elems.length;

				if (outermost) {
					outermostContext = context === document || context || outermost;
				}

				// Add elements passing elementMatchers directly to results
				// Support: IE<9, Safari
				// Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id
				for (; i !== len && (elem = elems[i]) != null; i++) {
					if (byElement && elem) {
						j = 0;
						if (!context && elem.ownerDocument !== document) {
							setDocument(elem);
							xml = !documentIsHTML;
						}
						while (matcher = elementMatchers[j++]) {
							if (matcher(elem, context || document, xml)) {
								results.push(elem);
								break;
							}
						}
						if (outermost) {
							dirruns = dirrunsUnique;
						}
					}

					// Track unmatched elements for set filters
					if (bySet) {
						// They will have gone through all possible matchers
						if (elem = !matcher && elem) {
							matchedCount--;
						}

						// Lengthen the array for every element, matched or not
						if (seed) {
							unmatched.push(elem);
						}
					}
				}

				// `i` is now the count of elements visited above, and adding it to `matchedCount`
				// makes the latter nonnegative.
				matchedCount += i;

				// Apply set filters to unmatched elements
				// NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`
				// equals `i`), unless we didn't visit _any_ elements in the above loop because we have
				// no element matchers and no seed.
				// Incrementing an initially-string "0" `i` allows `i` to remain a string only in that
				// case, which will result in a "00" `matchedCount` that differs from `i` but is also
				// numerically zero.
				if (bySet && i !== matchedCount) {
					j = 0;
					while (matcher = setMatchers[j++]) {
						matcher(unmatched, setMatched, context, xml);
					}

					if (seed) {
						// Reintegrate element matches to eliminate the need for sorting
						if (matchedCount > 0) {
							while (i--) {
								if (!(unmatched[i] || setMatched[i])) {
									setMatched[i] = pop.call(results);
								}
							}
						}

						// Discard index placeholder values to get only actual matches
						setMatched = condense(setMatched);
					}

					// Add matches to results
					push.apply(results, setMatched);

					// Seedless set matches succeeding multiple successful matchers stipulate sorting
					if (outermost && !seed && setMatched.length > 0 && matchedCount + setMatchers.length > 1) {

						Sizzle.uniqueSort(results);
					}
				}

				// Override manipulation of globals by nested matchers
				if (outermost) {
					dirruns = dirrunsUnique;
					outermostContext = contextBackup;
				}

				return unmatched;
			};

			return bySet ? markFunction(superMatcher) : superMatcher;
		}

		compile = Sizzle.compile = function (selector, match /* Internal Use Only */) {
			var i,
			    setMatchers = [],
			    elementMatchers = [],
			    cached = compilerCache[selector + " "];

			if (!cached) {
				// Generate a function of recursive functions that can be used to check each element
				if (!match) {
					match = tokenize(selector);
				}
				i = match.length;
				while (i--) {
					cached = matcherFromTokens(match[i]);
					if (cached[expando]) {
						setMatchers.push(cached);
					} else {
						elementMatchers.push(cached);
					}
				}

				// Cache the compiled function
				cached = compilerCache(selector, matcherFromGroupMatchers(elementMatchers, setMatchers));

				// Save selector and tokenization
				cached.selector = selector;
			}
			return cached;
		};

		/**
   * A low-level selection function that works with Sizzle's compiled
   *  selector functions
   * @param {String|Function} selector A selector or a pre-compiled
   *  selector function built with Sizzle.compile
   * @param {Element} context
   * @param {Array} [results]
   * @param {Array} [seed] A set of elements to match against
   */
		select = Sizzle.select = function (selector, context, results, seed) {
			var i,
			    tokens,
			    token,
			    type,
			    find,
			    compiled = typeof selector === "function" && selector,
			    match = !seed && tokenize(selector = compiled.selector || selector);

			results = results || [];

			// Try to minimize operations if there is only one selector in the list and no seed
			// (the latter of which guarantees us context)
			if (match.length === 1) {

				// Reduce context if the leading compound selector is an ID
				tokens = match[0] = match[0].slice(0);
				if (tokens.length > 2 && (token = tokens[0]).type === "ID" && context.nodeType === 9 && documentIsHTML && Expr.relative[tokens[1].type]) {

					context = (Expr.find["ID"](token.matches[0].replace(runescape, funescape), context) || [])[0];
					if (!context) {
						return results;

						// Precompiled matchers will still verify ancestry, so step up a level
					} else if (compiled) {
						context = context.parentNode;
					}

					selector = selector.slice(tokens.shift().value.length);
				}

				// Fetch a seed set for right-to-left matching
				i = matchExpr["needsContext"].test(selector) ? 0 : tokens.length;
				while (i--) {
					token = tokens[i];

					// Abort if we hit a combinator
					if (Expr.relative[type = token.type]) {
						break;
					}
					if (find = Expr.find[type]) {
						// Search, expanding context for leading sibling combinators
						if (seed = find(token.matches[0].replace(runescape, funescape), rsibling.test(tokens[0].type) && testContext(context.parentNode) || context)) {

							// If seed is empty or no tokens remain, we can return early
							tokens.splice(i, 1);
							selector = seed.length && toSelector(tokens);
							if (!selector) {
								push.apply(results, seed);
								return results;
							}

							break;
						}
					}
				}
			}

			// Compile and execute a filtering function if one is not provided
			// Provide `match` to avoid retokenization if we modified the selector above
			(compiled || compile(selector, match))(seed, context, !documentIsHTML, results, !context || rsibling.test(selector) && testContext(context.parentNode) || context);
			return results;
		};

		// One-time assignments

		// Sort stability
		support.sortStable = expando.split("").sort(sortOrder).join("") === expando;

		// Support: Chrome 14-35+
		// Always assume duplicates if they aren't passed to the comparison function
		support.detectDuplicates = !!hasDuplicate;

		// Initialize against the default document
		setDocument();

		// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
		// Detached nodes confoundingly follow *each other*
		support.sortDetached = assert(function (el) {
			// Should return 1, but returns 4 (following)
			return el.compareDocumentPosition(document.createElement("fieldset")) & 1;
		});

		// Support: IE<8
		// Prevent attribute/property "interpolation"
		// https://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
		if (!assert(function (el) {
			el.innerHTML = "<a href='#'></a>";
			return el.firstChild.getAttribute("href") === "#";
		})) {
			addHandle("type|href|height|width", function (elem, name, isXML) {
				if (!isXML) {
					return elem.getAttribute(name, name.toLowerCase() === "type" ? 1 : 2);
				}
			});
		}

		// Support: IE<9
		// Use defaultValue in place of getAttribute("value")
		if (!support.attributes || !assert(function (el) {
			el.innerHTML = "<input/>";
			el.firstChild.setAttribute("value", "");
			return el.firstChild.getAttribute("value") === "";
		})) {
			addHandle("value", function (elem, name, isXML) {
				if (!isXML && elem.nodeName.toLowerCase() === "input") {
					return elem.defaultValue;
				}
			});
		}

		// Support: IE<9
		// Use getAttributeNode to fetch booleans when getAttribute lies
		if (!assert(function (el) {
			return el.getAttribute("disabled") == null;
		})) {
			addHandle(booleans, function (elem, name, isXML) {
				var val;
				if (!isXML) {
					return elem[name] === true ? name.toLowerCase() : (val = elem.getAttributeNode(name)) && val.specified ? val.value : null;
				}
			});
		}

		return Sizzle;
	}(window);

	jQuery.find = Sizzle;
	jQuery.expr = Sizzle.selectors;

	// Deprecated
	jQuery.expr[":"] = jQuery.expr.pseudos;
	jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort;
	jQuery.text = Sizzle.getText;
	jQuery.isXMLDoc = Sizzle.isXML;
	jQuery.contains = Sizzle.contains;
	jQuery.escapeSelector = Sizzle.escape;

	var dir = function dir(elem, _dir, until) {
		var matched = [],
		    truncate = until !== undefined;

		while ((elem = elem[_dir]) && elem.nodeType !== 9) {
			if (elem.nodeType === 1) {
				if (truncate && jQuery(elem).is(until)) {
					break;
				}
				matched.push(elem);
			}
		}
		return matched;
	};

	var _siblings = function _siblings(n, elem) {
		var matched = [];

		for (; n; n = n.nextSibling) {
			if (n.nodeType === 1 && n !== elem) {
				matched.push(n);
			}
		}

		return matched;
	};

	var rneedsContext = jQuery.expr.match.needsContext;

	function nodeName(elem, name) {

		return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
	};
	var rsingleTag = /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i;

	// Implement the identical functionality for filter and not
	function winnow(elements, qualifier, not) {
		if (isFunction(qualifier)) {
			return jQuery.grep(elements, function (elem, i) {
				return !!qualifier.call(elem, i, elem) !== not;
			});
		}

		// Single element
		if (qualifier.nodeType) {
			return jQuery.grep(elements, function (elem) {
				return elem === qualifier !== not;
			});
		}

		// Arraylike of elements (jQuery, arguments, Array)
		if (typeof qualifier !== "string") {
			return jQuery.grep(elements, function (elem) {
				return indexOf.call(qualifier, elem) > -1 !== not;
			});
		}

		// Filtered directly for both simple and complex selectors
		return jQuery.filter(qualifier, elements, not);
	}

	jQuery.filter = function (expr, elems, not) {
		var elem = elems[0];

		if (not) {
			expr = ":not(" + expr + ")";
		}

		if (elems.length === 1 && elem.nodeType === 1) {
			return jQuery.find.matchesSelector(elem, expr) ? [elem] : [];
		}

		return jQuery.find.matches(expr, jQuery.grep(elems, function (elem) {
			return elem.nodeType === 1;
		}));
	};

	jQuery.fn.extend({
		find: function find(selector) {
			var i,
			    ret,
			    len = this.length,
			    self = this;

			if (typeof selector !== "string") {
				return this.pushStack(jQuery(selector).filter(function () {
					for (i = 0; i < len; i++) {
						if (jQuery.contains(self[i], this)) {
							return true;
						}
					}
				}));
			}

			ret = this.pushStack([]);

			for (i = 0; i < len; i++) {
				jQuery.find(selector, self[i], ret);
			}

			return len > 1 ? jQuery.uniqueSort(ret) : ret;
		},
		filter: function filter(selector) {
			return this.pushStack(winnow(this, selector || [], false));
		},
		not: function not(selector) {
			return this.pushStack(winnow(this, selector || [], true));
		},
		is: function is(selector) {
			return !!winnow(this,

			// If this is a positional/relative selector, check membership in the returned set
			// so $("p:first").is("p:last") won't return true for a doc with two "p".
			typeof selector === "string" && rneedsContext.test(selector) ? jQuery(selector) : selector || [], false).length;
		}
	});

	// Initialize a jQuery object


	// A central reference to the root jQuery(document)
	var rootjQuery,


	// A simple way to check for HTML strings
	// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
	// Strict HTML recognition (#11290: must start with <)
	// Shortcut simple #id case for speed
	rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/,
	    init = jQuery.fn.init = function (selector, context, root) {
		var match, elem;

		// HANDLE: $(""), $(null), $(undefined), $(false)
		if (!selector) {
			return this;
		}

		// Method init() accepts an alternate rootjQuery
		// so migrate can support jQuery.sub (gh-2101)
		root = root || rootjQuery;

		// Handle HTML strings
		if (typeof selector === "string") {
			if (selector[0] === "<" && selector[selector.length - 1] === ">" && selector.length >= 3) {

				// Assume that strings that start and end with <> are HTML and skip the regex check
				match = [null, selector, null];
			} else {
				match = rquickExpr.exec(selector);
			}

			// Match html or make sure no context is specified for #id
			if (match && (match[1] || !context)) {

				// HANDLE: $(html) -> $(array)
				if (match[1]) {
					context = context instanceof jQuery ? context[0] : context;

					// Option to run scripts is true for back-compat
					// Intentionally let the error be thrown if parseHTML is not present
					jQuery.merge(this, jQuery.parseHTML(match[1], context && context.nodeType ? context.ownerDocument || context : document, true));

					// HANDLE: $(html, props)
					if (rsingleTag.test(match[1]) && jQuery.isPlainObject(context)) {
						for (match in context) {

							// Properties of context are called as methods if possible
							if (isFunction(this[match])) {
								this[match](context[match]);

								// ...and otherwise set as attributes
							} else {
								this.attr(match, context[match]);
							}
						}
					}

					return this;

					// HANDLE: $(#id)
				} else {
					elem = document.getElementById(match[2]);

					if (elem) {

						// Inject the element directly into the jQuery object
						this[0] = elem;
						this.length = 1;
					}
					return this;
				}

				// HANDLE: $(expr, $(...))
			} else if (!context || context.jquery) {
				return (context || root).find(selector);

				// HANDLE: $(expr, context)
				// (which is just equivalent to: $(context).find(expr)
			} else {
				return this.constructor(context).find(selector);
			}

			// HANDLE: $(DOMElement)
		} else if (selector.nodeType) {
			this[0] = selector;
			this.length = 1;
			return this;

			// HANDLE: $(function)
			// Shortcut for document ready
		} else if (isFunction(selector)) {
			return root.ready !== undefined ? root.ready(selector) :

			// Execute immediately if ready is not present
			selector(jQuery);
		}

		return jQuery.makeArray(selector, this);
	};

	// Give the init function the jQuery prototype for later instantiation
	init.prototype = jQuery.fn;

	// Initialize central reference
	rootjQuery = jQuery(document);

	var rparentsprev = /^(?:parents|prev(?:Until|All))/,


	// Methods guaranteed to produce a unique set when starting from a unique set
	guaranteedUnique = {
		children: true,
		contents: true,
		next: true,
		prev: true
	};

	jQuery.fn.extend({
		has: function has(target) {
			var targets = jQuery(target, this),
			    l = targets.length;

			return this.filter(function () {
				var i = 0;
				for (; i < l; i++) {
					if (jQuery.contains(this, targets[i])) {
						return true;
					}
				}
			});
		},

		closest: function closest(selectors, context) {
			var cur,
			    i = 0,
			    l = this.length,
			    matched = [],
			    targets = typeof selectors !== "string" && jQuery(selectors);

			// Positional selectors never match, since there's no _selection_ context
			if (!rneedsContext.test(selectors)) {
				for (; i < l; i++) {
					for (cur = this[i]; cur && cur !== context; cur = cur.parentNode) {

						// Always skip document fragments
						if (cur.nodeType < 11 && (targets ? targets.index(cur) > -1 :

						// Don't pass non-elements to Sizzle
						cur.nodeType === 1 && jQuery.find.matchesSelector(cur, selectors))) {

							matched.push(cur);
							break;
						}
					}
				}
			}

			return this.pushStack(matched.length > 1 ? jQuery.uniqueSort(matched) : matched);
		},

		// Determine the position of an element within the set
		index: function index(elem) {

			// No argument, return index in parent
			if (!elem) {
				return this[0] && this[0].parentNode ? this.first().prevAll().length : -1;
			}

			// Index in selector
			if (typeof elem === "string") {
				return indexOf.call(jQuery(elem), this[0]);
			}

			// Locate the position of the desired element
			return indexOf.call(this,

			// If it receives a jQuery object, the first element is used
			elem.jquery ? elem[0] : elem);
		},

		add: function add(selector, context) {
			return this.pushStack(jQuery.uniqueSort(jQuery.merge(this.get(), jQuery(selector, context))));
		},

		addBack: function addBack(selector) {
			return this.add(selector == null ? this.prevObject : this.prevObject.filter(selector));
		}
	});

	function sibling(cur, dir) {
		while ((cur = cur[dir]) && cur.nodeType !== 1) {}
		return cur;
	}

	jQuery.each({
		parent: function parent(elem) {
			var parent = elem.parentNode;
			return parent && parent.nodeType !== 11 ? parent : null;
		},
		parents: function parents(elem) {
			return dir(elem, "parentNode");
		},
		parentsUntil: function parentsUntil(elem, i, until) {
			return dir(elem, "parentNode", until);
		},
		next: function next(elem) {
			return sibling(elem, "nextSibling");
		},
		prev: function prev(elem) {
			return sibling(elem, "previousSibling");
		},
		nextAll: function nextAll(elem) {
			return dir(elem, "nextSibling");
		},
		prevAll: function prevAll(elem) {
			return dir(elem, "previousSibling");
		},
		nextUntil: function nextUntil(elem, i, until) {
			return dir(elem, "nextSibling", until);
		},
		prevUntil: function prevUntil(elem, i, until) {
			return dir(elem, "previousSibling", until);
		},
		siblings: function siblings(elem) {
			return _siblings((elem.parentNode || {}).firstChild, elem);
		},
		children: function children(elem) {
			return _siblings(elem.firstChild);
		},
		contents: function contents(elem) {
			if (nodeName(elem, "iframe")) {
				return elem.contentDocument;
			}

			// Support: IE 9 - 11 only, iOS 7 only, Android Browser <=4.3 only
			// Treat the template element as a regular one in browsers that
			// don't support it.
			if (nodeName(elem, "template")) {
				elem = elem.content || elem;
			}

			return jQuery.merge([], elem.childNodes);
		}
	}, function (name, fn) {
		jQuery.fn[name] = function (until, selector) {
			var matched = jQuery.map(this, fn, until);

			if (name.slice(-5) !== "Until") {
				selector = until;
			}

			if (selector && typeof selector === "string") {
				matched = jQuery.filter(selector, matched);
			}

			if (this.length > 1) {

				// Remove duplicates
				if (!guaranteedUnique[name]) {
					jQuery.uniqueSort(matched);
				}

				// Reverse order for parents* and prev-derivatives
				if (rparentsprev.test(name)) {
					matched.reverse();
				}
			}

			return this.pushStack(matched);
		};
	});
	var rnothtmlwhite = /[^\x20\t\r\n\f]+/g;

	// Convert String-formatted options into Object-formatted ones
	function createOptions(options) {
		var object = {};
		jQuery.each(options.match(rnothtmlwhite) || [], function (_, flag) {
			object[flag] = true;
		});
		return object;
	}

	/*
  * Create a callback list using the following parameters:
  *
  *	options: an optional list of space-separated options that will change how
  *			the callback list behaves or a more traditional option object
  *
  * By default a callback list will act like an event callback list and can be
  * "fired" multiple times.
  *
  * Possible options:
  *
  *	once:			will ensure the callback list can only be fired once (like a Deferred)
  *
  *	memory:			will keep track of previous values and will call any callback added
  *					after the list has been fired right away with the latest "memorized"
  *					values (like a Deferred)
  *
  *	unique:			will ensure a callback can only be added once (no duplicate in the list)
  *
  *	stopOnFalse:	interrupt callings when a callback returns false
  *
  */
	jQuery.Callbacks = function (options) {

		// Convert options from String-formatted to Object-formatted if needed
		// (we check in cache first)
		options = typeof options === "string" ? createOptions(options) : jQuery.extend({}, options);

		var // Flag to know if list is currently firing
		firing,


		// Last fire value for non-forgettable lists
		memory,


		// Flag to know if list was already fired
		_fired,


		// Flag to prevent firing
		_locked,


		// Actual callback list
		list = [],


		// Queue of execution data for repeatable lists
		queue = [],


		// Index of currently firing callback (modified by add/remove as needed)
		firingIndex = -1,


		// Fire callbacks
		fire = function fire() {

			// Enforce single-firing
			_locked = _locked || options.once;

			// Execute callbacks for all pending executions,
			// respecting firingIndex overrides and runtime changes
			_fired = firing = true;
			for (; queue.length; firingIndex = -1) {
				memory = queue.shift();
				while (++firingIndex < list.length) {

					// Run callback and check for early termination
					if (list[firingIndex].apply(memory[0], memory[1]) === false && options.stopOnFalse) {

						// Jump to end and forget the data so .add doesn't re-fire
						firingIndex = list.length;
						memory = false;
					}
				}
			}

			// Forget the data if we're done with it
			if (!options.memory) {
				memory = false;
			}

			firing = false;

			// Clean up if we're done firing for good
			if (_locked) {

				// Keep an empty list if we have data for future add calls
				if (memory) {
					list = [];

					// Otherwise, this object is spent
				} else {
					list = "";
				}
			}
		},


		// Actual Callbacks object
		self = {

			// Add a callback or a collection of callbacks to the list
			add: function add() {
				if (list) {

					// If we have memory from a past run, we should fire after adding
					if (memory && !firing) {
						firingIndex = list.length - 1;
						queue.push(memory);
					}

					(function add(args) {
						jQuery.each(args, function (_, arg) {
							if (isFunction(arg)) {
								if (!options.unique || !self.has(arg)) {
									list.push(arg);
								}
							} else if (arg && arg.length && toType(arg) !== "string") {

								// Inspect recursively
								add(arg);
							}
						});
					})(arguments);

					if (memory && !firing) {
						fire();
					}
				}
				return this;
			},

			// Remove a callback from the list
			remove: function remove() {
				jQuery.each(arguments, function (_, arg) {
					var index;
					while ((index = jQuery.inArray(arg, list, index)) > -1) {
						list.splice(index, 1);

						// Handle firing indexes
						if (index <= firingIndex) {
							firingIndex--;
						}
					}
				});
				return this;
			},

			// Check if a given callback is in the list.
			// If no argument is given, return whether or not list has callbacks attached.
			has: function has(fn) {
				return fn ? jQuery.inArray(fn, list) > -1 : list.length > 0;
			},

			// Remove all callbacks from the list
			empty: function empty() {
				if (list) {
					list = [];
				}
				return this;
			},

			// Disable .fire and .add
			// Abort any current/pending executions
			// Clear all callbacks and values
			disable: function disable() {
				_locked = queue = [];
				list = memory = "";
				return this;
			},
			disabled: function disabled() {
				return !list;
			},

			// Disable .fire
			// Also disable .add unless we have memory (since it would have no effect)
			// Abort any pending executions
			lock: function lock() {
				_locked = queue = [];
				if (!memory && !firing) {
					list = memory = "";
				}
				return this;
			},
			locked: function locked() {
				return !!_locked;
			},

			// Call all callbacks with the given context and arguments
			fireWith: function fireWith(context, args) {
				if (!_locked) {
					args = args || [];
					args = [context, args.slice ? args.slice() : args];
					queue.push(args);
					if (!firing) {
						fire();
					}
				}
				return this;
			},

			// Call all the callbacks with the given arguments
			fire: function fire() {
				self.fireWith(this, arguments);
				return this;
			},

			// To know if the callbacks have already been called at least once
			fired: function fired() {
				return !!_fired;
			}
		};

		return self;
	};

	function Identity(v) {
		return v;
	}
	function Thrower(ex) {
		throw ex;
	}

	function adoptValue(value, resolve, reject, noValue) {
		var method;

		try {

			// Check for promise aspect first to privilege synchronous behavior
			if (value && isFunction(method = value.promise)) {
				method.call(value).done(resolve).fail(reject);

				// Other thenables
			} else if (value && isFunction(method = value.then)) {
				method.call(value, resolve, reject);

				// Other non-thenables
			} else {

				// Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer:
				// * false: [ value ].slice( 0 ) => resolve( value )
				// * true: [ value ].slice( 1 ) => resolve()
				resolve.apply(undefined, [value].slice(noValue));
			}

			// For Promises/A+, convert exceptions into rejections
			// Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in
			// Deferred#then to conditionally suppress rejection.
		} catch (value) {

			// Support: Android 4.0 only
			// Strict mode functions invoked without .call/.apply get global-object context
			reject.apply(undefined, [value]);
		}
	}

	jQuery.extend({

		Deferred: function Deferred(func) {
			var tuples = [

			// action, add listener, callbacks,
			// ... .then handlers, argument index, [final state]
			["notify", "progress", jQuery.Callbacks("memory"), jQuery.Callbacks("memory"), 2], ["resolve", "done", jQuery.Callbacks("once memory"), jQuery.Callbacks("once memory"), 0, "resolved"], ["reject", "fail", jQuery.Callbacks("once memory"), jQuery.Callbacks("once memory"), 1, "rejected"]],
			    _state = "pending",
			    _promise = {
				state: function state() {
					return _state;
				},
				always: function always() {
					deferred.done(arguments).fail(arguments);
					return this;
				},
				"catch": function _catch(fn) {
					return _promise.then(null, fn);
				},

				// Keep pipe for back-compat
				pipe: function pipe() /* fnDone, fnFail, fnProgress */{
					var fns = arguments;

					return jQuery.Deferred(function (newDefer) {
						jQuery.each(tuples, function (i, tuple) {

							// Map tuples (progress, done, fail) to arguments (done, fail, progress)
							var fn = isFunction(fns[tuple[4]]) && fns[tuple[4]];

							// deferred.progress(function() { bind to newDefer or newDefer.notify })
							// deferred.done(function() { bind to newDefer or newDefer.resolve })
							// deferred.fail(function() { bind to newDefer or newDefer.reject })
							deferred[tuple[1]](function () {
								var returned = fn && fn.apply(this, arguments);
								if (returned && isFunction(returned.promise)) {
									returned.promise().progress(newDefer.notify).done(newDefer.resolve).fail(newDefer.reject);
								} else {
									newDefer[tuple[0] + "With"](this, fn ? [returned] : arguments);
								}
							});
						});
						fns = null;
					}).promise();
				},
				then: function then(onFulfilled, onRejected, onProgress) {
					var maxDepth = 0;
					function resolve(depth, deferred, handler, special) {
						return function () {
							var that = this,
							    args = arguments,
							    mightThrow = function mightThrow() {
								var returned, then;

								// Support: Promises/A+ section 2.3.3.3.3
								// https://promisesaplus.com/#point-59
								// Ignore double-resolution attempts
								if (depth < maxDepth) {
									return;
								}

								returned = handler.apply(that, args);

								// Support: Promises/A+ section 2.3.1
								// https://promisesaplus.com/#point-48
								if (returned === deferred.promise()) {
									throw new TypeError("Thenable self-resolution");
								}

								// Support: Promises/A+ sections 2.3.3.1, 3.5
								// https://promisesaplus.com/#point-54
								// https://promisesaplus.com/#point-75
								// Retrieve `then` only once
								then = returned && (

								// Support: Promises/A+ section 2.3.4
								// https://promisesaplus.com/#point-64
								// Only check objects and functions for thenability
								(typeof returned === "undefined" ? "undefined" : _typeof(returned)) === "object" || typeof returned === "function") && returned.then;

								// Handle a returned thenable
								if (isFunction(then)) {

									// Special processors (notify) just wait for resolution
									if (special) {
										then.call(returned, resolve(maxDepth, deferred, Identity, special), resolve(maxDepth, deferred, Thrower, special));

										// Normal processors (resolve) also hook into progress
									} else {

										// ...and disregard older resolution values
										maxDepth++;

										then.call(returned, resolve(maxDepth, deferred, Identity, special), resolve(maxDepth, deferred, Thrower, special), resolve(maxDepth, deferred, Identity, deferred.notifyWith));
									}

									// Handle all other returned values
								} else {

									// Only substitute handlers pass on context
									// and multiple values (non-spec behavior)
									if (handler !== Identity) {
										that = undefined;
										args = [returned];
									}

									// Process the value(s)
									// Default process is resolve
									(special || deferred.resolveWith)(that, args);
								}
							},


							// Only normal processors (resolve) catch and reject exceptions
							process = special ? mightThrow : function () {
								try {
									mightThrow();
								} catch (e) {

									if (jQuery.Deferred.exceptionHook) {
										jQuery.Deferred.exceptionHook(e, process.stackTrace);
									}

									// Support: Promises/A+ section 2.3.3.3.4.1
									// https://promisesaplus.com/#point-61
									// Ignore post-resolution exceptions
									if (depth + 1 >= maxDepth) {

										// Only substitute handlers pass on context
										// and multiple values (non-spec behavior)
										if (handler !== Thrower) {
											that = undefined;
											args = [e];
										}

										deferred.rejectWith(that, args);
									}
								}
							};

							// Support: Promises/A+ section 2.3.3.3.1
							// https://promisesaplus.com/#point-57
							// Re-resolve promises immediately to dodge false rejection from
							// subsequent errors
							if (depth) {
								process();
							} else {

								// Call an optional hook to record the stack, in case of exception
								// since it's otherwise lost when execution goes async
								if (jQuery.Deferred.getStackHook) {
									process.stackTrace = jQuery.Deferred.getStackHook();
								}
								window.setTimeout(process);
							}
						};
					}

					return jQuery.Deferred(function (newDefer) {

						// progress_handlers.add( ... )
						tuples[0][3].add(resolve(0, newDefer, isFunction(onProgress) ? onProgress : Identity, newDefer.notifyWith));

						// fulfilled_handlers.add( ... )
						tuples[1][3].add(resolve(0, newDefer, isFunction(onFulfilled) ? onFulfilled : Identity));

						// rejected_handlers.add( ... )
						tuples[2][3].add(resolve(0, newDefer, isFunction(onRejected) ? onRejected : Thrower));
					}).promise();
				},

				// Get a promise for this deferred
				// If obj is provided, the promise aspect is added to the object
				promise: function promise(obj) {
					return obj != null ? jQuery.extend(obj, _promise) : _promise;
				}
			},
			    deferred = {};

			// Add list-specific methods
			jQuery.each(tuples, function (i, tuple) {
				var list = tuple[2],
				    stateString = tuple[5];

				// promise.progress = list.add
				// promise.done = list.add
				// promise.fail = list.add
				_promise[tuple[1]] = list.add;

				// Handle state
				if (stateString) {
					list.add(function () {

						// state = "resolved" (i.e., fulfilled)
						// state = "rejected"
						_state = stateString;
					},

					// rejected_callbacks.disable
					// fulfilled_callbacks.disable
					tuples[3 - i][2].disable,

					// rejected_handlers.disable
					// fulfilled_handlers.disable
					tuples[3 - i][3].disable,

					// progress_callbacks.lock
					tuples[0][2].lock,

					// progress_handlers.lock
					tuples[0][3].lock);
				}

				// progress_handlers.fire
				// fulfilled_handlers.fire
				// rejected_handlers.fire
				list.add(tuple[3].fire);

				// deferred.notify = function() { deferred.notifyWith(...) }
				// deferred.resolve = function() { deferred.resolveWith(...) }
				// deferred.reject = function() { deferred.rejectWith(...) }
				deferred[tuple[0]] = function () {
					deferred[tuple[0] + "With"](this === deferred ? undefined : this, arguments);
					return this;
				};

				// deferred.notifyWith = list.fireWith
				// deferred.resolveWith = list.fireWith
				// deferred.rejectWith = list.fireWith
				deferred[tuple[0] + "With"] = list.fireWith;
			});

			// Make the deferred a promise
			_promise.promise(deferred);

			// Call given func if any
			if (func) {
				func.call(deferred, deferred);
			}

			// All done!
			return deferred;
		},

		// Deferred helper
		when: function when(singleValue) {
			var

			// count of uncompleted subordinates
			remaining = arguments.length,


			// count of unprocessed arguments
			i = remaining,


			// subordinate fulfillment data
			resolveContexts = Array(i),
			    resolveValues = _slice.call(arguments),


			// the master Deferred
			master = jQuery.Deferred(),


			// subordinate callback factory
			updateFunc = function updateFunc(i) {
				return function (value) {
					resolveContexts[i] = this;
					resolveValues[i] = arguments.length > 1 ? _slice.call(arguments) : value;
					if (! --remaining) {
						master.resolveWith(resolveContexts, resolveValues);
					}
				};
			};

			// Single- and empty arguments are adopted like Promise.resolve
			if (remaining <= 1) {
				adoptValue(singleValue, master.done(updateFunc(i)).resolve, master.reject, !remaining);

				// Use .then() to unwrap secondary thenables (cf. gh-3000)
				if (master.state() === "pending" || isFunction(resolveValues[i] && resolveValues[i].then)) {

					return master.then();
				}
			}

			// Multiple arguments are aggregated like Promise.all array elements
			while (i--) {
				adoptValue(resolveValues[i], updateFunc(i), master.reject);
			}

			return master.promise();
		}
	});

	// These usually indicate a programmer mistake during development,
	// warn about them ASAP rather than swallowing them by default.
	var rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;

	jQuery.Deferred.exceptionHook = function (error, stack) {

		// Support: IE 8 - 9 only
		// Console exists when dev tools are open, which can happen at any time
		if (window.console && window.console.warn && error && rerrorNames.test(error.name)) {
			window.console.warn("jQuery.Deferred exception: " + error.message, error.stack, stack);
		}
	};

	jQuery.readyException = function (error) {
		window.setTimeout(function () {
			throw error;
		});
	};

	// The deferred used on DOM ready
	var readyList = jQuery.Deferred();

	jQuery.fn.ready = function (fn) {

		readyList.then(fn)

		// Wrap jQuery.readyException in a function so that the lookup
		// happens at the time of error handling instead of callback
		// registration.
		.catch(function (error) {
			jQuery.readyException(error);
		});

		return this;
	};

	jQuery.extend({

		// Is the DOM ready to be used? Set to true once it occurs.
		isReady: false,

		// A counter to track how many items to wait for before
		// the ready event fires. See #6781
		readyWait: 1,

		// Handle when the DOM is ready
		ready: function ready(wait) {

			// Abort if there are pending holds or we're already ready
			if (wait === true ? --jQuery.readyWait : jQuery.isReady) {
				return;
			}

			// Remember that the DOM is ready
			jQuery.isReady = true;

			// If a normal DOM Ready event fired, decrement, and wait if need be
			if (wait !== true && --jQuery.readyWait > 0) {
				return;
			}

			// If there are functions bound, to execute
			readyList.resolveWith(document, [jQuery]);
		}
	});

	jQuery.ready.then = readyList.then;

	// The ready event handler and self cleanup method
	function completed() {
		document.removeEventListener("DOMContentLoaded", completed);
		window.removeEventListener("load", completed);
		jQuery.ready();
	}

	// Catch cases where $(document).ready() is called
	// after the browser event has already occurred.
	// Support: IE <=9 - 10 only
	// Older IE sometimes signals "interactive" too soon
	if (document.readyState === "complete" || document.readyState !== "loading" && !document.documentElement.doScroll) {

		// Handle it asynchronously to allow scripts the opportunity to delay ready
		window.setTimeout(jQuery.ready);
	} else {

		// Use the handy event callback
		document.addEventListener("DOMContentLoaded", completed);

		// A fallback to window.onload, that will always work
		window.addEventListener("load", completed);
	}

	// Multifunctional method to get and set values of a collection
	// The value/s can optionally be executed if it's a function
	var access = function access(elems, fn, key, value, chainable, emptyGet, raw) {
		var i = 0,
		    len = elems.length,
		    bulk = key == null;

		// Sets many values
		if (toType(key) === "object") {
			chainable = true;
			for (i in key) {
				access(elems, fn, i, key[i], true, emptyGet, raw);
			}

			// Sets one value
		} else if (value !== undefined) {
			chainable = true;

			if (!isFunction(value)) {
				raw = true;
			}

			if (bulk) {

				// Bulk operations run against the entire set
				if (raw) {
					fn.call(elems, value);
					fn = null;

					// ...except when executing function values
				} else {
					bulk = fn;
					fn = function fn(elem, key, value) {
						return bulk.call(jQuery(elem), value);
					};
				}
			}

			if (fn) {
				for (; i < len; i++) {
					fn(elems[i], key, raw ? value : value.call(elems[i], i, fn(elems[i], key)));
				}
			}
		}

		if (chainable) {
			return elems;
		}

		// Gets
		if (bulk) {
			return fn.call(elems);
		}

		return len ? fn(elems[0], key) : emptyGet;
	};

	// Matches dashed string for camelizing
	var rmsPrefix = /^-ms-/,
	    rdashAlpha = /-([a-z])/g;

	// Used by camelCase as callback to replace()
	function fcamelCase(all, letter) {
		return letter.toUpperCase();
	}

	// Convert dashed to camelCase; used by the css and data modules
	// Support: IE <=9 - 11, Edge 12 - 15
	// Microsoft forgot to hump their vendor prefix (#9572)
	function camelCase(string) {
		return string.replace(rmsPrefix, "ms-").replace(rdashAlpha, fcamelCase);
	}
	var acceptData = function acceptData(owner) {

		// Accepts only:
		//  - Node
		//    - Node.ELEMENT_NODE
		//    - Node.DOCUMENT_NODE
		//  - Object
		//    - Any
		return owner.nodeType === 1 || owner.nodeType === 9 || !+owner.nodeType;
	};

	function Data() {
		this.expando = jQuery.expando + Data.uid++;
	}

	Data.uid = 1;

	Data.prototype = {

		cache: function cache(owner) {

			// Check if the owner object already has a cache
			var value = owner[this.expando];

			// If not, create one
			if (!value) {
				value = {};

				// We can accept data for non-element nodes in modern browsers,
				// but we should not, see #8335.
				// Always return an empty object.
				if (acceptData(owner)) {

					// If it is a node unlikely to be stringify-ed or looped over
					// use plain assignment
					if (owner.nodeType) {
						owner[this.expando] = value;

						// Otherwise secure it in a non-enumerable property
						// configurable must be true to allow the property to be
						// deleted when data is removed
					} else {
						Object.defineProperty(owner, this.expando, {
							value: value,
							configurable: true
						});
					}
				}
			}

			return value;
		},
		set: function set(owner, data, value) {
			var prop,
			    cache = this.cache(owner);

			// Handle: [ owner, key, value ] args
			// Always use camelCase key (gh-2257)
			if (typeof data === "string") {
				cache[camelCase(data)] = value;

				// Handle: [ owner, { properties } ] args
			} else {

				// Copy the properties one-by-one to the cache object
				for (prop in data) {
					cache[camelCase(prop)] = data[prop];
				}
			}
			return cache;
		},
		get: function get(owner, key) {
			return key === undefined ? this.cache(owner) :

			// Always use camelCase key (gh-2257)
			owner[this.expando] && owner[this.expando][camelCase(key)];
		},
		access: function access(owner, key, value) {

			// In cases where either:
			//
			//   1. No key was specified
			//   2. A string key was specified, but no value provided
			//
			// Take the "read" path and allow the get method to determine
			// which value to return, respectively either:
			//
			//   1. The entire cache object
			//   2. The data stored at the key
			//
			if (key === undefined || key && typeof key === "string" && value === undefined) {

				return this.get(owner, key);
			}

			// When the key is not a string, or both a key and value
			// are specified, set or extend (existing objects) with either:
			//
			//   1. An object of properties
			//   2. A key and value
			//
			this.set(owner, key, value);

			// Since the "set" path can have two possible entry points
			// return the expected data based on which path was taken[*]
			return value !== undefined ? value : key;
		},
		remove: function remove(owner, key) {
			var i,
			    cache = owner[this.expando];

			if (cache === undefined) {
				return;
			}

			if (key !== undefined) {

				// Support array or space separated string of keys
				if (Array.isArray(key)) {

					// If key is an array of keys...
					// We always set camelCase keys, so remove that.
					key = key.map(camelCase);
				} else {
					key = camelCase(key);

					// If a key with the spaces exists, use it.
					// Otherwise, create an array by matching non-whitespace
					key = key in cache ? [key] : key.match(rnothtmlwhite) || [];
				}

				i = key.length;

				while (i--) {
					delete cache[key[i]];
				}
			}

			// Remove the expando if there's no more data
			if (key === undefined || jQuery.isEmptyObject(cache)) {

				// Support: Chrome <=35 - 45
				// Webkit & Blink performance suffers when deleting properties
				// from DOM nodes, so set to undefined instead
				// https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted)
				if (owner.nodeType) {
					owner[this.expando] = undefined;
				} else {
					delete owner[this.expando];
				}
			}
		},
		hasData: function hasData(owner) {
			var cache = owner[this.expando];
			return cache !== undefined && !jQuery.isEmptyObject(cache);
		}
	};
	var dataPriv = new Data();

	var dataUser = new Data();

	//	Implementation Summary
	//
	//	1. Enforce API surface and semantic compatibility with 1.9.x branch
	//	2. Improve the module's maintainability by reducing the storage
	//		paths to a single mechanism.
	//	3. Use the same single mechanism to support "private" and "user" data.
	//	4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData)
	//	5. Avoid exposing implementation details on user objects (eg. expando properties)
	//	6. Provide a clear path for implementation upgrade to WeakMap in 2014

	var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,
	    rmultiDash = /[A-Z]/g;

	function getData(data) {
		if (data === "true") {
			return true;
		}

		if (data === "false") {
			return false;
		}

		if (data === "null") {
			return null;
		}

		// Only convert to a number if it doesn't change the string
		if (data === +data + "") {
			return +data;
		}

		if (rbrace.test(data)) {
			return JSON.parse(data);
		}

		return data;
	}

	function dataAttr(elem, key, data) {
		var name;

		// If nothing was found internally, try to fetch any
		// data from the HTML5 data-* attribute
		if (data === undefined && elem.nodeType === 1) {
			name = "data-" + key.replace(rmultiDash, "-$&").toLowerCase();
			data = elem.getAttribute(name);

			if (typeof data === "string") {
				try {
					data = getData(data);
				} catch (e) {}

				// Make sure we set the data so it isn't changed later
				dataUser.set(elem, key, data);
			} else {
				data = undefined;
			}
		}
		return data;
	}

	jQuery.extend({
		hasData: function hasData(elem) {
			return dataUser.hasData(elem) || dataPriv.hasData(elem);
		},

		data: function data(elem, name, _data) {
			return dataUser.access(elem, name, _data);
		},

		removeData: function removeData(elem, name) {
			dataUser.remove(elem, name);
		},

		// TODO: Now that all calls to _data and _removeData have been replaced
		// with direct calls to dataPriv methods, these can be deprecated.
		_data: function _data(elem, name, data) {
			return dataPriv.access(elem, name, data);
		},

		_removeData: function _removeData(elem, name) {
			dataPriv.remove(elem, name);
		}
	});

	jQuery.fn.extend({
		data: function data(key, value) {
			var i,
			    name,
			    data,
			    elem = this[0],
			    attrs = elem && elem.attributes;

			// Gets all values
			if (key === undefined) {
				if (this.length) {
					data = dataUser.get(elem);

					if (elem.nodeType === 1 && !dataPriv.get(elem, "hasDataAttrs")) {
						i = attrs.length;
						while (i--) {

							// Support: IE 11 only
							// The attrs elements can be null (#14894)
							if (attrs[i]) {
								name = attrs[i].name;
								if (name.indexOf("data-") === 0) {
									name = camelCase(name.slice(5));
									dataAttr(elem, name, data[name]);
								}
							}
						}
						dataPriv.set(elem, "hasDataAttrs", true);
					}
				}

				return data;
			}

			// Sets multiple values
			if ((typeof key === "undefined" ? "undefined" : _typeof(key)) === "object") {
				return this.each(function () {
					dataUser.set(this, key);
				});
			}

			return access(this, function (value) {
				var data;

				// The calling jQuery object (element matches) is not empty
				// (and therefore has an element appears at this[ 0 ]) and the
				// `value` parameter was not undefined. An empty jQuery object
				// will result in `undefined` for elem = this[ 0 ] which will
				// throw an exception if an attempt to read a data cache is made.
				if (elem && value === undefined) {

					// Attempt to get data from the cache
					// The key will always be camelCased in Data
					data = dataUser.get(elem, key);
					if (data !== undefined) {
						return data;
					}

					// Attempt to "discover" the data in
					// HTML5 custom data-* attrs
					data = dataAttr(elem, key);
					if (data !== undefined) {
						return data;
					}

					// We tried really hard, but the data doesn't exist.
					return;
				}

				// Set the data...
				this.each(function () {

					// We always store the camelCased key
					dataUser.set(this, key, value);
				});
			}, null, value, arguments.length > 1, null, true);
		},

		removeData: function removeData(key) {
			return this.each(function () {
				dataUser.remove(this, key);
			});
		}
	});

	jQuery.extend({
		queue: function queue(elem, type, data) {
			var queue;

			if (elem) {
				type = (type || "fx") + "queue";
				queue = dataPriv.get(elem, type);

				// Speed up dequeue by getting out quickly if this is just a lookup
				if (data) {
					if (!queue || Array.isArray(data)) {
						queue = dataPriv.access(elem, type, jQuery.makeArray(data));
					} else {
						queue.push(data);
					}
				}
				return queue || [];
			}
		},

		dequeue: function dequeue(elem, type) {
			type = type || "fx";

			var queue = jQuery.queue(elem, type),
			    startLength = queue.length,
			    fn = queue.shift(),
			    hooks = jQuery._queueHooks(elem, type),
			    next = function next() {
				jQuery.dequeue(elem, type);
			};

			// If the fx queue is dequeued, always remove the progress sentinel
			if (fn === "inprogress") {
				fn = queue.shift();
				startLength--;
			}

			if (fn) {

				// Add a progress sentinel to prevent the fx queue from being
				// automatically dequeued
				if (type === "fx") {
					queue.unshift("inprogress");
				}

				// Clear up the last queue stop function
				delete hooks.stop;
				fn.call(elem, next, hooks);
			}

			if (!startLength && hooks) {
				hooks.empty.fire();
			}
		},

		// Not public - generate a queueHooks object, or return the current one
		_queueHooks: function _queueHooks(elem, type) {
			var key = type + "queueHooks";
			return dataPriv.get(elem, key) || dataPriv.access(elem, key, {
				empty: jQuery.Callbacks("once memory").add(function () {
					dataPriv.remove(elem, [type + "queue", key]);
				})
			});
		}
	});

	jQuery.fn.extend({
		queue: function queue(type, data) {
			var setter = 2;

			if (typeof type !== "string") {
				data = type;
				type = "fx";
				setter--;
			}

			if (arguments.length < setter) {
				return jQuery.queue(this[0], type);
			}

			return data === undefined ? this : this.each(function () {
				var queue = jQuery.queue(this, type, data);

				// Ensure a hooks for this queue
				jQuery._queueHooks(this, type);

				if (type === "fx" && queue[0] !== "inprogress") {
					jQuery.dequeue(this, type);
				}
			});
		},
		dequeue: function dequeue(type) {
			return this.each(function () {
				jQuery.dequeue(this, type);
			});
		},
		clearQueue: function clearQueue(type) {
			return this.queue(type || "fx", []);
		},

		// Get a promise resolved when queues of a certain type
		// are emptied (fx is the type by default)
		promise: function promise(type, obj) {
			var tmp,
			    count = 1,
			    defer = jQuery.Deferred(),
			    elements = this,
			    i = this.length,
			    resolve = function resolve() {
				if (! --count) {
					defer.resolveWith(elements, [elements]);
				}
			};

			if (typeof type !== "string") {
				obj = type;
				type = undefined;
			}
			type = type || "fx";

			while (i--) {
				tmp = dataPriv.get(elements[i], type + "queueHooks");
				if (tmp && tmp.empty) {
					count++;
					tmp.empty.add(resolve);
				}
			}
			resolve();
			return defer.promise(obj);
		}
	});
	var pnum = /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source;

	var rcssNum = new RegExp("^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i");

	var cssExpand = ["Top", "Right", "Bottom", "Left"];

	var isHiddenWithinTree = function isHiddenWithinTree(elem, el) {

		// isHiddenWithinTree might be called from jQuery#filter function;
		// in that case, element will be second argument
		elem = el || elem;

		// Inline style trumps all
		return elem.style.display === "none" || elem.style.display === "" &&

		// Otherwise, check computed style
		// Support: Firefox <=43 - 45
		// Disconnected elements can have computed display: none, so first confirm that elem is
		// in the document.
		jQuery.contains(elem.ownerDocument, elem) && jQuery.css(elem, "display") === "none";
	};

	var swap = function swap(elem, options, callback, args) {
		var ret,
		    name,
		    old = {};

		// Remember the old values, and insert the new ones
		for (name in options) {
			old[name] = elem.style[name];
			elem.style[name] = options[name];
		}

		ret = callback.apply(elem, args || []);

		// Revert the old values
		for (name in options) {
			elem.style[name] = old[name];
		}

		return ret;
	};

	function adjustCSS(elem, prop, valueParts, tween) {
		var adjusted,
		    scale,
		    maxIterations = 20,
		    currentValue = tween ? function () {
			return tween.cur();
		} : function () {
			return jQuery.css(elem, prop, "");
		},
		    initial = currentValue(),
		    unit = valueParts && valueParts[3] || (jQuery.cssNumber[prop] ? "" : "px"),


		// Starting value computation is required for potential unit mismatches
		initialInUnit = (jQuery.cssNumber[prop] || unit !== "px" && +initial) && rcssNum.exec(jQuery.css(elem, prop));

		if (initialInUnit && initialInUnit[3] !== unit) {

			// Support: Firefox <=54
			// Halve the iteration target value to prevent interference from CSS upper bounds (gh-2144)
			initial = initial / 2;

			// Trust units reported by jQuery.css
			unit = unit || initialInUnit[3];

			// Iteratively approximate from a nonzero starting point
			initialInUnit = +initial || 1;

			while (maxIterations--) {

				// Evaluate and update our best guess (doubling guesses that zero out).
				// Finish if the scale equals or crosses 1 (making the old*new product non-positive).
				jQuery.style(elem, prop, initialInUnit + unit);
				if ((1 - scale) * (1 - (scale = currentValue() / initial || 0.5)) <= 0) {
					maxIterations = 0;
				}
				initialInUnit = initialInUnit / scale;
			}

			initialInUnit = initialInUnit * 2;
			jQuery.style(elem, prop, initialInUnit + unit);

			// Make sure we update the tween properties later on
			valueParts = valueParts || [];
		}

		if (valueParts) {
			initialInUnit = +initialInUnit || +initial || 0;

			// Apply relative offset (+=/-=) if specified
			adjusted = valueParts[1] ? initialInUnit + (valueParts[1] + 1) * valueParts[2] : +valueParts[2];
			if (tween) {
				tween.unit = unit;
				tween.start = initialInUnit;
				tween.end = adjusted;
			}
		}
		return adjusted;
	}

	var defaultDisplayMap = {};

	function getDefaultDisplay(elem) {
		var temp,
		    doc = elem.ownerDocument,
		    nodeName = elem.nodeName,
		    display = defaultDisplayMap[nodeName];

		if (display) {
			return display;
		}

		temp = doc.body.appendChild(doc.createElement(nodeName));
		display = jQuery.css(temp, "display");

		temp.parentNode.removeChild(temp);

		if (display === "none") {
			display = "block";
		}
		defaultDisplayMap[nodeName] = display;

		return display;
	}

	function showHide(elements, show) {
		var display,
		    elem,
		    values = [],
		    index = 0,
		    length = elements.length;

		// Determine new display value for elements that need to change
		for (; index < length; index++) {
			elem = elements[index];
			if (!elem.style) {
				continue;
			}

			display = elem.style.display;
			if (show) {

				// Since we force visibility upon cascade-hidden elements, an immediate (and slow)
				// check is required in this first loop unless we have a nonempty display value (either
				// inline or about-to-be-restored)
				if (display === "none") {
					values[index] = dataPriv.get(elem, "display") || null;
					if (!values[index]) {
						elem.style.display = "";
					}
				}
				if (elem.style.display === "" && isHiddenWithinTree(elem)) {
					values[index] = getDefaultDisplay(elem);
				}
			} else {
				if (display !== "none") {
					values[index] = "none";

					// Remember what we're overwriting
					dataPriv.set(elem, "display", display);
				}
			}
		}

		// Set the display of the elements in a second loop to avoid constant reflow
		for (index = 0; index < length; index++) {
			if (values[index] != null) {
				elements[index].style.display = values[index];
			}
		}

		return elements;
	}

	jQuery.fn.extend({
		show: function show() {
			return showHide(this, true);
		},
		hide: function hide() {
			return showHide(this);
		},
		toggle: function toggle(state) {
			if (typeof state === "boolean") {
				return state ? this.show() : this.hide();
			}

			return this.each(function () {
				if (isHiddenWithinTree(this)) {
					jQuery(this).show();
				} else {
					jQuery(this).hide();
				}
			});
		}
	});
	var rcheckableType = /^(?:checkbox|radio)$/i;

	var rtagName = /<([a-z][^\/\0>\x20\t\r\n\f]+)/i;

	var rscriptType = /^$|^module$|\/(?:java|ecma)script/i;

	// We have to close these tags to support XHTML (#13200)
	var wrapMap = {

		// Support: IE <=9 only
		option: [1, "<select multiple='multiple'>", "</select>"],

		// XHTML parsers do not magically insert elements in the
		// same way that tag soup parsers do. So we cannot shorten
		// this by omitting <tbody> or other required elements.
		thead: [1, "<table>", "</table>"],
		col: [2, "<table><colgroup>", "</colgroup></table>"],
		tr: [2, "<table><tbody>", "</tbody></table>"],
		td: [3, "<table><tbody><tr>", "</tr></tbody></table>"],

		_default: [0, "", ""]
	};

	// Support: IE <=9 only
	wrapMap.optgroup = wrapMap.option;

	wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
	wrapMap.th = wrapMap.td;

	function getAll(context, tag) {

		// Support: IE <=9 - 11 only
		// Use typeof to avoid zero-argument method invocation on host objects (#15151)
		var ret;

		if (typeof context.getElementsByTagName !== "undefined") {
			ret = context.getElementsByTagName(tag || "*");
		} else if (typeof context.querySelectorAll !== "undefined") {
			ret = context.querySelectorAll(tag || "*");
		} else {
			ret = [];
		}

		if (tag === undefined || tag && nodeName(context, tag)) {
			return jQuery.merge([context], ret);
		}

		return ret;
	}

	// Mark scripts as having already been evaluated
	function setGlobalEval(elems, refElements) {
		var i = 0,
		    l = elems.length;

		for (; i < l; i++) {
			dataPriv.set(elems[i], "globalEval", !refElements || dataPriv.get(refElements[i], "globalEval"));
		}
	}

	var rhtml = /<|&#?\w+;/;

	function buildFragment(elems, context, scripts, selection, ignored) {
		var elem,
		    tmp,
		    tag,
		    wrap,
		    contains,
		    j,
		    fragment = context.createDocumentFragment(),
		    nodes = [],
		    i = 0,
		    l = elems.length;

		for (; i < l; i++) {
			elem = elems[i];

			if (elem || elem === 0) {

				// Add nodes directly
				if (toType(elem) === "object") {

					// Support: Android <=4.0 only, PhantomJS 1 only
					// push.apply(_, arraylike) throws on ancient WebKit
					jQuery.merge(nodes, elem.nodeType ? [elem] : elem);

					// Convert non-html into a text node
				} else if (!rhtml.test(elem)) {
					nodes.push(context.createTextNode(elem));

					// Convert html into DOM nodes
				} else {
					tmp = tmp || fragment.appendChild(context.createElement("div"));

					// Deserialize a standard representation
					tag = (rtagName.exec(elem) || ["", ""])[1].toLowerCase();
					wrap = wrapMap[tag] || wrapMap._default;
					tmp.innerHTML = wrap[1] + jQuery.htmlPrefilter(elem) + wrap[2];

					// Descend through wrappers to the right content
					j = wrap[0];
					while (j--) {
						tmp = tmp.lastChild;
					}

					// Support: Android <=4.0 only, PhantomJS 1 only
					// push.apply(_, arraylike) throws on ancient WebKit
					jQuery.merge(nodes, tmp.childNodes);

					// Remember the top-level container
					tmp = fragment.firstChild;

					// Ensure the created nodes are orphaned (#12392)
					tmp.textContent = "";
				}
			}
		}

		// Remove wrapper from fragment
		fragment.textContent = "";

		i = 0;
		while (elem = nodes[i++]) {

			// Skip elements already in the context collection (trac-4087)
			if (selection && jQuery.inArray(elem, selection) > -1) {
				if (ignored) {
					ignored.push(elem);
				}
				continue;
			}

			contains = jQuery.contains(elem.ownerDocument, elem);

			// Append to fragment
			tmp = getAll(fragment.appendChild(elem), "script");

			// Preserve script evaluation history
			if (contains) {
				setGlobalEval(tmp);
			}

			// Capture executables
			if (scripts) {
				j = 0;
				while (elem = tmp[j++]) {
					if (rscriptType.test(elem.type || "")) {
						scripts.push(elem);
					}
				}
			}
		}

		return fragment;
	}

	(function () {
		var fragment = document.createDocumentFragment(),
		    div = fragment.appendChild(document.createElement("div")),
		    input = document.createElement("input");

		// Support: Android 4.0 - 4.3 only
		// Check state lost if the name is set (#11217)
		// Support: Windows Web Apps (WWA)
		// `name` and `type` must use .setAttribute for WWA (#14901)
		input.setAttribute("type", "radio");
		input.setAttribute("checked", "checked");
		input.setAttribute("name", "t");

		div.appendChild(input);

		// Support: Android <=4.1 only
		// Older WebKit doesn't clone checked state correctly in fragments
		support.checkClone = div.cloneNode(true).cloneNode(true).lastChild.checked;

		// Support: IE <=11 only
		// Make sure textarea (and checkbox) defaultValue is properly cloned
		div.innerHTML = "<textarea>x</textarea>";
		support.noCloneChecked = !!div.cloneNode(true).lastChild.defaultValue;
	})();
	var documentElement = document.documentElement;

	var rkeyEvent = /^key/,
	    rmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/,
	    rtypenamespace = /^([^.]*)(?:\.(.+)|)/;

	function returnTrue() {
		return true;
	}

	function returnFalse() {
		return false;
	}

	// Support: IE <=9 only
	// See #13393 for more info
	function safeActiveElement() {
		try {
			return document.activeElement;
		} catch (err) {}
	}

	function _on(elem, types, selector, data, fn, one) {
		var origFn, type;

		// Types can be a map of types/handlers
		if ((typeof types === "undefined" ? "undefined" : _typeof(types)) === "object") {

			// ( types-Object, selector, data )
			if (typeof selector !== "string") {

				// ( types-Object, data )
				data = data || selector;
				selector = undefined;
			}
			for (type in types) {
				_on(elem, type, selector, data, types[type], one);
			}
			return elem;
		}

		if (data == null && fn == null) {

			// ( types, fn )
			fn = selector;
			data = selector = undefined;
		} else if (fn == null) {
			if (typeof selector === "string") {

				// ( types, selector, fn )
				fn = data;
				data = undefined;
			} else {

				// ( types, data, fn )
				fn = data;
				data = selector;
				selector = undefined;
			}
		}
		if (fn === false) {
			fn = returnFalse;
		} else if (!fn) {
			return elem;
		}

		if (one === 1) {
			origFn = fn;
			fn = function fn(event) {

				// Can use an empty set, since event contains the info
				jQuery().off(event);
				return origFn.apply(this, arguments);
			};

			// Use same guid so caller can remove using origFn
			fn.guid = origFn.guid || (origFn.guid = jQuery.guid++);
		}
		return elem.each(function () {
			jQuery.event.add(this, types, fn, data, selector);
		});
	}

	/*
  * Helper functions for managing events -- not part of the public interface.
  * Props to Dean Edwards' addEvent library for many of the ideas.
  */
	jQuery.event = {

		global: {},

		add: function add(elem, types, handler, data, selector) {

			var handleObjIn,
			    eventHandle,
			    tmp,
			    events,
			    t,
			    handleObj,
			    special,
			    handlers,
			    type,
			    namespaces,
			    origType,
			    elemData = dataPriv.get(elem);

			// Don't attach events to noData or text/comment nodes (but allow plain objects)
			if (!elemData) {
				return;
			}

			// Caller can pass in an object of custom data in lieu of the handler
			if (handler.handler) {
				handleObjIn = handler;
				handler = handleObjIn.handler;
				selector = handleObjIn.selector;
			}

			// Ensure that invalid selectors throw exceptions at attach time
			// Evaluate against documentElement in case elem is a non-element node (e.g., document)
			if (selector) {
				jQuery.find.matchesSelector(documentElement, selector);
			}

			// Make sure that the handler has a unique ID, used to find/remove it later
			if (!handler.guid) {
				handler.guid = jQuery.guid++;
			}

			// Init the element's event structure and main handler, if this is the first
			if (!(events = elemData.events)) {
				events = elemData.events = {};
			}
			if (!(eventHandle = elemData.handle)) {
				eventHandle = elemData.handle = function (e) {

					// Discard the second event of a jQuery.event.trigger() and
					// when an event is called after a page has unloaded
					return typeof jQuery !== "undefined" && jQuery.event.triggered !== e.type ? jQuery.event.dispatch.apply(elem, arguments) : undefined;
				};
			}

			// Handle multiple events separated by a space
			types = (types || "").match(rnothtmlwhite) || [""];
			t = types.length;
			while (t--) {
				tmp = rtypenamespace.exec(types[t]) || [];
				type = origType = tmp[1];
				namespaces = (tmp[2] || "").split(".").sort();

				// There *must* be a type, no attaching namespace-only handlers
				if (!type) {
					continue;
				}

				// If event changes its type, use the special event handlers for the changed type
				special = jQuery.event.special[type] || {};

				// If selector defined, determine special event api type, otherwise given type
				type = (selector ? special.delegateType : special.bindType) || type;

				// Update special based on newly reset type
				special = jQuery.event.special[type] || {};

				// handleObj is passed to all event handlers
				handleObj = jQuery.extend({
					type: type,
					origType: origType,
					data: data,
					handler: handler,
					guid: handler.guid,
					selector: selector,
					needsContext: selector && jQuery.expr.match.needsContext.test(selector),
					namespace: namespaces.join(".")
				}, handleObjIn);

				// Init the event handler queue if we're the first
				if (!(handlers = events[type])) {
					handlers = events[type] = [];
					handlers.delegateCount = 0;

					// Only use addEventListener if the special events handler returns false
					if (!special.setup || special.setup.call(elem, data, namespaces, eventHandle) === false) {

						if (elem.addEventListener) {
							elem.addEventListener(type, eventHandle);
						}
					}
				}

				if (special.add) {
					special.add.call(elem, handleObj);

					if (!handleObj.handler.guid) {
						handleObj.handler.guid = handler.guid;
					}
				}

				// Add to the element's handler list, delegates in front
				if (selector) {
					handlers.splice(handlers.delegateCount++, 0, handleObj);
				} else {
					handlers.push(handleObj);
				}

				// Keep track of which events have ever been used, for event optimization
				jQuery.event.global[type] = true;
			}
		},

		// Detach an event or set of events from an element
		remove: function remove(elem, types, handler, selector, mappedTypes) {

			var j,
			    origCount,
			    tmp,
			    events,
			    t,
			    handleObj,
			    special,
			    handlers,
			    type,
			    namespaces,
			    origType,
			    elemData = dataPriv.hasData(elem) && dataPriv.get(elem);

			if (!elemData || !(events = elemData.events)) {
				return;
			}

			// Once for each type.namespace in types; type may be omitted
			types = (types || "").match(rnothtmlwhite) || [""];
			t = types.length;
			while (t--) {
				tmp = rtypenamespace.exec(types[t]) || [];
				type = origType = tmp[1];
				namespaces = (tmp[2] || "").split(".").sort();

				// Unbind all events (on this namespace, if provided) for the element
				if (!type) {
					for (type in events) {
						jQuery.event.remove(elem, type + types[t], handler, selector, true);
					}
					continue;
				}

				special = jQuery.event.special[type] || {};
				type = (selector ? special.delegateType : special.bindType) || type;
				handlers = events[type] || [];
				tmp = tmp[2] && new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)");

				// Remove matching events
				origCount = j = handlers.length;
				while (j--) {
					handleObj = handlers[j];

					if ((mappedTypes || origType === handleObj.origType) && (!handler || handler.guid === handleObj.guid) && (!tmp || tmp.test(handleObj.namespace)) && (!selector || selector === handleObj.selector || selector === "**" && handleObj.selector)) {
						handlers.splice(j, 1);

						if (handleObj.selector) {
							handlers.delegateCount--;
						}
						if (special.remove) {
							special.remove.call(elem, handleObj);
						}
					}
				}

				// Remove generic event handler if we removed something and no more handlers exist
				// (avoids potential for endless recursion during removal of special event handlers)
				if (origCount && !handlers.length) {
					if (!special.teardown || special.teardown.call(elem, namespaces, elemData.handle) === false) {

						jQuery.removeEvent(elem, type, elemData.handle);
					}

					delete events[type];
				}
			}

			// Remove data and the expando if it's no longer used
			if (jQuery.isEmptyObject(events)) {
				dataPriv.remove(elem, "handle events");
			}
		},

		dispatch: function dispatch(nativeEvent) {

			// Make a writable jQuery.Event from the native event object
			var event = jQuery.event.fix(nativeEvent);

			var i,
			    j,
			    ret,
			    matched,
			    handleObj,
			    handlerQueue,
			    args = new Array(arguments.length),
			    handlers = (dataPriv.get(this, "events") || {})[event.type] || [],
			    special = jQuery.event.special[event.type] || {};

			// Use the fix-ed jQuery.Event rather than the (read-only) native event
			args[0] = event;

			for (i = 1; i < arguments.length; i++) {
				args[i] = arguments[i];
			}

			event.delegateTarget = this;

			// Call the preDispatch hook for the mapped type, and let it bail if desired
			if (special.preDispatch && special.preDispatch.call(this, event) === false) {
				return;
			}

			// Determine handlers
			handlerQueue = jQuery.event.handlers.call(this, event, handlers);

			// Run delegates first; they may want to stop propagation beneath us
			i = 0;
			while ((matched = handlerQueue[i++]) && !event.isPropagationStopped()) {
				event.currentTarget = matched.elem;

				j = 0;
				while ((handleObj = matched.handlers[j++]) && !event.isImmediatePropagationStopped()) {

					// Triggered event must either 1) have no namespace, or 2) have namespace(s)
					// a subset or equal to those in the bound event (both can have no namespace).
					if (!event.rnamespace || event.rnamespace.test(handleObj.namespace)) {

						event.handleObj = handleObj;
						event.data = handleObj.data;

						ret = ((jQuery.event.special[handleObj.origType] || {}).handle || handleObj.handler).apply(matched.elem, args);

						if (ret !== undefined) {
							if ((event.result = ret) === false) {
								event.preventDefault();
								event.stopPropagation();
							}
						}
					}
				}
			}

			// Call the postDispatch hook for the mapped type
			if (special.postDispatch) {
				special.postDispatch.call(this, event);
			}

			return event.result;
		},

		handlers: function handlers(event, _handlers) {
			var i,
			    handleObj,
			    sel,
			    matchedHandlers,
			    matchedSelectors,
			    handlerQueue = [],
			    delegateCount = _handlers.delegateCount,
			    cur = event.target;

			// Find delegate handlers
			if (delegateCount &&

			// Support: IE <=9
			// Black-hole SVG <use> instance trees (trac-13180)
			cur.nodeType &&

			// Support: Firefox <=42
			// Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861)
			// https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click
			// Support: IE 11 only
			// ...but not arrow key "clicks" of radio inputs, which can have `button` -1 (gh-2343)
			!(event.type === "click" && event.button >= 1)) {

				for (; cur !== this; cur = cur.parentNode || this) {

					// Don't check non-elements (#13208)
					// Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)
					if (cur.nodeType === 1 && !(event.type === "click" && cur.disabled === true)) {
						matchedHandlers = [];
						matchedSelectors = {};
						for (i = 0; i < delegateCount; i++) {
							handleObj = _handlers[i];

							// Don't conflict with Object.prototype properties (#13203)
							sel = handleObj.selector + " ";

							if (matchedSelectors[sel] === undefined) {
								matchedSelectors[sel] = handleObj.needsContext ? jQuery(sel, this).index(cur) > -1 : jQuery.find(sel, this, null, [cur]).length;
							}
							if (matchedSelectors[sel]) {
								matchedHandlers.push(handleObj);
							}
						}
						if (matchedHandlers.length) {
							handlerQueue.push({ elem: cur, handlers: matchedHandlers });
						}
					}
				}
			}

			// Add the remaining (directly-bound) handlers
			cur = this;
			if (delegateCount < _handlers.length) {
				handlerQueue.push({ elem: cur, handlers: _handlers.slice(delegateCount) });
			}

			return handlerQueue;
		},

		addProp: function addProp(name, hook) {
			Object.defineProperty(jQuery.Event.prototype, name, {
				enumerable: true,
				configurable: true,

				get: isFunction(hook) ? function () {
					if (this.originalEvent) {
						return hook(this.originalEvent);
					}
				} : function () {
					if (this.originalEvent) {
						return this.originalEvent[name];
					}
				},

				set: function set(value) {
					Object.defineProperty(this, name, {
						enumerable: true,
						configurable: true,
						writable: true,
						value: value
					});
				}
			});
		},

		fix: function fix(originalEvent) {
			return originalEvent[jQuery.expando] ? originalEvent : new jQuery.Event(originalEvent);
		},

		special: {
			load: {

				// Prevent triggered image.load events from bubbling to window.load
				noBubble: true
			},
			focus: {

				// Fire native event if possible so blur/focus sequence is correct
				trigger: function trigger() {
					if (this !== safeActiveElement() && this.focus) {
						this.focus();
						return false;
					}
				},
				delegateType: "focusin"
			},
			blur: {
				trigger: function trigger() {
					if (this === safeActiveElement() && this.blur) {
						this.blur();
						return false;
					}
				},
				delegateType: "focusout"
			},
			click: {

				// For checkbox, fire native event so checked state will be right
				trigger: function trigger() {
					if (this.type === "checkbox" && this.click && nodeName(this, "input")) {
						this.click();
						return false;
					}
				},

				// For cross-browser consistency, don't fire native .click() on links
				_default: function _default(event) {
					return nodeName(event.target, "a");
				}
			},

			beforeunload: {
				postDispatch: function postDispatch(event) {

					// Support: Firefox 20+
					// Firefox doesn't alert if the returnValue field is not set.
					if (event.result !== undefined && event.originalEvent) {
						event.originalEvent.returnValue = event.result;
					}
				}
			}
		}
	};

	jQuery.removeEvent = function (elem, type, handle) {

		// This "if" is needed for plain objects
		if (elem.removeEventListener) {
			elem.removeEventListener(type, handle);
		}
	};

	jQuery.Event = function (src, props) {

		// Allow instantiation without the 'new' keyword
		if (!(this instanceof jQuery.Event)) {
			return new jQuery.Event(src, props);
		}

		// Event object
		if (src && src.type) {
			this.originalEvent = src;
			this.type = src.type;

			// Events bubbling up the document may have been marked as prevented
			// by a handler lower down the tree; reflect the correct value.
			this.isDefaultPrevented = src.defaultPrevented || src.defaultPrevented === undefined &&

			// Support: Android <=2.3 only
			src.returnValue === false ? returnTrue : returnFalse;

			// Create target properties
			// Support: Safari <=6 - 7 only
			// Target should not be a text node (#504, #13143)
			this.target = src.target && src.target.nodeType === 3 ? src.target.parentNode : src.target;

			this.currentTarget = src.currentTarget;
			this.relatedTarget = src.relatedTarget;

			// Event type
		} else {
			this.type = src;
		}

		// Put explicitly provided properties onto the event object
		if (props) {
			jQuery.extend(this, props);
		}

		// Create a timestamp if incoming event doesn't have one
		this.timeStamp = src && src.timeStamp || Date.now();

		// Mark it as fixed
		this[jQuery.expando] = true;
	};

	// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
	// https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
	jQuery.Event.prototype = {
		constructor: jQuery.Event,
		isDefaultPrevented: returnFalse,
		isPropagationStopped: returnFalse,
		isImmediatePropagationStopped: returnFalse,
		isSimulated: false,

		preventDefault: function preventDefault() {
			var e = this.originalEvent;

			this.isDefaultPrevented = returnTrue;

			if (e && !this.isSimulated) {
				e.preventDefault();
			}
		},
		stopPropagation: function stopPropagation() {
			var e = this.originalEvent;

			this.isPropagationStopped = returnTrue;

			if (e && !this.isSimulated) {
				e.stopPropagation();
			}
		},
		stopImmediatePropagation: function stopImmediatePropagation() {
			var e = this.originalEvent;

			this.isImmediatePropagationStopped = returnTrue;

			if (e && !this.isSimulated) {
				e.stopImmediatePropagation();
			}

			this.stopPropagation();
		}
	};

	// Includes all common event props including KeyEvent and MouseEvent specific props
	jQuery.each({
		altKey: true,
		bubbles: true,
		cancelable: true,
		changedTouches: true,
		ctrlKey: true,
		detail: true,
		eventPhase: true,
		metaKey: true,
		pageX: true,
		pageY: true,
		shiftKey: true,
		view: true,
		"char": true,
		charCode: true,
		key: true,
		keyCode: true,
		button: true,
		buttons: true,
		clientX: true,
		clientY: true,
		offsetX: true,
		offsetY: true,
		pointerId: true,
		pointerType: true,
		screenX: true,
		screenY: true,
		targetTouches: true,
		toElement: true,
		touches: true,

		which: function which(event) {
			var button = event.button;

			// Add which for key events
			if (event.which == null && rkeyEvent.test(event.type)) {
				return event.charCode != null ? event.charCode : event.keyCode;
			}

			// Add which for click: 1 === left; 2 === middle; 3 === right
			if (!event.which && button !== undefined && rmouseEvent.test(event.type)) {
				if (button & 1) {
					return 1;
				}

				if (button & 2) {
					return 3;
				}

				if (button & 4) {
					return 2;
				}

				return 0;
			}

			return event.which;
		}
	}, jQuery.event.addProp);

	// Create mouseenter/leave events using mouseover/out and event-time checks
	// so that event delegation works in jQuery.
	// Do the same for pointerenter/pointerleave and pointerover/pointerout
	//
	// Support: Safari 7 only
	// Safari sends mouseenter too often; see:
	// https://bugs.chromium.org/p/chromium/issues/detail?id=470258
	// for the description of the bug (it existed in older Chrome versions as well).
	jQuery.each({
		mouseenter: "mouseover",
		mouseleave: "mouseout",
		pointerenter: "pointerover",
		pointerleave: "pointerout"
	}, function (orig, fix) {
		jQuery.event.special[orig] = {
			delegateType: fix,
			bindType: fix,

			handle: function handle(event) {
				var ret,
				    target = this,
				    related = event.relatedTarget,
				    handleObj = event.handleObj;

				// For mouseenter/leave call the handler if related is outside the target.
				// NB: No relatedTarget if the mouse left/entered the browser window
				if (!related || related !== target && !jQuery.contains(target, related)) {
					event.type = handleObj.origType;
					ret = handleObj.handler.apply(this, arguments);
					event.type = fix;
				}
				return ret;
			}
		};
	});

	jQuery.fn.extend({

		on: function on(types, selector, data, fn) {
			return _on(this, types, selector, data, fn);
		},
		one: function one(types, selector, data, fn) {
			return _on(this, types, selector, data, fn, 1);
		},
		off: function off(types, selector, fn) {
			var handleObj, type;
			if (types && types.preventDefault && types.handleObj) {

				// ( event )  dispatched jQuery.Event
				handleObj = types.handleObj;
				jQuery(types.delegateTarget).off(handleObj.namespace ? handleObj.origType + "." + handleObj.namespace : handleObj.origType, handleObj.selector, handleObj.handler);
				return this;
			}
			if ((typeof types === "undefined" ? "undefined" : _typeof(types)) === "object") {

				// ( types-object [, selector] )
				for (type in types) {
					this.off(type, selector, types[type]);
				}
				return this;
			}
			if (selector === false || typeof selector === "function") {

				// ( types [, fn] )
				fn = selector;
				selector = undefined;
			}
			if (fn === false) {
				fn = returnFalse;
			}
			return this.each(function () {
				jQuery.event.remove(this, types, fn, selector);
			});
		}
	});

	var

	/* eslint-disable max-len */

	// See https://github.com/eslint/eslint/issues/3229
	rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([a-z][^\/\0>\x20\t\r\n\f]*)[^>]*)\/>/gi,


	/* eslint-enable */

	// Support: IE <=10 - 11, Edge 12 - 13 only
	// In IE/Edge using regex groups here causes severe slowdowns.
	// See https://connect.microsoft.com/IE/feedback/details/1736512/
	rnoInnerhtml = /<script|<style|<link/i,


	// checked="checked" or checked
	rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
	    rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g;

	// Prefer a tbody over its parent table for containing new rows
	function manipulationTarget(elem, content) {
		if (nodeName(elem, "table") && nodeName(content.nodeType !== 11 ? content : content.firstChild, "tr")) {

			return jQuery(elem).children("tbody")[0] || elem;
		}

		return elem;
	}

	// Replace/restore the type attribute of script elements for safe DOM manipulation
	function disableScript(elem) {
		elem.type = (elem.getAttribute("type") !== null) + "/" + elem.type;
		return elem;
	}
	function restoreScript(elem) {
		if ((elem.type || "").slice(0, 5) === "true/") {
			elem.type = elem.type.slice(5);
		} else {
			elem.removeAttribute("type");
		}

		return elem;
	}

	function cloneCopyEvent(src, dest) {
		var i, l, type, pdataOld, pdataCur, udataOld, udataCur, events;

		if (dest.nodeType !== 1) {
			return;
		}

		// 1. Copy private data: events, handlers, etc.
		if (dataPriv.hasData(src)) {
			pdataOld = dataPriv.access(src);
			pdataCur = dataPriv.set(dest, pdataOld);
			events = pdataOld.events;

			if (events) {
				delete pdataCur.handle;
				pdataCur.events = {};

				for (type in events) {
					for (i = 0, l = events[type].length; i < l; i++) {
						jQuery.event.add(dest, type, events[type][i]);
					}
				}
			}
		}

		// 2. Copy user data
		if (dataUser.hasData(src)) {
			udataOld = dataUser.access(src);
			udataCur = jQuery.extend({}, udataOld);

			dataUser.set(dest, udataCur);
		}
	}

	// Fix IE bugs, see support tests
	function fixInput(src, dest) {
		var nodeName = dest.nodeName.toLowerCase();

		// Fails to persist the checked state of a cloned checkbox or radio button.
		if (nodeName === "input" && rcheckableType.test(src.type)) {
			dest.checked = src.checked;

			// Fails to return the selected option to the default selected state when cloning options
		} else if (nodeName === "input" || nodeName === "textarea") {
			dest.defaultValue = src.defaultValue;
		}
	}

	function domManip(collection, args, callback, ignored) {

		// Flatten any nested arrays
		args = concat.apply([], args);

		var fragment,
		    first,
		    scripts,
		    hasScripts,
		    node,
		    doc,
		    i = 0,
		    l = collection.length,
		    iNoClone = l - 1,
		    value = args[0],
		    valueIsFunction = isFunction(value);

		// We can't cloneNode fragments that contain checked, in WebKit
		if (valueIsFunction || l > 1 && typeof value === "string" && !support.checkClone && rchecked.test(value)) {
			return collection.each(function (index) {
				var self = collection.eq(index);
				if (valueIsFunction) {
					args[0] = value.call(this, index, self.html());
				}
				domManip(self, args, callback, ignored);
			});
		}

		if (l) {
			fragment = buildFragment(args, collection[0].ownerDocument, false, collection, ignored);
			first = fragment.firstChild;

			if (fragment.childNodes.length === 1) {
				fragment = first;
			}

			// Require either new content or an interest in ignored elements to invoke the callback
			if (first || ignored) {
				scripts = jQuery.map(getAll(fragment, "script"), disableScript);
				hasScripts = scripts.length;

				// Use the original fragment for the last item
				// instead of the first because it can end up
				// being emptied incorrectly in certain situations (#8070).
				for (; i < l; i++) {
					node = fragment;

					if (i !== iNoClone) {
						node = jQuery.clone(node, true, true);

						// Keep references to cloned scripts for later restoration
						if (hasScripts) {

							// Support: Android <=4.0 only, PhantomJS 1 only
							// push.apply(_, arraylike) throws on ancient WebKit
							jQuery.merge(scripts, getAll(node, "script"));
						}
					}

					callback.call(collection[i], node, i);
				}

				if (hasScripts) {
					doc = scripts[scripts.length - 1].ownerDocument;

					// Reenable scripts
					jQuery.map(scripts, restoreScript);

					// Evaluate executable scripts on first document insertion
					for (i = 0; i < hasScripts; i++) {
						node = scripts[i];
						if (rscriptType.test(node.type || "") && !dataPriv.access(node, "globalEval") && jQuery.contains(doc, node)) {

							if (node.src && (node.type || "").toLowerCase() !== "module") {

								// Optional AJAX dependency, but won't run scripts if not present
								if (jQuery._evalUrl) {
									jQuery._evalUrl(node.src);
								}
							} else {
								DOMEval(node.textContent.replace(rcleanScript, ""), doc, node);
							}
						}
					}
				}
			}
		}

		return collection;
	}

	function _remove(elem, selector, keepData) {
		var node,
		    nodes = selector ? jQuery.filter(selector, elem) : elem,
		    i = 0;

		for (; (node = nodes[i]) != null; i++) {
			if (!keepData && node.nodeType === 1) {
				jQuery.cleanData(getAll(node));
			}

			if (node.parentNode) {
				if (keepData && jQuery.contains(node.ownerDocument, node)) {
					setGlobalEval(getAll(node, "script"));
				}
				node.parentNode.removeChild(node);
			}
		}

		return elem;
	}

	jQuery.extend({
		htmlPrefilter: function htmlPrefilter(html) {
			return html.replace(rxhtmlTag, "<$1></$2>");
		},

		clone: function clone(elem, dataAndEvents, deepDataAndEvents) {
			var i,
			    l,
			    srcElements,
			    destElements,
			    clone = elem.cloneNode(true),
			    inPage = jQuery.contains(elem.ownerDocument, elem);

			// Fix IE cloning issues
			if (!support.noCloneChecked && (elem.nodeType === 1 || elem.nodeType === 11) && !jQuery.isXMLDoc(elem)) {

				// We eschew Sizzle here for performance reasons: https://jsperf.com/getall-vs-sizzle/2
				destElements = getAll(clone);
				srcElements = getAll(elem);

				for (i = 0, l = srcElements.length; i < l; i++) {
					fixInput(srcElements[i], destElements[i]);
				}
			}

			// Copy the events from the original to the clone
			if (dataAndEvents) {
				if (deepDataAndEvents) {
					srcElements = srcElements || getAll(elem);
					destElements = destElements || getAll(clone);

					for (i = 0, l = srcElements.length; i < l; i++) {
						cloneCopyEvent(srcElements[i], destElements[i]);
					}
				} else {
					cloneCopyEvent(elem, clone);
				}
			}

			// Preserve script evaluation history
			destElements = getAll(clone, "script");
			if (destElements.length > 0) {
				setGlobalEval(destElements, !inPage && getAll(elem, "script"));
			}

			// Return the cloned set
			return clone;
		},

		cleanData: function cleanData(elems) {
			var data,
			    elem,
			    type,
			    special = jQuery.event.special,
			    i = 0;

			for (; (elem = elems[i]) !== undefined; i++) {
				if (acceptData(elem)) {
					if (data = elem[dataPriv.expando]) {
						if (data.events) {
							for (type in data.events) {
								if (special[type]) {
									jQuery.event.remove(elem, type);

									// This is a shortcut to avoid jQuery.event.remove's overhead
								} else {
									jQuery.removeEvent(elem, type, data.handle);
								}
							}
						}

						// Support: Chrome <=35 - 45+
						// Assign undefined instead of using delete, see Data#remove
						elem[dataPriv.expando] = undefined;
					}
					if (elem[dataUser.expando]) {

						// Support: Chrome <=35 - 45+
						// Assign undefined instead of using delete, see Data#remove
						elem[dataUser.expando] = undefined;
					}
				}
			}
		}
	});

	jQuery.fn.extend({
		detach: function detach(selector) {
			return _remove(this, selector, true);
		},

		remove: function remove(selector) {
			return _remove(this, selector);
		},

		text: function text(value) {
			return access(this, function (value) {
				return value === undefined ? jQuery.text(this) : this.empty().each(function () {
					if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) {
						this.textContent = value;
					}
				});
			}, null, value, arguments.length);
		},

		append: function append() {
			return domManip(this, arguments, function (elem) {
				if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) {
					var target = manipulationTarget(this, elem);
					target.appendChild(elem);
				}
			});
		},

		prepend: function prepend() {
			return domManip(this, arguments, function (elem) {
				if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) {
					var target = manipulationTarget(this, elem);
					target.insertBefore(elem, target.firstChild);
				}
			});
		},

		before: function before() {
			return domManip(this, arguments, function (elem) {
				if (this.parentNode) {
					this.parentNode.insertBefore(elem, this);
				}
			});
		},

		after: function after() {
			return domManip(this, arguments, function (elem) {
				if (this.parentNode) {
					this.parentNode.insertBefore(elem, this.nextSibling);
				}
			});
		},

		empty: function empty() {
			var elem,
			    i = 0;

			for (; (elem = this[i]) != null; i++) {
				if (elem.nodeType === 1) {

					// Prevent memory leaks
					jQuery.cleanData(getAll(elem, false));

					// Remove any remaining nodes
					elem.textContent = "";
				}
			}

			return this;
		},

		clone: function clone(dataAndEvents, deepDataAndEvents) {
			dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
			deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;

			return this.map(function () {
				return jQuery.clone(this, dataAndEvents, deepDataAndEvents);
			});
		},

		html: function html(value) {
			return access(this, function (value) {
				var elem = this[0] || {},
				    i = 0,
				    l = this.length;

				if (value === undefined && elem.nodeType === 1) {
					return elem.innerHTML;
				}

				// See if we can take a shortcut and just use innerHTML
				if (typeof value === "string" && !rnoInnerhtml.test(value) && !wrapMap[(rtagName.exec(value) || ["", ""])[1].toLowerCase()]) {

					value = jQuery.htmlPrefilter(value);

					try {
						for (; i < l; i++) {
							elem = this[i] || {};

							// Remove element nodes and prevent memory leaks
							if (elem.nodeType === 1) {
								jQuery.cleanData(getAll(elem, false));
								elem.innerHTML = value;
							}
						}

						elem = 0;

						// If using innerHTML throws an exception, use the fallback method
					} catch (e) {}
				}

				if (elem) {
					this.empty().append(value);
				}
			}, null, value, arguments.length);
		},

		replaceWith: function replaceWith() {
			var ignored = [];

			// Make the changes, replacing each non-ignored context element with the new content
			return domManip(this, arguments, function (elem) {
				var parent = this.parentNode;

				if (jQuery.inArray(this, ignored) < 0) {
					jQuery.cleanData(getAll(this));
					if (parent) {
						parent.replaceChild(elem, this);
					}
				}

				// Force callback invocation
			}, ignored);
		}
	});

	jQuery.each({
		appendTo: "append",
		prependTo: "prepend",
		insertBefore: "before",
		insertAfter: "after",
		replaceAll: "replaceWith"
	}, function (name, original) {
		jQuery.fn[name] = function (selector) {
			var elems,
			    ret = [],
			    insert = jQuery(selector),
			    last = insert.length - 1,
			    i = 0;

			for (; i <= last; i++) {
				elems = i === last ? this : this.clone(true);
				jQuery(insert[i])[original](elems);

				// Support: Android <=4.0 only, PhantomJS 1 only
				// .get() because push.apply(_, arraylike) throws on ancient WebKit
				push.apply(ret, elems.get());
			}

			return this.pushStack(ret);
		};
	});
	var rnumnonpx = new RegExp("^(" + pnum + ")(?!px)[a-z%]+$", "i");

	var getStyles = function getStyles(elem) {

		// Support: IE <=11 only, Firefox <=30 (#15098, #14150)
		// IE throws on elements created in popups
		// FF meanwhile throws on frame elements through "defaultView.getComputedStyle"
		var view = elem.ownerDocument.defaultView;

		if (!view || !view.opener) {
			view = window;
		}

		return view.getComputedStyle(elem);
	};

	var rboxStyle = new RegExp(cssExpand.join("|"), "i");

	(function () {

		// Executing both pixelPosition & boxSizingReliable tests require only one layout
		// so they're executed at the same time to save the second computation.
		function computeStyleTests() {

			// This is a singleton, we need to execute it only once
			if (!div) {
				return;
			}

			container.style.cssText = "position:absolute;left:-11111px;width:60px;" + "margin-top:1px;padding:0;border:0";
			div.style.cssText = "position:relative;display:block;box-sizing:border-box;overflow:scroll;" + "margin:auto;border:1px;padding:1px;" + "width:60%;top:1%";
			documentElement.appendChild(container).appendChild(div);

			var divStyle = window.getComputedStyle(div);
			pixelPositionVal = divStyle.top !== "1%";

			// Support: Android 4.0 - 4.3 only, Firefox <=3 - 44
			reliableMarginLeftVal = roundPixelMeasures(divStyle.marginLeft) === 12;

			// Support: Android 4.0 - 4.3 only, Safari <=9.1 - 10.1, iOS <=7.0 - 9.3
			// Some styles come back with percentage values, even though they shouldn't
			div.style.right = "60%";
			pixelBoxStylesVal = roundPixelMeasures(divStyle.right) === 36;

			// Support: IE 9 - 11 only
			// Detect misreporting of content dimensions for box-sizing:border-box elements
			boxSizingReliableVal = roundPixelMeasures(divStyle.width) === 36;

			// Support: IE 9 only
			// Detect overflow:scroll screwiness (gh-3699)
			div.style.position = "absolute";
			scrollboxSizeVal = div.offsetWidth === 36 || "absolute";

			documentElement.removeChild(container);

			// Nullify the div so it wouldn't be stored in the memory and
			// it will also be a sign that checks already performed
			div = null;
		}

		function roundPixelMeasures(measure) {
			return Math.round(parseFloat(measure));
		}

		var pixelPositionVal,
		    boxSizingReliableVal,
		    scrollboxSizeVal,
		    pixelBoxStylesVal,
		    reliableMarginLeftVal,
		    container = document.createElement("div"),
		    div = document.createElement("div");

		// Finish early in limited (non-browser) environments
		if (!div.style) {
			return;
		}

		// Support: IE <=9 - 11 only
		// Style of cloned element affects source element cloned (#8908)
		div.style.backgroundClip = "content-box";
		div.cloneNode(true).style.backgroundClip = "";
		support.clearCloneStyle = div.style.backgroundClip === "content-box";

		jQuery.extend(support, {
			boxSizingReliable: function boxSizingReliable() {
				computeStyleTests();
				return boxSizingReliableVal;
			},
			pixelBoxStyles: function pixelBoxStyles() {
				computeStyleTests();
				return pixelBoxStylesVal;
			},
			pixelPosition: function pixelPosition() {
				computeStyleTests();
				return pixelPositionVal;
			},
			reliableMarginLeft: function reliableMarginLeft() {
				computeStyleTests();
				return reliableMarginLeftVal;
			},
			scrollboxSize: function scrollboxSize() {
				computeStyleTests();
				return scrollboxSizeVal;
			}
		});
	})();

	function curCSS(elem, name, computed) {
		var width,
		    minWidth,
		    maxWidth,
		    ret,


		// Support: Firefox 51+
		// Retrieving style before computed somehow
		// fixes an issue with getting wrong values
		// on detached elements
		style = elem.style;

		computed = computed || getStyles(elem);

		// getPropertyValue is needed for:
		//   .css('filter') (IE 9 only, #12537)
		//   .css('--customProperty) (#3144)
		if (computed) {
			ret = computed.getPropertyValue(name) || computed[name];

			if (ret === "" && !jQuery.contains(elem.ownerDocument, elem)) {
				ret = jQuery.style(elem, name);
			}

			// A tribute to the "awesome hack by Dean Edwards"
			// Android Browser returns percentage for some values,
			// but width seems to be reliably pixels.
			// This is against the CSSOM draft spec:
			// https://drafts.csswg.org/cssom/#resolved-values
			if (!support.pixelBoxStyles() && rnumnonpx.test(ret) && rboxStyle.test(name)) {

				// Remember the original values
				width = style.width;
				minWidth = style.minWidth;
				maxWidth = style.maxWidth;

				// Put in the new values to get a computed value out
				style.minWidth = style.maxWidth = style.width = ret;
				ret = computed.width;

				// Revert the changed values
				style.width = width;
				style.minWidth = minWidth;
				style.maxWidth = maxWidth;
			}
		}

		return ret !== undefined ?

		// Support: IE <=9 - 11 only
		// IE returns zIndex value as an integer.
		ret + "" : ret;
	}

	function addGetHookIf(conditionFn, hookFn) {

		// Define the hook, we'll check on the first run if it's really needed.
		return {
			get: function get() {
				if (conditionFn()) {

					// Hook not needed (or it's not possible to use it due
					// to missing dependency), remove it.
					delete this.get;
					return;
				}

				// Hook needed; redefine it so that the support test is not executed again.
				return (this.get = hookFn).apply(this, arguments);
			}
		};
	}

	var

	// Swappable if display is none or starts with table
	// except "table", "table-cell", or "table-caption"
	// See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display
	rdisplayswap = /^(none|table(?!-c[ea]).+)/,
	    rcustomProp = /^--/,
	    cssShow = { position: "absolute", visibility: "hidden", display: "block" },
	    cssNormalTransform = {
		letterSpacing: "0",
		fontWeight: "400"
	},
	    cssPrefixes = ["Webkit", "Moz", "ms"],
	    emptyStyle = document.createElement("div").style;

	// Return a css property mapped to a potentially vendor prefixed property
	function vendorPropName(name) {

		// Shortcut for names that are not vendor prefixed
		if (name in emptyStyle) {
			return name;
		}

		// Check for vendor prefixed names
		var capName = name[0].toUpperCase() + name.slice(1),
		    i = cssPrefixes.length;

		while (i--) {
			name = cssPrefixes[i] + capName;
			if (name in emptyStyle) {
				return name;
			}
		}
	}

	// Return a property mapped along what jQuery.cssProps suggests or to
	// a vendor prefixed property.
	function finalPropName(name) {
		var ret = jQuery.cssProps[name];
		if (!ret) {
			ret = jQuery.cssProps[name] = vendorPropName(name) || name;
		}
		return ret;
	}

	function setPositiveNumber(elem, value, subtract) {

		// Any relative (+/-) values have already been
		// normalized at this point
		var matches = rcssNum.exec(value);
		return matches ?

		// Guard against undefined "subtract", e.g., when used as in cssHooks
		Math.max(0, matches[2] - (subtract || 0)) + (matches[3] || "px") : value;
	}

	function boxModelAdjustment(elem, dimension, box, isBorderBox, styles, computedVal) {
		var i = dimension === "width" ? 1 : 0,
		    extra = 0,
		    delta = 0;

		// Adjustment may not be necessary
		if (box === (isBorderBox ? "border" : "content")) {
			return 0;
		}

		for (; i < 4; i += 2) {

			// Both box models exclude margin
			if (box === "margin") {
				delta += jQuery.css(elem, box + cssExpand[i], true, styles);
			}

			// If we get here with a content-box, we're seeking "padding" or "border" or "margin"
			if (!isBorderBox) {

				// Add padding
				delta += jQuery.css(elem, "padding" + cssExpand[i], true, styles);

				// For "border" or "margin", add border
				if (box !== "padding") {
					delta += jQuery.css(elem, "border" + cssExpand[i] + "Width", true, styles);

					// But still keep track of it otherwise
				} else {
					extra += jQuery.css(elem, "border" + cssExpand[i] + "Width", true, styles);
				}

				// If we get here with a border-box (content + padding + border), we're seeking "content" or
				// "padding" or "margin"
			} else {

				// For "content", subtract padding
				if (box === "content") {
					delta -= jQuery.css(elem, "padding" + cssExpand[i], true, styles);
				}

				// For "content" or "padding", subtract border
				if (box !== "margin") {
					delta -= jQuery.css(elem, "border" + cssExpand[i] + "Width", true, styles);
				}
			}
		}

		// Account for positive content-box scroll gutter when requested by providing computedVal
		if (!isBorderBox && computedVal >= 0) {

			// offsetWidth/offsetHeight is a rounded sum of content, padding, scroll gutter, and border
			// Assuming integer scroll gutter, subtract the rest and round down
			delta += Math.max(0, Math.ceil(elem["offset" + dimension[0].toUpperCase() + dimension.slice(1)] - computedVal - delta - extra - 0.5));
		}

		return delta;
	}

	function getWidthOrHeight(elem, dimension, extra) {

		// Start with computed style
		var styles = getStyles(elem),
		    val = curCSS(elem, dimension, styles),
		    isBorderBox = jQuery.css(elem, "boxSizing", false, styles) === "border-box",
		    valueIsBorderBox = isBorderBox;

		// Support: Firefox <=54
		// Return a confounding non-pixel value or feign ignorance, as appropriate.
		if (rnumnonpx.test(val)) {
			if (!extra) {
				return val;
			}
			val = "auto";
		}

		// Check for style in case a browser which returns unreliable values
		// for getComputedStyle silently falls back to the reliable elem.style
		valueIsBorderBox = valueIsBorderBox && (support.boxSizingReliable() || val === elem.style[dimension]);

		// Fall back to offsetWidth/offsetHeight when value is "auto"
		// This happens for inline elements with no explicit setting (gh-3571)
		// Support: Android <=4.1 - 4.3 only
		// Also use offsetWidth/offsetHeight for misreported inline dimensions (gh-3602)
		if (val === "auto" || !parseFloat(val) && jQuery.css(elem, "display", false, styles) === "inline") {

			val = elem["offset" + dimension[0].toUpperCase() + dimension.slice(1)];

			// offsetWidth/offsetHeight provide border-box values
			valueIsBorderBox = true;
		}

		// Normalize "" and auto
		val = parseFloat(val) || 0;

		// Adjust for the element's box model
		return val + boxModelAdjustment(elem, dimension, extra || (isBorderBox ? "border" : "content"), valueIsBorderBox, styles,

		// Provide the current computed size to request scroll gutter calculation (gh-3589)
		val) + "px";
	}

	jQuery.extend({

		// Add in style property hooks for overriding the default
		// behavior of getting and setting a style property
		cssHooks: {
			opacity: {
				get: function get(elem, computed) {
					if (computed) {

						// We should always get a number back from opacity
						var ret = curCSS(elem, "opacity");
						return ret === "" ? "1" : ret;
					}
				}
			}
		},

		// Don't automatically add "px" to these possibly-unitless properties
		cssNumber: {
			"animationIterationCount": true,
			"columnCount": true,
			"fillOpacity": true,
			"flexGrow": true,
			"flexShrink": true,
			"fontWeight": true,
			"lineHeight": true,
			"opacity": true,
			"order": true,
			"orphans": true,
			"widows": true,
			"zIndex": true,
			"zoom": true
		},

		// Add in properties whose names you wish to fix before
		// setting or getting the value
		cssProps: {},

		// Get and set the style property on a DOM Node
		style: function style(elem, name, value, extra) {

			// Don't set styles on text and comment nodes
			if (!elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style) {
				return;
			}

			// Make sure that we're working with the right name
			var ret,
			    type,
			    hooks,
			    origName = camelCase(name),
			    isCustomProp = rcustomProp.test(name),
			    style = elem.style;

			// Make sure that we're working with the right name. We don't
			// want to query the value if it is a CSS custom property
			// since they are user-defined.
			if (!isCustomProp) {
				name = finalPropName(origName);
			}

			// Gets hook for the prefixed version, then unprefixed version
			hooks = jQuery.cssHooks[name] || jQuery.cssHooks[origName];

			// Check if we're setting a value
			if (value !== undefined) {
				type = typeof value === "undefined" ? "undefined" : _typeof(value);

				// Convert "+=" or "-=" to relative numbers (#7345)
				if (type === "string" && (ret = rcssNum.exec(value)) && ret[1]) {
					value = adjustCSS(elem, name, ret);

					// Fixes bug #9237
					type = "number";
				}

				// Make sure that null and NaN values aren't set (#7116)
				if (value == null || value !== value) {
					return;
				}

				// If a number was passed in, add the unit (except for certain CSS properties)
				if (type === "number") {
					value += ret && ret[3] || (jQuery.cssNumber[origName] ? "" : "px");
				}

				// background-* props affect original clone's values
				if (!support.clearCloneStyle && value === "" && name.indexOf("background") === 0) {
					style[name] = "inherit";
				}

				// If a hook was provided, use that value, otherwise just set the specified value
				if (!hooks || !("set" in hooks) || (value = hooks.set(elem, value, extra)) !== undefined) {

					if (isCustomProp) {
						style.setProperty(name, value);
					} else {
						style[name] = value;
					}
				}
			} else {

				// If a hook was provided get the non-computed value from there
				if (hooks && "get" in hooks && (ret = hooks.get(elem, false, extra)) !== undefined) {

					return ret;
				}

				// Otherwise just get the value from the style object
				return style[name];
			}
		},

		css: function css(elem, name, extra, styles) {
			var val,
			    num,
			    hooks,
			    origName = camelCase(name),
			    isCustomProp = rcustomProp.test(name);

			// Make sure that we're working with the right name. We don't
			// want to modify the value if it is a CSS custom property
			// since they are user-defined.
			if (!isCustomProp) {
				name = finalPropName(origName);
			}

			// Try prefixed name followed by the unprefixed name
			hooks = jQuery.cssHooks[name] || jQuery.cssHooks[origName];

			// If a hook was provided get the computed value from there
			if (hooks && "get" in hooks) {
				val = hooks.get(elem, true, extra);
			}

			// Otherwise, if a way to get the computed value exists, use that
			if (val === undefined) {
				val = curCSS(elem, name, styles);
			}

			// Convert "normal" to computed value
			if (val === "normal" && name in cssNormalTransform) {
				val = cssNormalTransform[name];
			}

			// Make numeric if forced or a qualifier was provided and val looks numeric
			if (extra === "" || extra) {
				num = parseFloat(val);
				return extra === true || isFinite(num) ? num || 0 : val;
			}

			return val;
		}
	});

	jQuery.each(["height", "width"], function (i, dimension) {
		jQuery.cssHooks[dimension] = {
			get: function get(elem, computed, extra) {
				if (computed) {

					// Certain elements can have dimension info if we invisibly show them
					// but it must have a current display style that would benefit
					return rdisplayswap.test(jQuery.css(elem, "display")) && (

					// Support: Safari 8+
					// Table columns in Safari have non-zero offsetWidth & zero
					// getBoundingClientRect().width unless display is changed.
					// Support: IE <=11 only
					// Running getBoundingClientRect on a disconnected node
					// in IE throws an error.
					!elem.getClientRects().length || !elem.getBoundingClientRect().width) ? swap(elem, cssShow, function () {
						return getWidthOrHeight(elem, dimension, extra);
					}) : getWidthOrHeight(elem, dimension, extra);
				}
			},

			set: function set(elem, value, extra) {
				var matches,
				    styles = getStyles(elem),
				    isBorderBox = jQuery.css(elem, "boxSizing", false, styles) === "border-box",
				    subtract = extra && boxModelAdjustment(elem, dimension, extra, isBorderBox, styles);

				// Account for unreliable border-box dimensions by comparing offset* to computed and
				// faking a content-box to get border and padding (gh-3699)
				if (isBorderBox && support.scrollboxSize() === styles.position) {
					subtract -= Math.ceil(elem["offset" + dimension[0].toUpperCase() + dimension.slice(1)] - parseFloat(styles[dimension]) - boxModelAdjustment(elem, dimension, "border", false, styles) - 0.5);
				}

				// Convert to pixels if value adjustment is needed
				if (subtract && (matches = rcssNum.exec(value)) && (matches[3] || "px") !== "px") {

					elem.style[dimension] = value;
					value = jQuery.css(elem, dimension);
				}

				return setPositiveNumber(elem, value, subtract);
			}
		};
	});

	jQuery.cssHooks.marginLeft = addGetHookIf(support.reliableMarginLeft, function (elem, computed) {
		if (computed) {
			return (parseFloat(curCSS(elem, "marginLeft")) || elem.getBoundingClientRect().left - swap(elem, { marginLeft: 0 }, function () {
				return elem.getBoundingClientRect().left;
			})) + "px";
		}
	});

	// These hooks are used by animate to expand properties
	jQuery.each({
		margin: "",
		padding: "",
		border: "Width"
	}, function (prefix, suffix) {
		jQuery.cssHooks[prefix + suffix] = {
			expand: function expand(value) {
				var i = 0,
				    expanded = {},


				// Assumes a single number if not a string
				parts = typeof value === "string" ? value.split(" ") : [value];

				for (; i < 4; i++) {
					expanded[prefix + cssExpand[i] + suffix] = parts[i] || parts[i - 2] || parts[0];
				}

				return expanded;
			}
		};

		if (prefix !== "margin") {
			jQuery.cssHooks[prefix + suffix].set = setPositiveNumber;
		}
	});

	jQuery.fn.extend({
		css: function css(name, value) {
			return access(this, function (elem, name, value) {
				var styles,
				    len,
				    map = {},
				    i = 0;

				if (Array.isArray(name)) {
					styles = getStyles(elem);
					len = name.length;

					for (; i < len; i++) {
						map[name[i]] = jQuery.css(elem, name[i], false, styles);
					}

					return map;
				}

				return value !== undefined ? jQuery.style(elem, name, value) : jQuery.css(elem, name);
			}, name, value, arguments.length > 1);
		}
	});

	function Tween(elem, options, prop, end, easing) {
		return new Tween.prototype.init(elem, options, prop, end, easing);
	}
	jQuery.Tween = Tween;

	Tween.prototype = {
		constructor: Tween,
		init: function init(elem, options, prop, end, easing, unit) {
			this.elem = elem;
			this.prop = prop;
			this.easing = easing || jQuery.easing._default;
			this.options = options;
			this.start = this.now = this.cur();
			this.end = end;
			this.unit = unit || (jQuery.cssNumber[prop] ? "" : "px");
		},
		cur: function cur() {
			var hooks = Tween.propHooks[this.prop];

			return hooks && hooks.get ? hooks.get(this) : Tween.propHooks._default.get(this);
		},
		run: function run(percent) {
			var eased,
			    hooks = Tween.propHooks[this.prop];

			if (this.options.duration) {
				this.pos = eased = jQuery.easing[this.easing](percent, this.options.duration * percent, 0, 1, this.options.duration);
			} else {
				this.pos = eased = percent;
			}
			this.now = (this.end - this.start) * eased + this.start;

			if (this.options.step) {
				this.options.step.call(this.elem, this.now, this);
			}

			if (hooks && hooks.set) {
				hooks.set(this);
			} else {
				Tween.propHooks._default.set(this);
			}
			return this;
		}
	};

	Tween.prototype.init.prototype = Tween.prototype;

	Tween.propHooks = {
		_default: {
			get: function get(tween) {
				var result;

				// Use a property on the element directly when it is not a DOM element,
				// or when there is no matching style property that exists.
				if (tween.elem.nodeType !== 1 || tween.elem[tween.prop] != null && tween.elem.style[tween.prop] == null) {
					return tween.elem[tween.prop];
				}

				// Passing an empty string as a 3rd parameter to .css will automatically
				// attempt a parseFloat and fallback to a string if the parse fails.
				// Simple values such as "10px" are parsed to Float;
				// complex values such as "rotate(1rad)" are returned as-is.
				result = jQuery.css(tween.elem, tween.prop, "");

				// Empty strings, null, undefined and "auto" are converted to 0.
				return !result || result === "auto" ? 0 : result;
			},
			set: function set(tween) {

				// Use step hook for back compat.
				// Use cssHook if its there.
				// Use .style if available and use plain properties where available.
				if (jQuery.fx.step[tween.prop]) {
					jQuery.fx.step[tween.prop](tween);
				} else if (tween.elem.nodeType === 1 && (tween.elem.style[jQuery.cssProps[tween.prop]] != null || jQuery.cssHooks[tween.prop])) {
					jQuery.style(tween.elem, tween.prop, tween.now + tween.unit);
				} else {
					tween.elem[tween.prop] = tween.now;
				}
			}
		}
	};

	// Support: IE <=9 only
	// Panic based approach to setting things on disconnected nodes
	Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {
		set: function set(tween) {
			if (tween.elem.nodeType && tween.elem.parentNode) {
				tween.elem[tween.prop] = tween.now;
			}
		}
	};

	jQuery.easing = {
		linear: function linear(p) {
			return p;
		},
		swing: function swing(p) {
			return 0.5 - Math.cos(p * Math.PI) / 2;
		},
		_default: "swing"
	};

	jQuery.fx = Tween.prototype.init;

	// Back compat <1.8 extension point
	jQuery.fx.step = {};

	var fxNow,
	    inProgress,
	    rfxtypes = /^(?:toggle|show|hide)$/,
	    rrun = /queueHooks$/;

	function schedule() {
		if (inProgress) {
			if (document.hidden === false && window.requestAnimationFrame) {
				window.requestAnimationFrame(schedule);
			} else {
				window.setTimeout(schedule, jQuery.fx.interval);
			}

			jQuery.fx.tick();
		}
	}

	// Animations created synchronously will run synchronously
	function createFxNow() {
		window.setTimeout(function () {
			fxNow = undefined;
		});
		return fxNow = Date.now();
	}

	// Generate parameters to create a standard animation
	function genFx(type, includeWidth) {
		var which,
		    i = 0,
		    attrs = { height: type };

		// If we include width, step value is 1 to do all cssExpand values,
		// otherwise step value is 2 to skip over Left and Right
		includeWidth = includeWidth ? 1 : 0;
		for (; i < 4; i += 2 - includeWidth) {
			which = cssExpand[i];
			attrs["margin" + which] = attrs["padding" + which] = type;
		}

		if (includeWidth) {
			attrs.opacity = attrs.width = type;
		}

		return attrs;
	}

	function createTween(value, prop, animation) {
		var tween,
		    collection = (Animation.tweeners[prop] || []).concat(Animation.tweeners["*"]),
		    index = 0,
		    length = collection.length;
		for (; index < length; index++) {
			if (tween = collection[index].call(animation, prop, value)) {

				// We're done with this property
				return tween;
			}
		}
	}

	function defaultPrefilter(elem, props, opts) {
		var prop,
		    value,
		    toggle,
		    hooks,
		    oldfire,
		    propTween,
		    restoreDisplay,
		    display,
		    isBox = "width" in props || "height" in props,
		    anim = this,
		    orig = {},
		    style = elem.style,
		    hidden = elem.nodeType && isHiddenWithinTree(elem),
		    dataShow = dataPriv.get(elem, "fxshow");

		// Queue-skipping animations hijack the fx hooks
		if (!opts.queue) {
			hooks = jQuery._queueHooks(elem, "fx");
			if (hooks.unqueued == null) {
				hooks.unqueued = 0;
				oldfire = hooks.empty.fire;
				hooks.empty.fire = function () {
					if (!hooks.unqueued) {
						oldfire();
					}
				};
			}
			hooks.unqueued++;

			anim.always(function () {

				// Ensure the complete handler is called before this completes
				anim.always(function () {
					hooks.unqueued--;
					if (!jQuery.queue(elem, "fx").length) {
						hooks.empty.fire();
					}
				});
			});
		}

		// Detect show/hide animations
		for (prop in props) {
			value = props[prop];
			if (rfxtypes.test(value)) {
				delete props[prop];
				toggle = toggle || value === "toggle";
				if (value === (hidden ? "hide" : "show")) {

					// Pretend to be hidden if this is a "show" and
					// there is still data from a stopped show/hide
					if (value === "show" && dataShow && dataShow[prop] !== undefined) {
						hidden = true;

						// Ignore all other no-op show/hide data
					} else {
						continue;
					}
				}
				orig[prop] = dataShow && dataShow[prop] || jQuery.style(elem, prop);
			}
		}

		// Bail out if this is a no-op like .hide().hide()
		propTween = !jQuery.isEmptyObject(props);
		if (!propTween && jQuery.isEmptyObject(orig)) {
			return;
		}

		// Restrict "overflow" and "display" styles during box animations
		if (isBox && elem.nodeType === 1) {

			// Support: IE <=9 - 11, Edge 12 - 15
			// Record all 3 overflow attributes because IE does not infer the shorthand
			// from identically-valued overflowX and overflowY and Edge just mirrors
			// the overflowX value there.
			opts.overflow = [style.overflow, style.overflowX, style.overflowY];

			// Identify a display type, preferring old show/hide data over the CSS cascade
			restoreDisplay = dataShow && dataShow.display;
			if (restoreDisplay == null) {
				restoreDisplay = dataPriv.get(elem, "display");
			}
			display = jQuery.css(elem, "display");
			if (display === "none") {
				if (restoreDisplay) {
					display = restoreDisplay;
				} else {

					// Get nonempty value(s) by temporarily forcing visibility
					showHide([elem], true);
					restoreDisplay = elem.style.display || restoreDisplay;
					display = jQuery.css(elem, "display");
					showHide([elem]);
				}
			}

			// Animate inline elements as inline-block
			if (display === "inline" || display === "inline-block" && restoreDisplay != null) {
				if (jQuery.css(elem, "float") === "none") {

					// Restore the original display value at the end of pure show/hide animations
					if (!propTween) {
						anim.done(function () {
							style.display = restoreDisplay;
						});
						if (restoreDisplay == null) {
							display = style.display;
							restoreDisplay = display === "none" ? "" : display;
						}
					}
					style.display = "inline-block";
				}
			}
		}

		if (opts.overflow) {
			style.overflow = "hidden";
			anim.always(function () {
				style.overflow = opts.overflow[0];
				style.overflowX = opts.overflow[1];
				style.overflowY = opts.overflow[2];
			});
		}

		// Implement show/hide animations
		propTween = false;
		for (prop in orig) {

			// General show/hide setup for this element animation
			if (!propTween) {
				if (dataShow) {
					if ("hidden" in dataShow) {
						hidden = dataShow.hidden;
					}
				} else {
					dataShow = dataPriv.access(elem, "fxshow", { display: restoreDisplay });
				}

				// Store hidden/visible for toggle so `.stop().toggle()` "reverses"
				if (toggle) {
					dataShow.hidden = !hidden;
				}

				// Show elements before animating them
				if (hidden) {
					showHide([elem], true);
				}

				/* eslint-disable no-loop-func */

				anim.done(function () {

					/* eslint-enable no-loop-func */

					// The final step of a "hide" animation is actually hiding the element
					if (!hidden) {
						showHide([elem]);
					}
					dataPriv.remove(elem, "fxshow");
					for (prop in orig) {
						jQuery.style(elem, prop, orig[prop]);
					}
				});
			}

			// Per-property setup
			propTween = createTween(hidden ? dataShow[prop] : 0, prop, anim);
			if (!(prop in dataShow)) {
				dataShow[prop] = propTween.start;
				if (hidden) {
					propTween.end = propTween.start;
					propTween.start = 0;
				}
			}
		}
	}

	function propFilter(props, specialEasing) {
		var index, name, easing, value, hooks;

		// camelCase, specialEasing and expand cssHook pass
		for (index in props) {
			name = camelCase(index);
			easing = specialEasing[name];
			value = props[index];
			if (Array.isArray(value)) {
				easing = value[1];
				value = props[index] = value[0];
			}

			if (index !== name) {
				props[name] = value;
				delete props[index];
			}

			hooks = jQuery.cssHooks[name];
			if (hooks && "expand" in hooks) {
				value = hooks.expand(value);
				delete props[name];

				// Not quite $.extend, this won't overwrite existing keys.
				// Reusing 'index' because we have the correct "name"
				for (index in value) {
					if (!(index in props)) {
						props[index] = value[index];
						specialEasing[index] = easing;
					}
				}
			} else {
				specialEasing[name] = easing;
			}
		}
	}

	function Animation(elem, properties, options) {
		var result,
		    stopped,
		    index = 0,
		    length = Animation.prefilters.length,
		    deferred = jQuery.Deferred().always(function () {

			// Don't match elem in the :animated selector
			delete tick.elem;
		}),
		    tick = function tick() {
			if (stopped) {
				return false;
			}
			var currentTime = fxNow || createFxNow(),
			    remaining = Math.max(0, animation.startTime + animation.duration - currentTime),


			// Support: Android 2.3 only
			// Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497)
			temp = remaining / animation.duration || 0,
			    percent = 1 - temp,
			    index = 0,
			    length = animation.tweens.length;

			for (; index < length; index++) {
				animation.tweens[index].run(percent);
			}

			deferred.notifyWith(elem, [animation, percent, remaining]);

			// If there's more to do, yield
			if (percent < 1 && length) {
				return remaining;
			}

			// If this was an empty animation, synthesize a final progress notification
			if (!length) {
				deferred.notifyWith(elem, [animation, 1, 0]);
			}

			// Resolve the animation and report its conclusion
			deferred.resolveWith(elem, [animation]);
			return false;
		},
		    animation = deferred.promise({
			elem: elem,
			props: jQuery.extend({}, properties),
			opts: jQuery.extend(true, {
				specialEasing: {},
				easing: jQuery.easing._default
			}, options),
			originalProperties: properties,
			originalOptions: options,
			startTime: fxNow || createFxNow(),
			duration: options.duration,
			tweens: [],
			createTween: function createTween(prop, end) {
				var tween = jQuery.Tween(elem, animation.opts, prop, end, animation.opts.specialEasing[prop] || animation.opts.easing);
				animation.tweens.push(tween);
				return tween;
			},
			stop: function stop(gotoEnd) {
				var index = 0,


				// If we are going to the end, we want to run all the tweens
				// otherwise we skip this part
				length = gotoEnd ? animation.tweens.length : 0;
				if (stopped) {
					return this;
				}
				stopped = true;
				for (; index < length; index++) {
					animation.tweens[index].run(1);
				}

				// Resolve when we played the last frame; otherwise, reject
				if (gotoEnd) {
					deferred.notifyWith(elem, [animation, 1, 0]);
					deferred.resolveWith(elem, [animation, gotoEnd]);
				} else {
					deferred.rejectWith(elem, [animation, gotoEnd]);
				}
				return this;
			}
		}),
		    props = animation.props;

		propFilter(props, animation.opts.specialEasing);

		for (; index < length; index++) {
			result = Animation.prefilters[index].call(animation, elem, props, animation.opts);
			if (result) {
				if (isFunction(result.stop)) {
					jQuery._queueHooks(animation.elem, animation.opts.queue).stop = result.stop.bind(result);
				}
				return result;
			}
		}

		jQuery.map(props, createTween, animation);

		if (isFunction(animation.opts.start)) {
			animation.opts.start.call(elem, animation);
		}

		// Attach callbacks from options
		animation.progress(animation.opts.progress).done(animation.opts.done, animation.opts.complete).fail(animation.opts.fail).always(animation.opts.always);

		jQuery.fx.timer(jQuery.extend(tick, {
			elem: elem,
			anim: animation,
			queue: animation.opts.queue
		}));

		return animation;
	}

	jQuery.Animation = jQuery.extend(Animation, {

		tweeners: {
			"*": [function (prop, value) {
				var tween = this.createTween(prop, value);
				adjustCSS(tween.elem, prop, rcssNum.exec(value), tween);
				return tween;
			}]
		},

		tweener: function tweener(props, callback) {
			if (isFunction(props)) {
				callback = props;
				props = ["*"];
			} else {
				props = props.match(rnothtmlwhite);
			}

			var prop,
			    index = 0,
			    length = props.length;

			for (; index < length; index++) {
				prop = props[index];
				Animation.tweeners[prop] = Animation.tweeners[prop] || [];
				Animation.tweeners[prop].unshift(callback);
			}
		},

		prefilters: [defaultPrefilter],

		prefilter: function prefilter(callback, prepend) {
			if (prepend) {
				Animation.prefilters.unshift(callback);
			} else {
				Animation.prefilters.push(callback);
			}
		}
	});

	jQuery.speed = function (speed, easing, fn) {
		var opt = speed && (typeof speed === "undefined" ? "undefined" : _typeof(speed)) === "object" ? jQuery.extend({}, speed) : {
			complete: fn || !fn && easing || isFunction(speed) && speed,
			duration: speed,
			easing: fn && easing || easing && !isFunction(easing) && easing
		};

		// Go to the end state if fx are off
		if (jQuery.fx.off) {
			opt.duration = 0;
		} else {
			if (typeof opt.duration !== "number") {
				if (opt.duration in jQuery.fx.speeds) {
					opt.duration = jQuery.fx.speeds[opt.duration];
				} else {
					opt.duration = jQuery.fx.speeds._default;
				}
			}
		}

		// Normalize opt.queue - true/undefined/null -> "fx"
		if (opt.queue == null || opt.queue === true) {
			opt.queue = "fx";
		}

		// Queueing
		opt.old = opt.complete;

		opt.complete = function () {
			if (isFunction(opt.old)) {
				opt.old.call(this);
			}

			if (opt.queue) {
				jQuery.dequeue(this, opt.queue);
			}
		};

		return opt;
	};

	jQuery.fn.extend({
		fadeTo: function fadeTo(speed, to, easing, callback) {

			// Show any hidden elements after setting opacity to 0
			return this.filter(isHiddenWithinTree).css("opacity", 0).show()

			// Animate to the value specified
			.end().animate({ opacity: to }, speed, easing, callback);
		},
		animate: function animate(prop, speed, easing, callback) {
			var empty = jQuery.isEmptyObject(prop),
			    optall = jQuery.speed(speed, easing, callback),
			    doAnimation = function doAnimation() {

				// Operate on a copy of prop so per-property easing won't be lost
				var anim = Animation(this, jQuery.extend({}, prop), optall);

				// Empty animations, or finishing resolves immediately
				if (empty || dataPriv.get(this, "finish")) {
					anim.stop(true);
				}
			};
			doAnimation.finish = doAnimation;

			return empty || optall.queue === false ? this.each(doAnimation) : this.queue(optall.queue, doAnimation);
		},
		stop: function stop(type, clearQueue, gotoEnd) {
			var stopQueue = function stopQueue(hooks) {
				var stop = hooks.stop;
				delete hooks.stop;
				stop(gotoEnd);
			};

			if (typeof type !== "string") {
				gotoEnd = clearQueue;
				clearQueue = type;
				type = undefined;
			}
			if (clearQueue && type !== false) {
				this.queue(type || "fx", []);
			}

			return this.each(function () {
				var dequeue = true,
				    index = type != null && type + "queueHooks",
				    timers = jQuery.timers,
				    data = dataPriv.get(this);

				if (index) {
					if (data[index] && data[index].stop) {
						stopQueue(data[index]);
					}
				} else {
					for (index in data) {
						if (data[index] && data[index].stop && rrun.test(index)) {
							stopQueue(data[index]);
						}
					}
				}

				for (index = timers.length; index--;) {
					if (timers[index].elem === this && (type == null || timers[index].queue === type)) {

						timers[index].anim.stop(gotoEnd);
						dequeue = false;
						timers.splice(index, 1);
					}
				}

				// Start the next in the queue if the last step wasn't forced.
				// Timers currently will call their complete callbacks, which
				// will dequeue but only if they were gotoEnd.
				if (dequeue || !gotoEnd) {
					jQuery.dequeue(this, type);
				}
			});
		},
		finish: function finish(type) {
			if (type !== false) {
				type = type || "fx";
			}
			return this.each(function () {
				var index,
				    data = dataPriv.get(this),
				    queue = data[type + "queue"],
				    hooks = data[type + "queueHooks"],
				    timers = jQuery.timers,
				    length = queue ? queue.length : 0;

				// Enable finishing flag on private data
				data.finish = true;

				// Empty the queue first
				jQuery.queue(this, type, []);

				if (hooks && hooks.stop) {
					hooks.stop.call(this, true);
				}

				// Look for any active animations, and finish them
				for (index = timers.length; index--;) {
					if (timers[index].elem === this && timers[index].queue === type) {
						timers[index].anim.stop(true);
						timers.splice(index, 1);
					}
				}

				// Look for any animations in the old queue and finish them
				for (index = 0; index < length; index++) {
					if (queue[index] && queue[index].finish) {
						queue[index].finish.call(this);
					}
				}

				// Turn off finishing flag
				delete data.finish;
			});
		}
	});

	jQuery.each(["toggle", "show", "hide"], function (i, name) {
		var cssFn = jQuery.fn[name];
		jQuery.fn[name] = function (speed, easing, callback) {
			return speed == null || typeof speed === "boolean" ? cssFn.apply(this, arguments) : this.animate(genFx(name, true), speed, easing, callback);
		};
	});

	// Generate shortcuts for custom animations
	jQuery.each({
		slideDown: genFx("show"),
		slideUp: genFx("hide"),
		slideToggle: genFx("toggle"),
		fadeIn: { opacity: "show" },
		fadeOut: { opacity: "hide" },
		fadeToggle: { opacity: "toggle" }
	}, function (name, props) {
		jQuery.fn[name] = function (speed, easing, callback) {
			return this.animate(props, speed, easing, callback);
		};
	});

	jQuery.timers = [];
	jQuery.fx.tick = function () {
		var timer,
		    i = 0,
		    timers = jQuery.timers;

		fxNow = Date.now();

		for (; i < timers.length; i++) {
			timer = timers[i];

			// Run the timer and safely remove it when done (allowing for external removal)
			if (!timer() && timers[i] === timer) {
				timers.splice(i--, 1);
			}
		}

		if (!timers.length) {
			jQuery.fx.stop();
		}
		fxNow = undefined;
	};

	jQuery.fx.timer = function (timer) {
		jQuery.timers.push(timer);
		jQuery.fx.start();
	};

	jQuery.fx.interval = 13;
	jQuery.fx.start = function () {
		if (inProgress) {
			return;
		}

		inProgress = true;
		schedule();
	};

	jQuery.fx.stop = function () {
		inProgress = null;
	};

	jQuery.fx.speeds = {
		slow: 600,
		fast: 200,

		// Default speed
		_default: 400
	};

	// Based off of the plugin by Clint Helfers, with permission.
	// https://web.archive.org/web/20100324014747/http://blindsignals.com/index.php/2009/07/jquery-delay/
	jQuery.fn.delay = function (time, type) {
		time = jQuery.fx ? jQuery.fx.speeds[time] || time : time;
		type = type || "fx";

		return this.queue(type, function (next, hooks) {
			var timeout = window.setTimeout(next, time);
			hooks.stop = function () {
				window.clearTimeout(timeout);
			};
		});
	};

	(function () {
		var input = document.createElement("input"),
		    select = document.createElement("select"),
		    opt = select.appendChild(document.createElement("option"));

		input.type = "checkbox";

		// Support: Android <=4.3 only
		// Default value for a checkbox should be "on"
		support.checkOn = input.value !== "";

		// Support: IE <=11 only
		// Must access selectedIndex to make default options select
		support.optSelected = opt.selected;

		// Support: IE <=11 only
		// An input loses its value after becoming a radio
		input = document.createElement("input");
		input.value = "t";
		input.type = "radio";
		support.radioValue = input.value === "t";
	})();

	var boolHook,
	    attrHandle = jQuery.expr.attrHandle;

	jQuery.fn.extend({
		attr: function attr(name, value) {
			return access(this, jQuery.attr, name, value, arguments.length > 1);
		},

		removeAttr: function removeAttr(name) {
			return this.each(function () {
				jQuery.removeAttr(this, name);
			});
		}
	});

	jQuery.extend({
		attr: function attr(elem, name, value) {
			var ret,
			    hooks,
			    nType = elem.nodeType;

			// Don't get/set attributes on text, comment and attribute nodes
			if (nType === 3 || nType === 8 || nType === 2) {
				return;
			}

			// Fallback to prop when attributes are not supported
			if (typeof elem.getAttribute === "undefined") {
				return jQuery.prop(elem, name, value);
			}

			// Attribute hooks are determined by the lowercase version
			// Grab necessary hook if one is defined
			if (nType !== 1 || !jQuery.isXMLDoc(elem)) {
				hooks = jQuery.attrHooks[name.toLowerCase()] || (jQuery.expr.match.bool.test(name) ? boolHook : undefined);
			}

			if (value !== undefined) {
				if (value === null) {
					jQuery.removeAttr(elem, name);
					return;
				}

				if (hooks && "set" in hooks && (ret = hooks.set(elem, value, name)) !== undefined) {
					return ret;
				}

				elem.setAttribute(name, value + "");
				return value;
			}

			if (hooks && "get" in hooks && (ret = hooks.get(elem, name)) !== null) {
				return ret;
			}

			ret = jQuery.find.attr(elem, name);

			// Non-existent attributes return null, we normalize to undefined
			return ret == null ? undefined : ret;
		},

		attrHooks: {
			type: {
				set: function set(elem, value) {
					if (!support.radioValue && value === "radio" && nodeName(elem, "input")) {
						var val = elem.value;
						elem.setAttribute("type", value);
						if (val) {
							elem.value = val;
						}
						return value;
					}
				}
			}
		},

		removeAttr: function removeAttr(elem, value) {
			var name,
			    i = 0,


			// Attribute names can contain non-HTML whitespace characters
			// https://html.spec.whatwg.org/multipage/syntax.html#attributes-2
			attrNames = value && value.match(rnothtmlwhite);

			if (attrNames && elem.nodeType === 1) {
				while (name = attrNames[i++]) {
					elem.removeAttribute(name);
				}
			}
		}
	});

	// Hooks for boolean attributes
	boolHook = {
		set: function set(elem, value, name) {
			if (value === false) {

				// Remove boolean attributes when set to false
				jQuery.removeAttr(elem, name);
			} else {
				elem.setAttribute(name, name);
			}
			return name;
		}
	};

	jQuery.each(jQuery.expr.match.bool.source.match(/\w+/g), function (i, name) {
		var getter = attrHandle[name] || jQuery.find.attr;

		attrHandle[name] = function (elem, name, isXML) {
			var ret,
			    handle,
			    lowercaseName = name.toLowerCase();

			if (!isXML) {

				// Avoid an infinite loop by temporarily removing this function from the getter
				handle = attrHandle[lowercaseName];
				attrHandle[lowercaseName] = ret;
				ret = getter(elem, name, isXML) != null ? lowercaseName : null;
				attrHandle[lowercaseName] = handle;
			}
			return ret;
		};
	});

	var rfocusable = /^(?:input|select|textarea|button)$/i,
	    rclickable = /^(?:a|area)$/i;

	jQuery.fn.extend({
		prop: function prop(name, value) {
			return access(this, jQuery.prop, name, value, arguments.length > 1);
		},

		removeProp: function removeProp(name) {
			return this.each(function () {
				delete this[jQuery.propFix[name] || name];
			});
		}
	});

	jQuery.extend({
		prop: function prop(elem, name, value) {
			var ret,
			    hooks,
			    nType = elem.nodeType;

			// Don't get/set properties on text, comment and attribute nodes
			if (nType === 3 || nType === 8 || nType === 2) {
				return;
			}

			if (nType !== 1 || !jQuery.isXMLDoc(elem)) {

				// Fix name and attach hooks
				name = jQuery.propFix[name] || name;
				hooks = jQuery.propHooks[name];
			}

			if (value !== undefined) {
				if (hooks && "set" in hooks && (ret = hooks.set(elem, value, name)) !== undefined) {
					return ret;
				}

				return elem[name] = value;
			}

			if (hooks && "get" in hooks && (ret = hooks.get(elem, name)) !== null) {
				return ret;
			}

			return elem[name];
		},

		propHooks: {
			tabIndex: {
				get: function get(elem) {

					// Support: IE <=9 - 11 only
					// elem.tabIndex doesn't always return the
					// correct value when it hasn't been explicitly set
					// https://web.archive.org/web/20141116233347/http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
					// Use proper attribute retrieval(#12072)
					var tabindex = jQuery.find.attr(elem, "tabindex");

					if (tabindex) {
						return parseInt(tabindex, 10);
					}

					if (rfocusable.test(elem.nodeName) || rclickable.test(elem.nodeName) && elem.href) {
						return 0;
					}

					return -1;
				}
			}
		},

		propFix: {
			"for": "htmlFor",
			"class": "className"
		}
	});

	// Support: IE <=11 only
	// Accessing the selectedIndex property
	// forces the browser to respect setting selected
	// on the option
	// The getter ensures a default option is selected
	// when in an optgroup
	// eslint rule "no-unused-expressions" is disabled for this code
	// since it considers such accessions noop
	if (!support.optSelected) {
		jQuery.propHooks.selected = {
			get: function get(elem) {

				/* eslint no-unused-expressions: "off" */

				var parent = elem.parentNode;
				if (parent && parent.parentNode) {
					parent.parentNode.selectedIndex;
				}
				return null;
			},
			set: function set(elem) {

				/* eslint no-unused-expressions: "off" */

				var parent = elem.parentNode;
				if (parent) {
					parent.selectedIndex;

					if (parent.parentNode) {
						parent.parentNode.selectedIndex;
					}
				}
			}
		};
	}

	jQuery.each(["tabIndex", "readOnly", "maxLength", "cellSpacing", "cellPadding", "rowSpan", "colSpan", "useMap", "frameBorder", "contentEditable"], function () {
		jQuery.propFix[this.toLowerCase()] = this;
	});

	// Strip and collapse whitespace according to HTML spec
	// https://infra.spec.whatwg.org/#strip-and-collapse-ascii-whitespace
	function stripAndCollapse(value) {
		var tokens = value.match(rnothtmlwhite) || [];
		return tokens.join(" ");
	}

	function getClass(elem) {
		return elem.getAttribute && elem.getAttribute("class") || "";
	}

	function classesToArray(value) {
		if (Array.isArray(value)) {
			return value;
		}
		if (typeof value === "string") {
			return value.match(rnothtmlwhite) || [];
		}
		return [];
	}

	jQuery.fn.extend({
		addClass: function addClass(value) {
			var classes,
			    elem,
			    cur,
			    curValue,
			    clazz,
			    j,
			    finalValue,
			    i = 0;

			if (isFunction(value)) {
				return this.each(function (j) {
					jQuery(this).addClass(value.call(this, j, getClass(this)));
				});
			}

			classes = classesToArray(value);

			if (classes.length) {
				while (elem = this[i++]) {
					curValue = getClass(elem);
					cur = elem.nodeType === 1 && " " + stripAndCollapse(curValue) + " ";

					if (cur) {
						j = 0;
						while (clazz = classes[j++]) {
							if (cur.indexOf(" " + clazz + " ") < 0) {
								cur += clazz + " ";
							}
						}

						// Only assign if different to avoid unneeded rendering.
						finalValue = stripAndCollapse(cur);
						if (curValue !== finalValue) {
							elem.setAttribute("class", finalValue);
						}
					}
				}
			}

			return this;
		},

		removeClass: function removeClass(value) {
			var classes,
			    elem,
			    cur,
			    curValue,
			    clazz,
			    j,
			    finalValue,
			    i = 0;

			if (isFunction(value)) {
				return this.each(function (j) {
					jQuery(this).removeClass(value.call(this, j, getClass(this)));
				});
			}

			if (!arguments.length) {
				return this.attr("class", "");
			}

			classes = classesToArray(value);

			if (classes.length) {
				while (elem = this[i++]) {
					curValue = getClass(elem);

					// This expression is here for better compressibility (see addClass)
					cur = elem.nodeType === 1 && " " + stripAndCollapse(curValue) + " ";

					if (cur) {
						j = 0;
						while (clazz = classes[j++]) {

							// Remove *all* instances
							while (cur.indexOf(" " + clazz + " ") > -1) {
								cur = cur.replace(" " + clazz + " ", " ");
							}
						}

						// Only assign if different to avoid unneeded rendering.
						finalValue = stripAndCollapse(cur);
						if (curValue !== finalValue) {
							elem.setAttribute("class", finalValue);
						}
					}
				}
			}

			return this;
		},

		toggleClass: function toggleClass(value, stateVal) {
			var type = typeof value === "undefined" ? "undefined" : _typeof(value),
			    isValidValue = type === "string" || Array.isArray(value);

			if (typeof stateVal === "boolean" && isValidValue) {
				return stateVal ? this.addClass(value) : this.removeClass(value);
			}

			if (isFunction(value)) {
				return this.each(function (i) {
					jQuery(this).toggleClass(value.call(this, i, getClass(this), stateVal), stateVal);
				});
			}

			return this.each(function () {
				var className, i, self, classNames;

				if (isValidValue) {

					// Toggle individual class names
					i = 0;
					self = jQuery(this);
					classNames = classesToArray(value);

					while (className = classNames[i++]) {

						// Check each className given, space separated list
						if (self.hasClass(className)) {
							self.removeClass(className);
						} else {
							self.addClass(className);
						}
					}

					// Toggle whole class name
				} else if (value === undefined || type === "boolean") {
					className = getClass(this);
					if (className) {

						// Store className if set
						dataPriv.set(this, "__className__", className);
					}

					// If the element has a class name or if we're passed `false`,
					// then remove the whole classname (if there was one, the above saved it).
					// Otherwise bring back whatever was previously saved (if anything),
					// falling back to the empty string if nothing was stored.
					if (this.setAttribute) {
						this.setAttribute("class", className || value === false ? "" : dataPriv.get(this, "__className__") || "");
					}
				}
			});
		},

		hasClass: function hasClass(selector) {
			var className,
			    elem,
			    i = 0;

			className = " " + selector + " ";
			while (elem = this[i++]) {
				if (elem.nodeType === 1 && (" " + stripAndCollapse(getClass(elem)) + " ").indexOf(className) > -1) {
					return true;
				}
			}

			return false;
		}
	});

	var rreturn = /\r/g;

	jQuery.fn.extend({
		val: function val(value) {
			var hooks,
			    ret,
			    valueIsFunction,
			    elem = this[0];

			if (!arguments.length) {
				if (elem) {
					hooks = jQuery.valHooks[elem.type] || jQuery.valHooks[elem.nodeName.toLowerCase()];

					if (hooks && "get" in hooks && (ret = hooks.get(elem, "value")) !== undefined) {
						return ret;
					}

					ret = elem.value;

					// Handle most common string cases
					if (typeof ret === "string") {
						return ret.replace(rreturn, "");
					}

					// Handle cases where value is null/undef or number
					return ret == null ? "" : ret;
				}

				return;
			}

			valueIsFunction = isFunction(value);

			return this.each(function (i) {
				var val;

				if (this.nodeType !== 1) {
					return;
				}

				if (valueIsFunction) {
					val = value.call(this, i, jQuery(this).val());
				} else {
					val = value;
				}

				// Treat null/undefined as ""; convert numbers to string
				if (val == null) {
					val = "";
				} else if (typeof val === "number") {
					val += "";
				} else if (Array.isArray(val)) {
					val = jQuery.map(val, function (value) {
						return value == null ? "" : value + "";
					});
				}

				hooks = jQuery.valHooks[this.type] || jQuery.valHooks[this.nodeName.toLowerCase()];

				// If set returns undefined, fall back to normal setting
				if (!hooks || !("set" in hooks) || hooks.set(this, val, "value") === undefined) {
					this.value = val;
				}
			});
		}
	});

	jQuery.extend({
		valHooks: {
			option: {
				get: function get(elem) {

					var val = jQuery.find.attr(elem, "value");
					return val != null ? val :

					// Support: IE <=10 - 11 only
					// option.text throws exceptions (#14686, #14858)
					// Strip and collapse whitespace
					// https://html.spec.whatwg.org/#strip-and-collapse-whitespace
					stripAndCollapse(jQuery.text(elem));
				}
			},
			select: {
				get: function get(elem) {
					var value,
					    option,
					    i,
					    options = elem.options,
					    index = elem.selectedIndex,
					    one = elem.type === "select-one",
					    values = one ? null : [],
					    max = one ? index + 1 : options.length;

					if (index < 0) {
						i = max;
					} else {
						i = one ? index : 0;
					}

					// Loop through all the selected options
					for (; i < max; i++) {
						option = options[i];

						// Support: IE <=9 only
						// IE8-9 doesn't update selected after form reset (#2551)
						if ((option.selected || i === index) &&

						// Don't return options that are disabled or in a disabled optgroup
						!option.disabled && (!option.parentNode.disabled || !nodeName(option.parentNode, "optgroup"))) {

							// Get the specific value for the option
							value = jQuery(option).val();

							// We don't need an array for one selects
							if (one) {
								return value;
							}

							// Multi-Selects return an array
							values.push(value);
						}
					}

					return values;
				},

				set: function set(elem, value) {
					var optionSet,
					    option,
					    options = elem.options,
					    values = jQuery.makeArray(value),
					    i = options.length;

					while (i--) {
						option = options[i];

						/* eslint-disable no-cond-assign */

						if (option.selected = jQuery.inArray(jQuery.valHooks.option.get(option), values) > -1) {
							optionSet = true;
						}

						/* eslint-enable no-cond-assign */
					}

					// Force browsers to behave consistently when non-matching value is set
					if (!optionSet) {
						elem.selectedIndex = -1;
					}
					return values;
				}
			}
		}
	});

	// Radios and checkboxes getter/setter
	jQuery.each(["radio", "checkbox"], function () {
		jQuery.valHooks[this] = {
			set: function set(elem, value) {
				if (Array.isArray(value)) {
					return elem.checked = jQuery.inArray(jQuery(elem).val(), value) > -1;
				}
			}
		};
		if (!support.checkOn) {
			jQuery.valHooks[this].get = function (elem) {
				return elem.getAttribute("value") === null ? "on" : elem.value;
			};
		}
	});

	// Return jQuery for attributes-only inclusion


	support.focusin = "onfocusin" in window;

	var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,
	    stopPropagationCallback = function stopPropagationCallback(e) {
		e.stopPropagation();
	};

	jQuery.extend(jQuery.event, {

		trigger: function trigger(event, data, elem, onlyHandlers) {

			var i,
			    cur,
			    tmp,
			    bubbleType,
			    ontype,
			    handle,
			    special,
			    lastElement,
			    eventPath = [elem || document],
			    type = hasOwn.call(event, "type") ? event.type : event,
			    namespaces = hasOwn.call(event, "namespace") ? event.namespace.split(".") : [];

			cur = lastElement = tmp = elem = elem || document;

			// Don't do events on text and comment nodes
			if (elem.nodeType === 3 || elem.nodeType === 8) {
				return;
			}

			// focus/blur morphs to focusin/out; ensure we're not firing them right now
			if (rfocusMorph.test(type + jQuery.event.triggered)) {
				return;
			}

			if (type.indexOf(".") > -1) {

				// Namespaced trigger; create a regexp to match event type in handle()
				namespaces = type.split(".");
				type = namespaces.shift();
				namespaces.sort();
			}
			ontype = type.indexOf(":") < 0 && "on" + type;

			// Caller can pass in a jQuery.Event object, Object, or just an event type string
			event = event[jQuery.expando] ? event : new jQuery.Event(type, (typeof event === "undefined" ? "undefined" : _typeof(event)) === "object" && event);

			// Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)
			event.isTrigger = onlyHandlers ? 2 : 3;
			event.namespace = namespaces.join(".");
			event.rnamespace = event.namespace ? new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)") : null;

			// Clean up the event in case it is being reused
			event.result = undefined;
			if (!event.target) {
				event.target = elem;
			}

			// Clone any incoming data and prepend the event, creating the handler arg list
			data = data == null ? [event] : jQuery.makeArray(data, [event]);

			// Allow special events to draw outside the lines
			special = jQuery.event.special[type] || {};
			if (!onlyHandlers && special.trigger && special.trigger.apply(elem, data) === false) {
				return;
			}

			// Determine event propagation path in advance, per W3C events spec (#9951)
			// Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
			if (!onlyHandlers && !special.noBubble && !isWindow(elem)) {

				bubbleType = special.delegateType || type;
				if (!rfocusMorph.test(bubbleType + type)) {
					cur = cur.parentNode;
				}
				for (; cur; cur = cur.parentNode) {
					eventPath.push(cur);
					tmp = cur;
				}

				// Only add window if we got to document (e.g., not plain obj or detached DOM)
				if (tmp === (elem.ownerDocument || document)) {
					eventPath.push(tmp.defaultView || tmp.parentWindow || window);
				}
			}

			// Fire handlers on the event path
			i = 0;
			while ((cur = eventPath[i++]) && !event.isPropagationStopped()) {
				lastElement = cur;
				event.type = i > 1 ? bubbleType : special.bindType || type;

				// jQuery handler
				handle = (dataPriv.get(cur, "events") || {})[event.type] && dataPriv.get(cur, "handle");
				if (handle) {
					handle.apply(cur, data);
				}

				// Native handler
				handle = ontype && cur[ontype];
				if (handle && handle.apply && acceptData(cur)) {
					event.result = handle.apply(cur, data);
					if (event.result === false) {
						event.preventDefault();
					}
				}
			}
			event.type = type;

			// If nobody prevented the default action, do it now
			if (!onlyHandlers && !event.isDefaultPrevented()) {

				if ((!special._default || special._default.apply(eventPath.pop(), data) === false) && acceptData(elem)) {

					// Call a native DOM method on the target with the same name as the event.
					// Don't do default actions on window, that's where global variables be (#6170)
					if (ontype && isFunction(elem[type]) && !isWindow(elem)) {

						// Don't re-trigger an onFOO event when we call its FOO() method
						tmp = elem[ontype];

						if (tmp) {
							elem[ontype] = null;
						}

						// Prevent re-triggering of the same event, since we already bubbled it above
						jQuery.event.triggered = type;

						if (event.isPropagationStopped()) {
							lastElement.addEventListener(type, stopPropagationCallback);
						}

						elem[type]();

						if (event.isPropagationStopped()) {
							lastElement.removeEventListener(type, stopPropagationCallback);
						}

						jQuery.event.triggered = undefined;

						if (tmp) {
							elem[ontype] = tmp;
						}
					}
				}
			}

			return event.result;
		},

		// Piggyback on a donor event to simulate a different one
		// Used only for `focus(in | out)` events
		simulate: function simulate(type, elem, event) {
			var e = jQuery.extend(new jQuery.Event(), event, {
				type: type,
				isSimulated: true
			});

			jQuery.event.trigger(e, null, elem);
		}

	});

	jQuery.fn.extend({

		trigger: function trigger(type, data) {
			return this.each(function () {
				jQuery.event.trigger(type, data, this);
			});
		},
		triggerHandler: function triggerHandler(type, data) {
			var elem = this[0];
			if (elem) {
				return jQuery.event.trigger(type, data, elem, true);
			}
		}
	});

	// Support: Firefox <=44
	// Firefox doesn't have focus(in | out) events
	// Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787
	//
	// Support: Chrome <=48 - 49, Safari <=9.0 - 9.1
	// focus(in | out) events fire after focus & blur events,
	// which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order
	// Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857
	if (!support.focusin) {
		jQuery.each({ focus: "focusin", blur: "focusout" }, function (orig, fix) {

			// Attach a single capturing handler on the document while someone wants focusin/focusout
			var handler = function handler(event) {
				jQuery.event.simulate(fix, event.target, jQuery.event.fix(event));
			};

			jQuery.event.special[fix] = {
				setup: function setup() {
					var doc = this.ownerDocument || this,
					    attaches = dataPriv.access(doc, fix);

					if (!attaches) {
						doc.addEventListener(orig, handler, true);
					}
					dataPriv.access(doc, fix, (attaches || 0) + 1);
				},
				teardown: function teardown() {
					var doc = this.ownerDocument || this,
					    attaches = dataPriv.access(doc, fix) - 1;

					if (!attaches) {
						doc.removeEventListener(orig, handler, true);
						dataPriv.remove(doc, fix);
					} else {
						dataPriv.access(doc, fix, attaches);
					}
				}
			};
		});
	}
	var location = window.location;

	var nonce = Date.now();

	var rquery = /\?/;

	// Cross-browser xml parsing
	jQuery.parseXML = function (data) {
		var xml;
		if (!data || typeof data !== "string") {
			return null;
		}

		// Support: IE 9 - 11 only
		// IE throws on parseFromString with invalid input.
		try {
			xml = new window.DOMParser().parseFromString(data, "text/xml");
		} catch (e) {
			xml = undefined;
		}

		if (!xml || xml.getElementsByTagName("parsererror").length) {
			jQuery.error("Invalid XML: " + data);
		}
		return xml;
	};

	var rbracket = /\[\]$/,
	    rCRLF = /\r?\n/g,
	    rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i,
	    rsubmittable = /^(?:input|select|textarea|keygen)/i;

	function buildParams(prefix, obj, traditional, add) {
		var name;

		if (Array.isArray(obj)) {

			// Serialize array item.
			jQuery.each(obj, function (i, v) {
				if (traditional || rbracket.test(prefix)) {

					// Treat each array item as a scalar.
					add(prefix, v);
				} else {

					// Item is non-scalar (array or object), encode its numeric index.
					buildParams(prefix + "[" + ((typeof v === "undefined" ? "undefined" : _typeof(v)) === "object" && v != null ? i : "") + "]", v, traditional, add);
				}
			});
		} else if (!traditional && toType(obj) === "object") {

			// Serialize object item.
			for (name in obj) {
				buildParams(prefix + "[" + name + "]", obj[name], traditional, add);
			}
		} else {

			// Serialize scalar item.
			add(prefix, obj);
		}
	}

	// Serialize an array of form elements or a set of
	// key/values into a query string
	jQuery.param = function (a, traditional) {
		var prefix,
		    s = [],
		    add = function add(key, valueOrFunction) {

			// If value is a function, invoke it and use its return value
			var value = isFunction(valueOrFunction) ? valueOrFunction() : valueOrFunction;

			s[s.length] = encodeURIComponent(key) + "=" + encodeURIComponent(value == null ? "" : value);
		};

		// If an array was passed in, assume that it is an array of form elements.
		if (Array.isArray(a) || a.jquery && !jQuery.isPlainObject(a)) {

			// Serialize the form elements
			jQuery.each(a, function () {
				add(this.name, this.value);
			});
		} else {

			// If traditional, encode the "old" way (the way 1.3.2 or older
			// did it), otherwise encode params recursively.
			for (prefix in a) {
				buildParams(prefix, a[prefix], traditional, add);
			}
		}

		// Return the resulting serialization
		return s.join("&");
	};

	jQuery.fn.extend({
		serialize: function serialize() {
			return jQuery.param(this.serializeArray());
		},
		serializeArray: function serializeArray() {
			return this.map(function () {

				// Can add propHook for "elements" to filter or add form elements
				var elements = jQuery.prop(this, "elements");
				return elements ? jQuery.makeArray(elements) : this;
			}).filter(function () {
				var type = this.type;

				// Use .is( ":disabled" ) so that fieldset[disabled] works
				return this.name && !jQuery(this).is(":disabled") && rsubmittable.test(this.nodeName) && !rsubmitterTypes.test(type) && (this.checked || !rcheckableType.test(type));
			}).map(function (i, elem) {
				var val = jQuery(this).val();

				if (val == null) {
					return null;
				}

				if (Array.isArray(val)) {
					return jQuery.map(val, function (val) {
						return { name: elem.name, value: val.replace(rCRLF, "\r\n") };
					});
				}

				return { name: elem.name, value: val.replace(rCRLF, "\r\n") };
			}).get();
		}
	});

	var r20 = /%20/g,
	    rhash = /#.*$/,
	    rantiCache = /([?&])_=[^&]*/,
	    rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg,


	// #7653, #8125, #8152: local protocol detection
	rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,
	    rnoContent = /^(?:GET|HEAD)$/,
	    rprotocol = /^\/\//,


	/* Prefilters
  * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
  * 2) These are called:
  *    - BEFORE asking for a transport
  *    - AFTER param serialization (s.data is a string if s.processData is true)
  * 3) key is the dataType
  * 4) the catchall symbol "*" can be used
  * 5) execution will start with transport dataType and THEN continue down to "*" if needed
  */
	prefilters = {},


	/* Transports bindings
  * 1) key is the dataType
  * 2) the catchall symbol "*" can be used
  * 3) selection will start with transport dataType and THEN go to "*" if needed
  */
	transports = {},


	// Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
	allTypes = "*/".concat("*"),


	// Anchor tag for parsing the document origin
	originAnchor = document.createElement("a");
	originAnchor.href = location.href;

	// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
	function addToPrefiltersOrTransports(structure) {

		// dataTypeExpression is optional and defaults to "*"
		return function (dataTypeExpression, func) {

			if (typeof dataTypeExpression !== "string") {
				func = dataTypeExpression;
				dataTypeExpression = "*";
			}

			var dataType,
			    i = 0,
			    dataTypes = dataTypeExpression.toLowerCase().match(rnothtmlwhite) || [];

			if (isFunction(func)) {

				// For each dataType in the dataTypeExpression
				while (dataType = dataTypes[i++]) {

					// Prepend if requested
					if (dataType[0] === "+") {
						dataType = dataType.slice(1) || "*";
						(structure[dataType] = structure[dataType] || []).unshift(func);

						// Otherwise append
					} else {
						(structure[dataType] = structure[dataType] || []).push(func);
					}
				}
			}
		};
	}

	// Base inspection function for prefilters and transports
	function inspectPrefiltersOrTransports(structure, options, originalOptions, jqXHR) {

		var inspected = {},
		    seekingTransport = structure === transports;

		function inspect(dataType) {
			var selected;
			inspected[dataType] = true;
			jQuery.each(structure[dataType] || [], function (_, prefilterOrFactory) {
				var dataTypeOrTransport = prefilterOrFactory(options, originalOptions, jqXHR);
				if (typeof dataTypeOrTransport === "string" && !seekingTransport && !inspected[dataTypeOrTransport]) {

					options.dataTypes.unshift(dataTypeOrTransport);
					inspect(dataTypeOrTransport);
					return false;
				} else if (seekingTransport) {
					return !(selected = dataTypeOrTransport);
				}
			});
			return selected;
		}

		return inspect(options.dataTypes[0]) || !inspected["*"] && inspect("*");
	}

	// A special extend for ajax options
	// that takes "flat" options (not to be deep extended)
	// Fixes #9887
	function ajaxExtend(target, src) {
		var key,
		    deep,
		    flatOptions = jQuery.ajaxSettings.flatOptions || {};

		for (key in src) {
			if (src[key] !== undefined) {
				(flatOptions[key] ? target : deep || (deep = {}))[key] = src[key];
			}
		}
		if (deep) {
			jQuery.extend(true, target, deep);
		}

		return target;
	}

	/* Handles responses to an ajax request:
  * - finds the right dataType (mediates between content-type and expected dataType)
  * - returns the corresponding response
  */
	function ajaxHandleResponses(s, jqXHR, responses) {

		var ct,
		    type,
		    finalDataType,
		    firstDataType,
		    contents = s.contents,
		    dataTypes = s.dataTypes;

		// Remove auto dataType and get content-type in the process
		while (dataTypes[0] === "*") {
			dataTypes.shift();
			if (ct === undefined) {
				ct = s.mimeType || jqXHR.getResponseHeader("Content-Type");
			}
		}

		// Check if we're dealing with a known content-type
		if (ct) {
			for (type in contents) {
				if (contents[type] && contents[type].test(ct)) {
					dataTypes.unshift(type);
					break;
				}
			}
		}

		// Check to see if we have a response for the expected dataType
		if (dataTypes[0] in responses) {
			finalDataType = dataTypes[0];
		} else {

			// Try convertible dataTypes
			for (type in responses) {
				if (!dataTypes[0] || s.converters[type + " " + dataTypes[0]]) {
					finalDataType = type;
					break;
				}
				if (!firstDataType) {
					firstDataType = type;
				}
			}

			// Or just use first one
			finalDataType = finalDataType || firstDataType;
		}

		// If we found a dataType
		// We add the dataType to the list if needed
		// and return the corresponding response
		if (finalDataType) {
			if (finalDataType !== dataTypes[0]) {
				dataTypes.unshift(finalDataType);
			}
			return responses[finalDataType];
		}
	}

	/* Chain conversions given the request and the original response
  * Also sets the responseXXX fields on the jqXHR instance
  */
	function ajaxConvert(s, response, jqXHR, isSuccess) {
		var conv2,
		    current,
		    conv,
		    tmp,
		    prev,
		    converters = {},


		// Work with a copy of dataTypes in case we need to modify it for conversion
		dataTypes = s.dataTypes.slice();

		// Create converters map with lowercased keys
		if (dataTypes[1]) {
			for (conv in s.converters) {
				converters[conv.toLowerCase()] = s.converters[conv];
			}
		}

		current = dataTypes.shift();

		// Convert to each sequential dataType
		while (current) {

			if (s.responseFields[current]) {
				jqXHR[s.responseFields[current]] = response;
			}

			// Apply the dataFilter if provided
			if (!prev && isSuccess && s.dataFilter) {
				response = s.dataFilter(response, s.dataType);
			}

			prev = current;
			current = dataTypes.shift();

			if (current) {

				// There's only work to do if current dataType is non-auto
				if (current === "*") {

					current = prev;

					// Convert response if prev dataType is non-auto and differs from current
				} else if (prev !== "*" && prev !== current) {

					// Seek a direct converter
					conv = converters[prev + " " + current] || converters["* " + current];

					// If none found, seek a pair
					if (!conv) {
						for (conv2 in converters) {

							// If conv2 outputs current
							tmp = conv2.split(" ");
							if (tmp[1] === current) {

								// If prev can be converted to accepted input
								conv = converters[prev + " " + tmp[0]] || converters["* " + tmp[0]];
								if (conv) {

									// Condense equivalence converters
									if (conv === true) {
										conv = converters[conv2];

										// Otherwise, insert the intermediate dataType
									} else if (converters[conv2] !== true) {
										current = tmp[0];
										dataTypes.unshift(tmp[1]);
									}
									break;
								}
							}
						}
					}

					// Apply converter (if not an equivalence)
					if (conv !== true) {

						// Unless errors are allowed to bubble, catch and return them
						if (conv && s.throws) {
							response = conv(response);
						} else {
							try {
								response = conv(response);
							} catch (e) {
								return {
									state: "parsererror",
									error: conv ? e : "No conversion from " + prev + " to " + current
								};
							}
						}
					}
				}
			}
		}

		return { state: "success", data: response };
	}

	jQuery.extend({

		// Counter for holding the number of active queries
		active: 0,

		// Last-Modified header cache for next request
		lastModified: {},
		etag: {},

		ajaxSettings: {
			url: location.href,
			type: "GET",
			isLocal: rlocalProtocol.test(location.protocol),
			global: true,
			processData: true,
			async: true,
			contentType: "application/x-www-form-urlencoded; charset=UTF-8",

			/*
   timeout: 0,
   data: null,
   dataType: null,
   username: null,
   password: null,
   cache: null,
   throws: false,
   traditional: false,
   headers: {},
   */

			accepts: {
				"*": allTypes,
				text: "text/plain",
				html: "text/html",
				xml: "application/xml, text/xml",
				json: "application/json, text/javascript"
			},

			contents: {
				xml: /\bxml\b/,
				html: /\bhtml/,
				json: /\bjson\b/
			},

			responseFields: {
				xml: "responseXML",
				text: "responseText",
				json: "responseJSON"
			},

			// Data converters
			// Keys separate source (or catchall "*") and destination types with a single space
			converters: {

				// Convert anything to text
				"* text": String,

				// Text to html (true = no transformation)
				"text html": true,

				// Evaluate text as a json expression
				"text json": JSON.parse,

				// Parse text as xml
				"text xml": jQuery.parseXML
			},

			// For options that shouldn't be deep extended:
			// you can add your own custom options here if
			// and when you create one that shouldn't be
			// deep extended (see ajaxExtend)
			flatOptions: {
				url: true,
				context: true
			}
		},

		// Creates a full fledged settings object into target
		// with both ajaxSettings and settings fields.
		// If target is omitted, writes into ajaxSettings.
		ajaxSetup: function ajaxSetup(target, settings) {
			return settings ?

			// Building a settings object
			ajaxExtend(ajaxExtend(target, jQuery.ajaxSettings), settings) :

			// Extending ajaxSettings
			ajaxExtend(jQuery.ajaxSettings, target);
		},

		ajaxPrefilter: addToPrefiltersOrTransports(prefilters),
		ajaxTransport: addToPrefiltersOrTransports(transports),

		// Main method
		ajax: function ajax(url, options) {

			// If url is an object, simulate pre-1.5 signature
			if ((typeof url === "undefined" ? "undefined" : _typeof(url)) === "object") {
				options = url;
				url = undefined;
			}

			// Force options to be an object
			options = options || {};

			var transport,


			// URL without anti-cache param
			cacheURL,


			// Response headers
			responseHeadersString,
			    responseHeaders,


			// timeout handle
			timeoutTimer,


			// Url cleanup var
			urlAnchor,


			// Request state (becomes false upon send and true upon completion)
			completed,


			// To know if global events are to be dispatched
			fireGlobals,


			// Loop variable
			i,


			// uncached part of the url
			uncached,


			// Create the final options object
			s = jQuery.ajaxSetup({}, options),


			// Callbacks context
			callbackContext = s.context || s,


			// Context for global events is callbackContext if it is a DOM node or jQuery collection
			globalEventContext = s.context && (callbackContext.nodeType || callbackContext.jquery) ? jQuery(callbackContext) : jQuery.event,


			// Deferreds
			deferred = jQuery.Deferred(),
			    completeDeferred = jQuery.Callbacks("once memory"),


			// Status-dependent callbacks
			_statusCode = s.statusCode || {},


			// Headers (they are sent all at once)
			requestHeaders = {},
			    requestHeadersNames = {},


			// Default abort message
			strAbort = "canceled",


			// Fake xhr
			jqXHR = {
				readyState: 0,

				// Builds headers hashtable if needed
				getResponseHeader: function getResponseHeader(key) {
					var match;
					if (completed) {
						if (!responseHeaders) {
							responseHeaders = {};
							while (match = rheaders.exec(responseHeadersString)) {
								responseHeaders[match[1].toLowerCase()] = match[2];
							}
						}
						match = responseHeaders[key.toLowerCase()];
					}
					return match == null ? null : match;
				},

				// Raw string
				getAllResponseHeaders: function getAllResponseHeaders() {
					return completed ? responseHeadersString : null;
				},

				// Caches the header
				setRequestHeader: function setRequestHeader(name, value) {
					if (completed == null) {
						name = requestHeadersNames[name.toLowerCase()] = requestHeadersNames[name.toLowerCase()] || name;
						requestHeaders[name] = value;
					}
					return this;
				},

				// Overrides response content-type header
				overrideMimeType: function overrideMimeType(type) {
					if (completed == null) {
						s.mimeType = type;
					}
					return this;
				},

				// Status-dependent callbacks
				statusCode: function statusCode(map) {
					var code;
					if (map) {
						if (completed) {

							// Execute the appropriate callbacks
							jqXHR.always(map[jqXHR.status]);
						} else {

							// Lazy-add the new callbacks in a way that preserves old ones
							for (code in map) {
								_statusCode[code] = [_statusCode[code], map[code]];
							}
						}
					}
					return this;
				},

				// Cancel the request
				abort: function abort(statusText) {
					var finalText = statusText || strAbort;
					if (transport) {
						transport.abort(finalText);
					}
					done(0, finalText);
					return this;
				}
			};

			// Attach deferreds
			deferred.promise(jqXHR);

			// Add protocol if not provided (prefilters might expect it)
			// Handle falsy url in the settings object (#10093: consistency with old signature)
			// We also use the url parameter if available
			s.url = ((url || s.url || location.href) + "").replace(rprotocol, location.protocol + "//");

			// Alias method option to type as per ticket #12004
			s.type = options.method || options.type || s.method || s.type;

			// Extract dataTypes list
			s.dataTypes = (s.dataType || "*").toLowerCase().match(rnothtmlwhite) || [""];

			// A cross-domain request is in order when the origin doesn't match the current origin.
			if (s.crossDomain == null) {
				urlAnchor = document.createElement("a");

				// Support: IE <=8 - 11, Edge 12 - 15
				// IE throws exception on accessing the href property if url is malformed,
				// e.g. http://example.com:80x/
				try {
					urlAnchor.href = s.url;

					// Support: IE <=8 - 11 only
					// Anchor's host property isn't correctly set when s.url is relative
					urlAnchor.href = urlAnchor.href;
					s.crossDomain = originAnchor.protocol + "//" + originAnchor.host !== urlAnchor.protocol + "//" + urlAnchor.host;
				} catch (e) {

					// If there is an error parsing the URL, assume it is crossDomain,
					// it can be rejected by the transport if it is invalid
					s.crossDomain = true;
				}
			}

			// Convert data if not already a string
			if (s.data && s.processData && typeof s.data !== "string") {
				s.data = jQuery.param(s.data, s.traditional);
			}

			// Apply prefilters
			inspectPrefiltersOrTransports(prefilters, s, options, jqXHR);

			// If request was aborted inside a prefilter, stop there
			if (completed) {
				return jqXHR;
			}

			// We can fire global events as of now if asked to
			// Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118)
			fireGlobals = jQuery.event && s.global;

			// Watch for a new set of requests
			if (fireGlobals && jQuery.active++ === 0) {
				jQuery.event.trigger("ajaxStart");
			}

			// Uppercase the type
			s.type = s.type.toUpperCase();

			// Determine if request has content
			s.hasContent = !rnoContent.test(s.type);

			// Save the URL in case we're toying with the If-Modified-Since
			// and/or If-None-Match header later on
			// Remove hash to simplify url manipulation
			cacheURL = s.url.replace(rhash, "");

			// More options handling for requests with no content
			if (!s.hasContent) {

				// Remember the hash so we can put it back
				uncached = s.url.slice(cacheURL.length);

				// If data is available and should be processed, append data to url
				if (s.data && (s.processData || typeof s.data === "string")) {
					cacheURL += (rquery.test(cacheURL) ? "&" : "?") + s.data;

					// #9682: remove data so that it's not used in an eventual retry
					delete s.data;
				}

				// Add or update anti-cache param if needed
				if (s.cache === false) {
					cacheURL = cacheURL.replace(rantiCache, "$1");
					uncached = (rquery.test(cacheURL) ? "&" : "?") + "_=" + nonce++ + uncached;
				}

				// Put hash and anti-cache on the URL that will be requested (gh-1732)
				s.url = cacheURL + uncached;

				// Change '%20' to '+' if this is encoded form body content (gh-2658)
			} else if (s.data && s.processData && (s.contentType || "").indexOf("application/x-www-form-urlencoded") === 0) {
				s.data = s.data.replace(r20, "+");
			}

			// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
			if (s.ifModified) {
				if (jQuery.lastModified[cacheURL]) {
					jqXHR.setRequestHeader("If-Modified-Since", jQuery.lastModified[cacheURL]);
				}
				if (jQuery.etag[cacheURL]) {
					jqXHR.setRequestHeader("If-None-Match", jQuery.etag[cacheURL]);
				}
			}

			// Set the correct header, if data is being sent
			if (s.data && s.hasContent && s.contentType !== false || options.contentType) {
				jqXHR.setRequestHeader("Content-Type", s.contentType);
			}

			// Set the Accepts header for the server, depending on the dataType
			jqXHR.setRequestHeader("Accept", s.dataTypes[0] && s.accepts[s.dataTypes[0]] ? s.accepts[s.dataTypes[0]] + (s.dataTypes[0] !== "*" ? ", " + allTypes + "; q=0.01" : "") : s.accepts["*"]);

			// Check for headers option
			for (i in s.headers) {
				jqXHR.setRequestHeader(i, s.headers[i]);
			}

			// Allow custom headers/mimetypes and early abort
			if (s.beforeSend && (s.beforeSend.call(callbackContext, jqXHR, s) === false || completed)) {

				// Abort if not done already and return
				return jqXHR.abort();
			}

			// Aborting is no longer a cancellation
			strAbort = "abort";

			// Install callbacks on deferreds
			completeDeferred.add(s.complete);
			jqXHR.done(s.success);
			jqXHR.fail(s.error);

			// Get transport
			transport = inspectPrefiltersOrTransports(transports, s, options, jqXHR);

			// If no transport, we auto-abort
			if (!transport) {
				done(-1, "No Transport");
			} else {
				jqXHR.readyState = 1;

				// Send global event
				if (fireGlobals) {
					globalEventContext.trigger("ajaxSend", [jqXHR, s]);
				}

				// If request was aborted inside ajaxSend, stop there
				if (completed) {
					return jqXHR;
				}

				// Timeout
				if (s.async && s.timeout > 0) {
					timeoutTimer = window.setTimeout(function () {
						jqXHR.abort("timeout");
					}, s.timeout);
				}

				try {
					completed = false;
					transport.send(requestHeaders, done);
				} catch (e) {

					// Rethrow post-completion exceptions
					if (completed) {
						throw e;
					}

					// Propagate others as results
					done(-1, e);
				}
			}

			// Callback for when everything is done
			function done(status, nativeStatusText, responses, headers) {
				var isSuccess,
				    success,
				    error,
				    response,
				    modified,
				    statusText = nativeStatusText;

				// Ignore repeat invocations
				if (completed) {
					return;
				}

				completed = true;

				// Clear timeout if it exists
				if (timeoutTimer) {
					window.clearTimeout(timeoutTimer);
				}

				// Dereference transport for early garbage collection
				// (no matter how long the jqXHR object will be used)
				transport = undefined;

				// Cache response headers
				responseHeadersString = headers || "";

				// Set readyState
				jqXHR.readyState = status > 0 ? 4 : 0;

				// Determine if successful
				isSuccess = status >= 200 && status < 300 || status === 304;

				// Get response data
				if (responses) {
					response = ajaxHandleResponses(s, jqXHR, responses);
				}

				// Convert no matter what (that way responseXXX fields are always set)
				response = ajaxConvert(s, response, jqXHR, isSuccess);

				// If successful, handle type chaining
				if (isSuccess) {

					// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
					if (s.ifModified) {
						modified = jqXHR.getResponseHeader("Last-Modified");
						if (modified) {
							jQuery.lastModified[cacheURL] = modified;
						}
						modified = jqXHR.getResponseHeader("etag");
						if (modified) {
							jQuery.etag[cacheURL] = modified;
						}
					}

					// if no content
					if (status === 204 || s.type === "HEAD") {
						statusText = "nocontent";

						// if not modified
					} else if (status === 304) {
						statusText = "notmodified";

						// If we have data, let's convert it
					} else {
						statusText = response.state;
						success = response.data;
						error = response.error;
						isSuccess = !error;
					}
				} else {

					// Extract error from statusText and normalize for non-aborts
					error = statusText;
					if (status || !statusText) {
						statusText = "error";
						if (status < 0) {
							status = 0;
						}
					}
				}

				// Set data for the fake xhr object
				jqXHR.status = status;
				jqXHR.statusText = (nativeStatusText || statusText) + "";

				// Success/Error
				if (isSuccess) {
					deferred.resolveWith(callbackContext, [success, statusText, jqXHR]);
				} else {
					deferred.rejectWith(callbackContext, [jqXHR, statusText, error]);
				}

				// Status-dependent callbacks
				jqXHR.statusCode(_statusCode);
				_statusCode = undefined;

				if (fireGlobals) {
					globalEventContext.trigger(isSuccess ? "ajaxSuccess" : "ajaxError", [jqXHR, s, isSuccess ? success : error]);
				}

				// Complete
				completeDeferred.fireWith(callbackContext, [jqXHR, statusText]);

				if (fireGlobals) {
					globalEventContext.trigger("ajaxComplete", [jqXHR, s]);

					// Handle the global AJAX counter
					if (! --jQuery.active) {
						jQuery.event.trigger("ajaxStop");
					}
				}
			}

			return jqXHR;
		},

		getJSON: function getJSON(url, data, callback) {
			return jQuery.get(url, data, callback, "json");
		},

		getScript: function getScript(url, callback) {
			return jQuery.get(url, undefined, callback, "script");
		}
	});

	jQuery.each(["get", "post"], function (i, method) {
		jQuery[method] = function (url, data, callback, type) {

			// Shift arguments if data argument was omitted
			if (isFunction(data)) {
				type = type || callback;
				callback = data;
				data = undefined;
			}

			// The url can be an options object (which then must have .url)
			return jQuery.ajax(jQuery.extend({
				url: url,
				type: method,
				dataType: type,
				data: data,
				success: callback
			}, jQuery.isPlainObject(url) && url));
		};
	});

	jQuery._evalUrl = function (url) {
		return jQuery.ajax({
			url: url,

			// Make this explicit, since user can override this through ajaxSetup (#11264)
			type: "GET",
			dataType: "script",
			cache: true,
			async: false,
			global: false,
			"throws": true
		});
	};

	jQuery.fn.extend({
		wrapAll: function wrapAll(html) {
			var wrap;

			if (this[0]) {
				if (isFunction(html)) {
					html = html.call(this[0]);
				}

				// The elements to wrap the target around
				wrap = jQuery(html, this[0].ownerDocument).eq(0).clone(true);

				if (this[0].parentNode) {
					wrap.insertBefore(this[0]);
				}

				wrap.map(function () {
					var elem = this;

					while (elem.firstElementChild) {
						elem = elem.firstElementChild;
					}

					return elem;
				}).append(this);
			}

			return this;
		},

		wrapInner: function wrapInner(html) {
			if (isFunction(html)) {
				return this.each(function (i) {
					jQuery(this).wrapInner(html.call(this, i));
				});
			}

			return this.each(function () {
				var self = jQuery(this),
				    contents = self.contents();

				if (contents.length) {
					contents.wrapAll(html);
				} else {
					self.append(html);
				}
			});
		},

		wrap: function wrap(html) {
			var htmlIsFunction = isFunction(html);

			return this.each(function (i) {
				jQuery(this).wrapAll(htmlIsFunction ? html.call(this, i) : html);
			});
		},

		unwrap: function unwrap(selector) {
			this.parent(selector).not("body").each(function () {
				jQuery(this).replaceWith(this.childNodes);
			});
			return this;
		}
	});

	jQuery.expr.pseudos.hidden = function (elem) {
		return !jQuery.expr.pseudos.visible(elem);
	};
	jQuery.expr.pseudos.visible = function (elem) {
		return !!(elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length);
	};

	jQuery.ajaxSettings.xhr = function () {
		try {
			return new window.XMLHttpRequest();
		} catch (e) {}
	};

	var xhrSuccessStatus = {

		// File protocol always yields status code 0, assume 200
		0: 200,

		// Support: IE <=9 only
		// #1450: sometimes IE returns 1223 when it should be 204
		1223: 204
	},
	    xhrSupported = jQuery.ajaxSettings.xhr();

	support.cors = !!xhrSupported && "withCredentials" in xhrSupported;
	support.ajax = xhrSupported = !!xhrSupported;

	jQuery.ajaxTransport(function (options) {
		var _callback, errorCallback;

		// Cross domain only allowed if supported through XMLHttpRequest
		if (support.cors || xhrSupported && !options.crossDomain) {
			return {
				send: function send(headers, complete) {
					var i,
					    xhr = options.xhr();

					xhr.open(options.type, options.url, options.async, options.username, options.password);

					// Apply custom fields if provided
					if (options.xhrFields) {
						for (i in options.xhrFields) {
							xhr[i] = options.xhrFields[i];
						}
					}

					// Override mime type if needed
					if (options.mimeType && xhr.overrideMimeType) {
						xhr.overrideMimeType(options.mimeType);
					}

					// X-Requested-With header
					// For cross-domain requests, seeing as conditions for a preflight are
					// akin to a jigsaw puzzle, we simply never set it to be sure.
					// (it can always be set on a per-request basis or even using ajaxSetup)
					// For same-domain requests, won't change header if already provided.
					if (!options.crossDomain && !headers["X-Requested-With"]) {
						headers["X-Requested-With"] = "XMLHttpRequest";
					}

					// Set headers
					for (i in headers) {
						xhr.setRequestHeader(i, headers[i]);
					}

					// Callback
					_callback = function callback(type) {
						return function () {
							if (_callback) {
								_callback = errorCallback = xhr.onload = xhr.onerror = xhr.onabort = xhr.ontimeout = xhr.onreadystatechange = null;

								if (type === "abort") {
									xhr.abort();
								} else if (type === "error") {

									// Support: IE <=9 only
									// On a manual native abort, IE9 throws
									// errors on any property access that is not readyState
									if (typeof xhr.status !== "number") {
										complete(0, "error");
									} else {
										complete(

										// File: protocol always yields status 0; see #8605, #14207
										xhr.status, xhr.statusText);
									}
								} else {
									complete(xhrSuccessStatus[xhr.status] || xhr.status, xhr.statusText,

									// Support: IE <=9 only
									// IE9 has no XHR2 but throws on binary (trac-11426)
									// For XHR2 non-text, let the caller handle it (gh-2498)
									(xhr.responseType || "text") !== "text" || typeof xhr.responseText !== "string" ? { binary: xhr.response } : { text: xhr.responseText }, xhr.getAllResponseHeaders());
								}
							}
						};
					};

					// Listen to events
					xhr.onload = _callback();
					errorCallback = xhr.onerror = xhr.ontimeout = _callback("error");

					// Support: IE 9 only
					// Use onreadystatechange to replace onabort
					// to handle uncaught aborts
					if (xhr.onabort !== undefined) {
						xhr.onabort = errorCallback;
					} else {
						xhr.onreadystatechange = function () {

							// Check readyState before timeout as it changes
							if (xhr.readyState === 4) {

								// Allow onerror to be called first,
								// but that will not handle a native abort
								// Also, save errorCallback to a variable
								// as xhr.onerror cannot be accessed
								window.setTimeout(function () {
									if (_callback) {
										errorCallback();
									}
								});
							}
						};
					}

					// Create the abort callback
					_callback = _callback("abort");

					try {

						// Do send the request (this may raise an exception)
						xhr.send(options.hasContent && options.data || null);
					} catch (e) {

						// #14683: Only rethrow if this hasn't been notified as an error yet
						if (_callback) {
							throw e;
						}
					}
				},

				abort: function abort() {
					if (_callback) {
						_callback();
					}
				}
			};
		}
	});

	// Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432)
	jQuery.ajaxPrefilter(function (s) {
		if (s.crossDomain) {
			s.contents.script = false;
		}
	});

	// Install script dataType
	jQuery.ajaxSetup({
		accepts: {
			script: "text/javascript, application/javascript, " + "application/ecmascript, application/x-ecmascript"
		},
		contents: {
			script: /\b(?:java|ecma)script\b/
		},
		converters: {
			"text script": function textScript(text) {
				jQuery.globalEval(text);
				return text;
			}
		}
	});

	// Handle cache's special case and crossDomain
	jQuery.ajaxPrefilter("script", function (s) {
		if (s.cache === undefined) {
			s.cache = false;
		}
		if (s.crossDomain) {
			s.type = "GET";
		}
	});

	// Bind script tag hack transport
	jQuery.ajaxTransport("script", function (s) {

		// This transport only deals with cross domain requests
		if (s.crossDomain) {
			var script, _callback2;
			return {
				send: function send(_, complete) {
					script = jQuery("<script>").prop({
						charset: s.scriptCharset,
						src: s.url
					}).on("load error", _callback2 = function callback(evt) {
						script.remove();
						_callback2 = null;
						if (evt) {
							complete(evt.type === "error" ? 404 : 200, evt.type);
						}
					});

					// Use native DOM manipulation to avoid our domManip AJAX trickery
					document.head.appendChild(script[0]);
				},
				abort: function abort() {
					if (_callback2) {
						_callback2();
					}
				}
			};
		}
	});

	var oldCallbacks = [],
	    rjsonp = /(=)\?(?=&|$)|\?\?/;

	// Default jsonp settings
	jQuery.ajaxSetup({
		jsonp: "callback",
		jsonpCallback: function jsonpCallback() {
			var callback = oldCallbacks.pop() || jQuery.expando + "_" + nonce++;
			this[callback] = true;
			return callback;
		}
	});

	// Detect, normalize options and install callbacks for jsonp requests
	jQuery.ajaxPrefilter("json jsonp", function (s, originalSettings, jqXHR) {

		var callbackName,
		    overwritten,
		    responseContainer,
		    jsonProp = s.jsonp !== false && (rjsonp.test(s.url) ? "url" : typeof s.data === "string" && (s.contentType || "").indexOf("application/x-www-form-urlencoded") === 0 && rjsonp.test(s.data) && "data");

		// Handle iff the expected data type is "jsonp" or we have a parameter to set
		if (jsonProp || s.dataTypes[0] === "jsonp") {

			// Get callback name, remembering preexisting value associated with it
			callbackName = s.jsonpCallback = isFunction(s.jsonpCallback) ? s.jsonpCallback() : s.jsonpCallback;

			// Insert callback into url or form data
			if (jsonProp) {
				s[jsonProp] = s[jsonProp].replace(rjsonp, "$1" + callbackName);
			} else if (s.jsonp !== false) {
				s.url += (rquery.test(s.url) ? "&" : "?") + s.jsonp + "=" + callbackName;
			}

			// Use data converter to retrieve json after script execution
			s.converters["script json"] = function () {
				if (!responseContainer) {
					jQuery.error(callbackName + " was not called");
				}
				return responseContainer[0];
			};

			// Force json dataType
			s.dataTypes[0] = "json";

			// Install callback
			overwritten = window[callbackName];
			window[callbackName] = function () {
				responseContainer = arguments;
			};

			// Clean-up function (fires after converters)
			jqXHR.always(function () {

				// If previous value didn't exist - remove it
				if (overwritten === undefined) {
					jQuery(window).removeProp(callbackName);

					// Otherwise restore preexisting value
				} else {
					window[callbackName] = overwritten;
				}

				// Save back as free
				if (s[callbackName]) {

					// Make sure that re-using the options doesn't screw things around
					s.jsonpCallback = originalSettings.jsonpCallback;

					// Save the callback name for future use
					oldCallbacks.push(callbackName);
				}

				// Call if it was a function and we have a response
				if (responseContainer && isFunction(overwritten)) {
					overwritten(responseContainer[0]);
				}

				responseContainer = overwritten = undefined;
			});

			// Delegate to script
			return "script";
		}
	});

	// Support: Safari 8 only
	// In Safari 8 documents created via document.implementation.createHTMLDocument
	// collapse sibling forms: the second one becomes a child of the first one.
	// Because of that, this security measure has to be disabled in Safari 8.
	// https://bugs.webkit.org/show_bug.cgi?id=137337
	support.createHTMLDocument = function () {
		var body = document.implementation.createHTMLDocument("").body;
		body.innerHTML = "<form></form><form></form>";
		return body.childNodes.length === 2;
	}();

	// Argument "data" should be string of html
	// context (optional): If specified, the fragment will be created in this context,
	// defaults to document
	// keepScripts (optional): If true, will include scripts passed in the html string
	jQuery.parseHTML = function (data, context, keepScripts) {
		if (typeof data !== "string") {
			return [];
		}
		if (typeof context === "boolean") {
			keepScripts = context;
			context = false;
		}

		var base, parsed, scripts;

		if (!context) {

			// Stop scripts or inline event handlers from being executed immediately
			// by using document.implementation
			if (support.createHTMLDocument) {
				context = document.implementation.createHTMLDocument("");

				// Set the base href for the created document
				// so any parsed elements with URLs
				// are based on the document's URL (gh-2965)
				base = context.createElement("base");
				base.href = document.location.href;
				context.head.appendChild(base);
			} else {
				context = document;
			}
		}

		parsed = rsingleTag.exec(data);
		scripts = !keepScripts && [];

		// Single tag
		if (parsed) {
			return [context.createElement(parsed[1])];
		}

		parsed = buildFragment([data], context, scripts);

		if (scripts && scripts.length) {
			jQuery(scripts).remove();
		}

		return jQuery.merge([], parsed.childNodes);
	};

	/**
  * Load a url into a page
  */
	jQuery.fn.load = function (url, params, callback) {
		var selector,
		    type,
		    response,
		    self = this,
		    off = url.indexOf(" ");

		if (off > -1) {
			selector = stripAndCollapse(url.slice(off));
			url = url.slice(0, off);
		}

		// If it's a function
		if (isFunction(params)) {

			// We assume that it's the callback
			callback = params;
			params = undefined;

			// Otherwise, build a param string
		} else if (params && (typeof params === "undefined" ? "undefined" : _typeof(params)) === "object") {
			type = "POST";
		}

		// If we have elements to modify, make the request
		if (self.length > 0) {
			jQuery.ajax({
				url: url,

				// If "type" variable is undefined, then "GET" method will be used.
				// Make value of this field explicit since
				// user can override it through ajaxSetup method
				type: type || "GET",
				dataType: "html",
				data: params
			}).done(function (responseText) {

				// Save response for use in complete callback
				response = arguments;

				self.html(selector ?

				// If a selector was specified, locate the right elements in a dummy div
				// Exclude scripts to avoid IE 'Permission Denied' errors
				jQuery("<div>").append(jQuery.parseHTML(responseText)).find(selector) :

				// Otherwise use the full result
				responseText);

				// If the request succeeds, this function gets "data", "status", "jqXHR"
				// but they are ignored because response was set above.
				// If it fails, this function gets "jqXHR", "status", "error"
			}).always(callback && function (jqXHR, status) {
				self.each(function () {
					callback.apply(this, response || [jqXHR.responseText, status, jqXHR]);
				});
			});
		}

		return this;
	};

	// Attach a bunch of functions for handling common AJAX events
	jQuery.each(["ajaxStart", "ajaxStop", "ajaxComplete", "ajaxError", "ajaxSuccess", "ajaxSend"], function (i, type) {
		jQuery.fn[type] = function (fn) {
			return this.on(type, fn);
		};
	});

	jQuery.expr.pseudos.animated = function (elem) {
		return jQuery.grep(jQuery.timers, function (fn) {
			return elem === fn.elem;
		}).length;
	};

	jQuery.offset = {
		setOffset: function setOffset(elem, options, i) {
			var curPosition,
			    curLeft,
			    curCSSTop,
			    curTop,
			    curOffset,
			    curCSSLeft,
			    calculatePosition,
			    position = jQuery.css(elem, "position"),
			    curElem = jQuery(elem),
			    props = {};

			// Set position first, in-case top/left are set even on static elem
			if (position === "static") {
				elem.style.position = "relative";
			}

			curOffset = curElem.offset();
			curCSSTop = jQuery.css(elem, "top");
			curCSSLeft = jQuery.css(elem, "left");
			calculatePosition = (position === "absolute" || position === "fixed") && (curCSSTop + curCSSLeft).indexOf("auto") > -1;

			// Need to be able to calculate position if either
			// top or left is auto and position is either absolute or fixed
			if (calculatePosition) {
				curPosition = curElem.position();
				curTop = curPosition.top;
				curLeft = curPosition.left;
			} else {
				curTop = parseFloat(curCSSTop) || 0;
				curLeft = parseFloat(curCSSLeft) || 0;
			}

			if (isFunction(options)) {

				// Use jQuery.extend here to allow modification of coordinates argument (gh-1848)
				options = options.call(elem, i, jQuery.extend({}, curOffset));
			}

			if (options.top != null) {
				props.top = options.top - curOffset.top + curTop;
			}
			if (options.left != null) {
				props.left = options.left - curOffset.left + curLeft;
			}

			if ("using" in options) {
				options.using.call(elem, props);
			} else {
				curElem.css(props);
			}
		}
	};

	jQuery.fn.extend({

		// offset() relates an element's border box to the document origin
		offset: function offset(options) {

			// Preserve chaining for setter
			if (arguments.length) {
				return options === undefined ? this : this.each(function (i) {
					jQuery.offset.setOffset(this, options, i);
				});
			}

			var rect,
			    win,
			    elem = this[0];

			if (!elem) {
				return;
			}

			// Return zeros for disconnected and hidden (display: none) elements (gh-2310)
			// Support: IE <=11 only
			// Running getBoundingClientRect on a
			// disconnected node in IE throws an error
			if (!elem.getClientRects().length) {
				return { top: 0, left: 0 };
			}

			// Get document-relative position by adding viewport scroll to viewport-relative gBCR
			rect = elem.getBoundingClientRect();
			win = elem.ownerDocument.defaultView;
			return {
				top: rect.top + win.pageYOffset,
				left: rect.left + win.pageXOffset
			};
		},

		// position() relates an element's margin box to its offset parent's padding box
		// This corresponds to the behavior of CSS absolute positioning
		position: function position() {
			if (!this[0]) {
				return;
			}

			var offsetParent,
			    offset,
			    doc,
			    elem = this[0],
			    parentOffset = { top: 0, left: 0 };

			// position:fixed elements are offset from the viewport, which itself always has zero offset
			if (jQuery.css(elem, "position") === "fixed") {

				// Assume position:fixed implies availability of getBoundingClientRect
				offset = elem.getBoundingClientRect();
			} else {
				offset = this.offset();

				// Account for the *real* offset parent, which can be the document or its root element
				// when a statically positioned element is identified
				doc = elem.ownerDocument;
				offsetParent = elem.offsetParent || doc.documentElement;
				while (offsetParent && (offsetParent === doc.body || offsetParent === doc.documentElement) && jQuery.css(offsetParent, "position") === "static") {

					offsetParent = offsetParent.parentNode;
				}
				if (offsetParent && offsetParent !== elem && offsetParent.nodeType === 1) {

					// Incorporate borders into its offset, since they are outside its content origin
					parentOffset = jQuery(offsetParent).offset();
					parentOffset.top += jQuery.css(offsetParent, "borderTopWidth", true);
					parentOffset.left += jQuery.css(offsetParent, "borderLeftWidth", true);
				}
			}

			// Subtract parent offsets and element margins
			return {
				top: offset.top - parentOffset.top - jQuery.css(elem, "marginTop", true),
				left: offset.left - parentOffset.left - jQuery.css(elem, "marginLeft", true)
			};
		},

		// This method will return documentElement in the following cases:
		// 1) For the element inside the iframe without offsetParent, this method will return
		//    documentElement of the parent window
		// 2) For the hidden or detached element
		// 3) For body or html element, i.e. in case of the html node - it will return itself
		//
		// but those exceptions were never presented as a real life use-cases
		// and might be considered as more preferable results.
		//
		// This logic, however, is not guaranteed and can change at any point in the future
		offsetParent: function offsetParent() {
			return this.map(function () {
				var offsetParent = this.offsetParent;

				while (offsetParent && jQuery.css(offsetParent, "position") === "static") {
					offsetParent = offsetParent.offsetParent;
				}

				return offsetParent || documentElement;
			});
		}
	});

	// Create scrollLeft and scrollTop methods
	jQuery.each({ scrollLeft: "pageXOffset", scrollTop: "pageYOffset" }, function (method, prop) {
		var top = "pageYOffset" === prop;

		jQuery.fn[method] = function (val) {
			return access(this, function (elem, method, val) {

				// Coalesce documents and windows
				var win;
				if (isWindow(elem)) {
					win = elem;
				} else if (elem.nodeType === 9) {
					win = elem.defaultView;
				}

				if (val === undefined) {
					return win ? win[prop] : elem[method];
				}

				if (win) {
					win.scrollTo(!top ? val : win.pageXOffset, top ? val : win.pageYOffset);
				} else {
					elem[method] = val;
				}
			}, method, val, arguments.length);
		};
	});

	// Support: Safari <=7 - 9.1, Chrome <=37 - 49
	// Add the top/left cssHooks using jQuery.fn.position
	// Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084
	// Blink bug: https://bugs.chromium.org/p/chromium/issues/detail?id=589347
	// getComputedStyle returns percent when specified for top/left/bottom/right;
	// rather than make the css module depend on the offset module, just check for it here
	jQuery.each(["top", "left"], function (i, prop) {
		jQuery.cssHooks[prop] = addGetHookIf(support.pixelPosition, function (elem, computed) {
			if (computed) {
				computed = curCSS(elem, prop);

				// If curCSS returns percentage, fallback to offset
				return rnumnonpx.test(computed) ? jQuery(elem).position()[prop] + "px" : computed;
			}
		});
	});

	// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods
	jQuery.each({ Height: "height", Width: "width" }, function (name, type) {
		jQuery.each({ padding: "inner" + name, content: type, "": "outer" + name }, function (defaultExtra, funcName) {

			// Margin is only for outerHeight, outerWidth
			jQuery.fn[funcName] = function (margin, value) {
				var chainable = arguments.length && (defaultExtra || typeof margin !== "boolean"),
				    extra = defaultExtra || (margin === true || value === true ? "margin" : "border");

				return access(this, function (elem, type, value) {
					var doc;

					if (isWindow(elem)) {

						// $( window ).outerWidth/Height return w/h including scrollbars (gh-1729)
						return funcName.indexOf("outer") === 0 ? elem["inner" + name] : elem.document.documentElement["client" + name];
					}

					// Get document width or height
					if (elem.nodeType === 9) {
						doc = elem.documentElement;

						// Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height],
						// whichever is greatest
						return Math.max(elem.body["scroll" + name], doc["scroll" + name], elem.body["offset" + name], doc["offset" + name], doc["client" + name]);
					}

					return value === undefined ?

					// Get width or height on the element, requesting but not forcing parseFloat
					jQuery.css(elem, type, extra) :

					// Set width or height on the element
					jQuery.style(elem, type, value, extra);
				}, type, chainable ? margin : undefined, chainable);
			};
		});
	});

	jQuery.each(("blur focus focusin focusout resize scroll click dblclick " + "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " + "change select submit keydown keypress keyup contextmenu").split(" "), function (i, name) {

		// Handle event binding
		jQuery.fn[name] = function (data, fn) {
			return arguments.length > 0 ? this.on(name, null, data, fn) : this.trigger(name);
		};
	});

	jQuery.fn.extend({
		hover: function hover(fnOver, fnOut) {
			return this.mouseenter(fnOver).mouseleave(fnOut || fnOver);
		}
	});

	jQuery.fn.extend({

		bind: function bind(types, data, fn) {
			return this.on(types, null, data, fn);
		},
		unbind: function unbind(types, fn) {
			return this.off(types, null, fn);
		},

		delegate: function delegate(selector, types, data, fn) {
			return this.on(types, selector, data, fn);
		},
		undelegate: function undelegate(selector, types, fn) {

			// ( namespace ) or ( selector, types [, fn] )
			return arguments.length === 1 ? this.off(selector, "**") : this.off(types, selector || "**", fn);
		}
	});

	// Bind a function to a context, optionally partially applying any
	// arguments.
	// jQuery.proxy is deprecated to promote standards (specifically Function#bind)
	// However, it is not slated for removal any time soon
	jQuery.proxy = function (fn, context) {
		var tmp, args, proxy;

		if (typeof context === "string") {
			tmp = fn[context];
			context = fn;
			fn = tmp;
		}

		// Quick check to determine if target is callable, in the spec
		// this throws a TypeError, but we will just return undefined.
		if (!isFunction(fn)) {
			return undefined;
		}

		// Simulated bind
		args = _slice.call(arguments, 2);
		proxy = function proxy() {
			return fn.apply(context || this, args.concat(_slice.call(arguments)));
		};

		// Set the guid of unique handler to the same of original handler, so it can be removed
		proxy.guid = fn.guid = fn.guid || jQuery.guid++;

		return proxy;
	};

	jQuery.holdReady = function (hold) {
		if (hold) {
			jQuery.readyWait++;
		} else {
			jQuery.ready(true);
		}
	};
	jQuery.isArray = Array.isArray;
	jQuery.parseJSON = JSON.parse;
	jQuery.nodeName = nodeName;
	jQuery.isFunction = isFunction;
	jQuery.isWindow = isWindow;
	jQuery.camelCase = camelCase;
	jQuery.type = toType;

	jQuery.now = Date.now;

	jQuery.isNumeric = function (obj) {

		// As of jQuery 3.0, isNumeric is limited to
		// strings and numbers (primitives or objects)
		// that can be coerced to finite numbers (gh-2662)
		var type = jQuery.type(obj);
		return (type === "number" || type === "string") &&

		// parseFloat NaNs numeric-cast false positives ("")
		// ...but misinterprets leading-number strings, particularly hex literals ("0x...")
		// subtraction forces infinities to NaN
		!isNaN(obj - parseFloat(obj));
	};

	// Register as a named AMD module, since jQuery can be concatenated with other
	// files that may use define, but not via a proper concatenation script that
	// understands anonymous AMD modules. A named AMD is safest and most robust
	// way to register. Lowercase jquery is used because AMD module names are
	// derived from file names, and jQuery is normally delivered in a lowercase
	// file name. Do this after creating the global so that if an AMD module wants
	// to call noConflict to hide this version of jQuery, it will work.

	// Note that for maximum portability, libraries that are not jQuery should
	// declare themselves as anonymous modules, and avoid setting a global if an
	// AMD loader is present. jQuery is a special case. For more information, see
	// https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon

	if (typeof define === "function" && define.amd) {
		define("jquery", [], function () {
			return jQuery;
		});
	}

	var

	// Map over jQuery in case of overwrite
	_jQuery = window.jQuery,


	// Map over the $ in case of overwrite
	_$ = window.$;

	jQuery.noConflict = function (deep) {
		if (window.$ === jQuery) {
			window.$ = _$;
		}

		if (deep && window.jQuery === jQuery) {
			window.jQuery = _jQuery;
		}

		return jQuery;
	};

	// Expose jQuery and $ identifiers, even in AMD
	// (#7102#comment:10, https://github.com/jquery/jquery/pull/557)
	// and CommonJS for browser emulators (#13566)
	if (!noGlobal) {
		window.jQuery = window.$ = jQuery;
	}

	return jQuery;
});

},{}],417:[function(require,module,exports){
'use strict';

var baseFlatten = require('../internal/baseFlatten');

/**
 * Recursively flattens a nested array.
 *
 * @static
 * @memberOf _
 * @category Array
 * @param {Array} array The array to recursively flatten.
 * @returns {Array} Returns the new flattened array.
 * @example
 *
 * _.flattenDeep([1, [2, 3, [4]]]);
 * // => [1, 2, 3, 4]
 */
function flattenDeep(array) {
  var length = array ? array.length : 0;
  return length ? baseFlatten(array, true) : [];
}

module.exports = flattenDeep;

},{"../internal/baseFlatten":444}],418:[function(require,module,exports){
"use strict";

/**
 * Gets the last element of `array`.
 *
 * @static
 * @memberOf _
 * @category Array
 * @param {Array} array The array to query.
 * @returns {*} Returns the last element of `array`.
 * @example
 *
 * _.last([1, 2, 3]);
 * // => 3
 */
function last(array) {
  var length = array ? array.length : 0;
  return length ? array[length - 1] : undefined;
}

module.exports = last;

},{}],419:[function(require,module,exports){
'use strict';

var arrayPush = require('../internal/arrayPush'),
    baseDifference = require('../internal/baseDifference'),
    baseUniq = require('../internal/baseUniq'),
    isArrayLike = require('../internal/isArrayLike');

/**
 * Creates an array of unique values that is the [symmetric difference](https://en.wikipedia.org/wiki/Symmetric_difference)
 * of the provided arrays.
 *
 * @static
 * @memberOf _
 * @category Array
 * @param {...Array} [arrays] The arrays to inspect.
 * @returns {Array} Returns the new array of values.
 * @example
 *
 * _.xor([1, 2], [4, 2]);
 * // => [1, 4]
 */
function xor() {
  var index = -1,
      length = arguments.length;

  while (++index < length) {
    var array = arguments[index];
    if (isArrayLike(array)) {
      var result = result ? arrayPush(baseDifference(result, array), baseDifference(array, result)) : array;
    }
  }
  return result ? baseUniq(result) : [];
}

module.exports = xor;

},{"../internal/arrayPush":432,"../internal/baseDifference":439,"../internal/baseUniq":459,"../internal/isArrayLike":478}],420:[function(require,module,exports){
'use strict';

var arrayFilter = require('../internal/arrayFilter'),
    baseCallback = require('../internal/baseCallback'),
    baseFilter = require('../internal/baseFilter'),
    isArray = require('../lang/isArray');

/**
 * Iterates over elements of `collection`, returning an array of all elements
 * `predicate` returns truthy for. The predicate is bound to `thisArg` and
 * invoked with three arguments: (value, index|key, collection).
 *
 * If a property name is provided for `predicate` the created `_.property`
 * style callback returns the property value of the given element.
 *
 * If a value is also provided for `thisArg` the created `_.matchesProperty`
 * style callback returns `true` for elements that have a matching property
 * value, else `false`.
 *
 * If an object is provided for `predicate` the created `_.matches` style
 * callback returns `true` for elements that have the properties of the given
 * object, else `false`.
 *
 * @static
 * @memberOf _
 * @alias select
 * @category Collection
 * @param {Array|Object|string} collection The collection to iterate over.
 * @param {Function|Object|string} [predicate=_.identity] The function invoked
 *  per iteration.
 * @param {*} [thisArg] The `this` binding of `predicate`.
 * @returns {Array} Returns the new filtered array.
 * @example
 *
 * _.filter([4, 5, 6], function(n) {
 *   return n % 2 == 0;
 * });
 * // => [4, 6]
 *
 * var users = [
 *   { 'user': 'barney', 'age': 36, 'active': true },
 *   { 'user': 'fred',   'age': 40, 'active': false }
 * ];
 *
 * // using the `_.matches` callback shorthand
 * _.pluck(_.filter(users, { 'age': 36, 'active': true }), 'user');
 * // => ['barney']
 *
 * // using the `_.matchesProperty` callback shorthand
 * _.pluck(_.filter(users, 'active', false), 'user');
 * // => ['fred']
 *
 * // using the `_.property` callback shorthand
 * _.pluck(_.filter(users, 'active'), 'user');
 * // => ['barney']
 */
function filter(collection, predicate, thisArg) {
  var func = isArray(collection) ? arrayFilter : baseFilter;
  predicate = baseCallback(predicate, thisArg, 3);
  return func(collection, predicate);
}

module.exports = filter;

},{"../internal/arrayFilter":430,"../internal/baseCallback":436,"../internal/baseFilter":441,"../lang/isArray":489}],421:[function(require,module,exports){
'use strict';

var baseEach = require('../internal/baseEach'),
    createFind = require('../internal/createFind');

/**
 * Iterates over elements of `collection`, returning the first element
 * `predicate` returns truthy for. The predicate is bound to `thisArg` and
 * invoked with three arguments: (value, index|key, collection).
 *
 * If a property name is provided for `predicate` the created `_.property`
 * style callback returns the property value of the given element.
 *
 * If a value is also provided for `thisArg` the created `_.matchesProperty`
 * style callback returns `true` for elements that have a matching property
 * value, else `false`.
 *
 * If an object is provided for `predicate` the created `_.matches` style
 * callback returns `true` for elements that have the properties of the given
 * object, else `false`.
 *
 * @static
 * @memberOf _
 * @alias detect
 * @category Collection
 * @param {Array|Object|string} collection The collection to search.
 * @param {Function|Object|string} [predicate=_.identity] The function invoked
 *  per iteration.
 * @param {*} [thisArg] The `this` binding of `predicate`.
 * @returns {*} Returns the matched element, else `undefined`.
 * @example
 *
 * var users = [
 *   { 'user': 'barney',  'age': 36, 'active': true },
 *   { 'user': 'fred',    'age': 40, 'active': false },
 *   { 'user': 'pebbles', 'age': 1,  'active': true }
 * ];
 *
 * _.result(_.find(users, function(chr) {
 *   return chr.age < 40;
 * }), 'user');
 * // => 'barney'
 *
 * // using the `_.matches` callback shorthand
 * _.result(_.find(users, { 'age': 1, 'active': true }), 'user');
 * // => 'pebbles'
 *
 * // using the `_.matchesProperty` callback shorthand
 * _.result(_.find(users, 'active', false), 'user');
 * // => 'fred'
 *
 * // using the `_.property` callback shorthand
 * _.result(_.find(users, 'active'), 'user');
 * // => 'barney'
 */
var find = createFind(baseEach);

module.exports = find;

},{"../internal/baseEach":440,"../internal/createFind":469}],422:[function(require,module,exports){
'use strict';

var arrayEach = require('../internal/arrayEach'),
    baseEach = require('../internal/baseEach'),
    createForEach = require('../internal/createForEach');

/**
 * Iterates over elements of `collection` invoking `iteratee` for each element.
 * The `iteratee` is bound to `thisArg` and invoked with three arguments:
 * (value, index|key, collection). Iteratee functions may exit iteration early
 * by explicitly returning `false`.
 *
 * **Note:** As with other "Collections" methods, objects with a "length" property
 * are iterated like arrays. To avoid this behavior `_.forIn` or `_.forOwn`
 * may be used for object iteration.
 *
 * @static
 * @memberOf _
 * @alias each
 * @category Collection
 * @param {Array|Object|string} collection The collection to iterate over.
 * @param {Function} [iteratee=_.identity] The function invoked per iteration.
 * @param {*} [thisArg] The `this` binding of `iteratee`.
 * @returns {Array|Object|string} Returns `collection`.
 * @example
 *
 * _([1, 2]).forEach(function(n) {
 *   console.log(n);
 * }).value();
 * // => logs each value from left to right and returns the array
 *
 * _.forEach({ 'a': 1, 'b': 2 }, function(n, key) {
 *   console.log(n, key);
 * });
 * // => logs each value-key pair and returns the object (iteration order is not guaranteed)
 */
var forEach = createForEach(arrayEach, baseEach);

module.exports = forEach;

},{"../internal/arrayEach":429,"../internal/baseEach":440,"../internal/createForEach":470}],423:[function(require,module,exports){
'use strict';

var createAggregator = require('../internal/createAggregator');

/**
 * Creates an object composed of keys generated from the results of running
 * each element of `collection` through `iteratee`. The corresponding value
 * of each key is the last element responsible for generating the key. The
 * iteratee function is bound to `thisArg` and invoked with three arguments:
 * (value, index|key, collection).
 *
 * If a property name is provided for `iteratee` the created `_.property`
 * style callback returns the property value of the given element.
 *
 * If a value is also provided for `thisArg` the created `_.matchesProperty`
 * style callback returns `true` for elements that have a matching property
 * value, else `false`.
 *
 * If an object is provided for `iteratee` the created `_.matches` style
 * callback returns `true` for elements that have the properties of the given
 * object, else `false`.
 *
 * @static
 * @memberOf _
 * @category Collection
 * @param {Array|Object|string} collection The collection to iterate over.
 * @param {Function|Object|string} [iteratee=_.identity] The function invoked
 *  per iteration.
 * @param {*} [thisArg] The `this` binding of `iteratee`.
 * @returns {Object} Returns the composed aggregate object.
 * @example
 *
 * var keyData = [
 *   { 'dir': 'left', 'code': 97 },
 *   { 'dir': 'right', 'code': 100 }
 * ];
 *
 * _.indexBy(keyData, 'dir');
 * // => { 'left': { 'dir': 'left', 'code': 97 }, 'right': { 'dir': 'right', 'code': 100 } }
 *
 * _.indexBy(keyData, function(object) {
 *   return String.fromCharCode(object.code);
 * });
 * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } }
 *
 * _.indexBy(keyData, function(object) {
 *   return this.fromCharCode(object.code);
 * }, String);
 * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } }
 */
var indexBy = createAggregator(function (result, value, key) {
  result[key] = value;
});

module.exports = indexBy;

},{"../internal/createAggregator":464}],424:[function(require,module,exports){
'use strict';

var arrayMap = require('../internal/arrayMap'),
    baseCallback = require('../internal/baseCallback'),
    baseMap = require('../internal/baseMap'),
    isArray = require('../lang/isArray');

/**
 * Creates an array of values by running each element in `collection` through
 * `iteratee`. The `iteratee` is bound to `thisArg` and invoked with three
 * arguments: (value, index|key, collection).
 *
 * If a property name is provided for `iteratee` the created `_.property`
 * style callback returns the property value of the given element.
 *
 * If a value is also provided for `thisArg` the created `_.matchesProperty`
 * style callback returns `true` for elements that have a matching property
 * value, else `false`.
 *
 * If an object is provided for `iteratee` the created `_.matches` style
 * callback returns `true` for elements that have the properties of the given
 * object, else `false`.
 *
 * Many lodash methods are guarded to work as iteratees for methods like
 * `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`.
 *
 * The guarded methods are:
 * `ary`, `callback`, `chunk`, `clone`, `create`, `curry`, `curryRight`,
 * `drop`, `dropRight`, `every`, `fill`, `flatten`, `invert`, `max`, `min`,
 * `parseInt`, `slice`, `sortBy`, `take`, `takeRight`, `template`, `trim`,
 * `trimLeft`, `trimRight`, `trunc`, `random`, `range`, `sample`, `some`,
 * `sum`, `uniq`, and `words`
 *
 * @static
 * @memberOf _
 * @alias collect
 * @category Collection
 * @param {Array|Object|string} collection The collection to iterate over.
 * @param {Function|Object|string} [iteratee=_.identity] The function invoked
 *  per iteration.
 * @param {*} [thisArg] The `this` binding of `iteratee`.
 * @returns {Array} Returns the new mapped array.
 * @example
 *
 * function timesThree(n) {
 *   return n * 3;
 * }
 *
 * _.map([1, 2], timesThree);
 * // => [3, 6]
 *
 * _.map({ 'a': 1, 'b': 2 }, timesThree);
 * // => [3, 6] (iteration order is not guaranteed)
 *
 * var users = [
 *   { 'user': 'barney' },
 *   { 'user': 'fred' }
 * ];
 *
 * // using the `_.property` callback shorthand
 * _.map(users, 'user');
 * // => ['barney', 'fred']
 */
function map(collection, iteratee, thisArg) {
  var func = isArray(collection) ? arrayMap : baseMap;
  iteratee = baseCallback(iteratee, thisArg, 3);
  return func(collection, iteratee);
}

module.exports = map;

},{"../internal/arrayMap":431,"../internal/baseCallback":436,"../internal/baseMap":452,"../lang/isArray":489}],425:[function(require,module,exports){
'use strict';

var getNative = require('../internal/getNative');

/* Native method references for those with the same name as other `lodash` methods. */
var nativeNow = getNative(Date, 'now');

/**
 * Gets the number of milliseconds that have elapsed since the Unix epoch
 * (1 January 1970 00:00:00 UTC).
 *
 * @static
 * @memberOf _
 * @category Date
 * @example
 *
 * _.defer(function(stamp) {
 *   console.log(_.now() - stamp);
 * }, _.now());
 * // => logs the number of milliseconds it took for the deferred function to be invoked
 */
var now = nativeNow || function () {
  return new Date().getTime();
};

module.exports = now;

},{"../internal/getNative":476}],426:[function(require,module,exports){
'use strict';

var isObject = require('../lang/isObject'),
    now = require('../date/now');

/** Used as the `TypeError` message for "Functions" methods. */
var FUNC_ERROR_TEXT = 'Expected a function';

/* Native method references for those with the same name as other `lodash` methods. */
var nativeMax = Math.max;

/**
 * Creates a debounced function that delays invoking `func` until after `wait`
 * milliseconds have elapsed since the last time the debounced function was
 * invoked. The debounced function comes with a `cancel` method to cancel
 * delayed invocations. Provide an options object to indicate that `func`
 * should be invoked on the leading and/or trailing edge of the `wait` timeout.
 * Subsequent calls to the debounced function return the result of the last
 * `func` invocation.
 *
 * **Note:** If `leading` and `trailing` options are `true`, `func` is invoked
 * on the trailing edge of the timeout only if the the debounced function is
 * invoked more than once during the `wait` timeout.
 *
 * See [David Corbacho's article](http://drupalmotion.com/article/debounce-and-throttle-visual-explanation)
 * for details over the differences between `_.debounce` and `_.throttle`.
 *
 * @static
 * @memberOf _
 * @category Function
 * @param {Function} func The function to debounce.
 * @param {number} [wait=0] The number of milliseconds to delay.
 * @param {Object} [options] The options object.
 * @param {boolean} [options.leading=false] Specify invoking on the leading
 *  edge of the timeout.
 * @param {number} [options.maxWait] The maximum time `func` is allowed to be
 *  delayed before it's invoked.
 * @param {boolean} [options.trailing=true] Specify invoking on the trailing
 *  edge of the timeout.
 * @returns {Function} Returns the new debounced function.
 * @example
 *
 * // avoid costly calculations while the window size is in flux
 * jQuery(window).on('resize', _.debounce(calculateLayout, 150));
 *
 * // invoke `sendMail` when the click event is fired, debouncing subsequent calls
 * jQuery('#postbox').on('click', _.debounce(sendMail, 300, {
 *   'leading': true,
 *   'trailing': false
 * }));
 *
 * // ensure `batchLog` is invoked once after 1 second of debounced calls
 * var source = new EventSource('/stream');
 * jQuery(source).on('message', _.debounce(batchLog, 250, {
 *   'maxWait': 1000
 * }));
 *
 * // cancel a debounced call
 * var todoChanges = _.debounce(batchLog, 1000);
 * Object.observe(models.todo, todoChanges);
 *
 * Object.observe(models, function(changes) {
 *   if (_.find(changes, { 'user': 'todo', 'type': 'delete'})) {
 *     todoChanges.cancel();
 *   }
 * }, ['delete']);
 *
 * // ...at some point `models.todo` is changed
 * models.todo.completed = true;
 *
 * // ...before 1 second has passed `models.todo` is deleted
 * // which cancels the debounced `todoChanges` call
 * delete models.todo;
 */
function debounce(func, wait, options) {
  var args,
      maxTimeoutId,
      result,
      stamp,
      thisArg,
      timeoutId,
      trailingCall,
      lastCalled = 0,
      maxWait = false,
      trailing = true;

  if (typeof func != 'function') {
    throw new TypeError(FUNC_ERROR_TEXT);
  }
  wait = wait < 0 ? 0 : +wait || 0;
  if (options === true) {
    var leading = true;
    trailing = false;
  } else if (isObject(options)) {
    leading = !!options.leading;
    maxWait = 'maxWait' in options && nativeMax(+options.maxWait || 0, wait);
    trailing = 'trailing' in options ? !!options.trailing : trailing;
  }

  function cancel() {
    if (timeoutId) {
      clearTimeout(timeoutId);
    }
    if (maxTimeoutId) {
      clearTimeout(maxTimeoutId);
    }
    lastCalled = 0;
    maxTimeoutId = timeoutId = trailingCall = undefined;
  }

  function complete(isCalled, id) {
    if (id) {
      clearTimeout(id);
    }
    maxTimeoutId = timeoutId = trailingCall = undefined;
    if (isCalled) {
      lastCalled = now();
      result = func.apply(thisArg, args);
      if (!timeoutId && !maxTimeoutId) {
        args = thisArg = undefined;
      }
    }
  }

  function delayed() {
    var remaining = wait - (now() - stamp);
    if (remaining <= 0 || remaining > wait) {
      complete(trailingCall, maxTimeoutId);
    } else {
      timeoutId = setTimeout(delayed, remaining);
    }
  }

  function maxDelayed() {
    complete(trailing, timeoutId);
  }

  function debounced() {
    args = arguments;
    stamp = now();
    thisArg = this;
    trailingCall = trailing && (timeoutId || !leading);

    if (maxWait === false) {
      var leadingCall = leading && !timeoutId;
    } else {
      if (!maxTimeoutId && !leading) {
        lastCalled = stamp;
      }
      var remaining = maxWait - (stamp - lastCalled),
          isCalled = remaining <= 0 || remaining > maxWait;

      if (isCalled) {
        if (maxTimeoutId) {
          maxTimeoutId = clearTimeout(maxTimeoutId);
        }
        lastCalled = stamp;
        result = func.apply(thisArg, args);
      } else if (!maxTimeoutId) {
        maxTimeoutId = setTimeout(maxDelayed, remaining);
      }
    }
    if (isCalled && timeoutId) {
      timeoutId = clearTimeout(timeoutId);
    } else if (!timeoutId && wait !== maxWait) {
      timeoutId = setTimeout(delayed, wait);
    }
    if (leadingCall) {
      isCalled = true;
      result = func.apply(thisArg, args);
    }
    if (isCalled && !timeoutId && !maxTimeoutId) {
      args = thisArg = undefined;
    }
    return result;
  }
  debounced.cancel = cancel;
  return debounced;
}

module.exports = debounce;

},{"../date/now":425,"../lang/isObject":493}],427:[function(require,module,exports){
'use strict';

/** Used as the `TypeError` message for "Functions" methods. */
var FUNC_ERROR_TEXT = 'Expected a function';

/* Native method references for those with the same name as other `lodash` methods. */
var nativeMax = Math.max;

/**
 * Creates a function that invokes `func` with the `this` binding of the
 * created function and arguments from `start` and beyond provided as an array.
 *
 * **Note:** This method is based on the [rest parameter](https://developer.mozilla.org/Web/JavaScript/Reference/Functions/rest_parameters).
 *
 * @static
 * @memberOf _
 * @category Function
 * @param {Function} func The function to apply a rest parameter to.
 * @param {number} [start=func.length-1] The start position of the rest parameter.
 * @returns {Function} Returns the new function.
 * @example
 *
 * var say = _.restParam(function(what, names) {
 *   return what + ' ' + _.initial(names).join(', ') +
 *     (_.size(names) > 1 ? ', & ' : '') + _.last(names);
 * });
 *
 * say('hello', 'fred', 'barney', 'pebbles');
 * // => 'hello fred, barney, & pebbles'
 */
function restParam(func, start) {
  if (typeof func != 'function') {
    throw new TypeError(FUNC_ERROR_TEXT);
  }
  start = nativeMax(start === undefined ? func.length - 1 : +start || 0, 0);
  return function () {
    var args = arguments,
        index = -1,
        length = nativeMax(args.length - start, 0),
        rest = Array(length);

    while (++index < length) {
      rest[index] = args[start + index];
    }
    switch (start) {
      case 0:
        return func.call(this, rest);
      case 1:
        return func.call(this, args[0], rest);
      case 2:
        return func.call(this, args[0], args[1], rest);
    }
    var otherArgs = Array(start + 1);
    index = -1;
    while (++index < start) {
      otherArgs[index] = args[index];
    }
    otherArgs[start] = rest;
    return func.apply(this, otherArgs);
  };
}

module.exports = restParam;

},{}],428:[function(require,module,exports){
(function (global){
'use strict';

var cachePush = require('./cachePush'),
    getNative = require('./getNative');

/** Native method references. */
var Set = getNative(global, 'Set');

/* Native method references for those with the same name as other `lodash` methods. */
var nativeCreate = getNative(Object, 'create');

/**
 *
 * Creates a cache object to store unique values.
 *
 * @private
 * @param {Array} [values] The values to cache.
 */
function SetCache(values) {
  var length = values ? values.length : 0;

  this.data = { 'hash': nativeCreate(null), 'set': new Set() };
  while (length--) {
    this.push(values[length]);
  }
}

// Add functions to the `Set` cache.
SetCache.prototype.push = cachePush;

module.exports = SetCache;

}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})

},{"./cachePush":463,"./getNative":476}],429:[function(require,module,exports){
"use strict";

/**
 * A specialized version of `_.forEach` for arrays without support for callback
 * shorthands and `this` binding.
 *
 * @private
 * @param {Array} array The array to iterate over.
 * @param {Function} iteratee The function invoked per iteration.
 * @returns {Array} Returns `array`.
 */
function arrayEach(array, iteratee) {
  var index = -1,
      length = array.length;

  while (++index < length) {
    if (iteratee(array[index], index, array) === false) {
      break;
    }
  }
  return array;
}

module.exports = arrayEach;

},{}],430:[function(require,module,exports){
"use strict";

/**
 * A specialized version of `_.filter` for arrays without support for callback
 * shorthands and `this` binding.
 *
 * @private
 * @param {Array} array The array to iterate over.
 * @param {Function} predicate The function invoked per iteration.
 * @returns {Array} Returns the new filtered array.
 */
function arrayFilter(array, predicate) {
  var index = -1,
      length = array.length,
      resIndex = -1,
      result = [];

  while (++index < length) {
    var value = array[index];
    if (predicate(value, index, array)) {
      result[++resIndex] = value;
    }
  }
  return result;
}

module.exports = arrayFilter;

},{}],431:[function(require,module,exports){
"use strict";

/**
 * A specialized version of `_.map` for arrays without support for callback
 * shorthands and `this` binding.
 *
 * @private
 * @param {Array} array The array to iterate over.
 * @param {Function} iteratee The function invoked per iteration.
 * @returns {Array} Returns the new mapped array.
 */
function arrayMap(array, iteratee) {
  var index = -1,
      length = array.length,
      result = Array(length);

  while (++index < length) {
    result[index] = iteratee(array[index], index, array);
  }
  return result;
}

module.exports = arrayMap;

},{}],432:[function(require,module,exports){
"use strict";

/**
 * Appends the elements of `values` to `array`.
 *
 * @private
 * @param {Array} array The array to modify.
 * @param {Array} values The values to append.
 * @returns {Array} Returns `array`.
 */
function arrayPush(array, values) {
  var index = -1,
      length = values.length,
      offset = array.length;

  while (++index < length) {
    array[offset + index] = values[index];
  }
  return array;
}

module.exports = arrayPush;

},{}],433:[function(require,module,exports){
"use strict";

/**
 * A specialized version of `_.some` for arrays without support for callback
 * shorthands and `this` binding.
 *
 * @private
 * @param {Array} array The array to iterate over.
 * @param {Function} predicate The function invoked per iteration.
 * @returns {boolean} Returns `true` if any element passes the predicate check,
 *  else `false`.
 */
function arraySome(array, predicate) {
  var index = -1,
      length = array.length;

  while (++index < length) {
    if (predicate(array[index], index, array)) {
      return true;
    }
  }
  return false;
}

module.exports = arraySome;

},{}],434:[function(require,module,exports){
'use strict';

var keys = require('../object/keys');

/**
 * A specialized version of `_.assign` for customizing assigned values without
 * support for argument juggling, multiple sources, and `this` binding `customizer`
 * functions.
 *
 * @private
 * @param {Object} object The destination object.
 * @param {Object} source The source object.
 * @param {Function} customizer The function to customize assigned values.
 * @returns {Object} Returns `object`.
 */
function assignWith(object, source, customizer) {
  var index = -1,
      props = keys(source),
      length = props.length;

  while (++index < length) {
    var key = props[index],
        value = object[key],
        result = customizer(value, source[key], key, object, source);

    if ((result === result ? result !== value : value === value) || value === undefined && !(key in object)) {
      object[key] = result;
    }
  }
  return object;
}

module.exports = assignWith;

},{"../object/keys":498}],435:[function(require,module,exports){
'use strict';

var baseCopy = require('./baseCopy'),
    keys = require('../object/keys');

/**
 * The base implementation of `_.assign` without support for argument juggling,
 * multiple sources, and `customizer` functions.
 *
 * @private
 * @param {Object} object The destination object.
 * @param {Object} source The source object.
 * @returns {Object} Returns `object`.
 */
function baseAssign(object, source) {
    return source == null ? object : baseCopy(source, keys(source), object);
}

module.exports = baseAssign;

},{"../object/keys":498,"./baseCopy":437}],436:[function(require,module,exports){
'use strict';

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

var baseMatches = require('./baseMatches'),
    baseMatchesProperty = require('./baseMatchesProperty'),
    bindCallback = require('./bindCallback'),
    identity = require('../utility/identity'),
    property = require('../utility/property');

/**
 * The base implementation of `_.callback` which supports specifying the
 * number of arguments to provide to `func`.
 *
 * @private
 * @param {*} [func=_.identity] The value to convert to a callback.
 * @param {*} [thisArg] The `this` binding of `func`.
 * @param {number} [argCount] The number of arguments to provide to `func`.
 * @returns {Function} Returns the callback.
 */
function baseCallback(func, thisArg, argCount) {
  var type = typeof func === 'undefined' ? 'undefined' : _typeof(func);
  if (type == 'function') {
    return thisArg === undefined ? func : bindCallback(func, thisArg, argCount);
  }
  if (func == null) {
    return identity;
  }
  if (type == 'object') {
    return baseMatches(func);
  }
  return thisArg === undefined ? property(func) : baseMatchesProperty(func, thisArg);
}

module.exports = baseCallback;

},{"../utility/identity":503,"../utility/property":504,"./baseMatches":453,"./baseMatchesProperty":454,"./bindCallback":461}],437:[function(require,module,exports){
"use strict";

/**
 * Copies properties of `source` to `object`.
 *
 * @private
 * @param {Object} source The object to copy properties from.
 * @param {Array} props The property names to copy.
 * @param {Object} [object={}] The object to copy properties to.
 * @returns {Object} Returns `object`.
 */
function baseCopy(source, props, object) {
  object || (object = {});

  var index = -1,
      length = props.length;

  while (++index < length) {
    var key = props[index];
    object[key] = source[key];
  }
  return object;
}

module.exports = baseCopy;

},{}],438:[function(require,module,exports){
'use strict';

var isObject = require('../lang/isObject');

/**
 * The base implementation of `_.create` without support for assigning
 * properties to the created object.
 *
 * @private
 * @param {Object} prototype The object to inherit from.
 * @returns {Object} Returns the new object.
 */
var baseCreate = function () {
  function object() {}
  return function (prototype) {
    if (isObject(prototype)) {
      object.prototype = prototype;
      var result = new object();
      object.prototype = undefined;
    }
    return result || {};
  };
}();

module.exports = baseCreate;

},{"../lang/isObject":493}],439:[function(require,module,exports){
'use strict';

var baseIndexOf = require('./baseIndexOf'),
    cacheIndexOf = require('./cacheIndexOf'),
    createCache = require('./createCache');

/** Used as the size to enable large array optimizations. */
var LARGE_ARRAY_SIZE = 200;

/**
 * The base implementation of `_.difference` which accepts a single array
 * of values to exclude.
 *
 * @private
 * @param {Array} array The array to inspect.
 * @param {Array} values The values to exclude.
 * @returns {Array} Returns the new array of filtered values.
 */
function baseDifference(array, values) {
  var length = array ? array.length : 0,
      result = [];

  if (!length) {
    return result;
  }
  var index = -1,
      indexOf = baseIndexOf,
      isCommon = true,
      cache = isCommon && values.length >= LARGE_ARRAY_SIZE ? createCache(values) : null,
      valuesLength = values.length;

  if (cache) {
    indexOf = cacheIndexOf;
    isCommon = false;
    values = cache;
  }
  outer: while (++index < length) {
    var value = array[index];

    if (isCommon && value === value) {
      var valuesIndex = valuesLength;
      while (valuesIndex--) {
        if (values[valuesIndex] === value) {
          continue outer;
        }
      }
      result.push(value);
    } else if (indexOf(values, value, 0) < 0) {
      result.push(value);
    }
  }
  return result;
}

module.exports = baseDifference;

},{"./baseIndexOf":448,"./cacheIndexOf":462,"./createCache":468}],440:[function(require,module,exports){
'use strict';

var baseForOwn = require('./baseForOwn'),
    createBaseEach = require('./createBaseEach');

/**
 * The base implementation of `_.forEach` without support for callback
 * shorthands and `this` binding.
 *
 * @private
 * @param {Array|Object|string} collection The collection to iterate over.
 * @param {Function} iteratee The function invoked per iteration.
 * @returns {Array|Object|string} Returns `collection`.
 */
var baseEach = createBaseEach(baseForOwn);

module.exports = baseEach;

},{"./baseForOwn":446,"./createBaseEach":466}],441:[function(require,module,exports){
'use strict';

var baseEach = require('./baseEach');

/**
 * The base implementation of `_.filter` without support for callback
 * shorthands and `this` binding.
 *
 * @private
 * @param {Array|Object|string} collection The collection to iterate over.
 * @param {Function} predicate The function invoked per iteration.
 * @returns {Array} Returns the new filtered array.
 */
function baseFilter(collection, predicate) {
  var result = [];
  baseEach(collection, function (value, index, collection) {
    if (predicate(value, index, collection)) {
      result.push(value);
    }
  });
  return result;
}

module.exports = baseFilter;

},{"./baseEach":440}],442:[function(require,module,exports){
"use strict";

/**
 * The base implementation of `_.find`, `_.findLast`, `_.findKey`, and `_.findLastKey`,
 * without support for callback shorthands and `this` binding, which iterates
 * over `collection` using the provided `eachFunc`.
 *
 * @private
 * @param {Array|Object|string} collection The collection to search.
 * @param {Function} predicate The function invoked per iteration.
 * @param {Function} eachFunc The function to iterate over `collection`.
 * @param {boolean} [retKey] Specify returning the key of the found element
 *  instead of the element itself.
 * @returns {*} Returns the found element or its key, else `undefined`.
 */
function baseFind(collection, predicate, eachFunc, retKey) {
  var result;
  eachFunc(collection, function (value, key, collection) {
    if (predicate(value, key, collection)) {
      result = retKey ? key : value;
      return false;
    }
  });
  return result;
}

module.exports = baseFind;

},{}],443:[function(require,module,exports){
"use strict";

/**
 * The base implementation of `_.findIndex` and `_.findLastIndex` without
 * support for callback shorthands and `this` binding.
 *
 * @private
 * @param {Array} array The array to search.
 * @param {Function} predicate The function invoked per iteration.
 * @param {boolean} [fromRight] Specify iterating from right to left.
 * @returns {number} Returns the index of the matched value, else `-1`.
 */
function baseFindIndex(array, predicate, fromRight) {
  var length = array.length,
      index = fromRight ? length : -1;

  while (fromRight ? index-- : ++index < length) {
    if (predicate(array[index], index, array)) {
      return index;
    }
  }
  return -1;
}

module.exports = baseFindIndex;

},{}],444:[function(require,module,exports){
'use strict';

var arrayPush = require('./arrayPush'),
    isArguments = require('../lang/isArguments'),
    isArray = require('../lang/isArray'),
    isArrayLike = require('./isArrayLike'),
    isObjectLike = require('./isObjectLike');

/**
 * The base implementation of `_.flatten` with added support for restricting
 * flattening and specifying the start index.
 *
 * @private
 * @param {Array} array The array to flatten.
 * @param {boolean} [isDeep] Specify a deep flatten.
 * @param {boolean} [isStrict] Restrict flattening to arrays-like objects.
 * @param {Array} [result=[]] The initial result value.
 * @returns {Array} Returns the new flattened array.
 */
function baseFlatten(array, isDeep, isStrict, result) {
  result || (result = []);

  var index = -1,
      length = array.length;

  while (++index < length) {
    var value = array[index];
    if (isObjectLike(value) && isArrayLike(value) && (isStrict || isArray(value) || isArguments(value))) {
      if (isDeep) {
        // Recursively flatten arrays (susceptible to call stack limits).
        baseFlatten(value, isDeep, isStrict, result);
      } else {
        arrayPush(result, value);
      }
    } else if (!isStrict) {
      result[result.length] = value;
    }
  }
  return result;
}

module.exports = baseFlatten;

},{"../lang/isArguments":488,"../lang/isArray":489,"./arrayPush":432,"./isArrayLike":478,"./isObjectLike":483}],445:[function(require,module,exports){
'use strict';

var createBaseFor = require('./createBaseFor');

/**
 * The base implementation of `baseForIn` and `baseForOwn` which iterates
 * over `object` properties returned by `keysFunc` invoking `iteratee` for
 * each property. Iteratee functions may exit iteration early by explicitly
 * returning `false`.
 *
 * @private
 * @param {Object} object The object to iterate over.
 * @param {Function} iteratee The function invoked per iteration.
 * @param {Function} keysFunc The function to get the keys of `object`.
 * @returns {Object} Returns `object`.
 */
var baseFor = createBaseFor();

module.exports = baseFor;

},{"./createBaseFor":467}],446:[function(require,module,exports){
'use strict';

var baseFor = require('./baseFor'),
    keys = require('../object/keys');

/**
 * The base implementation of `_.forOwn` without support for callback
 * shorthands and `this` binding.
 *
 * @private
 * @param {Object} object The object to iterate over.
 * @param {Function} iteratee The function invoked per iteration.
 * @returns {Object} Returns `object`.
 */
function baseForOwn(object, iteratee) {
  return baseFor(object, iteratee, keys);
}

module.exports = baseForOwn;

},{"../object/keys":498,"./baseFor":445}],447:[function(require,module,exports){
'use strict';

var toObject = require('./toObject');

/**
 * The base implementation of `get` without support for string paths
 * and default values.
 *
 * @private
 * @param {Object} object The object to query.
 * @param {Array} path The path of the property to get.
 * @param {string} [pathKey] The key representation of path.
 * @returns {*} Returns the resolved value.
 */
function baseGet(object, path, pathKey) {
  if (object == null) {
    return;
  }
  if (pathKey !== undefined && pathKey in toObject(object)) {
    path = [pathKey];
  }
  var index = 0,
      length = path.length;

  while (object != null && index < length) {
    object = object[path[index++]];
  }
  return index && index == length ? object : undefined;
}

module.exports = baseGet;

},{"./toObject":486}],448:[function(require,module,exports){
'use strict';

var indexOfNaN = require('./indexOfNaN');

/**
 * The base implementation of `_.indexOf` without support for binary searches.
 *
 * @private
 * @param {Array} array The array to search.
 * @param {*} value The value to search for.
 * @param {number} fromIndex The index to search from.
 * @returns {number} Returns the index of the matched value, else `-1`.
 */
function baseIndexOf(array, value, fromIndex) {
  if (value !== value) {
    return indexOfNaN(array, fromIndex);
  }
  var index = fromIndex - 1,
      length = array.length;

  while (++index < length) {
    if (array[index] === value) {
      return index;
    }
  }
  return -1;
}

module.exports = baseIndexOf;

},{"./indexOfNaN":477}],449:[function(require,module,exports){
'use strict';

var baseIsEqualDeep = require('./baseIsEqualDeep'),
    isObject = require('../lang/isObject'),
    isObjectLike = require('./isObjectLike');

/**
 * The base implementation of `_.isEqual` without support for `this` binding
 * `customizer` functions.
 *
 * @private
 * @param {*} value The value to compare.
 * @param {*} other The other value to compare.
 * @param {Function} [customizer] The function to customize comparing values.
 * @param {boolean} [isLoose] Specify performing partial comparisons.
 * @param {Array} [stackA] Tracks traversed `value` objects.
 * @param {Array} [stackB] Tracks traversed `other` objects.
 * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
 */
function baseIsEqual(value, other, customizer, isLoose, stackA, stackB) {
  if (value === other) {
    return true;
  }
  if (value == null || other == null || !isObject(value) && !isObjectLike(other)) {
    return value !== value && other !== other;
  }
  return baseIsEqualDeep(value, other, baseIsEqual, customizer, isLoose, stackA, stackB);
}

module.exports = baseIsEqual;

},{"../lang/isObject":493,"./baseIsEqualDeep":450,"./isObjectLike":483}],450:[function(require,module,exports){
'use strict';

var equalArrays = require('./equalArrays'),
    equalByTag = require('./equalByTag'),
    equalObjects = require('./equalObjects'),
    isArray = require('../lang/isArray'),
    isTypedArray = require('../lang/isTypedArray');

/** `Object#toString` result references. */
var argsTag = '[object Arguments]',
    arrayTag = '[object Array]',
    objectTag = '[object Object]';

/** Used for native method references. */
var objectProto = Object.prototype;

/** Used to check objects for own properties. */
var hasOwnProperty = objectProto.hasOwnProperty;

/**
 * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
 * of values.
 */
var objToString = objectProto.toString;

/**
 * A specialized version of `baseIsEqual` for arrays and objects which performs
 * deep comparisons and tracks traversed objects enabling objects with circular
 * references to be compared.
 *
 * @private
 * @param {Object} object The object to compare.
 * @param {Object} other The other object to compare.
 * @param {Function} equalFunc The function to determine equivalents of values.
 * @param {Function} [customizer] The function to customize comparing objects.
 * @param {boolean} [isLoose] Specify performing partial comparisons.
 * @param {Array} [stackA=[]] Tracks traversed `value` objects.
 * @param {Array} [stackB=[]] Tracks traversed `other` objects.
 * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
 */
function baseIsEqualDeep(object, other, equalFunc, customizer, isLoose, stackA, stackB) {
  var objIsArr = isArray(object),
      othIsArr = isArray(other),
      objTag = arrayTag,
      othTag = arrayTag;

  if (!objIsArr) {
    objTag = objToString.call(object);
    if (objTag == argsTag) {
      objTag = objectTag;
    } else if (objTag != objectTag) {
      objIsArr = isTypedArray(object);
    }
  }
  if (!othIsArr) {
    othTag = objToString.call(other);
    if (othTag == argsTag) {
      othTag = objectTag;
    } else if (othTag != objectTag) {
      othIsArr = isTypedArray(other);
    }
  }
  var objIsObj = objTag == objectTag,
      othIsObj = othTag == objectTag,
      isSameTag = objTag == othTag;

  if (isSameTag && !(objIsArr || objIsObj)) {
    return equalByTag(object, other, objTag);
  }
  if (!isLoose) {
    var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),
        othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');

    if (objIsWrapped || othIsWrapped) {
      return equalFunc(objIsWrapped ? object.value() : object, othIsWrapped ? other.value() : other, customizer, isLoose, stackA, stackB);
    }
  }
  if (!isSameTag) {
    return false;
  }
  // Assume cyclic values are equal.
  // For more information on detecting circular references see https://es5.github.io/#JO.
  stackA || (stackA = []);
  stackB || (stackB = []);

  var length = stackA.length;
  while (length--) {
    if (stackA[length] == object) {
      return stackB[length] == other;
    }
  }
  // Add `object` and `other` to the stack of traversed objects.
  stackA.push(object);
  stackB.push(other);

  var result = (objIsArr ? equalArrays : equalObjects)(object, other, equalFunc, customizer, isLoose, stackA, stackB);

  stackA.pop();
  stackB.pop();

  return result;
}

module.exports = baseIsEqualDeep;

},{"../lang/isArray":489,"../lang/isTypedArray":495,"./equalArrays":471,"./equalByTag":472,"./equalObjects":473}],451:[function(require,module,exports){
'use strict';

var baseIsEqual = require('./baseIsEqual'),
    toObject = require('./toObject');

/**
 * The base implementation of `_.isMatch` without support for callback
 * shorthands and `this` binding.
 *
 * @private
 * @param {Object} object The object to inspect.
 * @param {Array} matchData The propery names, values, and compare flags to match.
 * @param {Function} [customizer] The function to customize comparing objects.
 * @returns {boolean} Returns `true` if `object` is a match, else `false`.
 */
function baseIsMatch(object, matchData, customizer) {
  var index = matchData.length,
      length = index,
      noCustomizer = !customizer;

  if (object == null) {
    return !length;
  }
  object = toObject(object);
  while (index--) {
    var data = matchData[index];
    if (noCustomizer && data[2] ? data[1] !== object[data[0]] : !(data[0] in object)) {
      return false;
    }
  }
  while (++index < length) {
    data = matchData[index];
    var key = data[0],
        objValue = object[key],
        srcValue = data[1];

    if (noCustomizer && data[2]) {
      if (objValue === undefined && !(key in object)) {
        return false;
      }
    } else {
      var result = customizer ? customizer(objValue, srcValue, key) : undefined;
      if (!(result === undefined ? baseIsEqual(srcValue, objValue, customizer, true) : result)) {
        return false;
      }
    }
  }
  return true;
}

module.exports = baseIsMatch;

},{"./baseIsEqual":449,"./toObject":486}],452:[function(require,module,exports){
'use strict';

var baseEach = require('./baseEach'),
    isArrayLike = require('./isArrayLike');

/**
 * The base implementation of `_.map` without support for callback shorthands
 * and `this` binding.
 *
 * @private
 * @param {Array|Object|string} collection The collection to iterate over.
 * @param {Function} iteratee The function invoked per iteration.
 * @returns {Array} Returns the new mapped array.
 */
function baseMap(collection, iteratee) {
  var index = -1,
      result = isArrayLike(collection) ? Array(collection.length) : [];

  baseEach(collection, function (value, key, collection) {
    result[++index] = iteratee(value, key, collection);
  });
  return result;
}

module.exports = baseMap;

},{"./baseEach":440,"./isArrayLike":478}],453:[function(require,module,exports){
'use strict';

var baseIsMatch = require('./baseIsMatch'),
    getMatchData = require('./getMatchData'),
    toObject = require('./toObject');

/**
 * The base implementation of `_.matches` which does not clone `source`.
 *
 * @private
 * @param {Object} source The object of property values to match.
 * @returns {Function} Returns the new function.
 */
function baseMatches(source) {
  var matchData = getMatchData(source);
  if (matchData.length == 1 && matchData[0][2]) {
    var key = matchData[0][0],
        value = matchData[0][1];

    return function (object) {
      if (object == null) {
        return false;
      }
      return object[key] === value && (value !== undefined || key in toObject(object));
    };
  }
  return function (object) {
    return baseIsMatch(object, matchData);
  };
}

module.exports = baseMatches;

},{"./baseIsMatch":451,"./getMatchData":475,"./toObject":486}],454:[function(require,module,exports){
'use strict';

var baseGet = require('./baseGet'),
    baseIsEqual = require('./baseIsEqual'),
    baseSlice = require('./baseSlice'),
    isArray = require('../lang/isArray'),
    isKey = require('./isKey'),
    isStrictComparable = require('./isStrictComparable'),
    last = require('../array/last'),
    toObject = require('./toObject'),
    toPath = require('./toPath');

/**
 * The base implementation of `_.matchesProperty` which does not clone `srcValue`.
 *
 * @private
 * @param {string} path The path of the property to get.
 * @param {*} srcValue The value to compare.
 * @returns {Function} Returns the new function.
 */
function baseMatchesProperty(path, srcValue) {
  var isArr = isArray(path),
      isCommon = isKey(path) && isStrictComparable(srcValue),
      pathKey = path + '';

  path = toPath(path);
  return function (object) {
    if (object == null) {
      return false;
    }
    var key = pathKey;
    object = toObject(object);
    if ((isArr || !isCommon) && !(key in object)) {
      object = path.length == 1 ? object : baseGet(object, baseSlice(path, 0, -1));
      if (object == null) {
        return false;
      }
      key = last(path);
      object = toObject(object);
    }
    return object[key] === srcValue ? srcValue !== undefined || key in object : baseIsEqual(srcValue, object[key], undefined, true);
  };
}

module.exports = baseMatchesProperty;

},{"../array/last":418,"../lang/isArray":489,"./baseGet":447,"./baseIsEqual":449,"./baseSlice":457,"./isKey":481,"./isStrictComparable":484,"./toObject":486,"./toPath":487}],455:[function(require,module,exports){
"use strict";

/**
 * The base implementation of `_.property` without support for deep paths.
 *
 * @private
 * @param {string} key The key of the property to get.
 * @returns {Function} Returns the new function.
 */
function baseProperty(key) {
  return function (object) {
    return object == null ? undefined : object[key];
  };
}

module.exports = baseProperty;

},{}],456:[function(require,module,exports){
'use strict';

var baseGet = require('./baseGet'),
    toPath = require('./toPath');

/**
 * A specialized version of `baseProperty` which supports deep paths.
 *
 * @private
 * @param {Array|string} path The path of the property to get.
 * @returns {Function} Returns the new function.
 */
function basePropertyDeep(path) {
  var pathKey = path + '';
  path = toPath(path);
  return function (object) {
    return baseGet(object, path, pathKey);
  };
}

module.exports = basePropertyDeep;

},{"./baseGet":447,"./toPath":487}],457:[function(require,module,exports){
"use strict";

/**
 * The base implementation of `_.slice` without an iteratee call guard.
 *
 * @private
 * @param {Array} array The array to slice.
 * @param {number} [start=0] The start position.
 * @param {number} [end=array.length] The end position.
 * @returns {Array} Returns the slice of `array`.
 */
function baseSlice(array, start, end) {
  var index = -1,
      length = array.length;

  start = start == null ? 0 : +start || 0;
  if (start < 0) {
    start = -start > length ? 0 : length + start;
  }
  end = end === undefined || end > length ? length : +end || 0;
  if (end < 0) {
    end += length;
  }
  length = start > end ? 0 : end - start >>> 0;
  start >>>= 0;

  var result = Array(length);
  while (++index < length) {
    result[index] = array[index + start];
  }
  return result;
}

module.exports = baseSlice;

},{}],458:[function(require,module,exports){
'use strict';

/**
 * Converts `value` to a string if it's not one. An empty string is returned
 * for `null` or `undefined` values.
 *
 * @private
 * @param {*} value The value to process.
 * @returns {string} Returns the string.
 */
function baseToString(value) {
  return value == null ? '' : value + '';
}

module.exports = baseToString;

},{}],459:[function(require,module,exports){
'use strict';

var baseIndexOf = require('./baseIndexOf'),
    cacheIndexOf = require('./cacheIndexOf'),
    createCache = require('./createCache');

/** Used as the size to enable large array optimizations. */
var LARGE_ARRAY_SIZE = 200;

/**
 * The base implementation of `_.uniq` without support for callback shorthands
 * and `this` binding.
 *
 * @private
 * @param {Array} array The array to inspect.
 * @param {Function} [iteratee] The function invoked per iteration.
 * @returns {Array} Returns the new duplicate free array.
 */
function baseUniq(array, iteratee) {
  var index = -1,
      indexOf = baseIndexOf,
      length = array.length,
      isCommon = true,
      isLarge = isCommon && length >= LARGE_ARRAY_SIZE,
      seen = isLarge ? createCache() : null,
      result = [];

  if (seen) {
    indexOf = cacheIndexOf;
    isCommon = false;
  } else {
    isLarge = false;
    seen = iteratee ? [] : result;
  }
  outer: while (++index < length) {
    var value = array[index],
        computed = iteratee ? iteratee(value, index, array) : value;

    if (isCommon && value === value) {
      var seenIndex = seen.length;
      while (seenIndex--) {
        if (seen[seenIndex] === computed) {
          continue outer;
        }
      }
      if (iteratee) {
        seen.push(computed);
      }
      result.push(value);
    } else if (indexOf(seen, computed, 0) < 0) {
      if (iteratee || isLarge) {
        seen.push(computed);
      }
      result.push(value);
    }
  }
  return result;
}

module.exports = baseUniq;

},{"./baseIndexOf":448,"./cacheIndexOf":462,"./createCache":468}],460:[function(require,module,exports){
"use strict";

/**
 * The base implementation of `_.values` and `_.valuesIn` which creates an
 * array of `object` property values corresponding to the property names
 * of `props`.
 *
 * @private
 * @param {Object} object The object to query.
 * @param {Array} props The property names to get values for.
 * @returns {Object} Returns the array of property values.
 */
function baseValues(object, props) {
  var index = -1,
      length = props.length,
      result = Array(length);

  while (++index < length) {
    result[index] = object[props[index]];
  }
  return result;
}

module.exports = baseValues;

},{}],461:[function(require,module,exports){
'use strict';

var identity = require('../utility/identity');

/**
 * A specialized version of `baseCallback` which only supports `this` binding
 * and specifying the number of arguments to provide to `func`.
 *
 * @private
 * @param {Function} func The function to bind.
 * @param {*} thisArg The `this` binding of `func`.
 * @param {number} [argCount] The number of arguments to provide to `func`.
 * @returns {Function} Returns the callback.
 */
function bindCallback(func, thisArg, argCount) {
  if (typeof func != 'function') {
    return identity;
  }
  if (thisArg === undefined) {
    return func;
  }
  switch (argCount) {
    case 1:
      return function (value) {
        return func.call(thisArg, value);
      };
    case 3:
      return function (value, index, collection) {
        return func.call(thisArg, value, index, collection);
      };
    case 4:
      return function (accumulator, value, index, collection) {
        return func.call(thisArg, accumulator, value, index, collection);
      };
    case 5:
      return function (value, other, key, object, source) {
        return func.call(thisArg, value, other, key, object, source);
      };
  }
  return function () {
    return func.apply(thisArg, arguments);
  };
}

module.exports = bindCallback;

},{"../utility/identity":503}],462:[function(require,module,exports){
'use strict';

var isObject = require('../lang/isObject');

/**
 * Checks if `value` is in `cache` mimicking the return signature of
 * `_.indexOf` by returning `0` if the value is found, else `-1`.
 *
 * @private
 * @param {Object} cache The cache to search.
 * @param {*} value The value to search for.
 * @returns {number} Returns `0` if `value` is found, else `-1`.
 */
function cacheIndexOf(cache, value) {
  var data = cache.data,
      result = typeof value == 'string' || isObject(value) ? data.set.has(value) : data.hash[value];

  return result ? 0 : -1;
}

module.exports = cacheIndexOf;

},{"../lang/isObject":493}],463:[function(require,module,exports){
'use strict';

var isObject = require('../lang/isObject');

/**
 * Adds `value` to the cache.
 *
 * @private
 * @name push
 * @memberOf SetCache
 * @param {*} value The value to cache.
 */
function cachePush(value) {
  var data = this.data;
  if (typeof value == 'string' || isObject(value)) {
    data.set.add(value);
  } else {
    data.hash[value] = true;
  }
}

module.exports = cachePush;

},{"../lang/isObject":493}],464:[function(require,module,exports){
'use strict';

var baseCallback = require('./baseCallback'),
    baseEach = require('./baseEach'),
    isArray = require('../lang/isArray');

/**
 * Creates a `_.countBy`, `_.groupBy`, `_.indexBy`, or `_.partition` function.
 *
 * @private
 * @param {Function} setter The function to set keys and values of the accumulator object.
 * @param {Function} [initializer] The function to initialize the accumulator object.
 * @returns {Function} Returns the new aggregator function.
 */
function createAggregator(setter, initializer) {
  return function (collection, iteratee, thisArg) {
    var result = initializer ? initializer() : {};
    iteratee = baseCallback(iteratee, thisArg, 3);

    if (isArray(collection)) {
      var index = -1,
          length = collection.length;

      while (++index < length) {
        var value = collection[index];
        setter(result, value, iteratee(value, index, collection), collection);
      }
    } else {
      baseEach(collection, function (value, key, collection) {
        setter(result, value, iteratee(value, key, collection), collection);
      });
    }
    return result;
  };
}

module.exports = createAggregator;

},{"../lang/isArray":489,"./baseCallback":436,"./baseEach":440}],465:[function(require,module,exports){
'use strict';

var bindCallback = require('./bindCallback'),
    isIterateeCall = require('./isIterateeCall'),
    restParam = require('../function/restParam');

/**
 * Creates a `_.assign`, `_.defaults`, or `_.merge` function.
 *
 * @private
 * @param {Function} assigner The function to assign values.
 * @returns {Function} Returns the new assigner function.
 */
function createAssigner(assigner) {
  return restParam(function (object, sources) {
    var index = -1,
        length = object == null ? 0 : sources.length,
        customizer = length > 2 ? sources[length - 2] : undefined,
        guard = length > 2 ? sources[2] : undefined,
        thisArg = length > 1 ? sources[length - 1] : undefined;

    if (typeof customizer == 'function') {
      customizer = bindCallback(customizer, thisArg, 5);
      length -= 2;
    } else {
      customizer = typeof thisArg == 'function' ? thisArg : undefined;
      length -= customizer ? 1 : 0;
    }
    if (guard && isIterateeCall(sources[0], sources[1], guard)) {
      customizer = length < 3 ? undefined : customizer;
      length = 1;
    }
    while (++index < length) {
      var source = sources[index];
      if (source) {
        assigner(object, source, customizer);
      }
    }
    return object;
  });
}

module.exports = createAssigner;

},{"../function/restParam":427,"./bindCallback":461,"./isIterateeCall":480}],466:[function(require,module,exports){
'use strict';

var getLength = require('./getLength'),
    isLength = require('./isLength'),
    toObject = require('./toObject');

/**
 * Creates a `baseEach` or `baseEachRight` function.
 *
 * @private
 * @param {Function} eachFunc The function to iterate over a collection.
 * @param {boolean} [fromRight] Specify iterating from right to left.
 * @returns {Function} Returns the new base function.
 */
function createBaseEach(eachFunc, fromRight) {
  return function (collection, iteratee) {
    var length = collection ? getLength(collection) : 0;
    if (!isLength(length)) {
      return eachFunc(collection, iteratee);
    }
    var index = fromRight ? length : -1,
        iterable = toObject(collection);

    while (fromRight ? index-- : ++index < length) {
      if (iteratee(iterable[index], index, iterable) === false) {
        break;
      }
    }
    return collection;
  };
}

module.exports = createBaseEach;

},{"./getLength":474,"./isLength":482,"./toObject":486}],467:[function(require,module,exports){
'use strict';

var toObject = require('./toObject');

/**
 * Creates a base function for `_.forIn` or `_.forInRight`.
 *
 * @private
 * @param {boolean} [fromRight] Specify iterating from right to left.
 * @returns {Function} Returns the new base function.
 */
function createBaseFor(fromRight) {
  return function (object, iteratee, keysFunc) {
    var iterable = toObject(object),
        props = keysFunc(object),
        length = props.length,
        index = fromRight ? length : -1;

    while (fromRight ? index-- : ++index < length) {
      var key = props[index];
      if (iteratee(iterable[key], key, iterable) === false) {
        break;
      }
    }
    return object;
  };
}

module.exports = createBaseFor;

},{"./toObject":486}],468:[function(require,module,exports){
(function (global){
'use strict';

var SetCache = require('./SetCache'),
    getNative = require('./getNative');

/** Native method references. */
var Set = getNative(global, 'Set');

/* Native method references for those with the same name as other `lodash` methods. */
var nativeCreate = getNative(Object, 'create');

/**
 * Creates a `Set` cache object to optimize linear searches of large arrays.
 *
 * @private
 * @param {Array} [values] The values to cache.
 * @returns {null|Object} Returns the new cache object if `Set` is supported, else `null`.
 */
function createCache(values) {
  return nativeCreate && Set ? new SetCache(values) : null;
}

module.exports = createCache;

}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})

},{"./SetCache":428,"./getNative":476}],469:[function(require,module,exports){
'use strict';

var baseCallback = require('./baseCallback'),
    baseFind = require('./baseFind'),
    baseFindIndex = require('./baseFindIndex'),
    isArray = require('../lang/isArray');

/**
 * Creates a `_.find` or `_.findLast` function.
 *
 * @private
 * @param {Function} eachFunc The function to iterate over a collection.
 * @param {boolean} [fromRight] Specify iterating from right to left.
 * @returns {Function} Returns the new find function.
 */
function createFind(eachFunc, fromRight) {
  return function (collection, predicate, thisArg) {
    predicate = baseCallback(predicate, thisArg, 3);
    if (isArray(collection)) {
      var index = baseFindIndex(collection, predicate, fromRight);
      return index > -1 ? collection[index] : undefined;
    }
    return baseFind(collection, predicate, eachFunc);
  };
}

module.exports = createFind;

},{"../lang/isArray":489,"./baseCallback":436,"./baseFind":442,"./baseFindIndex":443}],470:[function(require,module,exports){
'use strict';

var bindCallback = require('./bindCallback'),
    isArray = require('../lang/isArray');

/**
 * Creates a function for `_.forEach` or `_.forEachRight`.
 *
 * @private
 * @param {Function} arrayFunc The function to iterate over an array.
 * @param {Function} eachFunc The function to iterate over a collection.
 * @returns {Function} Returns the new each function.
 */
function createForEach(arrayFunc, eachFunc) {
  return function (collection, iteratee, thisArg) {
    return typeof iteratee == 'function' && thisArg === undefined && isArray(collection) ? arrayFunc(collection, iteratee) : eachFunc(collection, bindCallback(iteratee, thisArg, 3));
  };
}

module.exports = createForEach;

},{"../lang/isArray":489,"./bindCallback":461}],471:[function(require,module,exports){
'use strict';

var arraySome = require('./arraySome');

/**
 * A specialized version of `baseIsEqualDeep` for arrays with support for
 * partial deep comparisons.
 *
 * @private
 * @param {Array} array The array to compare.
 * @param {Array} other The other array to compare.
 * @param {Function} equalFunc The function to determine equivalents of values.
 * @param {Function} [customizer] The function to customize comparing arrays.
 * @param {boolean} [isLoose] Specify performing partial comparisons.
 * @param {Array} [stackA] Tracks traversed `value` objects.
 * @param {Array} [stackB] Tracks traversed `other` objects.
 * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.
 */
function equalArrays(array, other, equalFunc, customizer, isLoose, stackA, stackB) {
  var index = -1,
      arrLength = array.length,
      othLength = other.length;

  if (arrLength != othLength && !(isLoose && othLength > arrLength)) {
    return false;
  }
  // Ignore non-index properties.
  while (++index < arrLength) {
    var arrValue = array[index],
        othValue = other[index],
        result = customizer ? customizer(isLoose ? othValue : arrValue, isLoose ? arrValue : othValue, index) : undefined;

    if (result !== undefined) {
      if (result) {
        continue;
      }
      return false;
    }
    // Recursively compare arrays (susceptible to call stack limits).
    if (isLoose) {
      if (!arraySome(other, function (othValue) {
        return arrValue === othValue || equalFunc(arrValue, othValue, customizer, isLoose, stackA, stackB);
      })) {
        return false;
      }
    } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, customizer, isLoose, stackA, stackB))) {
      return false;
    }
  }
  return true;
}

module.exports = equalArrays;

},{"./arraySome":433}],472:[function(require,module,exports){
'use strict';

/** `Object#toString` result references. */
var boolTag = '[object Boolean]',
    dateTag = '[object Date]',
    errorTag = '[object Error]',
    numberTag = '[object Number]',
    regexpTag = '[object RegExp]',
    stringTag = '[object String]';

/**
 * A specialized version of `baseIsEqualDeep` for comparing objects of
 * the same `toStringTag`.
 *
 * **Note:** This function only supports comparing values with tags of
 * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.
 *
 * @private
 * @param {Object} object The object to compare.
 * @param {Object} other The other object to compare.
 * @param {string} tag The `toStringTag` of the objects to compare.
 * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
 */
function equalByTag(object, other, tag) {
  switch (tag) {
    case boolTag:
    case dateTag:
      // Coerce dates and booleans to numbers, dates to milliseconds and booleans
      // to `1` or `0` treating invalid dates coerced to `NaN` as not equal.
      return +object == +other;

    case errorTag:
      return object.name == other.name && object.message == other.message;

    case numberTag:
      // Treat `NaN` vs. `NaN` as equal.
      return object != +object ? other != +other : object == +other;

    case regexpTag:
    case stringTag:
      // Coerce regexes to strings and treat strings primitives and string
      // objects as equal. See https://es5.github.io/#x15.10.6.4 for more details.
      return object == other + '';
  }
  return false;
}

module.exports = equalByTag;

},{}],473:[function(require,module,exports){
'use strict';

var keys = require('../object/keys');

/** Used for native method references. */
var objectProto = Object.prototype;

/** Used to check objects for own properties. */
var hasOwnProperty = objectProto.hasOwnProperty;

/**
 * A specialized version of `baseIsEqualDeep` for objects with support for
 * partial deep comparisons.
 *
 * @private
 * @param {Object} object The object to compare.
 * @param {Object} other The other object to compare.
 * @param {Function} equalFunc The function to determine equivalents of values.
 * @param {Function} [customizer] The function to customize comparing values.
 * @param {boolean} [isLoose] Specify performing partial comparisons.
 * @param {Array} [stackA] Tracks traversed `value` objects.
 * @param {Array} [stackB] Tracks traversed `other` objects.
 * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
 */
function equalObjects(object, other, equalFunc, customizer, isLoose, stackA, stackB) {
  var objProps = keys(object),
      objLength = objProps.length,
      othProps = keys(other),
      othLength = othProps.length;

  if (objLength != othLength && !isLoose) {
    return false;
  }
  var index = objLength;
  while (index--) {
    var key = objProps[index];
    if (!(isLoose ? key in other : hasOwnProperty.call(other, key))) {
      return false;
    }
  }
  var skipCtor = isLoose;
  while (++index < objLength) {
    key = objProps[index];
    var objValue = object[key],
        othValue = other[key],
        result = customizer ? customizer(isLoose ? othValue : objValue, isLoose ? objValue : othValue, key) : undefined;

    // Recursively compare objects (susceptible to call stack limits).
    if (!(result === undefined ? equalFunc(objValue, othValue, customizer, isLoose, stackA, stackB) : result)) {
      return false;
    }
    skipCtor || (skipCtor = key == 'constructor');
  }
  if (!skipCtor) {
    var objCtor = object.constructor,
        othCtor = other.constructor;

    // Non `Object` object instances with different constructors are not equal.
    if (objCtor != othCtor && 'constructor' in object && 'constructor' in other && !(typeof objCtor == 'function' && objCtor instanceof objCtor && typeof othCtor == 'function' && othCtor instanceof othCtor)) {
      return false;
    }
  }
  return true;
}

module.exports = equalObjects;

},{"../object/keys":498}],474:[function(require,module,exports){
'use strict';

var baseProperty = require('./baseProperty');

/**
 * Gets the "length" property value of `object`.
 *
 * **Note:** This function is used to avoid a [JIT bug](https://bugs.webkit.org/show_bug.cgi?id=142792)
 * that affects Safari on at least iOS 8.1-8.3 ARM64.
 *
 * @private
 * @param {Object} object The object to query.
 * @returns {*} Returns the "length" value.
 */
var getLength = baseProperty('length');

module.exports = getLength;

},{"./baseProperty":455}],475:[function(require,module,exports){
'use strict';

var isStrictComparable = require('./isStrictComparable'),
    pairs = require('../object/pairs');

/**
 * Gets the propery names, values, and compare flags of `object`.
 *
 * @private
 * @param {Object} object The object to query.
 * @returns {Array} Returns the match data of `object`.
 */
function getMatchData(object) {
  var result = pairs(object),
      length = result.length;

  while (length--) {
    result[length][2] = isStrictComparable(result[length][1]);
  }
  return result;
}

module.exports = getMatchData;

},{"../object/pairs":500,"./isStrictComparable":484}],476:[function(require,module,exports){
'use strict';

var isNative = require('../lang/isNative');

/**
 * Gets the native function at `key` of `object`.
 *
 * @private
 * @param {Object} object The object to query.
 * @param {string} key The key of the method to get.
 * @returns {*} Returns the function if it's native, else `undefined`.
 */
function getNative(object, key) {
  var value = object == null ? undefined : object[key];
  return isNative(value) ? value : undefined;
}

module.exports = getNative;

},{"../lang/isNative":492}],477:[function(require,module,exports){
"use strict";

/**
 * Gets the index at which the first occurrence of `NaN` is found in `array`.
 *
 * @private
 * @param {Array} array The array to search.
 * @param {number} fromIndex The index to search from.
 * @param {boolean} [fromRight] Specify iterating from right to left.
 * @returns {number} Returns the index of the matched `NaN`, else `-1`.
 */
function indexOfNaN(array, fromIndex, fromRight) {
  var length = array.length,
      index = fromIndex + (fromRight ? 0 : -1);

  while (fromRight ? index-- : ++index < length) {
    var other = array[index];
    if (other !== other) {
      return index;
    }
  }
  return -1;
}

module.exports = indexOfNaN;

},{}],478:[function(require,module,exports){
'use strict';

var getLength = require('./getLength'),
    isLength = require('./isLength');

/**
 * Checks if `value` is array-like.
 *
 * @private
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
 */
function isArrayLike(value) {
  return value != null && isLength(getLength(value));
}

module.exports = isArrayLike;

},{"./getLength":474,"./isLength":482}],479:[function(require,module,exports){
'use strict';

/** Used to detect unsigned integer values. */
var reIsUint = /^\d+$/;

/**
 * Used as the [maximum length](http://ecma-international.org/ecma-262/6.0/#sec-number.max_safe_integer)
 * of an array-like value.
 */
var MAX_SAFE_INTEGER = 9007199254740991;

/**
 * Checks if `value` is a valid array-like index.
 *
 * @private
 * @param {*} value The value to check.
 * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
 * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
 */
function isIndex(value, length) {
  value = typeof value == 'number' || reIsUint.test(value) ? +value : -1;
  length = length == null ? MAX_SAFE_INTEGER : length;
  return value > -1 && value % 1 == 0 && value < length;
}

module.exports = isIndex;

},{}],480:[function(require,module,exports){
'use strict';

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

var isArrayLike = require('./isArrayLike'),
    isIndex = require('./isIndex'),
    isObject = require('../lang/isObject');

/**
 * Checks if the provided arguments are from an iteratee call.
 *
 * @private
 * @param {*} value The potential iteratee value argument.
 * @param {*} index The potential iteratee index or key argument.
 * @param {*} object The potential iteratee object argument.
 * @returns {boolean} Returns `true` if the arguments are from an iteratee call, else `false`.
 */
function isIterateeCall(value, index, object) {
  if (!isObject(object)) {
    return false;
  }
  var type = typeof index === 'undefined' ? 'undefined' : _typeof(index);
  if (type == 'number' ? isArrayLike(object) && isIndex(index, object.length) : type == 'string' && index in object) {
    var other = object[index];
    return value === value ? value === other : other !== other;
  }
  return false;
}

module.exports = isIterateeCall;

},{"../lang/isObject":493,"./isArrayLike":478,"./isIndex":479}],481:[function(require,module,exports){
'use strict';

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

var isArray = require('../lang/isArray'),
    toObject = require('./toObject');

/** Used to match property names within property paths. */
var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\n\\]|\\.)*?\1)\]/,
    reIsPlainProp = /^\w*$/;

/**
 * Checks if `value` is a property name and not a property path.
 *
 * @private
 * @param {*} value The value to check.
 * @param {Object} [object] The object to query keys on.
 * @returns {boolean} Returns `true` if `value` is a property name, else `false`.
 */
function isKey(value, object) {
  var type = typeof value === 'undefined' ? 'undefined' : _typeof(value);
  if (type == 'string' && reIsPlainProp.test(value) || type == 'number') {
    return true;
  }
  if (isArray(value)) {
    return false;
  }
  var result = !reIsDeepProp.test(value);
  return result || object != null && value in toObject(object);
}

module.exports = isKey;

},{"../lang/isArray":489,"./toObject":486}],482:[function(require,module,exports){
'use strict';

/**
 * Used as the [maximum length](http://ecma-international.org/ecma-262/6.0/#sec-number.max_safe_integer)
 * of an array-like value.
 */
var MAX_SAFE_INTEGER = 9007199254740991;

/**
 * Checks if `value` is a valid array-like length.
 *
 * **Note:** This function is based on [`ToLength`](http://ecma-international.org/ecma-262/6.0/#sec-tolength).
 *
 * @private
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
 */
function isLength(value) {
  return typeof value == 'number' && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
}

module.exports = isLength;

},{}],483:[function(require,module,exports){
'use strict';

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

/**
 * Checks if `value` is object-like.
 *
 * @private
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
 */
function isObjectLike(value) {
  return !!value && (typeof value === 'undefined' ? 'undefined' : _typeof(value)) == 'object';
}

module.exports = isObjectLike;

},{}],484:[function(require,module,exports){
'use strict';

var isObject = require('../lang/isObject');

/**
 * Checks if `value` is suitable for strict equality comparisons, i.e. `===`.
 *
 * @private
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` if suitable for strict
 *  equality comparisons, else `false`.
 */
function isStrictComparable(value) {
  return value === value && !isObject(value);
}

module.exports = isStrictComparable;

},{"../lang/isObject":493}],485:[function(require,module,exports){
'use strict';

var isArguments = require('../lang/isArguments'),
    isArray = require('../lang/isArray'),
    isIndex = require('./isIndex'),
    isLength = require('./isLength'),
    keysIn = require('../object/keysIn');

/** Used for native method references. */
var objectProto = Object.prototype;

/** Used to check objects for own properties. */
var hasOwnProperty = objectProto.hasOwnProperty;

/**
 * A fallback implementation of `Object.keys` which creates an array of the
 * own enumerable property names of `object`.
 *
 * @private
 * @param {Object} object The object to query.
 * @returns {Array} Returns the array of property names.
 */
function shimKeys(object) {
  var props = keysIn(object),
      propsLength = props.length,
      length = propsLength && object.length;

  var allowIndexes = !!length && isLength(length) && (isArray(object) || isArguments(object));

  var index = -1,
      result = [];

  while (++index < propsLength) {
    var key = props[index];
    if (allowIndexes && isIndex(key, length) || hasOwnProperty.call(object, key)) {
      result.push(key);
    }
  }
  return result;
}

module.exports = shimKeys;

},{"../lang/isArguments":488,"../lang/isArray":489,"../object/keysIn":499,"./isIndex":479,"./isLength":482}],486:[function(require,module,exports){
'use strict';

var isObject = require('../lang/isObject');

/**
 * Converts `value` to an object if it's not one.
 *
 * @private
 * @param {*} value The value to process.
 * @returns {Object} Returns the object.
 */
function toObject(value) {
  return isObject(value) ? value : Object(value);
}

module.exports = toObject;

},{"../lang/isObject":493}],487:[function(require,module,exports){
'use strict';

var baseToString = require('./baseToString'),
    isArray = require('../lang/isArray');

/** Used to match property names within property paths. */
var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\n\\]|\\.)*?)\2)\]/g;

/** Used to match backslashes in property paths. */
var reEscapeChar = /\\(\\)?/g;

/**
 * Converts `value` to property path array if it's not one.
 *
 * @private
 * @param {*} value The value to process.
 * @returns {Array} Returns the property path array.
 */
function toPath(value) {
  if (isArray(value)) {
    return value;
  }
  var result = [];
  baseToString(value).replace(rePropName, function (match, number, quote, string) {
    result.push(quote ? string.replace(reEscapeChar, '$1') : number || match);
  });
  return result;
}

module.exports = toPath;

},{"../lang/isArray":489,"./baseToString":458}],488:[function(require,module,exports){
'use strict';

var isArrayLike = require('../internal/isArrayLike'),
    isObjectLike = require('../internal/isObjectLike');

/** Used for native method references. */
var objectProto = Object.prototype;

/** Used to check objects for own properties. */
var hasOwnProperty = objectProto.hasOwnProperty;

/** Native method references. */
var propertyIsEnumerable = objectProto.propertyIsEnumerable;

/**
 * Checks if `value` is classified as an `arguments` object.
 *
 * @static
 * @memberOf _
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
 * @example
 *
 * _.isArguments(function() { return arguments; }());
 * // => true
 *
 * _.isArguments([1, 2, 3]);
 * // => false
 */
function isArguments(value) {
    return isObjectLike(value) && isArrayLike(value) && hasOwnProperty.call(value, 'callee') && !propertyIsEnumerable.call(value, 'callee');
}

module.exports = isArguments;

},{"../internal/isArrayLike":478,"../internal/isObjectLike":483}],489:[function(require,module,exports){
'use strict';

var getNative = require('../internal/getNative'),
    isLength = require('../internal/isLength'),
    isObjectLike = require('../internal/isObjectLike');

/** `Object#toString` result references. */
var arrayTag = '[object Array]';

/** Used for native method references. */
var objectProto = Object.prototype;

/**
 * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
 * of values.
 */
var objToString = objectProto.toString;

/* Native method references for those with the same name as other `lodash` methods. */
var nativeIsArray = getNative(Array, 'isArray');

/**
 * Checks if `value` is classified as an `Array` object.
 *
 * @static
 * @memberOf _
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
 * @example
 *
 * _.isArray([1, 2, 3]);
 * // => true
 *
 * _.isArray(function() { return arguments; }());
 * // => false
 */
var isArray = nativeIsArray || function (value) {
  return isObjectLike(value) && isLength(value.length) && objToString.call(value) == arrayTag;
};

module.exports = isArray;

},{"../internal/getNative":476,"../internal/isLength":482,"../internal/isObjectLike":483}],490:[function(require,module,exports){
'use strict';

var isArguments = require('./isArguments'),
    isArray = require('./isArray'),
    isArrayLike = require('../internal/isArrayLike'),
    isFunction = require('./isFunction'),
    isObjectLike = require('../internal/isObjectLike'),
    isString = require('./isString'),
    keys = require('../object/keys');

/**
 * Checks if `value` is empty. A value is considered empty unless it's an
 * `arguments` object, array, string, or jQuery-like collection with a length
 * greater than `0` or an object with own enumerable properties.
 *
 * @static
 * @memberOf _
 * @category Lang
 * @param {Array|Object|string} value The value to inspect.
 * @returns {boolean} Returns `true` if `value` is empty, else `false`.
 * @example
 *
 * _.isEmpty(null);
 * // => true
 *
 * _.isEmpty(true);
 * // => true
 *
 * _.isEmpty(1);
 * // => true
 *
 * _.isEmpty([1, 2, 3]);
 * // => false
 *
 * _.isEmpty({ 'a': 1 });
 * // => false
 */
function isEmpty(value) {
  if (value == null) {
    return true;
  }
  if (isArrayLike(value) && (isArray(value) || isString(value) || isArguments(value) || isObjectLike(value) && isFunction(value.splice))) {
    return !value.length;
  }
  return !keys(value).length;
}

module.exports = isEmpty;

},{"../internal/isArrayLike":478,"../internal/isObjectLike":483,"../object/keys":498,"./isArguments":488,"./isArray":489,"./isFunction":491,"./isString":494}],491:[function(require,module,exports){
'use strict';

var isObject = require('./isObject');

/** `Object#toString` result references. */
var funcTag = '[object Function]';

/** Used for native method references. */
var objectProto = Object.prototype;

/**
 * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
 * of values.
 */
var objToString = objectProto.toString;

/**
 * Checks if `value` is classified as a `Function` object.
 *
 * @static
 * @memberOf _
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
 * @example
 *
 * _.isFunction(_);
 * // => true
 *
 * _.isFunction(/abc/);
 * // => false
 */
function isFunction(value) {
  // The use of `Object#toString` avoids issues with the `typeof` operator
  // in older versions of Chrome and Safari which return 'function' for regexes
  // and Safari 8 which returns 'object' for typed array constructors.
  return isObject(value) && objToString.call(value) == funcTag;
}

module.exports = isFunction;

},{"./isObject":493}],492:[function(require,module,exports){
'use strict';

var isFunction = require('./isFunction'),
    isObjectLike = require('../internal/isObjectLike');

/** Used to detect host constructors (Safari > 5). */
var reIsHostCtor = /^\[object .+?Constructor\]$/;

/** Used for native method references. */
var objectProto = Object.prototype;

/** Used to resolve the decompiled source of functions. */
var fnToString = Function.prototype.toString;

/** Used to check objects for own properties. */
var hasOwnProperty = objectProto.hasOwnProperty;

/** Used to detect if a method is native. */
var reIsNative = RegExp('^' + fnToString.call(hasOwnProperty).replace(/[\\^$.*+?()[\]{}|]/g, '\\$&').replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$');

/**
 * Checks if `value` is a native function.
 *
 * @static
 * @memberOf _
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a native function, else `false`.
 * @example
 *
 * _.isNative(Array.prototype.push);
 * // => true
 *
 * _.isNative(_);
 * // => false
 */
function isNative(value) {
  if (value == null) {
    return false;
  }
  if (isFunction(value)) {
    return reIsNative.test(fnToString.call(value));
  }
  return isObjectLike(value) && reIsHostCtor.test(value);
}

module.exports = isNative;

},{"../internal/isObjectLike":483,"./isFunction":491}],493:[function(require,module,exports){
'use strict';

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

/**
 * Checks if `value` is the [language type](https://es5.github.io/#x8) of `Object`.
 * (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
 *
 * @static
 * @memberOf _
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is an object, else `false`.
 * @example
 *
 * _.isObject({});
 * // => true
 *
 * _.isObject([1, 2, 3]);
 * // => true
 *
 * _.isObject(1);
 * // => false
 */
function isObject(value) {
  // Avoid a V8 JIT bug in Chrome 19-20.
  // See https://code.google.com/p/v8/issues/detail?id=2291 for more details.
  var type = typeof value === 'undefined' ? 'undefined' : _typeof(value);
  return !!value && (type == 'object' || type == 'function');
}

module.exports = isObject;

},{}],494:[function(require,module,exports){
'use strict';

var isObjectLike = require('../internal/isObjectLike');

/** `Object#toString` result references. */
var stringTag = '[object String]';

/** Used for native method references. */
var objectProto = Object.prototype;

/**
 * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
 * of values.
 */
var objToString = objectProto.toString;

/**
 * Checks if `value` is classified as a `String` primitive or object.
 *
 * @static
 * @memberOf _
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
 * @example
 *
 * _.isString('abc');
 * // => true
 *
 * _.isString(1);
 * // => false
 */
function isString(value) {
  return typeof value == 'string' || isObjectLike(value) && objToString.call(value) == stringTag;
}

module.exports = isString;

},{"../internal/isObjectLike":483}],495:[function(require,module,exports){
'use strict';

var isLength = require('../internal/isLength'),
    isObjectLike = require('../internal/isObjectLike');

/** `Object#toString` result references. */
var argsTag = '[object Arguments]',
    arrayTag = '[object Array]',
    boolTag = '[object Boolean]',
    dateTag = '[object Date]',
    errorTag = '[object Error]',
    funcTag = '[object Function]',
    mapTag = '[object Map]',
    numberTag = '[object Number]',
    objectTag = '[object Object]',
    regexpTag = '[object RegExp]',
    setTag = '[object Set]',
    stringTag = '[object String]',
    weakMapTag = '[object WeakMap]';

var arrayBufferTag = '[object ArrayBuffer]',
    float32Tag = '[object Float32Array]',
    float64Tag = '[object Float64Array]',
    int8Tag = '[object Int8Array]',
    int16Tag = '[object Int16Array]',
    int32Tag = '[object Int32Array]',
    uint8Tag = '[object Uint8Array]',
    uint8ClampedTag = '[object Uint8ClampedArray]',
    uint16Tag = '[object Uint16Array]',
    uint32Tag = '[object Uint32Array]';

/** Used to identify `toStringTag` values of typed arrays. */
var typedArrayTags = {};
typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;
typedArrayTags[argsTag] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag] = typedArrayTags[mapTag] = typedArrayTags[numberTag] = typedArrayTags[objectTag] = typedArrayTags[regexpTag] = typedArrayTags[setTag] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;

/** Used for native method references. */
var objectProto = Object.prototype;

/**
 * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
 * of values.
 */
var objToString = objectProto.toString;

/**
 * Checks if `value` is classified as a typed array.
 *
 * @static
 * @memberOf _
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
 * @example
 *
 * _.isTypedArray(new Uint8Array);
 * // => true
 *
 * _.isTypedArray([]);
 * // => false
 */
function isTypedArray(value) {
    return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[objToString.call(value)];
}

module.exports = isTypedArray;

},{"../internal/isLength":482,"../internal/isObjectLike":483}],496:[function(require,module,exports){
'use strict';

var assignWith = require('../internal/assignWith'),
    baseAssign = require('../internal/baseAssign'),
    createAssigner = require('../internal/createAssigner');

/**
 * Assigns own enumerable properties of source object(s) to the destination
 * object. Subsequent sources overwrite property assignments of previous sources.
 * If `customizer` is provided it's invoked to produce the assigned values.
 * The `customizer` is bound to `thisArg` and invoked with five arguments:
 * (objectValue, sourceValue, key, object, source).
 *
 * **Note:** This method mutates `object` and is based on
 * [`Object.assign`](http://ecma-international.org/ecma-262/6.0/#sec-object.assign).
 *
 * @static
 * @memberOf _
 * @alias extend
 * @category Object
 * @param {Object} object The destination object.
 * @param {...Object} [sources] The source objects.
 * @param {Function} [customizer] The function to customize assigned values.
 * @param {*} [thisArg] The `this` binding of `customizer`.
 * @returns {Object} Returns `object`.
 * @example
 *
 * _.assign({ 'user': 'barney' }, { 'age': 40 }, { 'user': 'fred' });
 * // => { 'user': 'fred', 'age': 40 }
 *
 * // using a customizer callback
 * var defaults = _.partialRight(_.assign, function(value, other) {
 *   return _.isUndefined(value) ? other : value;
 * });
 *
 * defaults({ 'user': 'barney' }, { 'age': 36 }, { 'user': 'fred' });
 * // => { 'user': 'barney', 'age': 36 }
 */
var assign = createAssigner(function (object, source, customizer) {
    return customizer ? assignWith(object, source, customizer) : baseAssign(object, source);
});

module.exports = assign;

},{"../internal/assignWith":434,"../internal/baseAssign":435,"../internal/createAssigner":465}],497:[function(require,module,exports){
'use strict';

var baseGet = require('../internal/baseGet'),
    toPath = require('../internal/toPath');

/**
 * Gets the property value at `path` of `object`. If the resolved value is
 * `undefined` the `defaultValue` is used in its place.
 *
 * @static
 * @memberOf _
 * @category Object
 * @param {Object} object The object to query.
 * @param {Array|string} path The path of the property to get.
 * @param {*} [defaultValue] The value returned if the resolved value is `undefined`.
 * @returns {*} Returns the resolved value.
 * @example
 *
 * var object = { 'a': [{ 'b': { 'c': 3 } }] };
 *
 * _.get(object, 'a[0].b.c');
 * // => 3
 *
 * _.get(object, ['a', '0', 'b', 'c']);
 * // => 3
 *
 * _.get(object, 'a.b.c', 'default');
 * // => 'default'
 */
function get(object, path, defaultValue) {
  var result = object == null ? undefined : baseGet(object, toPath(path), path + '');
  return result === undefined ? defaultValue : result;
}

module.exports = get;

},{"../internal/baseGet":447,"../internal/toPath":487}],498:[function(require,module,exports){
'use strict';

var getNative = require('../internal/getNative'),
    isArrayLike = require('../internal/isArrayLike'),
    isObject = require('../lang/isObject'),
    shimKeys = require('../internal/shimKeys');

/* Native method references for those with the same name as other `lodash` methods. */
var nativeKeys = getNative(Object, 'keys');

/**
 * Creates an array of the own enumerable property names of `object`.
 *
 * **Note:** Non-object values are coerced to objects. See the
 * [ES spec](http://ecma-international.org/ecma-262/6.0/#sec-object.keys)
 * for more details.
 *
 * @static
 * @memberOf _
 * @category Object
 * @param {Object} object The object to query.
 * @returns {Array} Returns the array of property names.
 * @example
 *
 * function Foo() {
 *   this.a = 1;
 *   this.b = 2;
 * }
 *
 * Foo.prototype.c = 3;
 *
 * _.keys(new Foo);
 * // => ['a', 'b'] (iteration order is not guaranteed)
 *
 * _.keys('hi');
 * // => ['0', '1']
 */
var keys = !nativeKeys ? shimKeys : function (object) {
  var Ctor = object == null ? undefined : object.constructor;
  if (typeof Ctor == 'function' && Ctor.prototype === object || typeof object != 'function' && isArrayLike(object)) {
    return shimKeys(object);
  }
  return isObject(object) ? nativeKeys(object) : [];
};

module.exports = keys;

},{"../internal/getNative":476,"../internal/isArrayLike":478,"../internal/shimKeys":485,"../lang/isObject":493}],499:[function(require,module,exports){
'use strict';

var isArguments = require('../lang/isArguments'),
    isArray = require('../lang/isArray'),
    isIndex = require('../internal/isIndex'),
    isLength = require('../internal/isLength'),
    isObject = require('../lang/isObject');

/** Used for native method references. */
var objectProto = Object.prototype;

/** Used to check objects for own properties. */
var hasOwnProperty = objectProto.hasOwnProperty;

/**
 * Creates an array of the own and inherited enumerable property names of `object`.
 *
 * **Note:** Non-object values are coerced to objects.
 *
 * @static
 * @memberOf _
 * @category Object
 * @param {Object} object The object to query.
 * @returns {Array} Returns the array of property names.
 * @example
 *
 * function Foo() {
 *   this.a = 1;
 *   this.b = 2;
 * }
 *
 * Foo.prototype.c = 3;
 *
 * _.keysIn(new Foo);
 * // => ['a', 'b', 'c'] (iteration order is not guaranteed)
 */
function keysIn(object) {
  if (object == null) {
    return [];
  }
  if (!isObject(object)) {
    object = Object(object);
  }
  var length = object.length;
  length = length && isLength(length) && (isArray(object) || isArguments(object)) && length || 0;

  var Ctor = object.constructor,
      index = -1,
      isProto = typeof Ctor == 'function' && Ctor.prototype === object,
      result = Array(length),
      skipIndexes = length > 0;

  while (++index < length) {
    result[index] = index + '';
  }
  for (var key in object) {
    if (!(skipIndexes && isIndex(key, length)) && !(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {
      result.push(key);
    }
  }
  return result;
}

module.exports = keysIn;

},{"../internal/isIndex":479,"../internal/isLength":482,"../lang/isArguments":488,"../lang/isArray":489,"../lang/isObject":493}],500:[function(require,module,exports){
'use strict';

var keys = require('./keys'),
    toObject = require('../internal/toObject');

/**
 * Creates a two dimensional array of the key-value pairs for `object`,
 * e.g. `[[key1, value1], [key2, value2]]`.
 *
 * @static
 * @memberOf _
 * @category Object
 * @param {Object} object The object to query.
 * @returns {Array} Returns the new array of key-value pairs.
 * @example
 *
 * _.pairs({ 'barney': 36, 'fred': 40 });
 * // => [['barney', 36], ['fred', 40]] (iteration order is not guaranteed)
 */
function pairs(object) {
  object = toObject(object);

  var index = -1,
      props = keys(object),
      length = props.length,
      result = Array(length);

  while (++index < length) {
    var key = props[index];
    result[index] = [key, object[key]];
  }
  return result;
}

module.exports = pairs;

},{"../internal/toObject":486,"./keys":498}],501:[function(require,module,exports){
'use strict';

var arrayEach = require('../internal/arrayEach'),
    baseCallback = require('../internal/baseCallback'),
    baseCreate = require('../internal/baseCreate'),
    baseForOwn = require('../internal/baseForOwn'),
    isArray = require('../lang/isArray'),
    isFunction = require('../lang/isFunction'),
    isObject = require('../lang/isObject'),
    isTypedArray = require('../lang/isTypedArray');

/**
 * An alternative to `_.reduce`; this method transforms `object` to a new
 * `accumulator` object which is the result of running each of its own enumerable
 * properties through `iteratee`, with each invocation potentially mutating
 * the `accumulator` object. The `iteratee` is bound to `thisArg` and invoked
 * with four arguments: (accumulator, value, key, object). Iteratee functions
 * may exit iteration early by explicitly returning `false`.
 *
 * @static
 * @memberOf _
 * @category Object
 * @param {Array|Object} object The object to iterate over.
 * @param {Function} [iteratee=_.identity] The function invoked per iteration.
 * @param {*} [accumulator] The custom accumulator value.
 * @param {*} [thisArg] The `this` binding of `iteratee`.
 * @returns {*} Returns the accumulated value.
 * @example
 *
 * _.transform([2, 3, 4], function(result, n) {
 *   result.push(n *= n);
 *   return n % 2 == 0;
 * });
 * // => [4, 9]
 *
 * _.transform({ 'a': 1, 'b': 2 }, function(result, n, key) {
 *   result[key] = n * 3;
 * });
 * // => { 'a': 3, 'b': 6 }
 */
function transform(object, iteratee, accumulator, thisArg) {
  var isArr = isArray(object) || isTypedArray(object);
  iteratee = baseCallback(iteratee, thisArg, 4);

  if (accumulator == null) {
    if (isArr || isObject(object)) {
      var Ctor = object.constructor;
      if (isArr) {
        accumulator = isArray(object) ? new Ctor() : [];
      } else {
        accumulator = baseCreate(isFunction(Ctor) ? Ctor.prototype : undefined);
      }
    } else {
      accumulator = {};
    }
  }
  (isArr ? arrayEach : baseForOwn)(object, function (value, index, object) {
    return iteratee(accumulator, value, index, object);
  });
  return accumulator;
}

module.exports = transform;

},{"../internal/arrayEach":429,"../internal/baseCallback":436,"../internal/baseCreate":438,"../internal/baseForOwn":446,"../lang/isArray":489,"../lang/isFunction":491,"../lang/isObject":493,"../lang/isTypedArray":495}],502:[function(require,module,exports){
'use strict';

var baseValues = require('../internal/baseValues'),
    keys = require('./keys');

/**
 * Creates an array of the own enumerable property values of `object`.
 *
 * **Note:** Non-object values are coerced to objects.
 *
 * @static
 * @memberOf _
 * @category Object
 * @param {Object} object The object to query.
 * @returns {Array} Returns the array of property values.
 * @example
 *
 * function Foo() {
 *   this.a = 1;
 *   this.b = 2;
 * }
 *
 * Foo.prototype.c = 3;
 *
 * _.values(new Foo);
 * // => [1, 2] (iteration order is not guaranteed)
 *
 * _.values('hi');
 * // => ['h', 'i']
 */
function values(object) {
  return baseValues(object, keys(object));
}

module.exports = values;

},{"../internal/baseValues":460,"./keys":498}],503:[function(require,module,exports){
"use strict";

/**
 * This method returns the first argument provided to it.
 *
 * @static
 * @memberOf _
 * @category Utility
 * @param {*} value Any value.
 * @returns {*} Returns `value`.
 * @example
 *
 * var object = { 'user': 'fred' };
 *
 * _.identity(object) === object;
 * // => true
 */
function identity(value) {
  return value;
}

module.exports = identity;

},{}],504:[function(require,module,exports){
'use strict';

var baseProperty = require('../internal/baseProperty'),
    basePropertyDeep = require('../internal/basePropertyDeep'),
    isKey = require('../internal/isKey');

/**
 * Creates a function that returns the property value at `path` on a
 * given object.
 *
 * @static
 * @memberOf _
 * @category Utility
 * @param {Array|string} path The path of the property to get.
 * @returns {Function} Returns the new function.
 * @example
 *
 * var objects = [
 *   { 'a': { 'b': { 'c': 2 } } },
 *   { 'a': { 'b': { 'c': 1 } } }
 * ];
 *
 * _.map(objects, _.property('a.b.c'));
 * // => [2, 1]
 *
 * _.pluck(_.sortBy(objects, _.property(['a', 'b', 'c'])), 'a.b.c');
 * // => [1, 2]
 */
function property(path) {
  return isKey(path) ? baseProperty(path) : basePropertyDeep(path);
}

module.exports = property;

},{"../internal/baseProperty":455,"../internal/basePropertyDeep":456,"../internal/isKey":481}],505:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

/**
 * Flatten array, one level deep.
 *
 * @param {Array<?>} arr
 *
 * @return {Array<?>}
 */
function flatten(arr) {
  return Array.prototype.concat.apply([], arr);
}

var nativeToString = Object.prototype.toString;
var nativeHasOwnProperty = Object.prototype.hasOwnProperty;

function isUndefined(obj) {
  return obj === undefined;
}

function isDefined(obj) {
  return obj !== undefined;
}

function isNil(obj) {
  return obj == null;
}

function isArray(obj) {
  return nativeToString.call(obj) === '[object Array]';
}

function isObject(obj) {
  return nativeToString.call(obj) === '[object Object]';
}

function isNumber(obj) {
  return nativeToString.call(obj) === '[object Number]';
}

function isFunction(obj) {
  return nativeToString.call(obj) === '[object Function]';
}

function isString(obj) {
  return nativeToString.call(obj) === '[object String]';
}

/**
 * Ensure collection is an array.
 *
 * @param {Object} obj
 */
function ensureArray(obj) {

  if (isArray(obj)) {
    return;
  }

  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}
 */
function has(target, key) {
  return nativeHasOwnProperty.call(target, key);
}

/**
 * Find element in collection.
 *
 * @param  {Array|Object} collection
 * @param  {Function|Object} matcher
 *
 * @return {Object}
 */
function find(collection, matcher) {

  matcher = toMatcher(matcher);

  var match;

  forEach(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}
 */
function findIndex(collection, matcher) {

  matcher = toMatcher(matcher);

  var idx = isArray(collection) ? -1 : undefined;

  forEach(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
 */
function filter(collection, matcher) {

  var result = [];

  forEach(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
 */
function forEach(collection, iterator) {

  if (isUndefined(collection)) {
    return;
  }

  var convertKey = isArray(collection) ? toNum : identity;

  for (var key in collection) {

    if (has(collection, key)) {
      var val = collection[key];

      var result = iterator(val, convertKey(key));

      if (result === false) {
        return;
      }
    }
  }
}

/**
 * Return collection without element.
 *
 * @param  {Array} arr
 * @param  {Function} matcher
 *
 * @return {Array}
 */
function without(arr, matcher) {

  if (isUndefined(arr)) {
    return [];
  }

  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
 */
function reduce(collection, iterator, result) {

  forEach(collection, function (value, idx) {
    result = iterator(result, value, idx);
  });

  return result;
}

/**
 * Return true if every element in the collection
 * matches the criteria.
 *
 * @param  {Object|Array} collection
 * @param  {Function} matcher
 *
 * @return {Boolean}
 */
function every(collection, matcher) {

  return reduce(collection, function (matches, val, key) {
    return matches && matcher(val, key);
  }, true);
}

/**
 * Return true if some elements in the collection
 * match the criteria.
 *
 * @param  {Object|Array} collection
 * @param  {Function} matcher
 *
 * @return {Boolean}
 */
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
 */
function map(collection, fn) {

  var result = [];

  forEach(collection, function (val, key) {
    result.push(fn(val, key));
  });

  return result;
}

/**
 * Get the collections keys.
 *
 * @param  {Object|Array} collection
 *
 * @return {Array}
 */
function keys(collection) {
  return collection && Object.keys(collection) || [];
}

/**
 * Shorthand for `keys(o).length`.
 *
 * @param  {Object|Array} collection
 *
 * @return {Number}
 */
function size(collection) {
  return keys(collection).length;
}

/**
 * Get the values in the collection.
 *
 * @param  {Object|Array} collection
 *
 * @return {Array}
 */
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 ] }
 */
function groupBy(collection, extractor) {
  var grouped = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};

  extractor = toExtractor(extractor);

  forEach(collection, function (val) {
    var discriminator = extractor(val) || '_';

    var group = grouped[discriminator];

    if (!group) {
      group = grouped[discriminator] = [];
    }

    group.push(val);
  });

  return grouped;
}

function uniqueBy(extractor) {

  extractor = toExtractor(extractor);

  var grouped = {};

  for (var _len = arguments.length, collections = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
    collections[_key - 1] = arguments[_key];
  }

  forEach(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}
 */
function sortBy(collection, extractor) {

  extractor = toExtractor(extractor);

  var sorted = [];

  forEach(collection, function (value, key) {
    var disc = extractor(value, key);

    var entry = {
      d: disc,
      v: value
    };

    for (var idx = 0; idx < sorted.length; idx++) {
      var d = sorted[idx].d;

      if (disc < d) {
        sorted.splice(idx, 0, entry);
        return;
      }
    }

    // not inserted, append (!)
    sorted.push(entry);
  });

  return map(sorted, function (e) {
    return e.v;
  });
}

/**
 * Create an object pattern matcher.
 *
 * @example
 *
 * const matcher = matchPattern({ id: 1 });
 *
 * var element = find(elements, matcher);
 *
 * @param  {Object} pattern
 *
 * @return {Function} matcherFn
 */
function matchPattern(pattern) {

  return function (el) {

    return every(pattern, function (val, key) {
      return el[key] === val;
    });
  };
}

function toExtractor(extractor) {
  return isFunction(extractor) ? extractor : function (e) {
    return e[extractor];
  };
}

function toMatcher(matcher) {
  return isFunction(matcher) ? matcher : function (e) {
    return e === matcher;
  };
}

function identity(arg) {
  return arg;
}

function toNum(arg) {
  return Number(arg);
}

/**
 * Debounce fn, calling it only once if
 * the given time elapsed between calls.
 *
 * @param  {Function} fn
 * @param  {Number} timeout
 *
 * @return {Function} debounced function
 */
function debounce(fn, timeout) {

  var timer;

  var lastArgs;
  var lastThis;

  var lastNow;

  function fire() {

    var now = Date.now();

    var scheduledDiff = lastNow + timeout - now;

    if (scheduledDiff > 0) {
      return schedule(scheduledDiff);
    }

    fn.apply(lastThis, lastArgs);

    timer = lastNow = lastArgs = lastThis = undefined;
  }

  function schedule(timeout) {
    timer = setTimeout(fire, timeout);
  }

  return function () {

    lastNow = Date.now();

    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }

    lastArgs = args;
    lastThis = this;

    // ensure an execution is scheduled
    if (!timer) {
      schedule(timeout);
    }
  };
}

/**
 * Throttle fn, calling at most once
 * in the given interval.
 *
 * @param  {Function} fn
 * @param  {Number} interval
 *
 * @return {Function} throttled function
 */
function throttle(fn, interval) {

  var throttling = false;

  return function () {

    if (throttling) {
      return;
    }

    fn.apply(undefined, arguments);
    throttling = true;

    setTimeout(function () {
      throttling = false;
    }, interval);
  };
}

/**
 * Bind function against target <this>.
 *
 * @param  {Function} fn
 * @param  {Object}   target
 *
 * @return {Function} bound function
 */
function bind(fn, target) {
  return fn.bind(target);
}

var _extends = Object.assign || function (target) {
  for (var i = 1; i < arguments.length; i++) {
    var source = arguments[i];for (var key in source) {
      if (Object.prototype.hasOwnProperty.call(source, key)) {
        target[key] = source[key];
      }
    }
  }return target;
};

/**
 * Convenience wrapper for `Object.assign`.
 *
 * @param {Object} target
 * @param {...Object} others
 *
 * @return {Object} the target
 */
function assign(target) {
  for (var _len = arguments.length, others = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
    others[_key - 1] = arguments[_key];
  }

  return _extends.apply(undefined, [target].concat(others));
}

/**
 * Pick given properties from the target object.
 *
 * @param {Object} target
 * @param {Array} properties
 *
 * @return {Object} target
 */
function pick(target, properties) {

  var result = {};

  var obj = Object(target);

  forEach(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
 */
function omit(target, properties) {

  var result = {};

  var obj = Object(target);

  forEach(obj, function (prop, key) {

    if (properties.indexOf(key) === -1) {
      result[key] = prop;
    }
  });

  return result;
}

/**
 * Recursively merge `...sources` into given target.
 *
 * Does support merging objects; does not support merging arrays.
 *
 * @param {Object} target
 * @param {...Object} sources
 *
 * @return {Object} the target
 */
function merge(target) {
  for (var _len2 = arguments.length, sources = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
    sources[_key2 - 1] = arguments[_key2];
  }

  if (!sources.length) {
    return target;
  }

  forEach(sources, function (source) {

    // skip non-obj sources, i.e. null
    if (!source || !isObject(source)) {
      return;
    }

    forEach(source, function (sourceVal, key) {

      var targetVal = target[key];

      if (isObject(sourceVal)) {

        if (!isObject(targetVal)) {
          // override target[key] with object
          targetVal = {};
        }

        target[key] = merge(targetVal, sourceVal);
      } else {
        target[key] = sourceVal;
      }
    });
  });

  return target;
}

exports.flatten = flatten;
exports.find = find;
exports.findIndex = findIndex;
exports.filter = filter;
exports.forEach = forEach;
exports.without = without;
exports.reduce = reduce;
exports.every = every;
exports.some = some;
exports.map = map;
exports.keys = keys;
exports.size = size;
exports.values = values;
exports.groupBy = groupBy;
exports.uniqueBy = uniqueBy;
exports.unionBy = unionBy;
exports.sortBy = sortBy;
exports.matchPattern = matchPattern;
exports.debounce = debounce;
exports.throttle = throttle;
exports.bind = bind;
exports.isUndefined = isUndefined;
exports.isDefined = isDefined;
exports.isNil = isNil;
exports.isArray = isArray;
exports.isObject = isObject;
exports.isNumber = isNumber;
exports.isFunction = isFunction;
exports.isString = isString;
exports.ensureArray = ensureArray;
exports.has = has;
exports.assign = assign;
exports.pick = pick;
exports.omit = omit;
exports.merge = merge;

},{}],506:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

/**
 * 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);
  }

  // remove
  if (val === null) {
    return el.removeAttribute(name);
  }

  // set
  el.setAttribute(name, val);

  return el;
}

var indexOf = [].indexOf;

var indexof = function indexof(arr, obj) {
  if (indexOf) return arr.indexOf(obj);
  for (var i = 0; i < arr.length; ++i) {
    if (arr[i] === obj) return i;
  }
  return -1;
};

/**
 * Taken from https://github.com/component/classes
 *
 * Without the component bits.
 */

/**
 * Whitespace regexp.
 */

var re = /\s+/;

/**
 * toString reference.
 */

var toString = Object.prototype.toString;

/**
 * Wrap `el` in a `ClassList`.
 *
 * @param {Element} el
 * @return {ClassList}
 * @api public
 */

function classes(el) {
  return new ClassList(el);
}

/**
 * Initialize a new ClassList for `el`.
 *
 * @param {Element} el
 * @api private
 */

function ClassList(el) {
  if (!el || !el.nodeType) {
    throw new Error('A DOM element reference is required');
  }
  this.el = el;
  this.list = el.classList;
}

/**
 * Add class `name` if not already present.
 *
 * @param {String} name
 * @return {ClassList}
 * @api public
 */

ClassList.prototype.add = function (name) {
  // classList
  if (this.list) {
    this.list.add(name);
    return this;
  }

  // fallback
  var arr = this.array();
  var i = indexof(arr, name);
  if (!~i) arr.push(name);
  this.el.className = arr.join(' ');
  return this;
};

/**
 * Remove class `name` when present, or
 * pass a regular expression to remove
 * any which match.
 *
 * @param {String|RegExp} name
 * @return {ClassList}
 * @api public
 */

ClassList.prototype.remove = function (name) {
  if ('[object RegExp]' == toString.call(name)) {
    return this.removeMatching(name);
  }

  // classList
  if (this.list) {
    this.list.remove(name);
    return this;
  }

  // fallback
  var arr = this.array();
  var i = indexof(arr, name);
  if (~i) arr.splice(i, 1);
  this.el.className = arr.join(' ');
  return this;
};

/**
 * Remove all classes matching `re`.
 *
 * @param {RegExp} re
 * @return {ClassList}
 * @api private
 */

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;
};

/**
 * 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
 */

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;
  }

  // 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);
    }
  }

  return this;
};

/**
 * Return an array of classes.
 *
 * @return {Array}
 * @api public
 */

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;
};

/**
 * Check if class `name` is present.
 *
 * @param {String} name
 * @return {ClassList}
 * @api public
 */

ClassList.prototype.has = ClassList.prototype.contains = function (name) {
  return this.list ? this.list.contains(name) : !!~indexof(this.array(), name);
};

/**
 * Remove all children from the given element.
 */
function clear(el) {

  var c;

  while (el.childNodes.length) {
    c = el.childNodes[0];
    el.removeChild(c);
  }

  return el;
}

/**
 * Element prototype.
 */

var proto = Element.prototype;

/**
 * Vendor function.
 */

var vendor = proto.matchesSelector || proto.webkitMatchesSelector || proto.mozMatchesSelector || proto.msMatchesSelector || proto.oMatchesSelector;

/**
 * Expose `match()`.
 */

var matchesSelector = match;

/**
 * Match `el` to `selector`.
 *
 * @param {Element} el
 * @param {String} selector
 * @return {Boolean}
 * @api public
 */

function match(el, selector) {
  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;
}

var closest = function closest(element, selector, checkYoSelf) {
  var parent = checkYoSelf ? element : element.parentNode;

  while (parent && parent !== document) {
    if (matchesSelector(parent, selector)) return parent;
    parent = parent.parentNode;
  }
};

var bind = window.addEventListener ? 'addEventListener' : 'attachEvent',
    unbind = window.removeEventListener ? 'removeEventListener' : 'detachEvent',
    prefix = bind !== 'addEventListener' ? 'on' : '';

/**
 * Bind `el` event `type` to `fn`.
 *
 * @param {Element} el
 * @param {String} type
 * @param {Function} fn
 * @param {Boolean} capture
 * @return {Function}
 * @api public
 */

var bind_1 = function bind_1(el, type, fn, capture) {
  el[bind](prefix + type, fn, capture || false);
  return fn;
};

/**
 * Unbind `el` event `type`'s callback `fn`.
 *
 * @param {Element} el
 * @param {String} type
 * @param {Function} fn
 * @param {Boolean} capture
 * @return {Function}
 * @api public
 */

var unbind_1 = function unbind_1(el, type, fn, capture) {
  el[unbind](prefix + type, fn, capture || false);
  return fn;
};

var componentEvent = {
  bind: bind_1,
  unbind: unbind_1
};

/**
 * Module dependencies.
 */

/**
 * 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
 */

// Some events don't bubble, so we want to bind to the capture phase instead
// when delegating.
var forceCaptureEvents = ['focus', 'blur'];

var bind$1 = function bind$1(el, selector, type, fn, capture) {
  if (forceCaptureEvents.indexOf(type) !== -1) capture = true;

  return componentEvent.bind(el, type, function (e) {
    var target = e.target || e.srcElement;
    e.delegateTarget = closest(target, selector, true, el);
    if (e.delegateTarget) fn.call(el, e);
  }, capture);
};

/**
 * Unbind event `type`'s callback `fn`.
 *
 * @param {Element} el
 * @param {String} type
 * @param {Function} fn
 * @param {Boolean} capture
 * @api public
 */

var unbind$1 = function unbind$1(el, type, fn, capture) {
  if (forceCaptureEvents.indexOf(type) !== -1) capture = true;

  componentEvent.unbind(el, type, fn, capture);
};

var delegateEvents = {
  bind: bind$1,
  unbind: unbind$1
};

/**
 * Expose `parse`.
 */

var domify = parse;

/**
 * Tests for browser support.
 */

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;
}

/**
 * Wrap map from jquery.
 */

var map = {
  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, '', '']
};

map.td = map.th = [3, '<table><tbody><tr>', '</tr></tbody></table>'];

map.option = map.optgroup = [1, '<select multiple="multiple">', '</select>'];

map.thead = map.tbody = map.colgroup = map.caption = map.tfoot = [1, '<table>', '</table>'];

map.polyline = map.ellipse = map.polygon = map.circle = map.text = map.line = map.path = map.rect = map.g = [1, '<svg xmlns="http://www.w3.org/2000/svg" version="1.1">', '</svg>'];

/**
 * 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
 */

function parse(html, doc) {
  if ('string' != typeof html) throw new TypeError('String expected');

  // default to the global `document` object
  if (!doc) doc = document;

  // tag name
  var m = /<([\w:]+)/.exec(html);
  if (!m) return doc.createTextNode(html);

  html = html.replace(/^\s+|\s+$/g, ''); // Remove leading/trailing whitespace

  var tag = m[1];

  // body support
  if (tag == 'body') {
    var el = doc.createElement('html');
    el.innerHTML = html;
    return el.removeChild(el.lastChild);
  }

  // wrap map
  var wrap = map[tag] || map._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;
  } // one element
  if (el.firstChild == el.lastChild) {
    return el.removeChild(el.firstChild);
  }

  // several elements
  var fragment = doc.createDocumentFragment();
  while (el.firstChild) {
    fragment.appendChild(el.removeChild(el.firstChild));
  }

  return fragment;
}

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;

var matchesSelector$1 = match$1;

/**
 * Match `el` to `selector`.
 *
 * @param {Element} el
 * @param {String} selector
 * @return {Boolean}
 * @api public
 */

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;
}

function query(selector, el) {
  el = el || document;

  return el.querySelector(selector);
}

function all(selector, el) {
  el = el || document;

  return el.querySelectorAll(selector);
}

function remove(el) {
  el.parentNode && el.parentNode.removeChild(el);
}

exports.attr = attr;
exports.classes = classes;
exports.clear = clear;
exports.closest = closest;
exports.delegate = delegateEvents;
exports.domify = domify;
exports.event = componentEvent;
exports.matches = matchesSelector$1;
exports.query = query;
exports.queryAll = all;
exports.remove = remove;

},{}],507:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _read = require('./lib/read');

Object.defineProperty(exports, 'Reader', {
  enumerable: true,
  get: function get() {
    return _read.Reader;
  }
});

var _write = require('./lib/write');

Object.defineProperty(exports, 'Writer', {
  enumerable: true,
  get: function get() {
    return _write.Writer;
  }
});

},{"./lib/read":509,"./lib/write":510}],508:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.hasLowerCaseAlias = hasLowerCaseAlias;
exports.serializeAsType = serializeAsType;
exports.serializeAsProperty = serializeAsProperty;
function hasLowerCaseAlias(pkg) {
  return pkg.xml && pkg.xml.tagAlias === 'lowerCase';
}

var DEFAULT_NS_MAP = exports.DEFAULT_NS_MAP = {
  'xsi': 'http://www.w3.org/2001/XMLSchema-instance'
};

var XSI_TYPE = exports.XSI_TYPE = 'xsi:type';

function serializeFormat(element) {
  return element.xml && element.xml.serialize;
}

function serializeAsType(element) {
  return serializeFormat(element) === XSI_TYPE;
}

function serializeAsProperty(element) {
  return serializeFormat(element) === 'property';
}

},{}],509:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.Context = Context;
exports.ElementHandler = ElementHandler;
exports.Reader = Reader;

var _minDash = require('min-dash');

var _tinyStack = require('tiny-stack');

var _tinyStack2 = _interopRequireDefault(_tinyStack);

var _saxen = require('saxen');

var _moddle = require('moddle');

var _moddle2 = _interopRequireDefault(_moddle);

var _ns = require('moddle/lib/ns');

var _types = require('moddle/lib/types');

var _common = require('./common');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function capitalize(str) {
  return str.charAt(0).toUpperCase() + str.slice(1);
}

function aliasToName(aliasNs, pkg) {

  if (!(0, _common.hasLowerCaseAlias)(pkg)) {
    return aliasNs.name;
  }

  return aliasNs.prefix + ':' + capitalize(aliasNs.localName);
}

function prefixedToName(nameNs, pkg) {

  var name = nameNs.name,
      localName = nameNs.localName;

  var typePrefix = pkg.xml && pkg.xml.typePrefix;

  if (typePrefix && localName.indexOf(typePrefix) === 0) {
    return nameNs.prefix + ':' + localName.slice(typePrefix.length);
  } else {
    return name;
  }
}

function normalizeXsiTypeName(name, model) {

  var nameNs = (0, _ns.parseName)(name);
  var pkg = model.getPackage(nameNs.prefix);

  return prefixedToName(nameNs, pkg);
}

function error(message) {
  return new Error(message);
}

/**
 * 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;
}

function defer(fn) {
  setTimeout(fn, 0);
}

/**
 * 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) {

  /**
   * @property {ElementHandler} rootHandler
   */

  /**
   * @property {Boolean} lax
   */

  (0, _minDash.assign)(this, options);

  this.elementsById = {};
  this.references = [];
  this.warnings = [];

  /**
   * Add an unresolved reference.
   *
   * @param {Object} reference
   */
  this.addReference = function (reference) {
    this.references.push(reference);
  };

  /**
   * Add a processed element.
   *
   * @param {ModdleElement} element
   */
  this.addElement = function (element) {

    if (!element) {
      throw error('expected element');
    }

    var elementsById = this.elementsById;

    var descriptor = getModdleDescriptor(element);

    var idProperty = descriptor.idProperty,
        id;

    if (idProperty) {
      id = element.get(idProperty.name);

      if (id) {

        if (elementsById[id]) {
          throw error('duplicate ID <' + id + '>');
        }

        elementsById[id] = element;
      }
    }
  };

  /**
   * Add an import warning.
   *
   * @param {Object} warning
   * @param {String} warning.message
   * @param {Error} [warning.error]
   */
  this.addWarning = function (warning) {
    this.warnings.push(warning);
  };
}

function BaseHandler() {}

BaseHandler.prototype.handleEnd = function () {};
BaseHandler.prototype.handleText = function () {};
BaseHandler.prototype.handleNode = function () {};

/**
 * 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() {}

NoopHandler.prototype = Object.create(BaseHandler.prototype);

NoopHandler.prototype.handleNode = function () {
  return this;
};

function BodyHandler() {}

BodyHandler.prototype = Object.create(BaseHandler.prototype);

BodyHandler.prototype.handleText = function (text) {
  this.body = (this.body || '') + text;
};

function ReferenceHandler(property, context) {
  this.property = property;
  this.context = context;
}

ReferenceHandler.prototype = Object.create(BodyHandler.prototype);

ReferenceHandler.prototype.handleNode = function (node) {

  if (this.element) {
    throw error('expected no sub nodes');
  } else {
    this.element = this.createReference(node);
  }

  return this;
};

ReferenceHandler.prototype.handleEnd = function () {
  this.element.id = this.body;
};

ReferenceHandler.prototype.createReference = function (node) {
  return {
    property: this.property.ns.name,
    id: ''
  };
};

function ValueHandler(propertyDesc, element) {
  this.element = element;
  this.propertyDesc = propertyDesc;
}

ValueHandler.prototype = Object.create(BodyHandler.prototype);

ValueHandler.prototype.handleEnd = function () {

  var value = this.body || '',
      element = this.element,
      propertyDesc = this.propertyDesc;

  value = (0, _types.coerceType)(propertyDesc.type, value);

  if (propertyDesc.isMany) {
    element.get(propertyDesc.name).push(value);
  } else {
    element.set(propertyDesc.name, value);
  }
};

function BaseElementHandler() {}

BaseElementHandler.prototype = Object.create(BodyHandler.prototype);

BaseElementHandler.prototype.handleNode = function (node) {
  var parser = this,
      element = this.element;

  if (!element) {
    element = this.element = this.createElement(node);

    this.context.addElement(element);
  } else {
    parser = this.handleChild(node);
  }

  return parser;
};

/**
 * @class Reader.ElementHandler
 *
 */
function ElementHandler(model, typeName, context) {
  this.model = model;
  this.type = model.getType(typeName);
  this.context = context;
}

ElementHandler.prototype = Object.create(BaseElementHandler.prototype);

ElementHandler.prototype.addReference = function (reference) {
  this.context.addReference(reference);
};

ElementHandler.prototype.handleEnd = function () {

  var value = this.body,
      element = this.element,
      descriptor = getModdleDescriptor(element),
      bodyProperty = descriptor.bodyProperty;

  if (bodyProperty && value !== undefined) {
    value = (0, _types.coerceType)(bodyProperty.type, value);
    element.set(bodyProperty.name, value);
  }
};

/**
 * 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;

  (0, _minDash.forEach)(attributes, function (value, name) {

    var prop = descriptor.propertiesByName[name],
        values;

    if (prop && prop.isReference) {

      if (!prop.isMany) {
        context.addReference({
          element: instance,
          property: prop.ns.name,
          id: value
        });
      } else {
        // IDREFS: parse references as whitespace-separated list
        values = value.split(' ');

        (0, _minDash.forEach)(values, function (v) {
          context.addReference({
            element: instance,
            property: prop.ns.name,
            id: v
          });
        });
      }
    } else {
      if (prop) {
        value = (0, _types.coerceType)(prop.type, value);
      } else if (name !== 'xmlns') {
        propNameNs = (0, _ns.parseName)(name, descriptor.ns.prefix);

        // 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)) {

          context.addWarning({
            message: 'unknown attribute <' + name + '>',
            element: instance,
            property: name,
            value: value
          });
        }
      }

      instance.set(name, value);
    }
  });

  return instance;
};

ElementHandler.prototype.getPropertyForNode = function (node) {

  var name = node.name;
  var nameNs = (0, _ns.parseName)(name);

  var type = this.type,
      model = this.model,
      descriptor = getModdleDescriptor(type);

  var propertyName = nameNs.name,
      property = descriptor.propertiesByName[propertyName],
      elementTypeName,
      elementType;

  // search for properties by name first

  if (property) {

    if ((0, _common.serializeAsType)(property)) {
      elementTypeName = node.attributes[_common.XSI_TYPE];

      // xsi type is optional, if it does not exists the
      // default type is assumed
      if (elementTypeName) {

        // take possible type prefixes from XML
        // into account, i.e.: xsi:type="t{ActualType}"
        elementTypeName = normalizeXsiTypeName(elementTypeName, model);

        elementType = model.getType(elementTypeName);

        return (0, _minDash.assign)({}, property, {
          effectiveType: getModdleDescriptor(elementType).name
        });
      }
    }

    // search for properties by name first
    return property;
  }

  var pkg = model.getPackage(nameNs.prefix);

  if (pkg) {
    elementTypeName = aliasToName(nameNs, pkg);
    elementType = model.getType(elementTypeName);

    // search for collection members later
    property = (0, _minDash.find)(descriptor.properties, function (p) {
      return !p.isVirtual && !p.isReference && !p.isAttribute && elementType.hasType(p.type);
    });

    if (property) {
      return (0, _minDash.assign)({}, property, {
        effectiveType: getModdleDescriptor(elementType).name
      });
    }
  } else {
    // parse unknown element (maybe extension)
    property = (0, _minDash.find)(descriptor.properties, function (p) {
      return !p.isReference && !p.isAttribute && p.type === 'Element';
    });

    if (property) {
      return property;
    }
  }

  throw error('unrecognized element <' + nameNs.name + '>');
};

ElementHandler.prototype.toString = function () {
  return 'ElementDescriptor[' + getModdleDescriptor(this.type).name + ']';
};

ElementHandler.prototype.valueHandler = function (propertyDesc, element) {
  return new ValueHandler(propertyDesc, element);
};

ElementHandler.prototype.referenceHandler = function (propertyDesc) {
  return new ReferenceHandler(propertyDesc, this.context);
};

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);
  }
};

/**
 * Handle the child element parsing
 *
 * @param  {Element} node the xml node
 */
ElementHandler.prototype.handleChild = function (node) {
  var propertyDesc, type, element, childHandler;

  propertyDesc = this.getPropertyForNode(node);
  element = this.element;

  type = propertyDesc.effectiveType || propertyDesc.type;

  if ((0, _types.isSimple)(type)) {
    return this.valueHandler(propertyDesc, element);
  }

  if (propertyDesc.isReference) {
    childHandler = this.referenceHandler(propertyDesc).handleNode(node);
  } else {
    childHandler = this.handler(type).handleNode(node);
  }

  var newElement = childHandler.element;

  // child handles may decide to skip elements
  // by not returning anything
  if (newElement !== undefined) {

    if (propertyDesc.isMany) {
      element.get(propertyDesc.name).push(newElement);
    } else {
      element.set(propertyDesc.name, newElement);
    }

    if (propertyDesc.isReference) {
      (0, _minDash.assign)(newElement, {
        element: element
      });

      this.context.addReference(newElement);
    } else {
      // establish child -> parent relationship
      newElement.$parent = element;
    }
  }

  return childHandler;
};

/**
 * 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);
}

RootElementHandler.prototype = Object.create(ElementHandler.prototype);

RootElementHandler.prototype.createElement = function (node) {

  var name = node.name,
      nameNs = (0, _ns.parseName)(name),
      model = this.model,
      type = this.type,
      pkg = model.getPackage(nameNs.prefix),
      typeName = pkg && aliasToName(nameNs, pkg) || name;

  // 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('unexpected element <' + node.originalName + '>');
  }

  return ElementHandler.prototype.createElement.call(this, node);
};

function GenericElementHandler(model, typeName, context) {
  this.model = model;
  this.context = context;
}

GenericElementHandler.prototype = Object.create(BaseElementHandler.prototype);

GenericElementHandler.prototype.createElement = function (node) {

  var name = node.name,
      ns = (0, _ns.parseName)(name),
      prefix = ns.prefix,
      uri = node.ns[prefix + '$uri'],
      attributes = node.attributes;

  return this.model.createAny(name, uri, attributes);
};

GenericElementHandler.prototype.handleChild = function (node) {

  var handler = new GenericElementHandler(this.model, 'Element', this.context).handleNode(node),
      element = this.element;

  var newElement = handler.element,
      children;

  if (newElement !== undefined) {
    children = element.$children = element.$children || [];
    children.push(newElement);

    // establish child -> parent relationship
    newElement.$parent = element;
  }

  return handler;
};

GenericElementHandler.prototype.handleText = function (text) {
  this.body = this.body || '' + text;
};

GenericElementHandler.prototype.handleEnd = function () {
  if (this.body) {
    this.element.$body = this.body;
  }
};

/**
 * 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) {

  if (options instanceof _moddle2.default) {
    options = {
      model: options
    };
  }

  (0, _minDash.assign)(this, { lax: false }, options);
}

/**
 * Parse the given XML into a moddle document tree.
 *
 * @param {String} xml
 * @param {ElementHandler|Object} options or rootHandler
 * @param  {Function} done
 */
Reader.prototype.fromXML = function (xml, options, done) {

  var rootHandler = options.rootHandler;

  if (options instanceof ElementHandler) {
    // root handler passed via (xml, { rootHandler: ElementHandler }, ...)
    rootHandler = options;
    options = {};
  } else {
    if (typeof options === 'string') {
      // rootHandler passed via (xml, 'someString', ...)
      rootHandler = this.handler(options);
      options = {};
    } else if (typeof rootHandler === 'string') {
      // rootHandler passed via (xml, { rootHandler: 'someString' }, ...)
      rootHandler = this.handler(rootHandler);
    }
  }

  var model = this.model,
      lax = this.lax;

  var context = new Context((0, _minDash.assign)({}, options, { rootHandler: rootHandler })),
      parser = new _saxen.Parser({ proxy: true }),
      stack = new _tinyStack2.default();

  rootHandler.context = context;

  // push root handler
  stack.push(rootHandler);

  /**
   * Handle error.
   *
   * @param  {Error} err
   * @param  {Function} getContext
   * @param  {boolean} lax
   *
   * @return {boolean} true if handled
   */
  function handleError(err, getContext, lax) {

    var ctx = getContext();

    var line = ctx.line,
        column = ctx.column,
        data = ctx.data;

    // 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(' ')) + '>';
    }

    var message = 'unparsable content ' + (data ? data + ' ' : '') + 'detected\n\t' + 'line: ' + line + '\n\t' + 'column: ' + column + '\n\t' + 'nested error: ' + err.message;

    if (lax) {
      context.addWarning({
        message: message,
        error: err
      });

      console.warn('could not parse node');
      console.warn(err);

      return true;
    } else {
      console.error('could not parse document');
      console.error(err);

      throw error(message);
    }
  }

  function handleWarning(err, getContext) {
    // just like handling errors in <lax=true> mode
    return handleError(err, getContext, true);
  }

  /**
   * Resolve collected references on parse end.
   */
  function resolveReferences() {

    var elementsById = context.elementsById;
    var references = context.references;

    var i, r;

    for (i = 0; r = references[i]; i++) {
      var element = r.element;
      var reference = elementsById[r.id];
      var property = getModdleDescriptor(element).propertiesByName[r.property];

      if (!reference) {
        context.addWarning({
          message: 'unresolved reference <' + r.id + '>',
          element: r.element,
          property: r.property,
          value: r.id
        });
      }

      if (property.isMany) {
        var collection = element.get(property.name),
            idx = collection.indexOf(r);

        // we replace an existing place holder (idx != -1) or
        // append to the collection instead
        if (idx === -1) {
          idx = collection.length;
        }

        if (!reference) {
          // remove unresolvable reference
          collection.splice(idx, 1);
        } else {
          // add or update reference in collection
          collection[idx] = reference;
        }
      } else {
        element.set(property.name, reference);
      }
    }
  }

  function handleClose() {
    stack.pop().handleEnd();
  }

  var PREAMBLE_START_PATTERN = /^<\?xml /i;

  var ENCODING_PATTERN = / encoding="([^"]+)"/i;

  var UTF_8_PATTERN = /^utf-8$/i;

  function handleQuestion(question) {

    if (!PREAMBLE_START_PATTERN.test(question)) {
      return;
    }

    var match = ENCODING_PATTERN.exec(question);
    var encoding = match && match[1];

    if (!encoding || UTF_8_PATTERN.test(encoding)) {
      return;
    }

    context.addWarning({
      message: 'unsupported document encoding <' + encoding + '>, ' + 'falling back to UTF-8'
    });
  }

  function handleOpen(node, getContext) {
    var handler = stack.peek();

    try {
      stack.push(handler.handleNode(node));
    } catch (err) {

      if (handleError(err, getContext, lax)) {
        stack.push(new NoopHandler());
      }
    }
  }

  function handleCData(text) {
    stack.peek().handleText(text);
  }

  function handleText(text) {
    // strip whitespace only nodes, i.e. before
    // <!CDATA[ ... ]> sections and in between tags
    text = text.trim();

    if (!text) {
      return;
    }

    stack.peek().handleText(text);
  }

  var uriMap = model.getPackages().reduce(function (uriMap, p) {
    uriMap[p.uri] = p.prefix;

    return uriMap;
  }, {});

  parser.ns(uriMap).on('openTag', function (obj, decodeStr, selfClosing, getContext) {

    // gracefully handle unparsable attributes (attrs=false)
    var attrs = obj.attrs || {};

    var decodedAttrs = Object.keys(attrs).reduce(function (d, key) {
      var value = decodeStr(attrs[key]);

      d[key] = value;

      return d;
    }, {});

    var node = {
      name: obj.name,
      originalName: obj.originalName,
      attributes: decodedAttrs,
      ns: obj.ns
    };

    handleOpen(node, getContext);
  }).on('question', handleQuestion).on('closeTag', handleClose).on('cdata', handleCData).on('text', function (text, decodeEntities) {
    handleText(decodeEntities(text));
  }).on('error', handleError).on('warn', handleWarning);

  // deferred parse XML to make loading really ascnchronous
  // this ensures the execution environment (node or browser)
  // is kept responsive and that certain optimization strategies
  // can kick in
  defer(function () {
    var err;

    try {
      parser.parse(xml);

      resolveReferences();
    } catch (e) {
      err = e;
    }

    var element = rootHandler.element;

    // handle the situation that we could not extract
    // the desired root element from the document
    if (!err && !element) {
      err = error('failed to parse document as <' + rootHandler.type.$descriptor.name + '>');
    }

    done(err, err ? undefined : element, context);
  });
};

Reader.prototype.handler = function (name) {
  return new RootElementHandler(this.model, name);
};

},{"./common":508,"min-dash":505,"moddle":511,"moddle/lib/ns":516,"moddle/lib/types":519,"saxen":524,"tiny-stack":534}],510:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.Namespaces = Namespaces;
exports.Writer = Writer;

var _minDash = require('min-dash');

var _types = require('moddle/lib/types');

var _ns = require('moddle/lib/ns');

var _common = require('./common');

var XML_PREAMBLE = '<?xml version="1.0" encoding="UTF-8"?>\n';

var ESCAPE_ATTR_CHARS = /<|>|'|"|&|\n\r|\n/g;
var ESCAPE_CHARS = /<|>|&/g;

function Namespaces(parent) {

  var prefixMap = {};
  var uriMap = {};
  var used = {};

  var wellknown = [];
  var custom = [];

  // API

  this.byUri = function (uri) {
    return uriMap[uri] || parent && parent.byUri(uri);
  };

  this.add = function (ns, isWellknown) {

    uriMap[ns.uri] = ns;

    if (isWellknown) {
      wellknown.push(ns);
    } else {
      custom.push(ns);
    }

    this.mapPrefix(ns.prefix, ns.uri);
  };

  this.uriByPrefix = function (prefix) {
    return prefixMap[prefix || 'xmlns'];
  };

  this.mapPrefix = function (prefix, uri) {
    prefixMap[prefix || 'xmlns'] = uri;
  };

  this.logUsed = function (ns) {
    var uri = ns.uri;

    used[uri] = this.byUri(uri);
  };

  this.getUsed = function (ns) {

    function isUsed(ns) {
      return used[ns.uri];
    }

    var allNs = [].concat(wellknown, custom);

    return allNs.filter(isUsed);
  };
}

function lower(string) {
  return string.charAt(0).toLowerCase() + string.slice(1);
}

function nameToAlias(name, pkg) {
  if ((0, _common.hasLowerCaseAlias)(pkg)) {
    return lower(name);
  } else {
    return name;
  }
}

function inherits(ctor, superCtor) {
  ctor.super_ = superCtor;
  ctor.prototype = Object.create(superCtor.prototype, {
    constructor: {
      value: ctor,
      enumerable: false,
      writable: true,
      configurable: true
    }
  });
}

function nsName(ns) {
  if ((0, _minDash.isString)(ns)) {
    return ns;
  } else {
    return (ns.prefix ? ns.prefix + ':' : '') + ns.localName;
  }
}

function getNsAttrs(namespaces) {

  return (0, _minDash.map)(namespaces.getUsed(), function (ns) {
    var name = 'xmlns' + (ns.prefix ? ':' + ns.prefix : '');
    return { name: name, value: ns.uri };
  });
}

function getElementNs(ns, descriptor) {
  if (descriptor.isGeneric) {
    return (0, _minDash.assign)({ localName: descriptor.ns.localName }, ns);
  } else {
    return (0, _minDash.assign)({ localName: nameToAlias(descriptor.ns.localName, descriptor.$pkg) }, ns);
  }
}

function getPropertyNs(ns, descriptor) {
  return (0, _minDash.assign)({ localName: descriptor.ns.localName }, ns);
}

function getSerializableProperties(element) {
  var descriptor = element.$descriptor;

  return (0, _minDash.filter)(descriptor.properties, function (p) {
    var name = p.name;

    if (p.isVirtual) {
      return false;
    }

    // do not serialize defaults
    if (!element.hasOwnProperty(name)) {
      return false;
    }

    var value = element[name];

    // do not serialize default equals
    if (value === p.default) {
      return false;
    }

    // do not serialize null properties
    if (value === null) {
      return false;
    }

    return p.isMany ? value.length : true;
  });
}

var ESCAPE_ATTR_MAP = {
  '\n': '#10',
  '\n\r': '#10',
  '"': '#34',
  '\'': '#39',
  '<': '#60',
  '>': '#62',
  '&': '#38'
};

var ESCAPE_MAP = {
  '<': 'lt',
  '>': 'gt',
  '&': 'amp'
};

function escape(str, charPattern, replaceMap) {

  // ensure we are handling strings here
  str = (0, _minDash.isString)(str) ? str : '' + str;

  return str.replace(charPattern, function (s) {
    return '&' + replaceMap[s] + ';';
  });
}

/**
 * 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);
}

function escapeBody(str) {
  return escape(str, ESCAPE_CHARS, ESCAPE_MAP);
}

function filterAttributes(props) {
  return (0, _minDash.filter)(props, function (p) {
    return p.isAttr;
  });
}

function filterContained(props) {
  return (0, _minDash.filter)(props, function (p) {
    return !p.isAttr;
  });
}

function ReferenceSerializer(tagName) {
  this.tagName = tagName;
}

ReferenceSerializer.prototype.build = function (element) {
  this.element = element;
  return this;
};

ReferenceSerializer.prototype.serializeTo = function (writer) {
  writer.appendIndent().append('<' + this.tagName + '>' + this.element.id + '</' + this.tagName + '>').appendNewLine();
};

function BodySerializer() {}

BodySerializer.prototype.serializeValue = BodySerializer.prototype.serializeTo = function (writer) {
  writer.append(this.escape ? escapeBody(this.value) : this.value);
};

BodySerializer.prototype.build = function (prop, value) {
  this.value = value;

  if (prop.type === 'String' && value.search(ESCAPE_CHARS) !== -1) {
    this.escape = true;
  }

  return this;
};

function ValueSerializer(tagName) {
  this.tagName = tagName;
}

inherits(ValueSerializer, BodySerializer);

ValueSerializer.prototype.serializeTo = function (writer) {

  writer.appendIndent().append('<' + this.tagName + '>');

  this.serializeValue(writer);

  writer.append('</' + this.tagName + '>').appendNewLine();
};

function ElementSerializer(parent, propertyDescriptor) {
  this.body = [];
  this.attrs = [];

  this.parent = parent;
  this.propertyDescriptor = propertyDescriptor;
}

ElementSerializer.prototype.build = function (element) {
  this.element = element;

  var elementDescriptor = element.$descriptor,
      propertyDescriptor = this.propertyDescriptor;

  var otherAttrs, properties;

  var isGeneric = elementDescriptor.isGeneric;

  if (isGeneric) {
    otherAttrs = this.parseGeneric(element);
  } else {
    otherAttrs = this.parseNsAttributes(element);
  }

  if (propertyDescriptor) {
    this.ns = this.nsPropertyTagName(propertyDescriptor);
  } else {
    this.ns = this.nsTagName(elementDescriptor);
  }

  // compute tag name
  this.tagName = this.addTagName(this.ns);

  if (!isGeneric) {
    properties = getSerializableProperties(element);

    this.parseAttributes(filterAttributes(properties));
    this.parseContainments(filterContained(properties));
  }

  this.parseGenericAttributes(element, otherAttrs);

  return this;
};

ElementSerializer.prototype.nsTagName = function (descriptor) {
  var effectiveNs = this.logNamespaceUsed(descriptor.ns);
  return getElementNs(effectiveNs, descriptor);
};

ElementSerializer.prototype.nsPropertyTagName = function (descriptor) {
  var effectiveNs = this.logNamespaceUsed(descriptor.ns);
  return getPropertyNs(effectiveNs, descriptor);
};

ElementSerializer.prototype.isLocalNs = function (ns) {
  return ns.uri === this.ns.uri;
};

/**
 * 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) {

  var ns;

  if ((0, _minDash.isString)(element)) {
    ns = (0, _ns.parseName)(element);
  } else {
    ns = element.ns;
  }

  // return just local name for inherited attributes
  if (element.inherited) {
    return { localName: ns.localName };
  }

  // parse + log effective ns
  var effectiveNs = this.logNamespaceUsed(ns);

  // LOG ACTUAL namespace use
  this.getNamespaces().logUsed(effectiveNs);

  // strip prefix if same namespace like parent
  if (this.isLocalNs(effectiveNs)) {
    return { localName: ns.localName };
  } else {
    return (0, _minDash.assign)({ localName: ns.localName }, effectiveNs);
  }
};

ElementSerializer.prototype.parseGeneric = function (element) {

  var self = this,
      body = this.body;

  var attributes = [];

  (0, _minDash.forEach)(element, function (val, key) {

    var nonNsAttr;

    if (key === '$body') {
      body.push(new BodySerializer().build({ type: 'String' }, val));
    } else if (key === '$children') {
      (0, _minDash.forEach)(val, function (child) {
        body.push(new ElementSerializer(self).build(child));
      });
    } else if (key.indexOf('$') !== 0) {
      nonNsAttr = self.parseNsAttribute(element, key, val);

      if (nonNsAttr) {
        attributes.push({ name: key, value: val });
      }
    }
  });

  return attributes;
};

ElementSerializer.prototype.parseNsAttribute = function (element, name, value) {
  var model = element.$model;

  var nameNs = (0, _ns.parseName)(name);

  var ns;

  // parse xmlns:foo="http://foo.bar"
  if (nameNs.prefix === 'xmlns') {
    ns = { prefix: nameNs.localName, uri: value };
  }

  // parse xmlns="http://foo.bar"
  if (!nameNs.prefix && nameNs.localName === 'xmlns') {
    ns = { uri: value };
  }

  if (!ns) {
    return {
      name: name,
      value: value
    };
  }

  if (model && model.getPackage(value)) {
    // register well known namespace
    this.logNamespace(ns, true, true);
  } else {
    // log custom namespace directly as used
    var actualNs = this.logNamespaceUsed(ns, true);

    this.getNamespaces().logUsed(actualNs);
  }
};

/**
 * 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;

  var genericAttrs = element.$attrs;

  var attributes = [];

  // parse namespace attributes first
  // and log them. push non namespace attributes to a list
  // and process them later
  (0, _minDash.forEach)(genericAttrs, function (value, name) {

    var nonNsAttr = self.parseNsAttribute(element, name, value);

    if (nonNsAttr) {
      attributes.push(nonNsAttr);
    }
  });

  return attributes;
};

ElementSerializer.prototype.parseGenericAttributes = function (element, attributes) {

  var self = this;

  (0, _minDash.forEach)(attributes, function (attr) {

    // do not serialize xsi:type attribute
    // it is set manually based on the actual implementation type
    if (attr.name === _common.XSI_TYPE) {
      return;
    }

    try {
      self.addAttribute(self.nsAttributeName(attr.name), attr.value);
    } catch (e) {
      console.warn('missing namespace information for ', attr.name, '=', attr.value, 'on', element, e);
    }
  });
};

ElementSerializer.prototype.parseContainments = function (properties) {

  var self = this,
      body = this.body,
      element = this.element;

  (0, _minDash.forEach)(properties, function (p) {
    var value = element.get(p.name),
        isReference = p.isReference,
        isMany = p.isMany;

    if (!isMany) {
      value = [value];
    }

    if (p.isBody) {
      body.push(new BodySerializer().build(p, value[0]));
    } else if ((0, _types.isSimple)(p.type)) {
      (0, _minDash.forEach)(value, function (v) {
        body.push(new ValueSerializer(self.addTagName(self.nsPropertyTagName(p))).build(p, v));
      });
    } else if (isReference) {
      (0, _minDash.forEach)(value, function (v) {
        body.push(new ReferenceSerializer(self.addTagName(self.nsPropertyTagName(p))).build(v));
      });
    } else {
      // allow serialization via type
      // rather than element name
      var asType = (0, _common.serializeAsType)(p),
          asProperty = (0, _common.serializeAsProperty)(p);

      (0, _minDash.forEach)(value, function (v) {
        var serializer;

        if (asType) {
          serializer = new TypeSerializer(self, p);
        } else if (asProperty) {
          serializer = new ElementSerializer(self, p);
        } else {
          serializer = new ElementSerializer(self);
        }

        body.push(serializer.build(v));
      });
    }
  });
};

ElementSerializer.prototype.getNamespaces = function (local) {

  var namespaces = this.namespaces,
      parent = this.parent,
      parentNamespaces;

  if (!namespaces) {
    parentNamespaces = parent && parent.getNamespaces();

    if (local || !parentNamespaces) {
      this.namespaces = namespaces = new Namespaces(parentNamespaces);
    } else {
      namespaces = parentNamespaces;
    }
  }

  return namespaces;
};

ElementSerializer.prototype.logNamespace = function (ns, wellknown, local) {
  var namespaces = this.getNamespaces(local);

  var nsUri = ns.uri,
      nsPrefix = ns.prefix;

  var existing = namespaces.byUri(nsUri);

  if (!existing) {
    namespaces.add(ns, wellknown);
  }

  namespaces.mapPrefix(nsPrefix, nsUri);

  return ns;
};

ElementSerializer.prototype.logNamespaceUsed = function (ns, local) {
  var element = this.element,
      model = element.$model,
      namespaces = this.getNamespaces(local);

  // ns may be
  //
  //   * prefix only
  //   * prefix:uri
  //   * localName only

  var prefix = ns.prefix,
      uri = ns.uri,
      newPrefix,
      idx,
      wellknownUri;

  // handle anonymous namespaces (elementForm=unqualified), cf. #23
  if (!prefix && !uri) {
    return { localName: ns.localName };
  }

  wellknownUri = _common.DEFAULT_NS_MAP[prefix] || model && (model.getPackage(prefix) || {}).uri;

  uri = uri || wellknownUri || namespaces.uriByPrefix(prefix);

  if (!uri) {
    throw new Error('no namespace uri given for prefix <' + prefix + '>');
  }

  ns = namespaces.byUri(uri);

  if (!ns) {
    newPrefix = prefix;
    idx = 1;

    // find a prefix that is not mapped yet
    while (namespaces.uriByPrefix(newPrefix)) {
      newPrefix = prefix + '_' + idx++;
    }

    ns = this.logNamespace({ prefix: newPrefix, uri: uri }, wellknownUri === uri);
  }

  if (prefix) {
    namespaces.mapPrefix(prefix, uri);
  }

  return ns;
};

ElementSerializer.prototype.parseAttributes = function (properties) {
  var self = this,
      element = this.element;

  (0, _minDash.forEach)(properties, function (p) {

    var value = element.get(p.name);

    if (p.isReference) {

      if (!p.isMany) {
        value = value.id;
      } else {
        var values = [];
        (0, _minDash.forEach)(value, function (v) {
          values.push(v.id);
        });
        // IDREFS is a whitespace-separated list of references.
        value = values.join(' ');
      }
    }

    self.addAttribute(self.nsAttributeName(p), value);
  });
};

ElementSerializer.prototype.addTagName = function (nsTagName) {
  var actualNs = this.logNamespaceUsed(nsTagName);

  this.getNamespaces().logUsed(actualNs);

  return nsName(nsTagName);
};

ElementSerializer.prototype.addAttribute = function (name, value) {
  var attrs = this.attrs;

  if ((0, _minDash.isString)(value)) {
    value = escapeAttr(value);
  }

  attrs.push({ name: name, value: value });
};

ElementSerializer.prototype.serializeAttributes = function (writer) {
  var attrs = this.attrs,
      namespaces = this.namespaces;

  if (namespaces) {
    attrs = getNsAttrs(namespaces).concat(attrs);
  }

  (0, _minDash.forEach)(attrs, function (a) {
    writer.append(' ').append(nsName(a.name)).append('="').append(a.value).append('"');
  });
};

ElementSerializer.prototype.serializeTo = function (writer) {
  var firstBody = this.body[0],
      indent = firstBody && firstBody.constructor !== BodySerializer;

  writer.appendIndent().append('<' + this.tagName);

  this.serializeAttributes(writer);

  writer.append(firstBody ? '>' : ' />');

  if (firstBody) {

    if (indent) {
      writer.appendNewLine().indent();
    }

    (0, _minDash.forEach)(this.body, function (b) {
      b.serializeTo(writer);
    });

    if (indent) {
      writer.unindent().appendIndent();
    }

    writer.append('</' + this.tagName + '>');
  }

  writer.appendNewLine();
};

/**
 * A serializer for types that handles serialization of data types
 */
function TypeSerializer(parent, propertyDescriptor) {
  ElementSerializer.call(this, parent, propertyDescriptor);
}

inherits(TypeSerializer, ElementSerializer);

TypeSerializer.prototype.parseNsAttributes = function (element) {

  // extracted attributes
  var attributes = ElementSerializer.prototype.parseNsAttributes.call(this, element);

  var descriptor = element.$descriptor;

  // only serialize xsi:type if necessary
  if (descriptor.name === this.propertyDescriptor.type) {
    return attributes;
  }

  var typeNs = this.typeNs = this.nsTagName(descriptor);
  this.getNamespaces().logUsed(this.typeNs);

  // add xsi:type attribute to represent the elements
  // actual type

  var pkg = element.$model.getPackage(typeNs.uri),
      typePrefix = pkg.xml && pkg.xml.typePrefix || '';

  this.addAttribute(this.nsAttributeName(_common.XSI_TYPE), (typeNs.prefix ? typeNs.prefix + ':' : '') + typePrefix + descriptor.ns.localName);

  return attributes;
};

TypeSerializer.prototype.isLocalNs = function (ns) {
  return ns.uri === (this.typeNs || this.ns).uri;
};

function SavingWriter() {
  this.value = '';

  this.write = function (str) {
    this.value += str;
  };
}

function FormatingWriter(out, format) {

  var indent = [''];

  this.append = function (str) {
    out.write(str);

    return this;
  };

  this.appendNewLine = function () {
    if (format) {
      out.write('\n');
    }

    return this;
  };

  this.appendIndent = function () {
    if (format) {
      out.write(indent.join('  '));
    }

    return this;
  };

  this.indent = function () {
    indent.push('');
    return this;
  };

  this.unindent = function () {
    indent.pop();
    return this;
  };
}

/**
 * A writer for meta-model backed document trees
 *
 * @param {Object} options output options to pass into the writer
 */
function Writer(options) {

  options = (0, _minDash.assign)({ format: false, preamble: true }, options || {});

  function toXML(tree, writer) {
    var internalWriter = writer || new SavingWriter();
    var formatingWriter = new FormatingWriter(internalWriter, options.format);

    if (options.preamble) {
      formatingWriter.append(XML_PREAMBLE);
    }

    new ElementSerializer().build(tree).serializeTo(formatingWriter);

    if (!writer) {
      return internalWriter.value;
    }
  }

  return {
    toXML: toXML
  };
}

},{"./common":508,"min-dash":505,"moddle/lib/ns":516,"moddle/lib/types":519}],511:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _moddle = require('./lib/moddle');

Object.defineProperty(exports, 'default', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_moddle).default;
  }
});

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

},{"./lib/moddle":515}],512:[function(require,module,exports){
"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = Base;
/**
 * Moddle base element.
 */
function Base() {}

Base.prototype.get = function (name) {
  return this.$model.properties.get(this, name);
};

Base.prototype.set = function (name, value) {
  this.$model.properties.set(this, name, value);
};

},{}],513:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = DescriptorBuilder;

var _minDash = require('min-dash');

var _ns = require('./ns');

/**
 * A utility to build element descriptors.
 */
function DescriptorBuilder(nameNs) {
  this.ns = nameNs;
  this.name = nameNs.name;
  this.allTypes = [];
  this.allTypesByName = {};
  this.properties = [];
  this.propertiesByName = {};
}

DescriptorBuilder.prototype.build = function () {
  return (0, _minDash.pick)(this, ['ns', 'name', 'allTypes', 'allTypesByName', 'properties', 'propertiesByName', 'bodyProperty', 'idProperty']);
};

/**
 * Add property at given index.
 *
 * @param {Object} p
 * @param {Number} [idx]
 * @param {Boolean} [validate=true]
 */
DescriptorBuilder.prototype.addProperty = function (p, idx, validate) {

  if (typeof idx === 'boolean') {
    validate = idx;
    idx = undefined;
  }

  this.addNamedProperty(p, validate !== false);

  var properties = this.properties;

  if (idx !== undefined) {
    properties.splice(idx, 0, p);
  } else {
    properties.push(p);
  }
};

DescriptorBuilder.prototype.replaceProperty = function (oldProperty, newProperty, replace) {
  var oldNameNs = oldProperty.ns;

  var props = this.properties,
      propertiesByName = this.propertiesByName,
      rename = oldProperty.name !== newProperty.name;

  if (oldProperty.isId) {
    if (!newProperty.isId) {
      throw new Error('property <' + newProperty.ns.name + '> must be id property ' + 'to refine <' + oldProperty.ns.name + '>');
    }

    this.setIdProperty(newProperty, false);
  }

  if (oldProperty.isBody) {

    if (!newProperty.isBody) {
      throw new Error('property <' + newProperty.ns.name + '> must be body property ' + 'to refine <' + oldProperty.ns.name + '>');
    }

    // TODO: Check compatibility
    this.setBodyProperty(newProperty, false);
  }

  // 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');
  }

  // remove old property
  props.splice(idx, 1);

  // 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);

  // make new property available under old name
  propertiesByName[oldNameNs.name] = propertiesByName[oldNameNs.localName] = newProperty;
};

DescriptorBuilder.prototype.redefineProperty = function (p, targetPropertyName, replace) {

  var nsPrefix = p.ns.prefix;
  var parts = targetPropertyName.split('#');

  var name = (0, _ns.parseName)(parts[0], nsPrefix);
  var attrName = (0, _ns.parseName)(parts[1], name.prefix).name;

  var redefinedProperty = this.propertiesByName[attrName];
  if (!redefinedProperty) {
    throw new Error('refined property <' + attrName + '> not found');
  } else {
    this.replaceProperty(redefinedProperty, p, replace);
  }

  delete p.redefines;
};

DescriptorBuilder.prototype.addNamedProperty = function (p, validate) {
  var ns = p.ns,
      propsByName = this.propertiesByName;

  if (validate) {
    this.assertNotDefined(p, ns.name);
    this.assertNotDefined(p, ns.localName);
  }

  propsByName[ns.name] = propsByName[ns.localName] = p;
};

DescriptorBuilder.prototype.removeNamedProperty = function (p) {
  var ns = p.ns,
      propsByName = this.propertiesByName;

  delete propsByName[ns.name];
  delete propsByName[ns.localName];
};

DescriptorBuilder.prototype.setBodyProperty = function (p, validate) {

  if (validate && this.bodyProperty) {
    throw new Error('body property defined multiple times ' + '(<' + this.bodyProperty.ns.name + '>, <' + p.ns.name + '>)');
  }

  this.bodyProperty = p;
};

DescriptorBuilder.prototype.setIdProperty = function (p, validate) {

  if (validate && this.idProperty) {
    throw new Error('id property defined multiple times ' + '(<' + this.idProperty.ns.name + '>, <' + p.ns.name + '>)');
  }

  this.idProperty = p;
};

DescriptorBuilder.prototype.assertNotDefined = function (p, name) {
  var propertyName = p.name,
      definedProperty = this.propertiesByName[propertyName];

  if (definedProperty) {
    throw new Error('property <' + propertyName + '> already defined; ' + 'override of <' + definedProperty.definedBy.ns.name + '#' + definedProperty.ns.name + '> by ' + '<' + p.definedBy.ns.name + '#' + p.ns.name + '> not allowed without redefines');
  }
};

DescriptorBuilder.prototype.hasProperty = function (name) {
  return this.propertiesByName[name];
};

DescriptorBuilder.prototype.addTrait = function (t, inherited) {

  var typesByName = this.allTypesByName,
      types = this.allTypes;

  var typeName = t.name;

  if (typeName in typesByName) {
    return;
  }

  (0, _minDash.forEach)(t.properties, (0, _minDash.bind)(function (p) {

    // clone property to allow extensions
    p = (0, _minDash.assign)({}, p, {
      name: p.ns.localName,
      inherited: inherited
    });

    Object.defineProperty(p, 'definedBy', {
      value: t
    });

    var replaces = p.replaces,
        redefines = p.redefines;

    // add replace/redefine support
    if (replaces || redefines) {
      this.redefineProperty(p, replaces || redefines, replaces);
    } else {
      if (p.isBody) {
        this.setBodyProperty(p);
      }
      if (p.isId) {
        this.setIdProperty(p);
      }
      this.addProperty(p);
    }
  }, this));

  types.push(t);
  typesByName[typeName] = t;
};

},{"./ns":516,"min-dash":505}],514:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = Factory;

var _minDash = require('min-dash');

var _base = require('./base');

var _base2 = _interopRequireDefault(_base);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * A model element factory.
 *
 * @param {Moddle} model
 * @param {Properties} properties
 */
function Factory(model, properties) {
  this.model = model;
  this.properties = properties;
}

Factory.prototype.createType = function (descriptor) {

  var model = this.model;

  var props = this.properties,
      prototype = Object.create(_base2.default.prototype);

  // initialize default values
  (0, _minDash.forEach)(descriptor.properties, function (p) {
    if (!p.isMany && p.default !== undefined) {
      prototype[p.name] = p.default;
    }
  });

  props.defineModel(prototype, model);
  props.defineDescriptor(prototype, descriptor);

  var name = descriptor.ns.name;

  /**
   * 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 });

    (0, _minDash.forEach)(attrs, (0, _minDash.bind)(function (val, key) {
      this.set(key, val);
    }, this));
  }

  ModdleElement.prototype = prototype;

  ModdleElement.hasType = prototype.$instanceOf = this.model.hasType;

  // static links
  props.defineModel(ModdleElement, model);
  props.defineDescriptor(ModdleElement, descriptor);

  return ModdleElement;
};

},{"./base":512,"min-dash":505}],515:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = Moddle;

var _minDash = require('min-dash');

var _factory = require('./factory');

var _factory2 = _interopRequireDefault(_factory);

var _registry = require('./registry');

var _registry2 = _interopRequireDefault(_registry);

var _properties = require('./properties');

var _properties2 = _interopRequireDefault(_properties);

var _ns = require('./ns');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

//// Moddle implementation /////////////////////////////////////////////////

/**
 * @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) {

  this.properties = new _properties2.default(this);

  this.factory = new _factory2.default(this, this.properties);
  this.registry = new _registry2.default(packages, this.properties);

  this.typeCache = {};
}

/**
 * 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);

  if (!Type) {
    throw new Error('unknown type <' + descriptor + '>');
  }

  return new Type(attrs);
};

/**
 * 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) {

  var cache = this.typeCache;

  var name = (0, _minDash.isString)(descriptor) ? descriptor : descriptor.ns.name;

  var type = cache[name];

  if (!type) {
    descriptor = this.registry.getEffectiveDescriptor(name);
    type = cache[name] = this.factory.createType(descriptor);
  }

  return type;
};

/**
 * Creates an any-element type to be used within model instances.
 *
 * This can be used to create custom elements that lie outside the meta-model.
 * The created element contains all the meta-data required to serialize it
 * as part of meta-model elements.
 *
 * @method Moddle#createAny
 *
 * @example
 *
 * var foo = moddle.createAny('vendor:Foo', 'http://vendor', {
 *   value: 'bar'
 * });
 *
 * var container = moddle.create('my:Container', 'http://my', {
 *   any: [ foo ]
 * });
 *
 * // go ahead and serialize the stuff
 *
 *
 * @param  {String} name  the name of the element
 * @param  {String} nsUri the namespace uri of the element
 * @param  {Object} [properties] a map of properties to initialize the instance with
 * @return {Object} the any type instance
 */
Moddle.prototype.createAny = function (name, nsUri, properties) {

  var nameNs = (0, _ns.parseName)(name);

  var element = {
    $type: name,
    $instanceOf: function $instanceOf(type) {
      return type === this.$type;
    }
  };

  var descriptor = {
    name: name,
    isGeneric: true,
    ns: {
      prefix: nameNs.prefix,
      localName: nameNs.localName,
      uri: nsUri
    }
  };

  this.properties.defineDescriptor(element, descriptor);
  this.properties.defineModel(element, this);
  this.properties.define(element, '$parent', { enumerable: false, writable: true });

  (0, _minDash.forEach)(properties, function (a, key) {
    if ((0, _minDash.isObject)(a) && a.value !== undefined) {
      element[a.name] = a.value;
    } else {
      element[key] = a;
    }
  });

  return element;
};

/**
 * Returns a registered package by uri or prefix
 *
 * @return {Object} the package
 */
Moddle.prototype.getPackage = function (uriOrPrefix) {
  return this.registry.getPackage(uriOrPrefix);
};

/**
 * Returns a snapshot of all known packages
 *
 * @return {Object} the package
 */
Moddle.prototype.getPackages = function () {
  return this.registry.getPackages();
};

/**
 * Returns the descriptor for an element
 */
Moddle.prototype.getElementDescriptor = function (element) {
  return element.$descriptor;
};

/**
 * Returns true if the given descriptor or instance
 * represents the given type.
 *
 * May be applied to this, if element is omitted.
 */
Moddle.prototype.hasType = function (element, type) {
  if (type === undefined) {
    type = element;
    element = this;
  }

  var descriptor = element.$model.getElementDescriptor(element);

  return type in descriptor.allTypesByName;
};

/**
 * Returns the descriptor of an elements named property
 */
Moddle.prototype.getPropertyDescriptor = function (element, property) {
  return this.getElementDescriptor(element).propertiesByName[property];
};

/**
 * Returns a mapped type's descriptor
 */
Moddle.prototype.getTypeDescriptor = function (type) {
  return this.registry.typeMap[type];
};

},{"./factory":514,"./ns":516,"./properties":517,"./registry":518,"min-dash":505}],516:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.parseName = parseName;
/**
 * 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;

  // 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);
    }

  name = (prefix ? prefix + ':' : '') + localName;

  return {
    name: name,
    prefix: prefix,
    localName: localName
  };
}

},{}],517:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = Properties;
/**
 * A utility that gets and sets properties of model elements.
 *
 * @param {Model} model
 */
function Properties(model) {
  this.model = model;
}

/**
 * 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) {

  var property = this.model.getPropertyDescriptor(target, name);

  var propertyName = property && property.name;

  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;
    }
  }
};

/**
 * Returns the named property of the given element
 *
 * @param  {Object} target
 * @param  {String} name
 *
 * @return {Object}
 */
Properties.prototype.get = function (target, name) {

  var property = this.model.getPropertyDescriptor(target, name);

  if (!property) {
    return target.$attrs[name];
  }

  var propertyName = property.name;

  // check if access to collection property and lazily initialize it
  if (!target[propertyName] && property.isMany) {
    defineProperty(target, property, []);
  }

  return target[propertyName];
};

/**
 * 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);
};

/**
 * Define the descriptor for an element
 */
Properties.prototype.defineDescriptor = function (target, descriptor) {
  this.define(target, '$descriptor', { value: descriptor });
};

/**
 * Define the model for an element
 */
Properties.prototype.defineModel = function (target, model) {
  this.define(target, '$model', { value: model });
};

function isUndefined(val) {
  return typeof val === 'undefined';
}

function defineProperty(target, property, value) {
  Object.defineProperty(target, property.name, {
    enumerable: !property.isReference,
    writable: true,
    value: value,
    configurable: true
  });
}

},{}],518:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = Registry;

var _minDash = require('min-dash');

var _types = require('./types');

var _descriptorBuilder = require('./descriptor-builder');

var _descriptorBuilder2 = _interopRequireDefault(_descriptorBuilder);

var _ns = require('./ns');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * A registry of Moddle packages.
 *
 * @param {Array<Package>} packages
 * @param {Properties} properties
 */
function Registry(packages, properties) {
  this.packageMap = {};
  this.typeMap = {};

  this.packages = [];

  this.properties = properties;

  (0, _minDash.forEach)(packages, (0, _minDash.bind)(this.registerPackage, this));
}

Registry.prototype.getPackage = function (uriOrPrefix) {
  return this.packageMap[uriOrPrefix];
};

Registry.prototype.getPackages = function () {
  return this.packages;
};

Registry.prototype.registerPackage = function (pkg) {

  // copy package
  pkg = (0, _minDash.assign)({}, pkg);

  var pkgMap = this.packageMap;

  ensureAvailable(pkgMap, pkg, 'prefix');
  ensureAvailable(pkgMap, pkg, 'uri');

  // register types
  (0, _minDash.forEach)(pkg.types, (0, _minDash.bind)(function (descriptor) {
    this.registerType(descriptor, pkg);
  }, this));

  pkgMap[pkg.uri] = pkgMap[pkg.prefix] = pkg;
  this.packages.push(pkg);
};

/**
 * Register a type from a specific package with us
 */
Registry.prototype.registerType = function (type, pkg) {

  type = (0, _minDash.assign)({}, type, {
    superClass: (type.superClass || []).slice(),
    extends: (type.extends || []).slice(),
    properties: (type.properties || []).slice(),
    meta: (0, _minDash.assign)(({}, type.meta || {}))
  });

  var ns = (0, _ns.parseName)(type.name, pkg.prefix),
      name = ns.name,
      propertiesByName = {};

  // parse properties
  (0, _minDash.forEach)(type.properties, (0, _minDash.bind)(function (p) {

    // namespace property names
    var propertyNs = (0, _ns.parseName)(p.name, ns.prefix),
        propertyName = propertyNs.name;

    // namespace property types
    if (!(0, _types.isBuiltIn)(p.type)) {
      p.type = (0, _ns.parseName)(p.type, propertyNs.prefix).name;
    }

    (0, _minDash.assign)(p, {
      ns: propertyNs,
      name: propertyName
    });

    propertiesByName[propertyName] = p;
  }, this));

  // update ns + name
  (0, _minDash.assign)(type, {
    ns: ns,
    name: name,
    propertiesByName: propertiesByName
  });

  (0, _minDash.forEach)(type.extends, (0, _minDash.bind)(function (extendsName) {
    var extended = this.typeMap[extendsName];

    extended.traits = extended.traits || [];
    extended.traits.push(name);
  }, this));

  // link to package
  this.definePackage(type, pkg);

  // register
  this.typeMap[name] = type;
};

/**
 * Traverse the type hierarchy from bottom to top,
 * calling iterator with (type, inherited) for all elements in
 * the inheritance chain.
 *
 * @param {Object} nsName
 * @param {Function} iterator
 * @param {Boolean} [trait=false]
 */
Registry.prototype.mapTypes = function (nsName, iterator, trait) {

  var type = (0, _types.isBuiltIn)(nsName.name) ? { name: nsName.name } : this.typeMap[nsName.name];

  var self = this;

  /**
   * Traverse the selected trait.
   *
   * @param {String} cls
   */
  function traverseTrait(cls) {
    return traverseSuper(cls, true);
  }

  /**
   * Traverse the selected super type or trait
   *
   * @param {String} cls
   * @param {Boolean} [trait=false]
   */
  function traverseSuper(cls, trait) {
    var parentNs = (0, _ns.parseName)(cls, (0, _types.isBuiltIn)(cls) ? '' : nsName.prefix);
    self.mapTypes(parentNs, iterator, trait);
  }

  if (!type) {
    throw new Error('unknown type <' + nsName.name + '>');
  }

  (0, _minDash.forEach)(type.superClass, trait ? traverseTrait : traverseSuper);

  // call iterator with (type, inherited=!trait)
  iterator(type, !trait);

  (0, _minDash.forEach)(type.traits, traverseTrait);
};

/**
 * 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) {

  var nsName = (0, _ns.parseName)(name);

  var builder = new _descriptorBuilder2.default(nsName);

  this.mapTypes(nsName, function (type, inherited) {
    builder.addTrait(type, inherited);
  });

  var descriptor = builder.build();

  // define package link
  this.definePackage(descriptor, descriptor.allTypes[descriptor.allTypes.length - 1].$pkg);

  return descriptor;
};

Registry.prototype.definePackage = function (target, pkg) {
  this.properties.define(target, '$pkg', { value: pkg });
};

///////// helpers ////////////////////////////

function ensureAvailable(packageMap, pkg, identifierKey) {

  var value = pkg[identifierKey];

  if (value in packageMap) {
    throw new Error('package with ' + identifierKey + ' <' + value + '> already defined');
  }
}

},{"./descriptor-builder":513,"./ns":516,"./types":519,"min-dash":505}],519:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.coerceType = coerceType;
exports.isBuiltIn = isBuiltIn;
exports.isSimple = isSimple;
/**
 * Built-in moddle types
 */
var BUILTINS = {
  String: true,
  Boolean: true,
  Integer: true,
  Real: true,
  Element: true
};

/**
 * Converters for built in types from string representations
 */
var TYPE_CONVERTERS = {
  String: function String(s) {
    return s;
  },
  Boolean: function Boolean(s) {
    return s === 'true';
  },
  Integer: function Integer(s) {
    return parseInt(s, 10);
  },
  Real: function Real(s) {
    return parseFloat(s, 10);
  }
};

/**
 * Convert a type to its real representation
 */
function coerceType(type, value) {

  var converter = TYPE_CONVERTERS[type];

  if (converter) {
    return converter(value);
  } else {
    return value;
  }
}

/**
 * Return whether the given type is built-in
 */
function isBuiltIn(type) {
  return !!BUILTINS[type];
}

/**
 * Return whether the given type is simple
 */
function isSimple(type) {
  return !!TYPE_CONVERTERS[type];
}

},{}],520:[function(require,module,exports){
'use strict';

module.exports = require('./lib/refs');

module.exports.Collection = require('./lib/collection');

},{"./lib/collection":521,"./lib/refs":522}],521:[function(require,module,exports){
'use strict';

/**
 * An empty collection stub. Use {@link RefsCollection.extend} to extend a
 * collection with ref semantics.
 *
 * @class RefsCollection
 */

/**
 * 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) {

  var inverseProperty = property.inverse;

  /**
   * 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 value(element) {
      var idx = this.indexOf(element);
      if (idx !== -1) {
        this.splice(idx, 1);

        // unset inverse
        refs.unset(element, inverseProperty, target);
      }

      return element;
    }
  });

  /**
   * 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 value(element) {
      return this.indexOf(element) !== -1;
    }
  });

  /**
   * 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 value(element, idx) {

      var currentIdx = this.indexOf(element);

      if (typeof idx === 'undefined') {

        if (currentIdx !== -1) {
          // element already in collection (!)
          return;
        }

        // add to end of array, as no idx is specified
        idx = this.length;
      }

      // handle already in collection
      if (currentIdx !== -1) {

        // remove element from currentIdx
        this.splice(currentIdx, 1);
      }

      // add element at idx
      this.splice(idx, 0, element);

      if (currentIdx === -1) {
        // set inverse, unless element was
        // in collection already
        refs.set(element, inverseProperty, target);
      }
    }
  });

  // a simple marker, identifying this element
  // as being a refs collection
  Object.defineProperty(collection, '__refs_collection', {
    value: true
  });

  return collection;
}

function isExtended(collection) {
  return collection.__refs_collection === true;
}

module.exports.extend = extend;

module.exports.isExtended = isExtended;

},{}],522:[function(require,module,exports){
'use strict';

var Collection = require('./collection');

function hasOwnProperty(e, property) {
  return Object.prototype.hasOwnProperty.call(e, property.name || property);
}

function defineCollectionProperty(ref, property, target) {

  var collection = Collection.extend(target[property.name] || [], ref, property, target);

  Object.defineProperty(target, property.name, {
    enumerable: property.enumerable,
    value: collection
  });

  if (collection.length) {

    collection.forEach(function (o) {
      ref.set(o, property.inverse, target);
    });
  }
}

function defineProperty(ref, property, target) {

  var inverseProperty = property.inverse;

  var _value = target[property.name];

  Object.defineProperty(target, property.name, {
    configurable: property.configurable,
    enumerable: property.enumerable,

    get: function get() {
      return _value;
    },

    set: function set(value) {

      // return if we already performed all changes
      if (value === _value) {
        return;
      }

      var old = _value;

      // temporary set null
      _value = null;

      if (old) {
        ref.unset(old, inverseProperty, target);
      }

      // set new value
      _value = value;

      // set inverse value
      ref.set(_value, inverseProperty, target);
    }
  });
}

/**
 * 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(a, b) {

  if (!(this instanceof Refs)) {
    return new Refs(a, b);
  }

  // link
  a.inverse = b;
  b.inverse = a;

  this.props = {};
  this.props[a.name] = a;
  this.props[b.name] = b;
}

/**
 * Binds one side of a bi-directional reference to a
 * target object.
 *
 * @memberOf Refs
 *
 * @param  {Object} target
 * @param  {String} property
 */
Refs.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];
  }

  if (property.collection) {
    defineCollectionProperty(this, property, target);
  } else {
    defineProperty(this, property, target);
  }
};

Refs.prototype.ensureRefsCollection = function (target, property) {

  var collection = target[property.name];

  if (!Collection.isExtended(collection)) {
    defineCollectionProperty(this, property, target);
  }

  return collection;
};

Refs.prototype.ensureBound = function (target, property) {
  if (!hasOwnProperty(target, property)) {
    this.bind(target, property);
  }
};

Refs.prototype.unset = function (target, property, value) {

  if (target) {
    this.ensureBound(target, property);

    if (property.collection) {
      this.ensureRefsCollection(target, property).remove(value);
    } else {
      target[property.name] = undefined;
    }
  }
};

Refs.prototype.set = function (target, property, value) {

  if (target) {
    this.ensureBound(target, property);

    if (property.collection) {
      this.ensureRefsCollection(target, property).add(value);
    } else {
      target[property.name] = value;
    }
  }
};

module.exports = Refs;

/**
 * An attribute descriptor to be used specify an attribute in a {@link Refs} instance
 *
 * @typedef {Object} Refs.AttributeDescriptor
 * @property {String} name
 * @property {boolean} [collection=false]
 * @property {boolean} [enumerable=false]
 */

},{"./collection":521}],523:[function(require,module,exports){
'use strict';

/**
 * This file contains portions that got extraced from Snap.svg (licensed Apache-2.0).
 *
 * @see https://github.com/adobe-webplatform/Snap.svg/blob/master/src/path.js
 */

/* eslint no-fallthrough: "off" */

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

var has = 'hasOwnProperty',
    p2s = /,?([a-z]),?/gi,
    toFloat = parseFloat,
    math = Math,
    PI = math.PI,
    mmin = math.min,
    mmax = math.max,
    pow = math.pow,
    abs = math.abs,
    pathCommand = /([a-z])[\s,]*((-?\d*\.?\d*(?:e[-+]?\d+)?[\s]*,?[\s]*)+)/ig,
    pathValues = /(-?\d*\.?\d*(?:e[-+]?\\d+)?)[\s]*,?[\s]*/ig;

function is(o, type) {
  type = String.prototype.toLowerCase.call(type);

  if (type == 'finite') {
    return isFinite(o);
  }

  if (type == 'array' && (o instanceof Array || Array.isArray && Array.isArray(o))) {
    return true;
  }

  return type == 'null' && o === null || type == (typeof o === 'undefined' ? 'undefined' : _typeof(o)) && o !== null || type == 'object' && o === Object(o) || Object.prototype.toString.call(o).slice(8, -1).toLowerCase() == type;
}

function clone(obj) {

  if (typeof obj == 'function' || Object(obj) !== obj) {
    return obj;
  }

  var res = new obj.constructor();

  for (var key in obj) {
    if (obj[has](key)) {
      res[key] = clone(obj[key]);
    }
  }return res;
}

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]);
    }
  }
}

function cacher(f, scope, postprocessor) {

  function newf() {

    var arg = Array.prototype.slice.call(arguments, 0),
        args = arg.join('\u2400'),
        cache = newf.cache = newf.cache || {},
        count = newf.count = newf.count || [];

    if (cache[has](args)) {
      repush(count, args);
      return postprocessor ? postprocessor(cache[args]) : cache[args];
    }

    count.length >= 1e3 && delete cache[count.shift()];
    count.push(args);
    cache[args] = f.apply(scope, arg);

    return postprocessor ? postprocessor(cache[args]) : cache[args];
  }
  return newf;
}

function parsePathString(pathString) {

  if (!pathString) {
    return null;
  }

  var pth = paths(pathString);

  if (pth.arr) {
    return clone(pth.arr);
  }

  var paramCounts = { a: 7, c: 6, o: 2, h: 1, l: 2, m: 2, r: 4, q: 4, s: 4, t: 2, v: 1, u: 3, z: 0 },
      data = [];

  if (is(pathString, 'array') && is(pathString[0], 'array')) {
    // rough assumption
    data = clone(pathString);
  }

  if (!data.length) {

    String(pathString).replace(pathCommand, function (a, b, c) {
      var params = [],
          name = b.toLowerCase();

      c.replace(pathValues, function (a, b) {
        b && params.push(+b);
      });

      if (name == 'm' && params.length > 2) {
        data.push([b].concat(params.splice(0, 2)));
        name = 'l';
        b = b == 'm' ? 'l' : 'L';
      }

      if (name == 'o' && params.length == 1) {
        data.push([b, params[0]]);
      }

      if (name == 'r') {
        data.push([b].concat(params));
      } else while (params.length >= paramCounts[name]) {
        data.push([b].concat(params.splice(0, paramCounts[name])));
        if (!paramCounts[name]) {
          break;
        }
      }
    });
  }

  data.toString = paths.toString;
  pth.arr = clone(data);

  return data;
}

function paths(ps) {
  var p = paths.ps = paths.ps || {};

  if (p[ps]) {
    p[ps].sleep = 100;
  } else {
    p[ps] = {
      sleep: 100
    };
  }

  setTimeout(function () {
    for (var key in p) {
      if (p[has](key) && key != ps) {
        p[key].sleep--;
        !p[key].sleep && delete p[key];
      }
    }
  });

  return p[ps];
}

function box(x, y, width, height) {
  if (x == null) {
    x = y = width = height = 0;
  }

  if (y == null) {
    y = x.y;
    width = x.width;
    height = x.height;
    x = x.x;
  }

  return {
    x: x,
    y: y,
    width: width,
    w: width,
    height: height,
    h: height,
    x2: x + width,
    y2: y + height,
    cx: x + width / 2,
    cy: y + height / 2,
    r1: math.min(width, height) / 2,
    r2: math.max(width, height) / 2,
    r0: math.sqrt(width * width + height * height) / 2,
    path: rectPath(x, y, width, height),
    vb: [x, y, width, height].join(' ')
  };
}

function pathToString() {
  return this.join(',').replace(p2s, '$1');
}

function pathClone(pathArray) {
  var res = clone(pathArray);
  res.toString = pathToString;
  return res;
}

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,
      mx = p1x + 2 * t * (c1x - p1x) + t2 * (c2x - 2 * c1x + p1x),
      my = p1y + 2 * t * (c1y - p1y) + t2 * (c2y - 2 * c1y + p1y),
      nx = c1x + 2 * t * (c2x - c1x) + t2 * (p2x - 2 * c2x + c1x),
      ny = c1y + 2 * t * (c2y - c1y) + t2 * (p2y - 2 * c2y + c1y),
      ax = t1 * p1x + t * c1x,
      ay = t1 * p1y + t * c1y,
      cx = t1 * c2x + t * p2x,
      cy = t1 * c2y + t * p2y,
      alpha = 90 - math.atan2(mx - nx, my - ny) * 180 / PI;

  return {
    x: x,
    y: y,
    m: { x: mx, y: my },
    n: { x: nx, y: ny },
    start: { x: ax, y: ay },
    end: { x: cx, y: cy },
    alpha: alpha
  };
}

function bezierBBox(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y) {

  if (!is(p1x, 'array')) {
    p1x = [p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y];
  }

  var bbox = curveBBox.apply(null, p1x);

  return box(bbox.min.x, bbox.min.y, bbox.max.x - bbox.min.x, bbox.max.y - bbox.min.y);
}

function isPointInsideBBox(bbox, x, y) {
  return x >= bbox.x && x <= bbox.x + bbox.width && y >= bbox.y && y <= bbox.y + bbox.height;
}

function isBBoxIntersect(bbox1, bbox2) {
  bbox1 = box(bbox1);
  bbox2 = box(bbox2);
  return isPointInsideBBox(bbox2, bbox1.x, bbox1.y) || isPointInsideBBox(bbox2, bbox1.x2, bbox1.y) || isPointInsideBBox(bbox2, bbox1.x, bbox1.y2) || isPointInsideBBox(bbox2, bbox1.x2, bbox1.y2) || isPointInsideBBox(bbox1, bbox2.x, bbox2.y) || isPointInsideBBox(bbox1, bbox2.x2, bbox2.y) || isPointInsideBBox(bbox1, bbox2.x, bbox2.y2) || isPointInsideBBox(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);
}

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;
}

function bezlen(x1, y1, x2, y2, x3, y3, x4, y4, z) {

  if (z == null) {
    z = 1;
  }

  z = z > 1 ? 1 : z < 0 ? 0 : z;

  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;

  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;

    sum += Cvalues[i] * math.sqrt(comb);
  }

  return z2 * sum;
}

function intersectLines(x1, y1, x2, y2, x3, y3, x4, y4) {

  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;
  }

  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);

  if (!denominator) {
    return;
  }

  var px = nx / denominator,
      py = ny / denominator,
      px2 = +px.toFixed(2),
      py2 = +py.toFixed(2);

  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;
  }

  return { x: px, y: py };
}

function findBezierIntersections(bez1, bez2, justCount) {
  var bbox1 = bezierBBox(bez1),
      bbox2 = bezierBBox(bez2);

  if (!isBBoxIntersect(bbox1, bbox2)) {
    return justCount ? 0 : [];
  }

  var l1 = bezlen.apply(0, bez1),
      l2 = bezlen.apply(0, bez2),
      n1 = ~~(l1 / 5),
      n2 = ~~(l2 / 5),
      dots1 = [],
      dots2 = [],
      xy = {},
      res = justCount ? 0 : [];

  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 });
  }

  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 });
  }

  for (i = 0; i < n1; i++) {

    for (var j = 0; j < n2; j++) {
      var di = dots1[i],
          di1 = dots1[i + 1],
          dj = dots2[j],
          dj1 = dots2[j + 1],
          ci = abs(di1.x - di.x) < .01 ? 'y' : 'x',
          cj = abs(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);

      if (is) {

        if (xy[is.x.toFixed(0)] == is.y.toFixed(0)) {
          continue;
        }

        xy[is.x.toFixed(0)] = is.y.toFixed(0);

        var t1 = di.t + abs((is[ci] - di[ci]) / (di1[ci] - di[ci])) * (di1.t - di.t),
            t2 = dj.t + abs((is[cj] - dj[cj]) / (dj1[cj] - dj[cj])) * (dj1.t - dj.t);

        if (t1 >= 0 && t1 <= 1 && t2 >= 0 && t2 <= 1) {

          if (justCount) {
            res++;
          } else {
            res.push({
              x: is.x,
              y: is.y,
              t1: t1,
              t2: t2
            });
          }
        }
      }
    }
  }

  return res;
}

/**
 * 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);

  var x1,
      y1,
      x2,
      y2,
      x1m,
      y1m,
      x2m,
      y2m,
      bez1,
      bez2,
      res = justCount ? 0 : [];

  for (var i = 0, ii = path1.length; i < ii; i++) {
    var pi = path1[i];

    if (pi[0] == 'M') {
      x1 = x1m = pi[1];
      y1 = y1m = pi[2];
    } else {

      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;
      }

      for (var j = 0, jj = path2.length; j < jj; j++) {
        var pj = path2[j];

        if (pj[0] == 'M') {
          x2 = x2m = pj[1];
          y2 = y2m = pj[2];
        } else {

          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;
          }

          var intr = findBezierIntersections(bez1, bez2, justCount);

          if (justCount) {
            res += intr;
          } else {

            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;
            }

            res = res.concat(intr);
          }
        }
      }
    }
  }

  return res;
}

function rectPath(x, y, w, h, r) {
  if (r) {
    return [['M', +x + +r, y], ['l', w - r * 2, 0], ['a', r, r, 0, 0, 1, r, r], ['l', 0, h - r * 2], ['a', r, r, 0, 0, 1, -r, r], ['l', r * 2 - w, 0], ['a', r, r, 0, 0, 1, -r, -r], ['l', 0, r * 2 - h], ['a', r, r, 0, 0, 1, r, -r], ['z']];
  }

  var res = [['M', x, y], ['l', w, 0], ['l', 0, h], ['l', -w, 0], ['z']];
  res.toString = pathToString;

  return res;
}

function ellipsePath(x, y, rx, ry, a) {
  if (a == null && ry == null) {
    ry = rx;
  }

  x = +x;
  y = +y;
  rx = +rx;
  ry = +ry;

  if (a != null) {
    var rad = Math.PI / 180,
        x1 = x + rx * Math.cos(-ry * rad),
        x2 = x + rx * Math.cos(-a * rad),
        y1 = y + rx * Math.sin(-ry * rad),
        y2 = y + rx * Math.sin(-a * rad),
        res = [['M', x1, y1], ['A', rx, rx, 0, +(a - ry > 180), 0, x2, y2]];
  } else {
    res = [['M', x, y], ['m', 0, -ry], ['a', rx, ry, 0, 1, 1, 0, 2 * ry], ['a', rx, ry, 0, 1, 1, 0, -2 * ry], ['z']];
  }

  res.toString = pathToString;

  return res;
}

function pathToAbsolute(pathArray) {
  var pth = paths(pathArray);

  if (pth.abs) {
    return pathClone(pth.abs);
  }

  if (!is(pathArray, 'array') || !is(pathArray && pathArray[0], 'array')) {
    // rough assumption
    pathArray = parsePathString(pathArray);
  }

  if (!pathArray || !pathArray.length) {
    return [['M', 0, 0]];
  }

  var res = [],
      x = 0,
      y = 0,
      mx = 0,
      my = 0,
      start = 0,
      pa0;

  if (pathArray[0][0] == 'M') {
    x = +pathArray[0][1];
    y = +pathArray[0][2];
    mx = x;
    my = y;
    start++;
    res[0] = ['M', x, y];
  }

  var crz = pathArray.length == 3 && pathArray[0][0] == 'M' && pathArray[1][0].toUpperCase() == 'R' && pathArray[2][0].toUpperCase() == 'Z';

  for (var r, pa, i = start, ii = pathArray.length; i < ii; i++) {
    res.push(r = []);
    pa = pathArray[i];
    pa0 = pa[0];

    if (pa0 != pa0.toUpperCase()) {
      r[0] = pa0.toUpperCase();

      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 'R':
          var dots = [x, y].concat(pa.slice(1));

          for (var j = 2, jj = dots.length; j < jj; j++) {
            dots[j] = +dots[j] + x;
            dots[++j] = +dots[j] + y;
          }

          res.pop();
          res = res.concat(catmulRomToBezier(dots, crz));
          break;
        case 'O':
          res.pop();
          dots = ellipsePath(x, y, pa[1], pa[2]);
          dots.push(dots[0]);
          res = res.concat(dots);
          break;
        case 'U':
          res.pop();
          res = res.concat(ellipsePath(x, y, pa[1], pa[2], pa[3]));
          r = ['U'].concat(res[res.length - 1].slice(-2));
          break;
        case 'M':
          mx = +pa[1] + x;
          my = +pa[2] + y;
        default:

          for (j = 1, jj = pa.length; j < jj; j++) {
            r[j] = +pa[j] + (j % 2 ? x : y);
          }
      }
    } else if (pa0 == 'R') {
      dots = [x, y].concat(pa.slice(1));
      res.pop();
      res = res.concat(catmulRomToBezier(dots, crz));
      r = ['R'].concat(pa.slice(-2));
    } else if (pa0 == 'O') {
      res.pop();
      dots = ellipsePath(x, y, pa[1], pa[2]);
      dots.push(dots[0]);
      res = res.concat(dots);
    } else if (pa0 == 'U') {
      res.pop();
      res = res.concat(ellipsePath(x, y, pa[1], pa[2], pa[3]));
      r = ['U'].concat(res[res.length - 1].slice(-2));
    } else {

      for (var k = 0, kk = pa.length; k < kk; k++) {
        r[k] = pa[k];
      }
    }
    pa0 = pa0.toUpperCase();

    if (pa0 != 'O') {
      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];
      }
    }
  }

  res.toString = pathToString;
  pth.abs = pathClone(res);

  return res;
}

function lineToCurve(x1, y1, x2, y2) {
  return [x1, y1, x2, y2, x2, y2];
}

function qubicToCurve(x1, y1, ax, ay, x2, y2) {
  var _13 = 1 / 3,
      _23 = 2 / 3;

  return [_13 * x1 + _23 * ax, _13 * y1 + _23 * ay, _13 * x2 + _23 * ax, _13 * y2 + _23 * ay, x2, y2];
}

function arcToCurve(x1, y1, rx, ry, angle, large_arc_flag, sweep_flag, x2, y2, recursive) {

  // 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);

    return { x: X, y: Y };
  });

  if (!recursive) {
    xy = rotate(x1, y1, -rad);
    x1 = xy.x;
    y1 = xy.y;
    xy = rotate(x2, y2, -rad);
    x2 = xy.x;
    y2 = xy.y;

    var x = (x1 - x2) / 2,
        y = (y1 - y2) / 2;

    var h = x * x / (rx * rx) + y * y / (ry * ry);

    if (h > 1) {
      h = math.sqrt(h);
      rx = h * rx;
      ry = h * ry;
    }

    var rx2 = rx * rx,
        ry2 = ry * ry,
        k = (large_arc_flag == sweep_flag ? -1 : 1) * math.sqrt(abs((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));

    f1 = x1 < cx ? PI - f1 : f1;
    f2 = x2 < cx ? PI - f2 : f2;
    f1 < 0 && (f1 = PI * 2 + f1);
    f2 < 0 && (f2 = PI * 2 + f2);

    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];
  }

  var df = f2 - f1;

  if (abs(df) > _120) {
    var f2old = f2,
        x2old = x2,
        y2old = y2;

    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]);
  }

  df = f2 - f1;

  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];

  m2[0] = 2 * m1[0] - m2[0];
  m2[1] = 2 * m1[1] - m2[1];

  if (recursive) {
    return [m2, m3, m4].concat(res);
  } else {
    res = [m2, m3, m4].concat(res).join().split(',');
    var newres = [];

    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;
    }

    return newres;
  }
}

// http://schepers.cc/getting-to-the-point
function catmulRomToBezier(crp, z) {
  var d = [];

  for (var i = 0, iLen = crp.length; iLen - 2 * !z > i; i += 2) {
    var p = [{ x: +crp[i - 2], y: +crp[i - 1] }, { x: +crp[i], y: +crp[i + 1] }, { x: +crp[i + 2], y: +crp[i + 3] }, { x: +crp[i + 4], y: +crp[i + 5] }];

    if (z) {

      if (!i) {
        p[0] = { x: +crp[iLen - 2], y: +crp[iLen - 1] };
      } else if (iLen - 4 == i) {
        p[3] = { x: +crp[0], y: +crp[1] };
      } else if (iLen - 2 == i) {
        p[2] = { x: +crp[0], y: +crp[1] };
        p[3] = { x: +crp[2], y: +crp[3] };
      }
    } else {

      if (iLen - 4 == i) {
        p[3] = p[2];
      } else if (!i) {
        p[0] = { x: +crp[i], y: +crp[i + 1] };
      }
    }

    d.push(['C', (-p[0].x + 6 * p[1].x + p[2].x) / 6, (-p[0].y + 6 * p[1].y + p[2].y) / 6, (p[1].x + 6 * p[2].x - p[3].x) / 6, (p[1].y + 6 * p[2].y - p[3].y) / 6, p[2].x, p[2].y]);
  }

  return d;
}

// 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;

  for (var i = 0; i < 2; ++i) {

    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;
    }

    if (abs(a) < 1e-12) {

      if (abs(b) < 1e-12) {
        continue;
      }

      t = -c / b;

      if (0 < t && t < 1) {
        tvalues.push(t);
      }

      continue;
    }

    b2ac = b * b - 4 * c * a;
    sqrtb2ac = math.sqrt(b2ac);

    if (b2ac < 0) {
      continue;
    }

    t1 = (-b + sqrtb2ac) / (2 * a);

    if (0 < t1 && t1 < 1) {
      tvalues.push(t1);
    }

    t2 = (-b - sqrtb2ac) / (2 * a);

    if (0 < t2 && t2 < 1) {
      tvalues.push(t2);
    }
  }

  var j = tvalues.length,
      jlen = j,
      mt;

  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;
  }

  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;

  return {
    min: { x: mmin.apply(0, bounds[0]), y: mmin.apply(0, bounds[1]) },
    max: { x: mmax.apply(0, bounds[0]), y: mmax.apply(0, bounds[1]) }
  };
}

function pathToCurve(path, path2) {
  var pth = !path2 && paths(path);

  if (!path2 && pth.curve) {
    return pathClone(pth.curve);
  }

  var p = pathToAbsolute(path),
      p2 = path2 && pathToAbsolute(path2),
      attrs = { x: 0, y: 0, bx: 0, by: 0, X: 0, Y: 0, qx: null, qy: null },
      attrs2 = { x: 0, y: 0, bx: 0, by: 0, X: 0, Y: 0, qx: null, qy: null },
      processPath = function processPath(path, d, pcom) {
    var nx, ny;

    if (!path) {
      return ['C', d.x, d.y, d.x, d.y, d.x, d.y];
    }

    !(path[0] in { T: 1, Q: 1 }) && (d.qx = d.qy = null);

    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 (pcom == 'C' || pcom == 'S') {
          // In 'S' case we have to take into account, if the previous command is C/S.
          nx = d.x * 2 - d.bx;
          // And reflect the previous
          ny = d.y * 2 - d.by;
          // command's control point relative to the current point.
        } else {
          // or some else or nothing
          nx = d.x;
          ny = d.y;
        }
        path = ['C', nx, ny].concat(path.slice(1));
        break;
      case 'T':
        if (pcom == 'Q' || pcom == 'T') {
          // In 'T' case we have to take into account, if the previous command is Q/T.
          d.qx = d.x * 2 - d.qx;
          // And make a reflection similar
          d.qy = d.y * 2 - d.qy;
          // to case 'S'.
        } else {
          // 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;
    }

    return path;
  },
      fixArc = function fixArc(pp, i) {

    if (pp[i].length > 7) {
      pp[i].shift();
      var pi = pp[i];

      while (pi.length) {
        pcoms1[i] = 'A'; // if created multiple C:s, their original seg is saved
        p2 && (pcoms2[i] = 'A'); // the same as above
        pp.splice(i++, 0, ['C'].concat(pi.splice(0, 6)));
      }

      pp.splice(i, 1);
      ii = mmax(p.length, p2 && p2.length || 0);
    }
  },
      fixM = function fixM(path1, path2, a1, a2, i) {

    if (path1 && path2 && path1[i][0] == 'M' && path2[i][0] != 'M') {
      path2.splice(i, 0, ['M', a2.x, a2.y]);
      a1.bx = 0;
      a1.by = 0;
      a1.x = path1[i][1];
      a1.y = path1[i][2];
      ii = mmax(p.length, p2 && p2.length || 0);
    }
  },
      pcoms1 = [],
      // path commands of original path p
  pcoms2 = [],
      // path commands of original path p2
  pfirst = '',
      // temporary holder for original path command
  pcom = ''; // holder for previous path command of original path

  for (var i = 0, ii = mmax(p.length, p2 && p2.length || 0); i < ii; i++) {
    p[i] && (pfirst = p[i][0]); // save current path command

    if (pfirst != 'C') // C is not saved yet, because it may be result of conversion
      {
        pcoms1[i] = pfirst; // Save current path command
        i && (pcom = pcoms1[i - 1]); // Get previous path command pcom
      }
    p[i] = processPath(p[i], attrs, pcom); // Previous path command is inputted to processPath

    if (pcoms1[i] != 'A' && pfirst == 'C') pcoms1[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

    fixArc(p, i); // fixArc adds also the right amount of A:s to pcoms1

    if (p2) {
      // the same procedures is done to p2
      p2[i] && (pfirst = p2[i][0]);

      if (pfirst != 'C') {
        pcoms2[i] = pfirst;
        i && (pcom = pcoms2[i - 1]);
      }

      p2[i] = processPath(p2[i], attrs2, pcom);

      if (pcoms2[i] != 'A' && pfirst == 'C') {
        pcoms2[i] = 'C';
      }

      fixArc(p2, i);
    }

    fixM(p, p2, attrs, attrs2, i);
    fixM(p2, p, attrs2, attrs, i);

    var seg = p[i],
        seg2 = p2 && p2[i],
        seglen = seg.length,
        seg2len = p2 && seg2.length;

    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;
    attrs2.bx = p2 && (toFloat(seg2[seg2len - 4]) || attrs2.x);
    attrs2.by = p2 && (toFloat(seg2[seg2len - 3]) || attrs2.y);
    attrs2.x = p2 && seg2[seg2len - 2];
    attrs2.y = p2 && seg2[seg2len - 1];
  }

  if (!p2) {
    pth.curve = pathClone(p);
  }

  return p2 ? [p, p2] : p;
}

module.exports = findPathIntersections;

},{}],524:[function(require,module,exports){
'use strict';

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

Object.defineProperty(exports, '__esModule', { value: true });

var fromCharCode = String.fromCharCode;

var hasOwnProperty = Object.prototype.hasOwnProperty;

var ENTITY_PATTERN = /&#(\d+);|&#x([0-9a-f]+);|&(\w+);/ig;

var ENTITY_MAPPING = {
  'amp': '&',
  'apos': '\'',
  'gt': '>',
  'lt': '<',
  'quot': '"'
};

// map UPPERCASE variants of supported special chars
Object.keys(ENTITY_MAPPING).forEach(function (k) {
  ENTITY_MAPPING[k.toUpperCase()] = ENTITY_MAPPING[k];
});

function replaceEntities(_, d, x, z) {

  // reserved names, i.e. &nbsp;
  if (z) {
    if (hasOwnProperty.call(ENTITY_MAPPING, z)) {
      return ENTITY_MAPPING[z];
    } else {
      // fall back to original value
      return '&' + z + ';';
    }
  }

  // decimal encoded char
  if (d) {
    return fromCharCode(d);
  }

  // hex encoded char
  return fromCharCode(parseInt(x, 16));
}

/**
 * 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);
  }

  return s;
}

var XSI_URI = 'http://www.w3.org/2001/XMLSchema-instance';
var XSI_PREFIX = 'xsi';
var XSI_TYPE = 'xsi:type';

var NON_WHITESPACE_OUTSIDE_ROOT_NODE = 'non-whitespace outside of root node';

function error(msg) {
  return new Error(msg);
}

function missingNamespaceForPrefix(prefix) {
  return 'missing namespace for prefix <' + prefix + '>';
}

function getter(getFn) {
  return {
    'get': getFn,
    'enumerable': true
  };
}

function cloneNsMatrix(nsMatrix) {
  var clone = {},
      key;
  for (key in nsMatrix) {
    clone[key] = nsMatrix[key];
  }
  return clone;
}

function uriPrefix(prefix) {
  return prefix + '$uri';
}

function buildNsMatrix(nsUriToPrefix) {
  var nsMatrix = {},
      uri,
      prefix;

  for (uri in nsUriToPrefix) {
    prefix = nsUriToPrefix[uri];
    nsMatrix[prefix] = prefix;
    nsMatrix[uriPrefix(prefix)] = uri;
  }

  return nsMatrix;
}

function noopGetContext() {
  return { 'line': 0, 'column': 0 };
}

function throwFunc(err) {
  throw err;
}

/**
 * Creates a new parser with the given options.
 *
 * @constructor
 *
 * @param  {!Object<string, ?>=} options
 */
function Parser(options) {

  if (!this) {
    return new Parser(options);
  }

  var proxy = options && options['proxy'];

  var onText,
      onOpenTag,
      onCloseTag,
      onCDATA,
      onError = throwFunc,
      onWarning,
      onComment,
      onQuestion,
      onAttention;

  var getContext = noopGetContext;

  /**
   * Do we need to parse the current elements attributes for namespaces?
   *
   * @type {boolean}
   */
  var maybeNS = false;

  /**
   * Do we process namespaces at all?
   *
   * @type {boolean}
   */
  var isNamespace = false;

  /**
   * The caught error returned on parse end
   *
   * @type {Error}
   */
  var returnError = null;

  /**
   * Should we stop parsing?
   *
   * @type {boolean}
   */
  var parseStop = false;

  /**
   * 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;

  /**
   * Handle parse error.
   *
   * @param  {string|Error} err
   */
  function handleError(err) {
    if (!(err instanceof Error)) {
      err = error(err);
    }

    returnError = err;

    onError(err, getContext);
  }

  /**
   * Handle parse error.
   *
   * @param  {string|Error} err
   */
  function handleWarning(err) {

    if (!onWarning) {
      return;
    }

    if (!(err instanceof Error)) {
      err = error(err);
    }

    onWarning(err, getContext);
  }

  /**
   * Register parse listener.
   *
   * @param  {string}   name
   * @param  {Function} cb
   *
   * @return {Parser}
   */
  this['on'] = function (name, cb) {

    if (typeof cb !== 'function') {
      throw error('required args <name, cb>');
    }

    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('unsupported event: ' + name);
    }

    return this;
  };

  /**
   * 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) {

    if (typeof nsMap === 'undefined') {
      nsMap = {};
    }

    if ((typeof nsMap === 'undefined' ? 'undefined' : _typeof(nsMap)) !== 'object') {
      throw error('required args <nsMap={}>');
    }

    var _nsUriToPrefix = {},
        k;

    for (k in nsMap) {
      _nsUriToPrefix[k] = nsMap[k];
    }

    // FORCE default mapping for schema instance
    _nsUriToPrefix[XSI_URI] = XSI_PREFIX;

    isNamespace = true;
    nsUriToPrefix = _nsUriToPrefix;

    return this;
  };

  /**
   * Parse xml string.
   *
   * @param  {string} xml
   *
   * @return {Error} returnError, if not thrown
   */
  this['parse'] = function (xml) {
    if (typeof xml !== 'string') {
      throw error('required args <xml=string>');
    }

    returnError = null;

    parse(xml);

    getContext = noopGetContext;
    parseStop = false;

    return returnError;
  };

  /**
   * Stop parsing.
   */
  this['stop'] = function () {
    parseStop = true;
  };

  /**
   * 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,
        xmlns,
        elementName,
        _elementName,
        elementProxy;

    var attrsString = '',
        attrsStart = 0,
        cachedAttrs // false = parsed with errors, null = needs parsing
    ;

    /**
     * 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;
      }

      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;

      parseAttr: for (; i < l; i++) {
        skipAttr = false;
        w = s.charCodeAt(i);

        if (w === 32 || w < 14 && w > 8) {
          // WHITESPACE={ \f\n\r\t\v}
          continue;
        }

        // 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;
          }
        }

        // parse attribute name
        for (j = i + 1; j < l; j++) {
          w = s.charCodeAt(j);

          if (w > 96 && w < 123 || w > 64 && w < 91 || w > 47 && w < 59 || w === 46 || // '.'
          w === 45 || // '-'
          w === 95 // '_'
          ) {
              continue;
            }

          // unexpected whitespace
          if (w === 32 || w < 14 && w > 8) {
            // WHITESPACE
            handleWarning('missing attribute value');
            i = j;

            continue parseAttr;
          }

          // expected "="
          if (w === 61) {
            // "=" == 61
            break;
          }

          handleWarning('illegal attribute name char');
          skipAttr = true;
        }

        name = s.substring(i, j);

        if (name === 'xmlns:xmlns') {
          handleWarning('illegal declaration of xmlns');
          skipAttr = true;
        }

        w = s.charCodeAt(j + 1);

        if (w === 34) {
          // '"'
          j = s.indexOf('"', i = j + 2);

          if (j === -1) {
            j = s.indexOf('\'', i);

            if (j !== -1) {
              handleWarning('attribute value quote missmatch');
              skipAttr = true;
            }
          }
        } else if (w === 39) {
          // "'"
          j = s.indexOf('\'', i = j + 2);

          if (j === -1) {
            j = s.indexOf('"', i);

            if (j !== -1) {
              handleWarning('attribute value quote missmatch');
              skipAttr = true;
            }
          }
        } else {
          handleWarning('missing attribute value quotes');
          skipAttr = true;

          // skip to next space
          for (j = j + 1; j < l; j++) {
            w = s.charCodeAt(j + 1);

            if (w === 32 || w < 14 && w > 8) {
              // WHITESPACE
              break;
            }
          }
        }

        if (j === -1) {
          handleWarning('missing closing quotes');

          j = l;
          skipAttr = true;
        }

        if (!skipAttr) {
          value = s.substring(i, j);
        }

        i = j;

        // ensure SPACE follows attribute
        // skip illegal content otherwise
        // example a="b"c
        for (; j + 1 < l; j++) {
          w = s.charCodeAt(j + 1);

          if (w === 32 || w < 14 && w > 8) {
            // WHITESPACE
            break;
          }

          // FIRST ILLEGAL CHAR
          if (i === j) {
            handleWarning('illegal character after attribute end');
            skipAttr = true;
          }
        }

        // advance cursor to next attribute
        i = j + 1;

        if (skipAttr) {
          continue parseAttr;
        }

        // check attribute re-declaration
        if (name in seenAttrs) {
          handleWarning('attribute <' + name + '> already defined');
          continue;
        }

        seenAttrs[name] = true;

        if (!isNamespace) {
          attrs[name] = value;
          continue;
        }

        // try to extract namespace information
        if (maybeNS) {
          newalias = name === 'xmlns' ? 'xmlns' : name.charCodeAt(0) === 120 && name.substr(0, 6) === 'xmlns:' ? name.substr(6) : null;

          // handle xmlns(:alias) assignment
          if (newalias !== null) {
            nsUri = decodeEntities(value);
            nsUriPrefix = uriPrefix(newalias);

            alias = nsUriToPrefix[nsUri];

            if (!alias) {
              // no prefix defined or prefix collision
              if (newalias === 'xmlns' || nsUriPrefix in nsMatrix && nsMatrix[nsUriPrefix] !== nsUri) {
                // alocate free ns prefix
                do {
                  alias = 'ns' + anonymousNsCount++;
                } while (typeof nsMatrix[alias] !== 'undefined');
              } else {
                alias = newalias;
              }

              nsUriToPrefix[nsUri] = alias;
            }

            if (nsMatrix[newalias] !== alias) {
              if (!hasNewMatrix) {
                nsMatrix = cloneNsMatrix(nsMatrix);
                hasNewMatrix = true;
              }

              nsMatrix[newalias] = alias;
              if (newalias === 'xmlns') {
                nsMatrix[uriPrefix(alias)] = nsUri;
                defaultAlias = alias;
              }

              nsMatrix[nsUriPrefix] = nsUri;
            }

            // expose xmlns(:asd)="..." in attributes
            attrs[name] = value;
            continue;
          }

          // collect attributes until all namespace
          // declarations are processed
          attrList.push(name, value);
          continue;
        } /** end if (maybeNs) */

        // handle attributes on element without
        // namespace declarations
        w = name.indexOf(':');
        if (w === -1) {
          attrs[name] = value;
          continue;
        }

        // normalize ns attribute name
        if (!(nsName = nsMatrix[name.substring(0, w)])) {
          handleWarning(missingNamespaceForPrefix(name.substring(0, w)));
          continue;
        }

        name = defaultAlias === nsName ? name.substr(w + 1) : nsName + name.substr(w);
        // end: normalize ns attribute name

        // normalize xsi:type ns attribute value
        if (name === XSI_TYPE) {
          w = value.indexOf(':');

          if (w !== -1) {
            nsName = value.substring(0, w);
            // handle default prefixes, i.e. xs:String gracefully
            nsName = nsMatrix[nsName] || nsName;
            value = nsName + value.substring(w);
          } else {
            value = defaultAlias + ':' + value;
          }
        }
        // end: normalize xsi:type ns attribute value

        attrs[name] = value;
      }

      // handle deferred, possibly namespaced attributes
      if (maybeNS) {

        // normalize captured attributes
        for (i = 0, l = attrList.length; i < l; i++) {

          name = attrList[i++];
          value = attrList[i];

          w = name.indexOf(':');

          if (w !== -1) {
            // normalize ns attribute name
            if (!(nsName = nsMatrix[name.substring(0, w)])) {
              handleWarning(missingNamespaceForPrefix(name.substring(0, w)));
              continue;
            }

            name = defaultAlias === nsName ? name.substr(w + 1) : nsName + name.substr(w);
            // end: normalize ns attribute name

            // normalize xsi:type ns attribute value
            if (name === XSI_TYPE) {
              w = value.indexOf(':');

              if (w !== -1) {
                nsName = value.substring(0, w);
                // handle default prefixes, i.e. xs:String gracefully
                nsName = nsMatrix[nsName] || nsName;
                value = nsName + value.substring(w);
              } else {
                value = defaultAlias + ':' + value;
              }
            }
            // end: normalize xsi:type ns attribute value
          }

          attrs[name] = value;
        }
        // end: normalize captured attributes
      }

      return cachedAttrs = attrs;
    }

    /**
     * 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;

      var line = 0;
      var column = 0;
      var startOfLine = 0;
      var endOfLine = j;
      var match;
      var data;

      while (i >= startOfLine) {

        match = splitsRe.exec(xml);

        if (!match) {
          break;
        }

        // end of line = (break idx + break chars)
        endOfLine = match[0].length + match.index;

        if (endOfLine > i) {
          break;
        }

        // advance to next line
        line += 1;

        startOfLine = endOfLine;
      }

      // EOF errors
      if (i == -1) {
        column = endOfLine;
        data = xml.substring(j);
      } else
        // start errors
        if (j === 0) {
          console.log(i - startOfLine);
          data = xml.substring(j, i);
        }
        // other errors
        else {
            column = i - startOfLine;
            data = j == -1 ? xml.substring(i) : xml.substring(i, j + 1);
          }

      return {
        'data': data,
        'line': line,
        'column': column
      };
    }

    getContext = getParseContext;

    if (proxy) {
      elementProxy = Object.create({}, {
        'name': getter(function () {
          return elementName;
        }),
        'originalName': getter(function () {
          return _elementName;
        }),
        'attrs': getter(getAttrs),
        'ns': getter(function () {
          return nsMatrix;
        })
      });
    }

    // actual parse logic
    while (j !== -1) {

      if (xml.charCodeAt(j) === 60) {
        // "<"
        i = j;
      } else {
        i = xml.indexOf('<', j);
      }

      // parse end
      if (i === -1) {
        if (nodeStack.length) {
          return handleError('unexpected end of file');
        }

        if (j === 0) {
          return handleError('missing start tag');
        }

        if (j < xml.length) {
          if (xml.substring(j).trim()) {
            handleWarning(NON_WHITESPACE_OUTSIDE_ROOT_NODE);
          }
        }

        return;
      }

      // parse text
      if (j !== i) {

        if (nodeStack.length) {
          if (onText) {
            onText(xml.substring(j, i), decodeEntities, getContext);

            if (parseStop) {
              return;
            }
          }
        } else {
          if (xml.substring(j, i).trim()) {
            handleWarning(NON_WHITESPACE_OUTSIDE_ROOT_NODE);

            if (parseStop) {
              return;
            }
          }
        }
      }

      w = xml.charCodeAt(i + 1);

      // parse comments + CDATA
      if (w === 33) {
        // "!"
        w = xml.charCodeAt(i + 2);
        if (w === 91 && xml.substr(i + 3, 6) === 'CDATA[') {
          // 91 == "["
          j = xml.indexOf(']]>', i);
          if (j === -1) {
            return handleError('unclosed cdata');
          }

          if (onCDATA) {
            onCDATA(xml.substring(i + 9, j), getContext);
            if (parseStop) {
              return;
            }
          }

          j += 3;
          continue;
        }

        if (w === 45 && xml.charCodeAt(i + 3) === 45) {
          // 45 == "-"
          j = xml.indexOf('-->', i);
          if (j === -1) {
            return handleError('unclosed comment');
          }

          if (onComment) {
            onComment(xml.substring(i + 4, j), decodeEntities, getContext);
            if (parseStop) {
              return;
            }
          }

          j += 3;
          continue;
        }

        j = xml.indexOf('>', i + 1);
        if (j === -1) {
          return handleError('unclosed tag');
        }

        if (onAttention) {
          onAttention(xml.substring(i, j + 1), decodeEntities, getContext);
          if (parseStop) {
            return;
          }
        }

        j += 1;
        continue;
      }

      if (w === 63) {
        // "?"
        j = xml.indexOf('?>', i);
        if (j === -1) {
          return handleError('unclosed question');
        }

        if (onQuestion) {
          onQuestion(xml.substring(i, j + 2), getContext);
          if (parseStop) {
            return;
          }
        }

        j += 2;
        continue;
      }

      j = xml.indexOf('>', i + 1);

      if (j == -1) {
        return handleError('unclosed tag');
      }

      // don't process attributes;
      // there are none
      cachedAttrs = {};

      // if (xml.charCodeAt(i+1) === 47) { // </...
      if (w === 47) {
        // </...
        tagStart = false;
        tagEnd = true;

        if (!nodeStack.length) {
          return handleError('missing open tag');
        }

        // verify open <-> close tag match
        x = elementName = nodeStack.pop();
        q = i + 2 + x.length;

        if (xml.substring(i + 2, q) !== x) {
          return handleError('closing tag mismatch');
        }

        // verify chars in close tag
        for (; q < j; q++) {
          w = xml.charCodeAt(q);

          if (w === 32 || w > 8 && w < 14) {
            // \f\n\r\t\v space
            continue;
          }

          return handleError('close tag');
        }
      } else {
        if (xml.charCodeAt(j - 1) === 47) {
          // .../>
          x = elementName = xml.substring(i + 1, j - 1);

          tagStart = true;
          tagEnd = true;
        } else {
          x = elementName = xml.substring(i + 1, j);

          tagStart = true;
          tagEnd = false;
        }

        if (!(w > 96 && w < 123 || w > 64 && w < 91 || w === 95 || w === 58)) {
          // char 95"_" 58":"
          return handleError('illegal first char nodeName');
        }

        for (q = 1, y = x.length; q < y; q++) {
          w = x.charCodeAt(q);

          if (w > 96 && w < 123 || w > 64 && w < 91 || w > 47 && w < 59 || w === 45 || w === 95 || w == 46) {
            continue;
          }

          if (w === 32 || w < 14 && w > 8) {
            // \f\n\r\t\v space
            elementName = x.substring(0, q);
            // maybe there are attributes
            cachedAttrs = null;
            break;
          }

          return handleError('invalid nodeName');
        }

        if (!tagEnd) {
          nodeStack.push(elementName);
        }
      }

      if (isNamespace) {

        _nsMatrix = nsMatrix;

        if (tagStart) {
          // remember old namespace
          // unless we're self-closing
          if (!tagEnd) {
            nsMatrixStack.push(_nsMatrix);
          }

          if (cachedAttrs === null) {
            // 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;

              getAttrs();

              maybeNS = false;
            }
          }
        }

        _elementName = elementName;

        w = elementName.indexOf(':');
        if (w !== -1) {
          xmlns = nsMatrix[elementName.substring(0, w)];

          // prefix given; namespace must exist
          if (!xmlns) {
            return handleError('missing namespace on <' + _elementName + '>');
          }

          elementName = elementName.substr(w + 1);
        } else {
          xmlns = nsMatrix['xmlns'];

          // 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.
        }

        // adjust namespace prefixs as configured
        if (xmlns) {
          elementName = xmlns + ':' + elementName;
        }
      }

      if (tagStart) {
        attrsStart = q;
        attrsString = x;

        if (onOpenTag) {
          if (proxy) {
            onOpenTag(elementProxy, decodeEntities, tagEnd, getContext);
          } else {
            onOpenTag(elementName, getAttrs, decodeEntities, tagEnd, getContext);
          }

          if (parseStop) {
            return;
          }
        }
      }

      if (tagEnd) {

        if (onCloseTag) {
          onCloseTag(proxy ? elementProxy : elementName, decodeEntities, tagStart, getContext);

          if (parseStop) {
            return;
          }
        }

        // restore old namespace
        if (isNamespace) {
          if (!tagStart) {
            nsMatrix = nsMatrixStack.pop();
          } else {
            nsMatrix = _nsMatrix;
          }
        }
      }

      j += 1;
    }
  } /** end parse */
}

exports.Parser = Parser;
exports.decode = decodeEntities;

},{}],525:[function(require,module,exports){
'use strict';

var domify = require('min-dom/lib/domify'),
    domClasses = require('min-dom/lib/classes'),
    domMatches = require('min-dom/lib/matches'),
    domDelegate = require('min-dom/lib/delegate'),
    domQuery = require('min-dom/lib/query'),
    domEvent = require('min-dom/lib/event'),
    domAttr = require('min-dom/lib/attr');

var filter = require('lodash/collection/filter'),
    assign = require('lodash/object/assign');

var inherits = require('inherits');

var EventEmitter = require('events');

var DEFAULT_OPTIONS = {
  scrollSymbolLeft: '‹',
  scrollSymbolRight: '›'
};

/**
 * This component adds the functionality to scroll over a list of tabs.
 *
 * It adds scroll buttons on the left and right side of the tabs container
 * if not all tabs are visible. It also adds a mouse wheel listener on the
 * container.
 *
 * If either a button is clicked or the mouse wheel is used over the tabs,
 * a 'scroll' event is being fired. This event contains the node elements
 * of the new and old active tab, and the direction in which the tab has
 * changed relative to the old active tab.
 *
 * @example:
 * (1) provide a tabs-container:
 *
 * var $el = (
 *   <div>
 *     <!-- button added by scrollTabs -->
 *     <span class="scroll-tabs-button scroll-tabs-left"></span>
 *     <ul class="my-tabs-container">
 *       <li class="my-tab i-am-active"></li>
 *       <li class="my-tab"></li>
 *       <li class="my-tab ignore-me"></li>
 *     </ul>
 *     <!-- button added by scrollTabs -->
 *     <span class="scroll-tabs-button scroll-tabs-right"></span>
 *   </div>
 * );
 *
 *
 * (2) initialize scrollTabs:
 *
 *  var scroller = scrollTabs(tabBarNode, {
 *    selectors: {
 *      tabsContainer: '.my-tabs-container',
 *      tab: '.my-tab',
 *      ignore: '.ignore-me',
 *      active: '.i-am-active'
 *    }
 *  });
 *
 *
 * (3) listen to the scroll event:
 *
 * scroller.on('scroll', function(newActiveNode, oldActiveNode, direction) {
 *   // direction is any of (-1: left, 1: right)
 *   // activate the new active tab
 * });
 *
 *
 * (4) update the scroller if tabs change and or the tab container resizes:
 *
 * scroller.update();
 *
 *
 * @param  {DOMElement} el
 * @param  {Object} options
 * @param  {Object} options.selectors
 * @param  {String} options.selectors.tabsContainer the container all tabs are contained in
 * @param  {String} options.selectors.tab a single tab inside the tab container
 * @param  {String} options.selectors.ignore tabs that should be ignored during scroll left/right
 * @param  {String} options.selectors.active selector for the current active tab
 * @param  {String} [options.scrollSymbolLeft]
 * @param  {String} [options.scrollSymbolRight]
 */
function ScrollTabs($el, options) {

  // we are an event emitter
  EventEmitter.call(this);

  this.options = options = assign({}, DEFAULT_OPTIONS, options);
  this.container = $el;

  this._createScrollButtons($el, options);

  this._bindEvents($el);
}

inherits(ScrollTabs, EventEmitter);

/**
 * Create a clickable scroll button
 *
 * @param {Object} options
 * @param {String} options.className
 * @param {String} options.label
 * @param {Number} options.direction
 *
 * @return {DOMElement} The created scroll button node
 */
ScrollTabs.prototype._createButton = function (parentNode, options) {

  var className = options.className,
      direction = options.direction;

  var button = domQuery('.' + className, parentNode);

  if (!button) {
    button = domify('<span class="scroll-tabs-button ' + className + '">' + options.label + '</span>');

    parentNode.insertBefore(button, parentNode.childNodes[0]);
  }

  domAttr(button, 'data-direction', direction);

  return button;
};

/**
 * Create both scroll buttons
 *
 * @param  {DOMElement} parentNode
 * @param  {Object} options
 * @param  {String} options.scrollSymbolLeft
 * @param  {String} options.scrollSymbolRight
 */
ScrollTabs.prototype._createScrollButtons = function (parentNode, options) {

  // Create a button that scrolls to the tab left to the currently active tab
  this._createButton(parentNode, {
    className: 'scroll-tabs-left',
    label: options.scrollSymbolLeft,
    direction: -1
  });

  // Create a button that scrolls to the tab right to the currently active tab
  this._createButton(parentNode, {
    className: 'scroll-tabs-right',
    label: options.scrollSymbolRight,
    direction: 1
  });
};

/**
 * Get the current active tab
 *
 * @return {DOMElement}
 */
ScrollTabs.prototype.getActiveTabNode = function () {
  return domQuery(this.options.selectors.active, this.container);
};

/**
 * Get the container all tabs are contained in
 *
 * @return {DOMElement}
 */
ScrollTabs.prototype.getTabsContainerNode = function () {
  return domQuery(this.options.selectors.tabsContainer, this.container);
};

/**
 * Get all tabs (visible and invisible ones)
 *
 * @return {Array<DOMElement>}
 */
ScrollTabs.prototype.getAllTabNodes = function () {
  return domQuery.all(this.options.selectors.tab, this.container);
};

/**
 * Gets all tabs that don't have the ignore class set
 *
 * @return {Array<DOMElement>}
 */
ScrollTabs.prototype.getVisibleTabs = function () {
  var allTabs = this.getAllTabNodes();

  var ignore = this.options.selectors.ignore;

  return filter(allTabs, function (tabNode) {
    return !domMatches(tabNode, ignore);
  });
};

/**
 * Get a tab relative to a reference tab.
 *
 * @param  {DOMElement} referenceTabNode
 * @param  {Number} n gets the nth tab next or previous to the reference tab
 *
 * @return {DOMElement}
 *
 * @example:
 * Visible tabs: [ A | B | C | D | E ]
 * Assume tab 'C' is the reference tab:
 * If direction === -1, it returns tab 'B',
 * if direction ===  2, it returns tab 'E'
 */
ScrollTabs.prototype.getAdjacentTab = function (referenceTabNode, n) {
  var visibleTabs = this.getVisibleTabs();

  var index = visibleTabs.indexOf(referenceTabNode);

  return visibleTabs[index + n];
};

ScrollTabs.prototype._bindEvents = function (node) {
  this._bindWheelEvent(node);
  this._bindTabClickEvents(node);
  this._bindScrollButtonEvents(node);
};

/**
 *  Bind a click listener to a DOM node.
 *  Make sure a tab link is entirely visible after onClick.
 *
 * @param {DOMElement} node
 */
ScrollTabs.prototype._bindTabClickEvents = function (node) {
  var selector = this.options.selectors.tab;

  var self = this;

  domDelegate.bind(node, selector, 'click', function onClick(event) {
    self.scrollToTabNode(event.delegateTarget);
  });
};

/**
 * Bind the wheel event listener to a DOM node
 *
 * @param {DOMElement} node
 */
ScrollTabs.prototype._bindWheelEvent = function (node) {
  var self = this;

  domEvent.bind(node, 'wheel', function (e) {

    // scroll direction (-1: left, 1: right)
    var direction = Math.sign(e.deltaY);

    var oldActiveTab = self.getActiveTabNode();

    var newActiveTab = self.getAdjacentTab(oldActiveTab, direction);

    if (newActiveTab) {
      self.scrollToTabNode(newActiveTab);
      self.emit('scroll', newActiveTab, oldActiveTab, direction);
    }

    e.preventDefault();
  });
};

/**
 * Bind scroll button events to a DOM node
 *
 * @param  {DOMElement} node
 */
ScrollTabs.prototype._bindScrollButtonEvents = function (node) {

  var self = this;

  domDelegate.bind(node, '.scroll-tabs-button', 'click', function (event) {

    var target = event.delegateTarget;

    // data-direction is either -1 or 1
    var direction = parseInt(domAttr(target, 'data-direction'), 10);

    var oldActiveTabNode = self.getActiveTabNode();

    var newActiveTabNode = self.getAdjacentTab(oldActiveTabNode, direction);

    if (newActiveTabNode) {
      self.scrollToTabNode(newActiveTabNode);
      self.emit('scroll', newActiveTabNode, oldActiveTabNode, direction);
    }

    event.preventDefault();
  });
};

/**
* Scroll to a tab if it is not entirely visible
*
* @param  {DOMElement} tabNode tab node to scroll to
*/
ScrollTabs.prototype.scrollToTabNode = function (tabNode) {
  if (!tabNode) {
    return;
  }

  var tabsContainerNode = tabNode.parentNode;

  var tabWidth = tabNode.offsetWidth,
      tabOffsetLeft = tabNode.offsetLeft,
      tabOffsetRight = tabOffsetLeft + tabWidth,
      containerWidth = tabsContainerNode.offsetWidth,
      containerScrollLeft = tabsContainerNode.scrollLeft;

  if (containerScrollLeft > tabOffsetLeft) {
    // scroll to the left, if the tab is overflowing on the left side
    tabsContainerNode.scrollLeft = 0;
  } else if (tabOffsetRight > containerWidth) {
    // scroll to the right, if the tab is overflowing on the right side
    tabsContainerNode.scrollLeft = tabOffsetRight - containerWidth;
  }
};

/**
 * React on tab changes from outside (resize/show/hide/add/remove),
 * update scroll button visibility.
 */
ScrollTabs.prototype.update = function () {

  var tabsContainerNode = this.getTabsContainerNode();

  // check if tabs fit in container
  var overflow = tabsContainerNode.scrollWidth > tabsContainerNode.offsetWidth;

  // TODO(nikku): distinguish overflow left / overflow right?
  var overflowClass = 'scroll-tabs-overflow';

  domClasses(this.container).toggle(overflowClass, overflow);

  if (overflow) {
    // make sure the current active tab is always visible
    this.scrollToTabNode(this.getActiveTabNode());
  }
};

////// module exports /////////////////////////////////////////

/**
 * Create a scrollTabs instance on the given element.
 *
 * @param {DOMElement} $el
 * @param {Object} options
 *
 * @return {ScrollTabs}
 */
function create($el, options) {

  var scrollTabs = get($el);

  if (!scrollTabs) {
    scrollTabs = new ScrollTabs($el, options);

    $el.__scrollTabs = scrollTabs;
  }

  return scrollTabs;
}

/**
 * Factory function to get or create a new scroll tabs instance.
 */
module.exports = create;

/**
 * Return the scrollTabs instance that has been previously
 * initialized on the element.
 *
 * @param {DOMElement} $el
 * @return {ScrollTabs}
 */
function get($el) {
  return $el.__scrollTabs;
}

/**
 * Getter to retrieve an already initialized scroll tabs instance.
 */
module.exports.get = get;

},{"events":228,"inherits":415,"lodash/collection/filter":420,"lodash/object/assign":496,"min-dom/lib/attr":526,"min-dom/lib/classes":527,"min-dom/lib/delegate":528,"min-dom/lib/domify":529,"min-dom/lib/event":530,"min-dom/lib/matches":531,"min-dom/lib/query":532}],526:[function(require,module,exports){
arguments[4][105][0].apply(exports,arguments)
},{"dup":105}],527:[function(require,module,exports){
arguments[4][106][0].apply(exports,arguments)
},{"component-classes":230,"dup":106}],528:[function(require,module,exports){
arguments[4][109][0].apply(exports,arguments)
},{"component-delegate":232,"dup":109}],529:[function(require,module,exports){
arguments[4][110][0].apply(exports,arguments)
},{"domify":411,"dup":110}],530:[function(require,module,exports){
'use strict';

module.exports = require('component-event');

},{"component-event":233}],531:[function(require,module,exports){
arguments[4][111][0].apply(exports,arguments)
},{"component-matches-selector":235,"dup":111}],532:[function(require,module,exports){
arguments[4][112][0].apply(exports,arguments)
},{"component-query":236,"dup":112}],533:[function(require,module,exports){
'use strict';

/**
 * Calculate the selection update for the given
 * current and new input values.
 *
 * @param {Object} currentSelection as {start, end}
 * @param {String} currentValue
 * @param {String} newValue
 *
 * @return {Object} newSelection as {start, end}
 */

function calculateUpdate(currentSelection, currentValue, newValue) {

  var currentCursor = currentSelection.start,
      newCursor = currentCursor,
      diff = newValue.length - currentValue.length,
      idx;

  var lengthDelta = newValue.length - currentValue.length;

  var currentTail = currentValue.substring(currentCursor);

  // check if we can remove common ending from the equation
  // to be able to properly detect a selection change for
  // the following scenarios:
  //
  //  * (AAATTT|TF) => (AAAT|TF)
  //  * (AAAT|TF) =>  (AAATTT|TF)
  //
  if (newValue.lastIndexOf(currentTail) === newValue.length - currentTail.length) {
    currentValue = currentValue.substring(0, currentValue.length - currentTail.length);
    newValue = newValue.substring(0, newValue.length - currentTail.length);
  }

  // diff
  var diff = createDiff(currentValue, newValue);

  if (diff) {
    if (diff.type === 'remove') {
      newCursor = diff.newStart;
    } else {
      newCursor = diff.newEnd;
    }
  }

  return range(newCursor);
}

module.exports = calculateUpdate;

function createDiff(currentValue, newValue) {

  var insert;

  var l_str,
      l_char,
      l_idx = 0,
      s_str,
      s_char,
      s_idx = 0;

  if (newValue.length > currentValue.length) {
    l_str = newValue;
    s_str = currentValue;
  } else {
    l_str = currentValue;
    s_str = newValue;
  }

  // assume there will be only one insert / remove and
  // detect that _first_ edit operation only
  while (l_idx < l_str.length) {

    l_char = l_str.charAt(l_idx);
    s_char = s_str.charAt(s_idx);

    // chars no not equal
    if (l_char !== s_char) {

      if (!insert) {
        insert = {
          l_start: l_idx,
          s_start: s_idx
        };
      }

      l_idx++;
    }

    // chars equal (again?)
    else {

        if (insert && !insert.complete) {
          insert.l_end = l_idx;
          insert.s_end = s_idx;
          insert.complete = true;
        }

        s_idx++;
        l_idx++;
      }
  }

  if (insert && !insert.complete) {
    insert.complete = true;
    insert.s_end = s_str.length;
    insert.l_end = l_str.length;
  }

  // no diff
  if (!insert) {
    return;
  }

  if (newValue.length > currentValue.length) {
    return {
      newStart: insert.l_start,
      newEnd: insert.l_end,
      type: 'add'
    };
  } else {
    return {
      newStart: insert.s_start,
      newEnd: insert.s_end,
      type: newValue.length < currentValue.length ? 'remove' : 'replace'
    };
  }
}

/**
 * Utility method for creating a new selection range {start, end} object.
 *
 * @param {Number} start
 * @param {Number} [end]
 *
 * @return {Object} selection range as {start, end}
 */
function range(start, end) {
  return {
    start: start,
    end: end === undefined ? start : end
  };
}

module.exports.range = range;

function splitStr(str, position) {
  return {
    before: str.substring(0, position),
    after: str.substring(position)
  };
}

},{}],534:[function(require,module,exports){
(function (global){
"use strict";

var _createClass = function () {
	function defineProperties(target, props) {
		for (var i = 0; i < props.length; i++) {
			var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ("value" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);
		}
	}return function (Constructor, protoProps, staticProps) {
		if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;
	};
}();

function _classCallCheck(instance, Constructor) {
	if (!(instance instanceof Constructor)) {
		throw new TypeError("Cannot call a class as a function");
	}
}

/**
 * Tiny stack for browser or server
 *
 * @author Jason Mulligan <jason.mulligan@avoidwork.com>
 * @copyright 2018
 * @license BSD-3-Clause
 * @link http://avoidwork.github.io/tiny-stack
 * @version 1.1.0
 */
(function (global) {
	"use strict";

	var TinyStack = function () {
		function TinyStack() {
			_classCallCheck(this, TinyStack);

			for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
				args[_key] = arguments[_key];
			}

			this.data = [null].concat(args);
			this.top = this.data.length - 1;
		}

		_createClass(TinyStack, [{
			key: "clear",
			value: function clear() {
				this.data.length = 1;
				this.top = 0;

				return this;
			}
		}, {
			key: "empty",
			value: function empty() {
				return this.top === 0;
			}
		}, {
			key: "length",
			value: function length() {
				return this.top;
			}
		}, {
			key: "peek",
			value: function peek() {
				return this.data[this.top];
			}
		}, {
			key: "pop",
			value: function pop() {
				var result = void 0;

				if (this.top > 0) {
					result = this.data.pop();
					this.top--;
				}

				return result;
			}
		}, {
			key: "push",
			value: function push(arg) {
				this.data[++this.top] = arg;

				return this;
			}
		}, {
			key: "search",
			value: function search(arg) {
				var index = this.data.indexOf(arg);

				return index === -1 ? -1 : this.data.length - index;
			}
		}]);

		return TinyStack;
	}();

	function factory() {
		for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
			args[_key2] = arguments[_key2];
		}

		return new (Function.prototype.bind.apply(TinyStack, [null].concat(args)))();
	}

	// Node, AMD & window supported
	if (typeof exports !== "undefined") {
		module.exports = factory;
	} else if (typeof define === "function" && define.amd !== void 0) {
		define(function () {
			return factory;
		});
	} else {
		global.stack = factory;
	}
})(typeof window !== "undefined" ? window : global);

}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})

},{}],535:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

function ensureImported(element, target) {

  if (element.ownerDocument !== target.ownerDocument) {
    try {
      // may fail on webkit
      return target.ownerDocument.importNode(element, true);
    } catch (e) {
      // ignore
    }
  }

  return element;
}

/**
 * appendTo utility
 */

/**
 * Append a node to a target element and return the appended node.
 *
 * @param  {SVGElement} element
 * @param  {SVGElement} target
 *
 * @return {SVGElement} the appended node
 */
function appendTo(element, target) {
  return target.appendChild(ensureImported(element, target));
}

/**
 * append utility
 */

/**
 * Append a node to an element
 *
 * @param  {SVGElement} element
 * @param  {SVGElement} node
 *
 * @return {SVGElement} the element
 */
function append(target, node) {
  appendTo(node, target);
  return target;
}

/**
 * attribute accessor utility
 */

var LENGTH_ATTR = 2;

var CSS_PROPERTIES = {
  'alignment-baseline': 1,
  '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
};

function getAttribute(node, name) {
  if (CSS_PROPERTIES[name]) {
    return node.style[name];
  } else {
    return node.getAttributeNS(null, name);
  }
}

function setAttribute(node, name, value) {
  var hyphenated = name.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();

  var type = CSS_PROPERTIES[hyphenated];

  if (type) {
    // append pixel unit, unless present
    if (type === LENGTH_ATTR && typeof value === 'number') {
      value = String(value) + 'px';
    }

    node.style[hyphenated] = value;
  } else {
    node.setAttributeNS(null, name, value);
  }
}

function setAttributes(node, attrs) {

  var names = Object.keys(attrs),
      i,
      name;

  for (i = 0, name; name = names[i]; i++) {
    setAttribute(node, name, attrs[name]);
  }
}

/**
 * Gets or sets raw attributes on a node.
 *
 * @param  {SVGElement} node
 * @param  {Object} [attrs]
 * @param  {String} [name]
 * @param  {String} [value]
 *
 * @return {String}
 */
function attr(node, name, value) {
  if (typeof name === 'string') {
    if (value !== undefined) {
      setAttribute(node, name, value);
    } else {
      return getAttribute(node, name);
    }
  } else {
    setAttributes(node, name);
  }

  return node;
}

/**
 * Clear utility
 */
function index(arr, obj) {
  if (arr.indexOf) {
    return arr.indexOf(obj);
  }

  for (var i = 0; i < arr.length; ++i) {
    if (arr[i] === obj) {
      return i;
    }
  }

  return -1;
}

var re = /\s+/;

var toString = Object.prototype.toString;

function defined(o) {
  return typeof o !== 'undefined';
}

/**
 * Wrap `el` in a `ClassList`.
 *
 * @param {Element} el
 * @return {ClassList}
 * @api public
 */

function classes(el) {
  return new ClassList(el);
}

function ClassList(el) {
  if (!el || !el.nodeType) {
    throw new Error('A DOM element reference is required');
  }
  this.el = el;
  this.list = el.classList;
}

/**
 * Add class `name` if not already present.
 *
 * @param {String} name
 * @return {ClassList}
 * @api public
 */

ClassList.prototype.add = function (name) {

  // classList
  if (this.list) {
    this.list.add(name);
    return this;
  }

  // fallback
  var arr = this.array();
  var i = index(arr, name);
  if (!~i) {
    arr.push(name);
  }

  if (defined(this.el.className.baseVal)) {
    this.el.className.baseVal = arr.join(' ');
  } else {
    this.el.className = arr.join(' ');
  }

  return this;
};

/**
 * Remove class `name` when present, or
 * pass a regular expression to remove
 * any which match.
 *
 * @param {String|RegExp} name
 * @return {ClassList}
 * @api public
 */

ClassList.prototype.remove = function (name) {
  if ('[object RegExp]' === toString.call(name)) {
    return this.removeMatching(name);
  }

  // classList
  if (this.list) {
    this.list.remove(name);
    return this;
  }

  // fallback
  var arr = this.array();
  var i = index(arr, name);
  if (~i) {
    arr.splice(i, 1);
  }
  this.el.className.baseVal = arr.join(' ');
  return this;
};

/**
 * Remove all classes matching `re`.
 *
 * @param {RegExp} re
 * @return {ClassList}
 * @api private
 */

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;
};

/**
 * 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
 */

ClassList.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;
  }

  // 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);
    }
  }

  return this;
};

/**
 * Return an array of classes.
 *
 * @return {Array}
 * @api public
 */

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;
};

/**
 * Check if class `name` is present.
 *
 * @param {String} name
 * @return {ClassList}
 * @api public
 */

ClassList.prototype.has = ClassList.prototype.contains = function (name) {
  return this.list ? this.list.contains(name) : !!~index(this.array(), name);
};

function remove(element) {
  var parent = element.parentNode;

  if (parent) {
    parent.removeChild(element);
  }

  return element;
}

/**
 * Clear utility
 */

/**
 * Removes all children from the given element
 *
 * @param  {DOMElement} element
 * @return {DOMElement} the element (for chaining)
 */
function clear(element) {
  var child;

  while (child = element.firstChild) {
    remove(child);
  }

  return element;
}

function clone(element) {
  return element.cloneNode(true);
}

var ns = {
  svg: 'http://www.w3.org/2000/svg'
};

/**
 * DOM parsing utility
 */

var SVG_START = '<svg xmlns="' + ns.svg + '"';

function parse(svg) {

  var unwrap = false;

  // 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;
  }

  var parsed = parseDocument(svg);

  if (!unwrap) {
    return parsed;
  }

  var fragment = document.createDocumentFragment();

  var parent = parsed.firstChild;

  while (parent.firstChild) {
    fragment.appendChild(parent.firstChild);
  }

  return fragment;
}

function parseDocument(svg) {

  var parser;

  // parse
  parser = new DOMParser();
  parser.async = false;

  return parser.parseFromString(svg, 'text/xml');
}

/**
 * Create utility for SVG elements
 */

/**
 * 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(name, attrs) {
  var element;

  if (name.charAt(0) === '<') {
    element = parse(name).firstChild;
    element = document.importNode(element, true);
  } else {
    element = document.createElementNS(ns.svg, name);
  }

  if (attrs) {
    attr(element, attrs);
  }

  return element;
}

/**
 * Events handling utility
 */

function on(node, event, listener, useCapture) {
  node.addEventListener(event, listener, useCapture);
}

function off(node, event, listener, useCapture) {
  node.removeEventListener(event, listener, useCapture);
}

/**
 * Geometry helpers
 */

// fake node used to instantiate svg geometry elements
var node = create('svg');

function extend(object, props) {
  var i,
      k,
      keys = Object.keys(props);

  for (i = 0; k = keys[i]; i++) {
    object[k] = props[k];
  }

  return object;
}

function createPoint(x, y) {
  var point = node.createSVGPoint();

  switch (arguments.length) {
    case 0:
      return point;
    case 2:
      x = {
        x: x,
        y: y
      };
      break;
  }

  return extend(point, x);
}

function createMatrix(a, b, c, d, e, f) {
  var matrix = node.createSVGMatrix();

  switch (arguments.length) {
    case 0:
      return matrix;
    case 6:
      a = {
        a: a,
        b: b,
        c: c,
        d: d,
        e: e,
        f: f
      };
      break;
  }

  return extend(matrix, a);
}

function createTransform(matrix) {
  if (matrix) {
    return node.createSVGTransformFromMatrix(matrix);
  } else {
    return node.createSVGTransform();
  }
}

/**
 * Serialization util
 */

var TEXT_ENTITIES = /([&<>]{1})/g;
var ATTR_ENTITIES = /([\n\r"]{1})/g;

var ENTITY_REPLACEMENT = {
  '&': '&amp;',
  '<': '&lt;',
  '>': '&gt;',
  '"': '\''
};

function escape(str, pattern) {

  function replaceFn(match, entity) {
    return ENTITY_REPLACEMENT[entity] || entity;
  }

  return str.replace(pattern, replaceFn);
}

function serialize(node, output) {

  var i, len, attrMap, attrNode, childNodes;

  switch (node.nodeType) {
    // TEXT
    case 3:
      // replace special XML characters
      output.push(escape(node.textContent, TEXT_ENTITIES));
      break;

    // ELEMENT
    case 1:
      output.push('<', node.tagName);

      if (node.hasAttributes()) {
        attrMap = node.attributes;
        for (i = 0, len = attrMap.length; i < len; ++i) {
          attrNode = attrMap.item(i);
          output.push(' ', attrNode.name, '="', escape(attrNode.value, ATTR_ENTITIES), '"');
        }
      }

      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;

    // COMMENT
    case 8:
      output.push('<!--', escape(node.nodeValue, TEXT_ENTITIES), '-->');
      break;

    // CDATA
    case 4:
      output.push('<![CDATA[', node.nodeValue, ']]>');
      break;

    default:
      throw new Error('unable to handle node ' + node.nodeType);
  }

  return output;
}

/**
 * innerHTML like functionality for SVG elements.
 * based on innerSVG (https://code.google.com/p/innersvg)
 */

function set(element, svg) {

  var parsed = parse(svg);

  // clear element contents
  clear(element);

  if (!svg) {
    return;
  }

  if (!isFragment(parsed)) {
    // extract <svg> from parsed document
    parsed = parsed.documentElement;
  }

  var nodes = slice(parsed.childNodes);

  // import + append each node
  for (var i = 0; i < nodes.length; i++) {
    appendTo(nodes[i], element);
  }
}

function get(element) {
  var child = element.firstChild,
      output = [];

  while (child) {
    serialize(child, output);
    child = child.nextSibling;
  }

  return output.join('');
}

function isFragment(node) {
  return node.nodeName === '#document-fragment';
}

function innerSVG(element, svg) {

  if (svg !== undefined) {

    try {
      set(element, svg);
    } catch (e) {
      throw new Error('error parsing SVG: ' + e.message);
    }

    return element;
  } else {
    return get(element);
  }
}

function slice(arr) {
  return Array.prototype.slice.call(arr);
}

/**
 * Selection utilities
 */

function select(node, selector) {
  return node.querySelector(selector);
}

function selectAll(node, selector) {
  var nodes = node.querySelectorAll(selector);

  return [].map.call(nodes, function (element) {
    return element;
  });
}

/**
 * prependTo utility
 */

/**
 * Prepend a node to a target element and return the prepended node.
 *
 * @param  {SVGElement} node
 * @param  {SVGElement} target
 *
 * @return {SVGElement} the prepended node
 */
function prependTo(node, target) {
  return target.insertBefore(ensureImported(node, target), target.firstChild || null);
}

/**
 * prepend utility
 */

/**
 * Prepend a node to a target element
 *
 * @param  {SVGElement} target
 * @param  {SVGElement} node
 *
 * @return {SVGElement} the target element
 */
function prepend(target, node) {
  prependTo(node, target);
  return target;
}

/**
 * Replace utility
 */

function replace(element, replacement) {
  element.parentNode.replaceChild(ensureImported(replacement, element), element);
  return replacement;
}

/**
 * transform accessor utility
 */

function wrapMatrix(transformList, transform) {
  if (transform instanceof SVGMatrix) {
    return transformList.createSVGTransformFromMatrix(transform);
  } else {
    return transform;
  }
}

function setTransforms(transformList, transforms) {
  var i, t;

  transformList.clear();

  for (i = 0; t = transforms[i]; i++) {
    transformList.appendItem(wrapMatrix(transformList, t));
  }

  transformList.consolidate();
}

function transform(node, transforms) {
  var transformList = node.transform.baseVal;

  if (arguments.length === 1) {
    return transformList.consolidate();
  } else {
    if (transforms.length) {
      setTransforms(transformList, transforms);
    } else {
      transformList.initialize(wrapMatrix(transformList, transforms));
    }
  }
}

exports.append = append;
exports.appendTo = appendTo;
exports.attr = attr;
exports.classes = classes;
exports.clear = clear;
exports.clone = clone;
exports.create = create;
exports.innerSVG = innerSVG;
exports.prepend = prepend;
exports.prependTo = prependTo;
exports.remove = remove;
exports.replace = replace;
exports.transform = transform;
exports.on = on;
exports.off = off;
exports.createPoint = createPoint;
exports.createMatrix = createMatrix;
exports.createTransform = createTransform;
exports.select = select;
exports.selectAll = selectAll;

},{}],536:[function(require,module,exports){
module.exports = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n<bpmn2:definitions xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:bpmn2=\"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\" xmlns:di=\"http://www.omg.org/spec/DD/20100524/DI\" xsi:schemaLocation=\"http://www.omg.org/spec/BPMN/20100524/MODEL BPMN20.xsd\" id=\"sample-diagram\" targetNamespace=\"http://bpmn.io/schema/bpmn\">\r\n  <bpmn2:process id=\"Process_1\" isExecutable=\"false\">\r\n    <bpmn2:startEvent id=\"StartEvent_1\"/>\r\n  </bpmn2:process>\r\n  <bpmndi:BPMNDiagram id=\"BPMNDiagram_1\">\r\n    <bpmndi:BPMNPlane id=\"BPMNPlane_1\" bpmnElement=\"Process_1\">\r\n      <bpmndi:BPMNShape id=\"_BPMNShape_StartEvent_2\" bpmnElement=\"StartEvent_1\">\r\n        <dc:Bounds height=\"36.0\" width=\"36.0\" x=\"412.0\" y=\"240.0\"/>\r\n      </bpmndi:BPMNShape>\r\n    </bpmndi:BPMNPlane>\r\n  </bpmndi:BPMNDiagram>\r\n</bpmn2:definitions>";

},{}]},{},[1])
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","app/index.js","node_modules/bpmn-js-properties-panel/index.js","node_modules/bpmn-js-properties-panel/lib/PropertiesActivator.js","node_modules/bpmn-js-properties-panel/lib/PropertiesPanel.js","node_modules/bpmn-js-properties-panel/lib/Utils.js","node_modules/bpmn-js-properties-panel/lib/cmd/CreateAndReferenceHandler.js","node_modules/bpmn-js-properties-panel/lib/cmd/CreateBusinessObjectListHandler.js","node_modules/bpmn-js-properties-panel/lib/cmd/MultiCommandHandler.js","node_modules/bpmn-js-properties-panel/lib/cmd/UpdateBusinessObjectHandler.js","node_modules/bpmn-js-properties-panel/lib/cmd/UpdateBusinessObjectListHandler.js","node_modules/bpmn-js-properties-panel/lib/cmd/index.js","node_modules/bpmn-js-properties-panel/lib/factory/CheckboxEntryFactory.js","node_modules/bpmn-js-properties-panel/lib/factory/ComboEntryFactory.js","node_modules/bpmn-js-properties-panel/lib/factory/EntryFactory.js","node_modules/bpmn-js-properties-panel/lib/factory/EntryFieldDescription.js","node_modules/bpmn-js-properties-panel/lib/factory/LabelFactory.js","node_modules/bpmn-js-properties-panel/lib/factory/LinkEntryFactory.js","node_modules/bpmn-js-properties-panel/lib/factory/SelectEntryFactory.js","node_modules/bpmn-js-properties-panel/lib/factory/TableEntryFactory.js","node_modules/bpmn-js-properties-panel/lib/factory/TextBoxEntryFactory.js","node_modules/bpmn-js-properties-panel/lib/factory/TextInputEntryFactory.js","node_modules/bpmn-js-properties-panel/lib/factory/ValidationAwareTextInput.js","node_modules/bpmn-js-properties-panel/lib/helper/AsyncCapableHelper.js","node_modules/bpmn-js-properties-panel/lib/helper/CmdHelper.js","node_modules/bpmn-js-properties-panel/lib/helper/ElementHelper.js","node_modules/bpmn-js-properties-panel/lib/helper/EventDefinitionHelper.js","node_modules/bpmn-js-properties-panel/lib/helper/ExtensionElementsHelper.js","node_modules/bpmn-js-properties-panel/lib/helper/FormHelper.js","node_modules/bpmn-js-properties-panel/lib/helper/ImplementationTypeHelper.js","node_modules/bpmn-js-properties-panel/lib/helper/InputOutputHelper.js","node_modules/bpmn-js-properties-panel/lib/helper/ParticipantHelper.js","node_modules/bpmn-js-properties-panel/lib/index.js","node_modules/bpmn-js-properties-panel/lib/provider/bpmn/parts/DocumentationProps.js","node_modules/bpmn-js-properties-panel/lib/provider/bpmn/parts/EventProps.js","node_modules/bpmn-js-properties-panel/lib/provider/bpmn/parts/ExecutableProps.js","node_modules/bpmn-js-properties-panel/lib/provider/bpmn/parts/IdProps.js","node_modules/bpmn-js-properties-panel/lib/provider/bpmn/parts/LinkProps.js","node_modules/bpmn-js-properties-panel/lib/provider/bpmn/parts/NameProps.js","node_modules/bpmn-js-properties-panel/lib/provider/bpmn/parts/ProcessProps.js","node_modules/bpmn-js-properties-panel/lib/provider/bpmn/parts/implementation/CompensateEventDefinition.js","node_modules/bpmn-js-properties-panel/lib/provider/bpmn/parts/implementation/ConditionalEventDefinition.js","node_modules/bpmn-js-properties-panel/lib/provider/bpmn/parts/implementation/ElementReferenceProperty.js","node_modules/bpmn-js-properties-panel/lib/provider/bpmn/parts/implementation/ErrorEventDefinition.js","node_modules/bpmn-js-properties-panel/lib/provider/bpmn/parts/implementation/EscalationEventDefinition.js","node_modules/bpmn-js-properties-panel/lib/provider/bpmn/parts/implementation/EventDefinitionReference.js","node_modules/bpmn-js-properties-panel/lib/provider/bpmn/parts/implementation/MessageEventDefinition.js","node_modules/bpmn-js-properties-panel/lib/provider/bpmn/parts/implementation/Name.js","node_modules/bpmn-js-properties-panel/lib/provider/bpmn/parts/implementation/SignalEventDefinition.js","node_modules/bpmn-js-properties-panel/lib/provider/bpmn/parts/implementation/TimerEventDefinition.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/CamundaPropertiesProvider.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/element-templates/CreateHelper.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/element-templates/CustomElementsPropertiesActivator.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/element-templates/ElementTemplates.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/element-templates/ElementTemplatesLoader.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/element-templates/Helper.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/element-templates/Validator.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/element-templates/cmd/ChangeElementTemplateHandler.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/element-templates/cmd/index.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/element-templates/index.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/element-templates/parts/ChooserProps.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/element-templates/parts/CustomProps.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/index.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/parts/AsynchronousContinuationProps.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/parts/CallActivityProps.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/parts/ConnectorDetailProps.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/parts/ConnectorInputOutputParameterProps.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/parts/ConnectorInputOutputProps.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/parts/ExternalTaskConfigurationProps.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/parts/FieldInjectionProps.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/parts/FormProps.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/parts/HistoryTimeToLiveProps.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/parts/InputOutputParameterProps.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/parts/InputOutputProps.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/parts/JobConfigurationProps.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/parts/ListenerDetailProps.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/parts/ListenerFieldInjectionProps.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/parts/ListenerProps.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/parts/MultiInstanceLoopProps.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/parts/PropertiesProps.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/parts/ScriptTaskProps.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/parts/SequenceFlowProps.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/parts/ServiceTaskDelegateProps.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/parts/StartEventInitiator.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/parts/UserTaskProps.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/parts/VariableMappingProps.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/parts/VersionTagProps.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/parts/implementation/AsyncContinuation.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/parts/implementation/Callable.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/parts/implementation/Delegate.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/parts/implementation/ExtensionElements.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/parts/implementation/External.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/parts/implementation/ExternalTaskPriority.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/parts/implementation/FieldInjection.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/parts/implementation/HistoryTimeToLive.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/parts/implementation/ImplementationType.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/parts/implementation/InputOutput.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/parts/implementation/InputOutputParameter.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/parts/implementation/JobPriority.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/parts/implementation/JobRetryTimeCycle.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/parts/implementation/Listener.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/parts/implementation/MultiInstanceLoopCharacteristics.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/parts/implementation/Properties.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/parts/implementation/ResultVariable.js","node_modules/bpmn-js-properties-panel/lib/provider/camunda/parts/implementation/Script.js","node_modules/bpmn-js-properties-panel/node_modules/min-dom/lib/attr.js","node_modules/bpmn-js-properties-panel/node_modules/min-dom/lib/classes.js","node_modules/bpmn-js-properties-panel/node_modules/min-dom/lib/clear.js","node_modules/bpmn-js-properties-panel/node_modules/min-dom/lib/closest.js","node_modules/bpmn-js-properties-panel/node_modules/min-dom/lib/delegate.js","node_modules/bpmn-js-properties-panel/node_modules/min-dom/lib/domify.js","node_modules/bpmn-js-properties-panel/node_modules/min-dom/lib/matches.js","node_modules/bpmn-js-properties-panel/node_modules/min-dom/lib/query.js","node_modules/bpmn-js-properties-panel/node_modules/min-dom/lib/remove.js","node_modules/bpmn-js/lib/Modeler.js","node_modules/bpmn-js/lib/NavigatedViewer.js","node_modules/bpmn-js/lib/Viewer.js","node_modules/bpmn-js/lib/core/index.js","node_modules/bpmn-js/lib/draw/BpmnRenderUtil.js","node_modules/bpmn-js/lib/draw/BpmnRenderer.js","node_modules/bpmn-js/lib/draw/PathMap.js","node_modules/bpmn-js/lib/draw/TextRenderer.js","node_modules/bpmn-js/lib/draw/index.js","node_modules/bpmn-js/lib/features/auto-place/AutoPlace.js","node_modules/bpmn-js/lib/features/auto-place/AutoPlaceSelectionBehavior.js","node_modules/bpmn-js/lib/features/auto-place/AutoPlaceUtil.js","node_modules/bpmn-js/lib/features/auto-place/index.js","node_modules/bpmn-js/lib/features/auto-resize/BpmnAutoResize.js","node_modules/bpmn-js/lib/features/auto-resize/BpmnAutoResizeProvider.js","node_modules/bpmn-js/lib/features/auto-resize/index.js","node_modules/bpmn-js/lib/features/context-pad/ContextPadProvider.js","node_modules/bpmn-js/lib/features/context-pad/index.js","node_modules/bpmn-js/lib/features/copy-paste/BpmnCopyPaste.js","node_modules/bpmn-js/lib/features/copy-paste/index.js","node_modules/bpmn-js/lib/features/distribute-elements/BpmnDistributeElements.js","node_modules/bpmn-js/lib/features/distribute-elements/index.js","node_modules/bpmn-js/lib/features/editor-actions/BpmnEditorActions.js","node_modules/bpmn-js/lib/features/editor-actions/index.js","node_modules/bpmn-js/lib/features/keyboard/BpmnKeyboardBindings.js","node_modules/bpmn-js/lib/features/keyboard/index.js","node_modules/bpmn-js/lib/features/label-editing/LabelEditingPreview.js","node_modules/bpmn-js/lib/features/label-editing/LabelEditingProvider.js","node_modules/bpmn-js/lib/features/label-editing/LabelUtil.js","node_modules/bpmn-js/lib/features/label-editing/cmd/UpdateLabelHandler.js","node_modules/bpmn-js/lib/features/label-editing/index.js","node_modules/bpmn-js/lib/features/modeling/BpmnFactory.js","node_modules/bpmn-js/lib/features/modeling/BpmnLayouter.js","node_modules/bpmn-js/lib/features/modeling/BpmnUpdater.js","node_modules/bpmn-js/lib/features/modeling/ElementFactory.js","node_modules/bpmn-js/lib/features/modeling/Modeling.js","node_modules/bpmn-js/lib/features/modeling/behavior/AdaptiveLabelPositioningBehavior.js","node_modules/bpmn-js/lib/features/modeling/behavior/AppendBehavior.js","node_modules/bpmn-js/lib/features/modeling/behavior/BoundaryEventBehavior.js","node_modules/bpmn-js/lib/features/modeling/behavior/CopyPasteBehavior.js","node_modules/bpmn-js/lib/features/modeling/behavior/CreateBoundaryEventBehavior.js","node_modules/bpmn-js/lib/features/modeling/behavior/CreateDataObjectBehavior.js","node_modules/bpmn-js/lib/features/modeling/behavior/CreateParticipantBehavior.js","node_modules/bpmn-js/lib/features/modeling/behavior/DataInputAssociationBehavior.js","node_modules/bpmn-js/lib/features/modeling/behavior/DataStoreBehavior.js","node_modules/bpmn-js/lib/features/modeling/behavior/DeleteLaneBehavior.js","node_modules/bpmn-js/lib/features/modeling/behavior/DropOnFlowBehavior.js","node_modules/bpmn-js/lib/features/modeling/behavior/ImportDockingFix.js","node_modules/bpmn-js/lib/features/modeling/behavior/LabelBehavior.js","node_modules/bpmn-js/lib/features/modeling/behavior/ModelingFeedback.js","node_modules/bpmn-js/lib/features/modeling/behavior/RemoveElementBehavior.js","node_modules/bpmn-js/lib/features/modeling/behavior/RemoveParticipantBehavior.js","node_modules/bpmn-js/lib/features/modeling/behavior/ReplaceConnectionBehavior.js","node_modules/bpmn-js/lib/features/modeling/behavior/ReplaceElementBehaviour.js","node_modules/bpmn-js/lib/features/modeling/behavior/ResizeLaneBehavior.js","node_modules/bpmn-js/lib/features/modeling/behavior/ToggleElementCollapseBehaviour.js","node_modules/bpmn-js/lib/features/modeling/behavior/UnclaimIdBehavior.js","node_modules/bpmn-js/lib/features/modeling/behavior/UnsetDefaultFlowBehavior.js","node_modules/bpmn-js/lib/features/modeling/behavior/UpdateFlowNodeRefsBehavior.js","node_modules/bpmn-js/lib/features/modeling/behavior/index.js","node_modules/bpmn-js/lib/features/modeling/behavior/util/GeometricUtil.js","node_modules/bpmn-js/lib/features/modeling/behavior/util/LabelLayoutUtil.js","node_modules/bpmn-js/lib/features/modeling/behavior/util/LineAttachmentUtil.js","node_modules/bpmn-js/lib/features/modeling/behavior/util/LineIntersect.js","node_modules/bpmn-js/lib/features/modeling/cmd/AddLaneHandler.js","node_modules/bpmn-js/lib/features/modeling/cmd/IdClaimHandler.js","node_modules/bpmn-js/lib/features/modeling/cmd/ResizeLaneHandler.js","node_modules/bpmn-js/lib/features/modeling/cmd/SetColorHandler.js","node_modules/bpmn-js/lib/features/modeling/cmd/SplitLaneHandler.js","node_modules/bpmn-js/lib/features/modeling/cmd/UpdateCanvasRootHandler.js","node_modules/bpmn-js/lib/features/modeling/cmd/UpdateFlowNodeRefsHandler.js","node_modules/bpmn-js/lib/features/modeling/cmd/UpdatePropertiesHandler.js","node_modules/bpmn-js/lib/features/modeling/cmd/UpdateSemanticParentHandler.js","node_modules/bpmn-js/lib/features/modeling/index.js","node_modules/bpmn-js/lib/features/modeling/util/LaneUtil.js","node_modules/bpmn-js/lib/features/modeling/util/ModelingUtil.js","node_modules/bpmn-js/lib/features/ordering/BpmnOrderingProvider.js","node_modules/bpmn-js/lib/features/ordering/index.js","node_modules/bpmn-js/lib/features/palette/PaletteProvider.js","node_modules/bpmn-js/lib/features/palette/index.js","node_modules/bpmn-js/lib/features/popup-menu/ReplaceMenuProvider.js","node_modules/bpmn-js/lib/features/popup-menu/index.js","node_modules/bpmn-js/lib/features/popup-menu/util/TypeUtil.js","node_modules/bpmn-js/lib/features/replace-preview/BpmnReplacePreview.js","node_modules/bpmn-js/lib/features/replace-preview/index.js","node_modules/bpmn-js/lib/features/replace/BpmnReplace.js","node_modules/bpmn-js/lib/features/replace/ReplaceOptions.js","node_modules/bpmn-js/lib/features/replace/index.js","node_modules/bpmn-js/lib/features/rules/BpmnRules.js","node_modules/bpmn-js/lib/features/rules/index.js","node_modules/bpmn-js/lib/features/search/BpmnSearchProvider.js","node_modules/bpmn-js/lib/features/search/index.js","node_modules/bpmn-js/lib/features/snapping/BpmnSnapping.js","node_modules/bpmn-js/lib/features/snapping/BpmnSnappingUtil.js","node_modules/bpmn-js/lib/features/snapping/index.js","node_modules/bpmn-js/lib/import/BpmnImporter.js","node_modules/bpmn-js/lib/import/BpmnTreeWalker.js","node_modules/bpmn-js/lib/import/Importer.js","node_modules/bpmn-js/lib/import/Util.js","node_modules/bpmn-js/lib/import/index.js","node_modules/bpmn-js/lib/util/DiUtil.js","node_modules/bpmn-js/lib/util/LabelUtil.js","node_modules/bpmn-js/lib/util/ModelUtil.js","node_modules/bpmn-js/lib/util/PoweredByUtil.js","node_modules/bpmn-js/lib/util/model/ModelCloneHelper.js","node_modules/bpmn-js/lib/util/model/ModelCloneUtils.js","node_modules/bpmn-moddle/index.js","node_modules/bpmn-moddle/lib/bpmn-moddle.js","node_modules/bpmn-moddle/lib/simple.js","node_modules/bpmn-moddle/resources/bpmn-io/json/bioc.json","node_modules/bpmn-moddle/resources/bpmn/json/bpmn.json","node_modules/bpmn-moddle/resources/bpmn/json/bpmndi.json","node_modules/bpmn-moddle/resources/bpmn/json/dc.json","node_modules/bpmn-moddle/resources/bpmn/json/di.json","node_modules/browserify/node_modules/events/events.js","node_modules/camunda-bpmn-moddle/resources/camunda.json","node_modules/component-classes/index.js","node_modules/component-closest/index.js","node_modules/component-delegate/index.js","node_modules/component-event/index.js","node_modules/component-indexof/index.js","node_modules/component-matches-selector/index.js","node_modules/component-query/index.js","node_modules/css.escape/css.escape.js","node_modules/diagram-js-direct-editing/index.js","node_modules/diagram-js-direct-editing/lib/DirectEditing.js","node_modules/diagram-js-direct-editing/lib/TextBox.js","node_modules/diagram-js/index.js","node_modules/diagram-js/lib/Diagram.js","node_modules/diagram-js/lib/command/CommandInterceptor.js","node_modules/diagram-js/lib/command/CommandStack.js","node_modules/diagram-js/lib/command/index.js","node_modules/diagram-js/lib/core/Canvas.js","node_modules/diagram-js/lib/core/ElementFactory.js","node_modules/diagram-js/lib/core/ElementRegistry.js","node_modules/diagram-js/lib/core/EventBus.js","node_modules/diagram-js/lib/core/GraphicsFactory.js","node_modules/diagram-js/lib/core/index.js","node_modules/diagram-js/lib/draw/BaseRenderer.js","node_modules/diagram-js/lib/draw/DefaultRenderer.js","node_modules/diagram-js/lib/draw/Styles.js","node_modules/diagram-js/lib/draw/index.js","node_modules/diagram-js/lib/features/align-elements/AlignElements.js","node_modules/diagram-js/lib/features/align-elements/index.js","node_modules/diagram-js/lib/features/attach-support/AttachSupport.js","node_modules/diagram-js/lib/features/attach-support/index.js","node_modules/diagram-js/lib/features/auto-resize/AutoResize.js","node_modules/diagram-js/lib/features/auto-resize/AutoResizeProvider.js","node_modules/diagram-js/lib/features/auto-scroll/AutoScroll.js","node_modules/diagram-js/lib/features/auto-scroll/index.js","node_modules/diagram-js/lib/features/bendpoints/BendpointMove.js","node_modules/diagram-js/lib/features/bendpoints/BendpointSnapping.js","node_modules/diagram-js/lib/features/bendpoints/BendpointUtil.js","node_modules/diagram-js/lib/features/bendpoints/Bendpoints.js","node_modules/diagram-js/lib/features/bendpoints/ConnectionSegmentMove.js","node_modules/diagram-js/lib/features/bendpoints/index.js","node_modules/diagram-js/lib/features/change-support/ChangeSupport.js","node_modules/diagram-js/lib/features/change-support/index.js","node_modules/diagram-js/lib/features/clipboard/Clipboard.js","node_modules/diagram-js/lib/features/clipboard/index.js","node_modules/diagram-js/lib/features/connect/Connect.js","node_modules/diagram-js/lib/features/connect/index.js","node_modules/diagram-js/lib/features/context-pad/ContextPad.js","node_modules/diagram-js/lib/features/context-pad/index.js","node_modules/diagram-js/lib/features/copy-paste/CopyPaste.js","node_modules/diagram-js/lib/features/copy-paste/index.js","node_modules/diagram-js/lib/features/create/Create.js","node_modules/diagram-js/lib/features/create/index.js","node_modules/diagram-js/lib/features/distribute-elements/DistributeElements.js","node_modules/diagram-js/lib/features/distribute-elements/index.js","node_modules/diagram-js/lib/features/dragging/Dragging.js","node_modules/diagram-js/lib/features/dragging/HoverFix.js","node_modules/diagram-js/lib/features/dragging/index.js","node_modules/diagram-js/lib/features/editor-actions/EditorActions.js","node_modules/diagram-js/lib/features/editor-actions/index.js","node_modules/diagram-js/lib/features/global-connect/GlobalConnect.js","node_modules/diagram-js/lib/features/global-connect/index.js","node_modules/diagram-js/lib/features/hand-tool/HandTool.js","node_modules/diagram-js/lib/features/hand-tool/index.js","node_modules/diagram-js/lib/features/interaction-events/InteractionEvents.js","node_modules/diagram-js/lib/features/interaction-events/index.js","node_modules/diagram-js/lib/features/keyboard-move-selection/KeyboardMoveSelection.js","node_modules/diagram-js/lib/features/keyboard-move-selection/index.js","node_modules/diagram-js/lib/features/keyboard/Keyboard.js","node_modules/diagram-js/lib/features/keyboard/KeyboardBindings.js","node_modules/diagram-js/lib/features/keyboard/KeyboardUtil.js","node_modules/diagram-js/lib/features/keyboard/index.js","node_modules/diagram-js/lib/features/label-support/LabelSupport.js","node_modules/diagram-js/lib/features/label-support/index.js","node_modules/diagram-js/lib/features/lasso-tool/LassoTool.js","node_modules/diagram-js/lib/features/lasso-tool/index.js","node_modules/diagram-js/lib/features/modeling/Modeling.js","node_modules/diagram-js/lib/features/modeling/cmd/AlignElementsHandler.js","node_modules/diagram-js/lib/features/modeling/cmd/AppendShapeHandler.js","node_modules/diagram-js/lib/features/modeling/cmd/CreateConnectionHandler.js","node_modules/diagram-js/lib/features/modeling/cmd/CreateLabelHandler.js","node_modules/diagram-js/lib/features/modeling/cmd/CreateShapeHandler.js","node_modules/diagram-js/lib/features/modeling/cmd/DeleteConnectionHandler.js","node_modules/diagram-js/lib/features/modeling/cmd/DeleteElementsHandler.js","node_modules/diagram-js/lib/features/modeling/cmd/DeleteShapeHandler.js","node_modules/diagram-js/lib/features/modeling/cmd/DistributeElementsHandler.js","node_modules/diagram-js/lib/features/modeling/cmd/LayoutConnectionHandler.js","node_modules/diagram-js/lib/features/modeling/cmd/MoveConnectionHandler.js","node_modules/diagram-js/lib/features/modeling/cmd/MoveElementsHandler.js","node_modules/diagram-js/lib/features/modeling/cmd/MoveShapeHandler.js","node_modules/diagram-js/lib/features/modeling/cmd/PasteHandler.js","node_modules/diagram-js/lib/features/modeling/cmd/ReconnectConnectionHandler.js","node_modules/diagram-js/lib/features/modeling/cmd/ReplaceShapeHandler.js","node_modules/diagram-js/lib/features/modeling/cmd/ResizeShapeHandler.js","node_modules/diagram-js/lib/features/modeling/cmd/SpaceToolHandler.js","node_modules/diagram-js/lib/features/modeling/cmd/ToggleShapeCollapseHandler.js","node_modules/diagram-js/lib/features/modeling/cmd/UpdateAttachmentHandler.js","node_modules/diagram-js/lib/features/modeling/cmd/UpdateWaypointsHandler.js","node_modules/diagram-js/lib/features/modeling/cmd/helper/AnchorsHelper.js","node_modules/diagram-js/lib/features/modeling/cmd/helper/MoveClosure.js","node_modules/diagram-js/lib/features/modeling/cmd/helper/MoveHelper.js","node_modules/diagram-js/lib/features/mouse-tracking/MouseTracking.js","node_modules/diagram-js/lib/features/mouse-tracking/index.js","node_modules/diagram-js/lib/features/move/Move.js","node_modules/diagram-js/lib/features/move/MovePreview.js","node_modules/diagram-js/lib/features/move/index.js","node_modules/diagram-js/lib/features/ordering/OrderingProvider.js","node_modules/diagram-js/lib/features/outline/Outline.js","node_modules/diagram-js/lib/features/outline/index.js","node_modules/diagram-js/lib/features/overlays/Overlays.js","node_modules/diagram-js/lib/features/overlays/index.js","node_modules/diagram-js/lib/features/palette/Palette.js","node_modules/diagram-js/lib/features/palette/index.js","node_modules/diagram-js/lib/features/popup-menu/PopupMenu.js","node_modules/diagram-js/lib/features/popup-menu/index.js","node_modules/diagram-js/lib/features/preview-support/PreviewSupport.js","node_modules/diagram-js/lib/features/preview-support/index.js","node_modules/diagram-js/lib/features/replace/Replace.js","node_modules/diagram-js/lib/features/replace/index.js","node_modules/diagram-js/lib/features/resize/Resize.js","node_modules/diagram-js/lib/features/resize/ResizeHandles.js","node_modules/diagram-js/lib/features/resize/ResizePreview.js","node_modules/diagram-js/lib/features/resize/ResizeUtil.js","node_modules/diagram-js/lib/features/resize/index.js","node_modules/diagram-js/lib/features/rules/RuleProvider.js","node_modules/diagram-js/lib/features/rules/Rules.js","node_modules/diagram-js/lib/features/rules/index.js","node_modules/diagram-js/lib/features/search-pad/SearchPad.js","node_modules/diagram-js/lib/features/search-pad/index.js","node_modules/diagram-js/lib/features/selection/Selection.js","node_modules/diagram-js/lib/features/selection/SelectionBehavior.js","node_modules/diagram-js/lib/features/selection/SelectionVisuals.js","node_modules/diagram-js/lib/features/selection/index.js","node_modules/diagram-js/lib/features/snapping/SnapContext.js","node_modules/diagram-js/lib/features/snapping/SnapUtil.js","node_modules/diagram-js/lib/features/snapping/Snapping.js","node_modules/diagram-js/lib/features/space-tool/SpaceTool.js","node_modules/diagram-js/lib/features/space-tool/SpaceToolPreview.js","node_modules/diagram-js/lib/features/space-tool/SpaceUtil.js","node_modules/diagram-js/lib/features/space-tool/index.js","node_modules/diagram-js/lib/features/tool-manager/ToolManager.js","node_modules/diagram-js/lib/features/tool-manager/index.js","node_modules/diagram-js/lib/features/tooltips/Tooltips.js","node_modules/diagram-js/lib/features/tooltips/index.js","node_modules/diagram-js/lib/features/touch/TouchFix.js","node_modules/diagram-js/lib/features/touch/TouchInteractionEvents.js","node_modules/diagram-js/lib/features/touch/index.js","node_modules/diagram-js/lib/i18n/translate/index.js","node_modules/diagram-js/lib/i18n/translate/translate.js","node_modules/diagram-js/lib/layout/BaseLayouter.js","node_modules/diagram-js/lib/layout/CroppingConnectionDocking.js","node_modules/diagram-js/lib/layout/LayoutUtil.js","node_modules/diagram-js/lib/layout/ManhattanLayout.js","node_modules/diagram-js/lib/model/index.js","node_modules/diagram-js/lib/navigation/keyboard-move/KeyboardMove.js","node_modules/diagram-js/lib/navigation/keyboard-move/index.js","node_modules/diagram-js/lib/navigation/movecanvas/MoveCanvas.js","node_modules/diagram-js/lib/navigation/movecanvas/index.js","node_modules/diagram-js/lib/navigation/touch/index.js","node_modules/diagram-js/lib/navigation/zoomscroll/ZoomScroll.js","node_modules/diagram-js/lib/navigation/zoomscroll/ZoomUtil.js","node_modules/diagram-js/lib/navigation/zoomscroll/index.js","node_modules/diagram-js/lib/util/AttachUtil.js","node_modules/diagram-js/lib/util/ClickTrap.js","node_modules/diagram-js/lib/util/Collections.js","node_modules/diagram-js/lib/util/CopyPasteUtil.js","node_modules/diagram-js/lib/util/Cursor.js","node_modules/diagram-js/lib/util/Elements.js","node_modules/diagram-js/lib/util/Event.js","node_modules/diagram-js/lib/util/Geometry.js","node_modules/diagram-js/lib/util/GraphicsUtil.js","node_modules/diagram-js/lib/util/IdGenerator.js","node_modules/diagram-js/lib/util/LineIntersection.js","node_modules/diagram-js/lib/util/Math.js","node_modules/diagram-js/lib/util/Mouse.js","node_modules/diagram-js/lib/util/Platform.js","node_modules/diagram-js/lib/util/PositionUtil.js","node_modules/diagram-js/lib/util/Removal.js","node_modules/diagram-js/lib/util/RenderUtil.js","node_modules/diagram-js/lib/util/SvgTransformUtil.js","node_modules/diagram-js/lib/util/Text.js","node_modules/didi/dist/index.js","node_modules/domify/index.js","node_modules/hammerjs/hammer.js","node_modules/hat/index.js","node_modules/ids/index.js","node_modules/inherits/inherits_browser.js","node_modules/jquery/dist/jquery.js","node_modules/lodash/array/flattenDeep.js","node_modules/lodash/array/last.js","node_modules/lodash/array/xor.js","node_modules/lodash/collection/filter.js","node_modules/lodash/collection/find.js","node_modules/lodash/collection/forEach.js","node_modules/lodash/collection/indexBy.js","node_modules/lodash/collection/map.js","node_modules/lodash/date/now.js","node_modules/lodash/function/debounce.js","node_modules/lodash/function/restParam.js","node_modules/lodash/internal/SetCache.js","node_modules/lodash/internal/arrayEach.js","node_modules/lodash/internal/arrayFilter.js","node_modules/lodash/internal/arrayMap.js","node_modules/lodash/internal/arrayPush.js","node_modules/lodash/internal/arraySome.js","node_modules/lodash/internal/assignWith.js","node_modules/lodash/internal/baseAssign.js","node_modules/lodash/internal/baseCallback.js","node_modules/lodash/internal/baseCopy.js","node_modules/lodash/internal/baseCreate.js","node_modules/lodash/internal/baseDifference.js","node_modules/lodash/internal/baseEach.js","node_modules/lodash/internal/baseFilter.js","node_modules/lodash/internal/baseFind.js","node_modules/lodash/internal/baseFindIndex.js","node_modules/lodash/internal/baseFlatten.js","node_modules/lodash/internal/baseFor.js","node_modules/lodash/internal/baseForOwn.js","node_modules/lodash/internal/baseGet.js","node_modules/lodash/internal/baseIndexOf.js","node_modules/lodash/internal/baseIsEqual.js","node_modules/lodash/internal/baseIsEqualDeep.js","node_modules/lodash/internal/baseIsMatch.js","node_modules/lodash/internal/baseMap.js","node_modules/lodash/internal/baseMatches.js","node_modules/lodash/internal/baseMatchesProperty.js","node_modules/lodash/internal/baseProperty.js","node_modules/lodash/internal/basePropertyDeep.js","node_modules/lodash/internal/baseSlice.js","node_modules/lodash/internal/baseToString.js","node_modules/lodash/internal/baseUniq.js","node_modules/lodash/internal/baseValues.js","node_modules/lodash/internal/bindCallback.js","node_modules/lodash/internal/cacheIndexOf.js","node_modules/lodash/internal/cachePush.js","node_modules/lodash/internal/createAggregator.js","node_modules/lodash/internal/createAssigner.js","node_modules/lodash/internal/createBaseEach.js","node_modules/lodash/internal/createBaseFor.js","node_modules/lodash/internal/createCache.js","node_modules/lodash/internal/createFind.js","node_modules/lodash/internal/createForEach.js","node_modules/lodash/internal/equalArrays.js","node_modules/lodash/internal/equalByTag.js","node_modules/lodash/internal/equalObjects.js","node_modules/lodash/internal/getLength.js","node_modules/lodash/internal/getMatchData.js","node_modules/lodash/internal/getNative.js","node_modules/lodash/internal/indexOfNaN.js","node_modules/lodash/internal/isArrayLike.js","node_modules/lodash/internal/isIndex.js","node_modules/lodash/internal/isIterateeCall.js","node_modules/lodash/internal/isKey.js","node_modules/lodash/internal/isLength.js","node_modules/lodash/internal/isObjectLike.js","node_modules/lodash/internal/isStrictComparable.js","node_modules/lodash/internal/shimKeys.js","node_modules/lodash/internal/toObject.js","node_modules/lodash/internal/toPath.js","node_modules/lodash/lang/isArguments.js","node_modules/lodash/lang/isArray.js","node_modules/lodash/lang/isEmpty.js","node_modules/lodash/lang/isFunction.js","node_modules/lodash/lang/isNative.js","node_modules/lodash/lang/isObject.js","node_modules/lodash/lang/isString.js","node_modules/lodash/lang/isTypedArray.js","node_modules/lodash/object/assign.js","node_modules/lodash/object/get.js","node_modules/lodash/object/keys.js","node_modules/lodash/object/keysIn.js","node_modules/lodash/object/pairs.js","node_modules/lodash/object/transform.js","node_modules/lodash/object/values.js","node_modules/lodash/utility/identity.js","node_modules/lodash/utility/property.js","node_modules/min-dash/dist/index.js","node_modules/min-dom/dist/index.js","node_modules/moddle-xml/index.js","node_modules/moddle-xml/lib/common.js","node_modules/moddle-xml/lib/read.js","node_modules/moddle-xml/lib/write.js","node_modules/moddle/index.js","node_modules/moddle/lib/base.js","node_modules/moddle/lib/descriptor-builder.js","node_modules/moddle/lib/factory.js","node_modules/moddle/lib/moddle.js","node_modules/moddle/lib/ns.js","node_modules/moddle/lib/properties.js","node_modules/moddle/lib/registry.js","node_modules/moddle/lib/types.js","node_modules/object-refs/index.js","node_modules/object-refs/lib/collection.js","node_modules/object-refs/lib/refs.js","node_modules/path-intersection/intersect.js","node_modules/saxen/dist/index.js","node_modules/scroll-tabs/index.js","node_modules/scroll-tabs/node_modules/min-dom/lib/event.js","node_modules/selection-update/index.js","node_modules/tiny-stack/lib/tiny-stack.js","node_modules/tiny-svg/dist/index.cjs.js","resources/newDiagram.bpmn"],"names":[],"mappings":"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;kBC9Ce,UAAS,kBAAT,EAA6B,OAA7B,EAAsC;AACnD,MAAI,MAAM,qBAAO,EAAP,EAAW,QAAX,EAAqB,kBAArB,CAAV;;AAEA,SAAO,IAAI,oBAAJ,CAAe,GAAf,EAAoB,OAApB,CAAP;AACD,C;;AAxBD;;AAIA;;;;AAEA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;;;AAEA,IAAI,WAAW;AACb,QAAM,cADO;AAEb,UAAQ,gBAFK;AAGb,MAAI,YAHS;AAIb,MAAI,YAJS;AAKb,QAAM;AALO,CAAf;;;ACZA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC74FA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;AC7OA;AACA;AACA;AACA;AACA;AACA;A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AI,MAAxB,EAAgC,EAAE,CAAlC,EAAqC;AACnC,QAAI,CAAJ,IAAS,IAAI,CAAJ,EAAO,QAAP,IAAmB,IAAI,CAAJ,CAA5B;AACD;AACD,SAAO,GAAP;AACD;;AAED,SAAS,oBAAT,CAA8B,KAA9B,EAAqC;AACnC,MAAI,IAAI,SAAJ,CAAI,GAAW,CAAE,CAArB;AACA,IAAE,SAAF,GAAc,KAAd;AACA,SAAO,IAAI,CAAJ,EAAP;AACD;AACD,SAAS,kBAAT,CAA4B,GAA5B,EAAiC;AAC/B,MAAI,OAAO,EAAX;AACA,OAAK,IAAI,CAAT,IAAc,GAAd;AAAmB,QAAI,OAAO,SAAP,CAAiB,cAAjB,CAAgC,IAAhC,CAAqC,GAArC,EAA0C,CAA1C,CAAJ,EAAkD;AACnE,WAAK,IAAL,CAAU,CAAV;AACD;AAFD,GAGA,OAAO,CAAP;AACD;AACD,SAAS,oBAAT,CAA8B,OAA9B,EAAuC;AACrC,MAAI,KAAK,IAAT;AACA,SAAO,YAAY;AACjB,WAAO,GAAG,KAAH,CAAS,OAAT,EAAkB,SAAlB,CAAP;AACD,GAFD;AAGD;;;AC1gBD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACjjCA;;;;AAIA,IA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","file":"generated.js","sourceRoot":"","sourcesContent":["(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c=\"function\"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error(\"Cannot find module '\"+i+\"'\");throw a.code=\"MODULE_NOT_FOUND\",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u=\"function\"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()","import $ from 'jquery';\r\nimport BpmnModeler from 'bpmn-js/lib/Modeler';\r\n\r\nimport propertiesPanelModule from 'bpmn-js-properties-panel';\r\nimport propertiesProviderModule from 'bpmn-js-properties-panel/lib/provider/camunda';\r\nimport camundaModdleDescriptor from 'camunda-bpmn-moddle/resources/camunda';\r\n\r\nimport {\r\n  debounce\r\n} from 'min-dash';\r\n\r\nimport diagramXML from '../resources/newDiagram.bpmn';\r\n\r\n\r\nvar container = $('#js-drop-zone');\r\n\r\nvar canvas = $('#js-canvas');\r\n\r\nvar bpmnModeler = new BpmnModeler({\r\n  container: canvas,\r\n  propertiesPanel: {\r\n    parent: '#js-properties-panel'\r\n  },\r\n  additionalModules: [\r\n    propertiesPanelModule,\r\n    propertiesProviderModule\r\n  ],\r\n  moddleExtensions: {\r\n    camunda: camundaModdleDescriptor\r\n  }\r\n});\r\ncontainer.removeClass('with-diagram');\r\n\r\nfunction createNewDiagram() {\r\n  openDiagram(diagramXML);\r\n}\r\n\r\nfunction openDiagram(xml) {\r\n\r\n  bpmnModeler.importXML(xml, function(err) {\r\n\r\n    if (err) {\r\n      container\r\n        .removeClass('with-diagram')\r\n        .addClass('with-error');\r\n\r\n      container.find('.error pre').text(err.message);\r\n\r\n      console.error(err);\r\n    } else {\r\n      container\r\n        .removeClass('with-error')\r\n        .addClass('with-diagram');\r\n    }\r\n\r\n\r\n  });\r\n}\r\n\r\nfunction saveSVG(done) {\r\n  bpmnModeler.saveSVG(done);\r\n}\r\n\r\nfunction saveDiagram(done) {\r\n\r\n  bpmnModeler.saveXML({ format: true }, function(err, xml) {\r\n    done(err, xml);\r\n  });\r\n}\r\n\r\nfunction registerFileDrop(container, callback) {\r\n\r\n  function handleFileSelect(e) {\r\n    e.stopPropagation();\r\n    e.preventDefault();\r\n\r\n    var files = e.dataTransfer.files;\r\n\r\n    var file = files[0];\r\n\r\n    var reader = new FileReader();\r\n\r\n    reader.onload = function(e) {\r\n\r\n      var xml = e.target.result;\r\n\r\n      callback(xml);\r\n    };\r\n\r\n    reader.readAsText(file);\r\n  }\r\n\r\n  function handleDragOver(e) {\r\n    e.stopPropagation();\r\n    e.preventDefault();\r\n\r\n    e.dataTransfer.dropEffect = 'copy'; // Explicitly show this is a copy.\r\n  }\r\n\r\n  container.get(0).addEventListener('dragover', handleDragOver, false);\r\n  container.get(0).addEventListener('drop', handleFileSelect, false);\r\n}\r\n\r\n\r\n////// file drag / drop ///////////////////////\r\n\r\n// check file api availability\r\nif (!window.FileList || !window.FileReader) {\r\n  window.alert(\r\n    'Looks like you use an older browser that does not support drag and drop. ' +\r\n    'Try using Chrome, Firefox or the Internet Explorer > 10.');\r\n} else {\r\n  registerFileDrop(container, openDiagram);\r\n}\r\n\r\n// bootstrap diagram functions\r\n\r\n$(function() {\r\n\r\n  $('#js-create-diagram').click(function(e) {\r\n    e.stopPropagation();\r\n    e.preventDefault();\r\n\r\n    createNewDiagram();\r\n  });\r\n\r\n  var downloadLink = $('#js-download-diagram');\r\n  var downloadSvgLink = $('#js-download-svg');\r\n\r\n  $('.buttons a').click(function(e) {\r\n    if (!$(this).is('.active')) {\r\n      e.preventDefault();\r\n      e.stopPropagation();\r\n    }\r\n  });\r\n\r\n  function setEncoded(link, name, data) {\r\n    var encodedData = encodeURIComponent(data);\r\n\r\n    if (data) {\r\n      link.addClass('active').attr({\r\n        'href': 'data:application/bpmn20-xml;charset=UTF-8,' + encodedData,\r\n        'download': name\r\n      });\r\n    } else {\r\n      link.removeClass('active');\r\n    }\r\n  }\r\n\r\n  var exportArtifacts = debounce(function() {\r\n\r\n    saveSVG(function(err, svg) {\r\n      setEncoded(downloadSvgLink, 'diagram.svg', err ? null : svg);\r\n    });\r\n\r\n    saveDiagram(function(err, xml) {\r\n      setEncoded(downloadLink, 'diagram.bpmn', err ? null : xml);\r\n    });\r\n  }, 500);\r\n\r\n  bpmnModeler.on('commandStack.changed', exportArtifacts);\r\n});\r\n","module.exports = require('./lib');\n","'use strict';\n\nvar DEFAULT_PRIORITY = 1000;\n\n\n/**\n * A component that decides upon the visibility / editable\n * state of properties in the properties panel.\n *\n * Implementors must subclass this component and override\n * {@link PropertiesActivator#isEntryVisible} and\n * {@link PropertiesActivator#isPropertyEditable} to provide\n * custom behavior.\n *\n * @class\n * @constructor\n *\n * @param {EventBus} eventBus\n * @param {Number} [priority] at which priority to hook into the activation\n */\nfunction PropertiesActivator(eventBus, priority) {\n  var self = this;\n\n  priority = priority || DEFAULT_PRIORITY;\n\n  eventBus.on('propertiesPanel.isEntryVisible', priority, function(e) {\n    return self.isEntryVisible(e.entry, e.element);\n  });\n\n  eventBus.on('propertiesPanel.isPropertyEditable', priority, function(e) {\n    return self.isPropertyEditable(e.entry, e.propertyName, e.element);\n  });\n}\n\nPropertiesActivator.$inject = [ 'eventBus' ];\n\nmodule.exports = PropertiesActivator;\n\n\n/**\n * Should the given entry be visible for the specified element.\n *\n * @method  PropertiesActivator#isEntryVisible\n *\n * @param {EntryDescriptor} entry\n * @param {ModdleElement} element\n *\n * @returns {Boolean}\n */\nPropertiesActivator.prototype.isEntryVisible = function(entry, element) {\n  return true;\n};\n\n/**\n * Should the given property be editable for the specified element\n *\n * @method  PropertiesActivator#isPropertyEditable\n *\n * @param {EntryDescriptor} entry\n * @param {String} propertyName\n * @param {ModdleElement} element\n *\n * @returns {Boolean}\n */\nPropertiesActivator.prototype.isPropertyEditable = function(entry, propertyName, element) {\n  return true;\n};","'use strict';\n\nvar domify = require('min-dom/lib/domify'),\n    domQuery = require('min-dom/lib/query'),\n    domRemove = require('min-dom/lib/remove'),\n    domClasses = require('min-dom/lib/classes'),\n    domClosest = require('min-dom/lib/closest'),\n    domAttr = require('min-dom/lib/attr'),\n    domDelegate = require('min-dom/lib/delegate'),\n    domMatches = require('min-dom/lib/matches');\n\nvar forEach = require('lodash/collection/forEach'),\n    filter = require('lodash/collection/filter'),\n    get = require('lodash/object/get'),\n    keys = require('lodash/object/keys'),\n    isEmpty = require('lodash/lang/isEmpty'),\n    isArray = require('lodash/lang/isArray'),\n    xor = require('lodash/array/xor'),\n    debounce = require('lodash/function/debounce');\n\nvar updateSelection = require('selection-update');\n\nvar scrollTabs = require('scroll-tabs');\n\nvar getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject;\n\nvar HIDE_CLASS = 'bpp-hidden';\nvar DEBOUNCE_DELAY = 300;\n\n\nfunction isToggle(node) {\n  return node.type === 'checkbox' || node.type === 'radio';\n}\n\nfunction isSelect(node) {\n  return node.type === 'select-one';\n}\n\nfunction isContentEditable(node) {\n  return domAttr(node, 'contenteditable');\n}\n\nfunction getPropertyPlaceholders(node) {\n  var selector = 'input[name], textarea[name], [data-value], [contenteditable]';\n  var placeholders = domQuery.all(selector, node);\n  if ((!placeholders || !placeholders.length) && domMatches(node, selector)) {\n    placeholders = [ node ];\n  }\n  return placeholders;\n}\n\n/**\n * Return all active form controls.\n * This excludes the invisible controls unless all is true\n *\n * @param {Element} node\n * @param {Boolean} [all=false]\n */\nfunction getFormControls(node, all) {\n  var controls = domQuery.all('input[name], textarea[name], select[name], [contenteditable]', node);\n\n  if (!controls || !controls.length) {\n    controls = domMatches(node, 'option') ? [ node ] : controls;\n  }\n\n  if (!all) {\n    controls = filter(controls, function(node) {\n      return !domClosest(node, '.' + HIDE_CLASS);\n    });\n  }\n\n  return controls;\n}\n\nfunction getFormControlValuesInScope(entryNode) {\n  var values = {};\n\n  var controlNodes = getFormControls(entryNode);\n\n  forEach(controlNodes, function(controlNode) {\n    var value = controlNode.value;\n\n    var name = domAttr(controlNode, 'name') || domAttr(controlNode, 'data-name');\n\n    // take toggle state into account for radio / checkboxes\n    if (isToggle(controlNode)) {\n      if (controlNode.checked) {\n        if (!domAttr(controlNode, 'value')) {\n          value = true;\n        } else {\n          value = controlNode.value;\n        }\n      } else {\n        value = null;\n      }\n    } else\n    if (isContentEditable(controlNode)) {\n      value = controlNode.innerText;\n    }\n\n    if (value !== null) {\n      // return the actual value\n      // handle serialization in entry provider\n      // (ie. if empty string should be serialized or not)\n      values[name] = value;\n    }\n  });\n\n  return values;\n\n}\n\n/**\n * Extract input values from entry node\n *\n * @param  {DOMElement} entryNode\n * @returns {Object}\n */\nfunction getFormControlValues(entryNode) {\n\n  var values;\n\n  var listContainer = domQuery('[data-list-entry-container]', entryNode);\n  if (listContainer) {\n    values = [];\n    var listNodes = listContainer.children || [];\n    forEach(listNodes, function(listNode) {\n      values.push(getFormControlValuesInScope(listNode));\n    });\n  } else {\n    values = getFormControlValuesInScope(entryNode);\n  }\n\n  return values;\n}\n\n/**\n * Return true if the given form extracted value equals\n * to an old cached version.\n *\n * @param {Object} value\n * @param {Object} oldValue\n * @return {Boolean}\n */\nfunction valueEqual(value, oldValue) {\n\n  if (value && !oldValue) {\n    return false;\n  }\n\n  var allKeys = keys(value).concat(keys(oldValue));\n\n  return allKeys.every(function(key) {\n    return value[key] === oldValue[key];\n  });\n}\n\n/**\n * Return true if the given form extracted value(s)\n * equal an old cached version.\n *\n * @param {Array<Object>|Object} values\n * @param {Array<Object>|Object} oldValues\n * @return {Boolean}\n */\nfunction valuesEqual(values, oldValues) {\n\n  if (isArray(values)) {\n\n    if (values.length !== oldValues.length) {\n      return false;\n    }\n\n    return values.every(function(v, idx) {\n      return valueEqual(v, oldValues[idx]);\n    });\n  }\n\n  return valueEqual(values, oldValues);\n}\n\n/**\n * Return a mapping of { id: entry } for all entries in the given groups in the given tabs.\n *\n * @param {Object} tabs\n * @return {Object}\n */\nfunction extractEntries(tabs) {\n  return indexBy(flattenDeep(map(flattenDeep(map(tabs, 'groups')), 'entries')), 'id');\n}\n\n/**\n * Return a mapping of { id: group } for all groups in the given tabs.\n *\n * @param {Object} tabs\n * @return {Object}\n */\nfunction extractGroups(tabs) {\n  return indexBy(flattenDeep(map(tabs, 'groups')), 'id');\n}\n\n/**\n * A properties panel implementation.\n *\n * To use it provide a `propertiesProvider` component that knows\n * about which properties to display.\n *\n * Properties edit state / visibility can be intercepted\n * via a custom {@link PropertiesActivator}.\n *\n * @class\n * @constructor\n *\n * @param {Object} config\n * @param {EventBus} eventBus\n * @param {Modeling} modeling\n * @param {PropertiesProvider} propertiesProvider\n * @param {Canvas} canvas\n * @param {CommandStack} commandStack\n */\nfunction PropertiesPanel(config, eventBus, modeling, propertiesProvider, commandStack, canvas) {\n\n  this._eventBus = eventBus;\n  this._modeling = modeling;\n  this._commandStack = commandStack;\n  this._canvas = canvas;\n  this._propertiesProvider = propertiesProvider;\n\n  this._init(config);\n}\n\nPropertiesPanel.$inject = [\n  'config.propertiesPanel',\n  'eventBus',\n  'modeling',\n  'propertiesProvider',\n  'commandStack',\n  'canvas'\n];\n\nmodule.exports = PropertiesPanel;\n\n\nPropertiesPanel.prototype._init = function(config) {\n\n  var eventBus = this._eventBus;\n\n  var self = this;\n\n  /**\n   * Select the root element once it is added to the canvas\n   */\n  eventBus.on('root.added', function(e) {\n    self.update(e.element);\n  });\n\n  eventBus.on('selection.changed', function(e) {\n    var newElement = e.newSelection[0];\n\n    self.update(newElement);\n  });\n\n  // add / update tab-bar scrolling\n  eventBus.on([\n    'propertiesPanel.changed',\n    'propertiesPanel.resized'\n  ], function(event) {\n\n    var tabBarNode = domQuery('.bpp-properties-tab-bar', self._container);\n\n    if (!tabBarNode) {\n      return;\n    }\n\n    var scroller = scrollTabs.get(tabBarNode);\n\n    if (!scroller) {\n\n      // we did not initialize yet, do that\n      // now and make sure we select the active\n      // tab on scroll update\n      scroller = scrollTabs(tabBarNode, {\n        selectors: {\n          tabsContainer: '.bpp-properties-tabs-links',\n          tab: '.bpp-properties-tabs-links li',\n          ignore: '.bpp-hidden',\n          active: '.bpp-active'\n        }\n      });\n\n\n      scroller.on('scroll', function(newActiveNode, oldActiveNode, direction) {\n\n        var linkNode = domQuery('[data-tab-target]', newActiveNode);\n\n        var tabId = domAttr(linkNode, 'data-tab-target');\n\n        self.activateTab(tabId);\n      });\n    }\n\n    // react on tab changes and or tabContainer resize\n    // and make sure the active tab is shown completely\n    scroller.update();\n  });\n\n  eventBus.on('elements.changed', function(e) {\n\n    var current = self._current;\n    var element = current && current.element;\n\n    if (element) {\n      if (e.elements.indexOf(element) !== -1) {\n        self.update(element);\n      }\n    }\n  });\n\n  eventBus.on('elementTemplates.changed', function() {\n    var current = self._current;\n    var element = current && current.element;\n\n    if (element) {\n      self.update(element);\n    }\n  });\n\n  eventBus.on('diagram.destroy', function() {\n    self.detach();\n  });\n\n  this._container = domify('<div class=\"bpp-properties-panel\"></div>');\n\n  this._bindListeners(this._container);\n\n  if (config && config.parent) {\n    this.attachTo(config.parent);\n  }\n};\n\n\nPropertiesPanel.prototype.attachTo = function(parentNode) {\n\n  if (!parentNode) {\n    throw new Error('parentNode required');\n  }\n\n  // ensure we detach from the\n  // previous, old parent\n  this.detach();\n\n  // unwrap jQuery if provided\n  if (parentNode.get && parentNode.constructor.prototype.jquery) {\n    parentNode = parentNode.get(0);\n  }\n\n  if (typeof parentNode === 'string') {\n    parentNode = domQuery(parentNode);\n  }\n\n  var container = this._container;\n\n  parentNode.appendChild(container);\n\n  this._emit('attach');\n};\n\nPropertiesPanel.prototype.detach = function() {\n\n  var container = this._container,\n      parentNode = container.parentNode;\n\n  if (!parentNode) {\n    return;\n  }\n\n  this._emit('detach');\n\n  parentNode.removeChild(container);\n};\n\n\n/**\n * Select the given tab within the properties panel.\n *\n * @param {Object|String} tab\n */\nPropertiesPanel.prototype.activateTab = function(tab) {\n\n  var tabId = typeof tab === 'string' ? tab : tab.id;\n\n  var current = this._current;\n\n  var panelNode = current.panel;\n\n  var allTabNodes = domQuery.all('.bpp-properties-tab', panelNode),\n      allTabLinkNodes = domQuery.all('.bpp-properties-tab-link', panelNode);\n\n  forEach(allTabNodes, function(tabNode) {\n\n    var currentTabId = domAttr(tabNode, 'data-tab');\n\n    domClasses(tabNode).toggle('bpp-active', tabId === currentTabId);\n  });\n\n  forEach(allTabLinkNodes, function(tabLinkNode) {\n\n    var tabLink = domQuery('[data-tab-target]', tabLinkNode),\n        currentTabId = domAttr(tabLink, 'data-tab-target');\n\n    domClasses(tabLinkNode).toggle('bpp-active', tabId === currentTabId);\n  });\n};\n\n/**\n * Update the DOM representation of the properties panel\n */\nPropertiesPanel.prototype.update = function(element) {\n  var current = this._current;\n\n  // no actual selection change\n  var needsCreate = true;\n\n  if (typeof element === 'undefined') {\n\n    // use RootElement of BPMN diagram to generate properties panel if no element is selected\n    element = this._canvas.getRootElement();\n  }\n\n  var newTabs = this._propertiesProvider.getTabs(element);\n\n  if (current && current.element === element) {\n    // see if we can reuse the existing panel\n\n    needsCreate = this._entriesChanged(current, newTabs);\n  }\n\n  if (needsCreate) {\n\n    if (current) {\n\n      // get active tab from the existing panel before remove it\n      var activeTabNode = domQuery('.bpp-properties-tab.bpp-active', current.panel);\n\n      var activeTabId;\n      if (activeTabNode) {\n        activeTabId = domAttr(activeTabNode, 'data-tab');\n      }\n\n      // remove old panel\n      domRemove(current.panel);\n    }\n\n    this._current = this._create(element, newTabs);\n\n    // activate the saved active tab from the remove panel or the first tab\n    (activeTabId) ? this.activateTab(activeTabId) : this.activateTab(this._current.tabs[0]);\n\n  }\n\n  if (this._current) {\n    // make sure correct tab contents are visible\n    this._updateActivation(this._current);\n\n  }\n\n  this._emit('changed');\n};\n\n\n/**\n * Returns true if one of two groups has different entries than the other.\n *\n * @param  {Object} current\n * @param  {Object} newTabs\n * @return {Booelan}\n */\nPropertiesPanel.prototype._entriesChanged = function(current, newTabs) {\n\n  var oldEntryIds = keys(current.entries),\n      newEntryIds = keys(extractEntries(newTabs));\n\n  return !isEmpty(xor(oldEntryIds, newEntryIds));\n};\n\nPropertiesPanel.prototype._emit = function(event) {\n  this._eventBus.fire('propertiesPanel.' + event, { panel: this, current: this._current });\n};\n\nPropertiesPanel.prototype._bindListeners = function(container) {\n\n  var self = this;\n\n  // handles a change for a given event\n  var handleChange = function handleChange(event) {\n\n    // see if we handle a change inside a [data-entry] element.\n    // if not, drop out\n    var node = domClosest(event.delegateTarget, '[data-entry]'),\n        entryId, entry;\n\n    // change from outside a [data-entry] element, simply ignore\n    if (!node) {\n      return;\n    }\n\n    entryId = domAttr(node, 'data-entry');\n    entry = self.getEntry(entryId);\n\n    var values = getFormControlValues(node);\n\n    if (event.type === 'change') {\n\n      // - if the \"data-on-change\" attribute is present and a value is changed,\n      //   then the associated action is performed.\n      // - if the associated action returns \"true\" then an update to the business\n      //   object is done\n      // - if it does not return \"true\", then only the DOM content is updated\n      var onChangeAction = event.delegateTarget.getAttribute('data-on-change');\n\n      if (onChangeAction) {\n        var isEntryDirty = self.executeAction(entry, node, onChangeAction, event);\n\n        if (!isEntryDirty) {\n          return self.update(self._current.element);\n        }\n      }\n    }\n    self.applyChanges(entry, values, node);\n    self.updateState(entry, node);\n  };\n\n  // debounce update only elements that are target of key events,\n  // i.e. INPUT and TEXTAREA. SELECTs will trigger an immediate update anyway.\n  domDelegate.bind(container, 'input, textarea, [contenteditable]', 'input', debounce(handleChange, DEBOUNCE_DELAY));\n  domDelegate.bind(container, 'input, textarea, select, [contenteditable]', 'change', handleChange);\n\n  domDelegate.bind(container, '[data-action]', 'click', function onClick(event) {\n\n    // triggers on all inputs\n    var inputNode = event.delegateTarget;\n    var entryNode = domClosest(inputNode, '[data-entry]');\n\n    var actionId = domAttr(inputNode, 'data-action'),\n        entryId = domAttr(entryNode, 'data-entry');\n\n    var entry = self.getEntry(entryId);\n\n    var isEntryDirty = self.executeAction(entry, entryNode, actionId, event);\n\n    if (isEntryDirty) {\n      var values = getFormControlValues(entryNode);\n\n      self.applyChanges(entry, values, entryNode);\n    }\n\n    self.updateState(entry, entryNode);\n  });\n\n  function handleInput(event, element) {\n    // triggers on all inputs\n    var inputNode = event.delegateTarget;\n\n    var entryNode = domClosest(inputNode, '[data-entry]');\n\n    // only work on data entries\n    if (!entryNode) {\n      return;\n    }\n\n    var eventHandlerId = domAttr(inputNode, 'data-blur'),\n        entryId = domAttr(entryNode, 'data-entry');\n\n    var entry = self.getEntry(entryId);\n\n    var isEntryDirty = self.executeAction(entry, entryNode, eventHandlerId, event);\n\n    if (isEntryDirty) {\n      var values = getFormControlValues(entryNode);\n\n      self.applyChanges(entry, values, entryNode);\n    }\n\n    self.updateState(entry, entryNode);\n  }\n\n  domDelegate.bind(container, '[data-blur]', 'blur', handleInput, true);\n\n  // make tab links interactive\n  domDelegate.bind(container, '.bpp-properties-tabs-links [data-tab-target]', 'click', function(event) {\n    event.preventDefault();\n\n    var delegateTarget = event.delegateTarget;\n\n    var tabId = domAttr(delegateTarget, 'data-tab-target');\n\n    // activate tab on link click\n    self.activateTab(tabId);\n  });\n\n};\n\nPropertiesPanel.prototype.updateState = function(entry, entryNode) {\n  this.updateShow(entry, entryNode);\n  this.updateDisable(entry, entryNode);\n};\n\n/**\n * Update the visibility of the entry node in the DOM\n */\nPropertiesPanel.prototype.updateShow = function(entry, node) {\n\n  var current = this._current;\n\n  if (!current) {\n    return;\n  }\n\n  var showNodes = domQuery.all('[data-show]', node) || [];\n\n  forEach(showNodes, function(showNode) {\n\n    var expr = domAttr(showNode, 'data-show');\n    var fn = get(entry, expr);\n    if (fn) {\n      var scope = domClosest(showNode, '[data-scope]') || node;\n      var shouldShow = fn(current.element, node, showNode, scope) || false;\n      if (shouldShow) {\n        domClasses(showNode).remove(HIDE_CLASS);\n      } else {\n        domClasses(showNode).add(HIDE_CLASS);\n      }\n    }\n  });\n};\n\n/**\n * Evaluates a given function. If it returns true, then the\n * node is marked as \"disabled\".\n */\nPropertiesPanel.prototype.updateDisable = function(entry, node) {\n  var current = this._current;\n\n  if (!current) {\n    return;\n  }\n\n  var nodes = domQuery.all('[data-disable]', node) || [];\n\n  forEach(nodes, function(currentNode) {\n    var expr = domAttr(currentNode, 'data-disable');\n    var fn = get(entry, expr);\n    if (fn) {\n      var scope = domClosest(currentNode, '[data-scope]') || node;\n      var shouldDisable = fn(current.element, node, currentNode, scope) || false;\n      domAttr(currentNode, 'disabled', shouldDisable ? '' : null);\n    }\n  });\n};\n\nPropertiesPanel.prototype.executeAction = function(entry, entryNode, actionId, event) {\n  var current = this._current;\n\n  if (!current) {\n    return;\n  }\n\n  var fn = get(entry, actionId);\n  if (fn) {\n    var scopeNode = domClosest(event.target, '[data-scope]') || entryNode;\n    return fn.apply(entry, [ current.element, entryNode, event, scopeNode ]);\n  }\n};\n\n/**\n * Apply changes to the business object by executing a command\n */\nPropertiesPanel.prototype.applyChanges = function(entry, values, containerElement) {\n\n  var element = this._current.element;\n\n  // ensure we only update the model if we got dirty changes\n  if (valuesEqual(values, entry.oldValues)) {\n    return;\n  }\n\n  var command = entry.set(element, values, containerElement);\n\n  var commandToExecute;\n\n  if (isArray(command)) {\n    if (command.length) {\n      commandToExecute = {\n        cmd: 'properties-panel.multi-command-executor',\n        context: flattenDeep(command)\n      };\n    }\n  } else {\n    commandToExecute = command;\n  }\n\n  if (commandToExecute) {\n    this._commandStack.execute(commandToExecute.cmd, commandToExecute.context || { element : element });\n  } else {\n    this.update(element);\n  }\n};\n\n\n/**\n * apply validation errors in the DOM and show or remove an error message near the entry node.\n */\nPropertiesPanel.prototype.applyValidationErrors = function(validationErrors, entryNode) {\n\n  var valid = true;\n\n  var controlNodes = getFormControls(entryNode, true);\n\n  forEach(controlNodes, function(controlNode) {\n\n    var name = domAttr(controlNode, 'name') || domAttr(controlNode, 'data-name');\n\n    var error = validationErrors && validationErrors[name];\n\n    var errorMessageNode = domQuery('.bpp-error-message', controlNode.parentNode);\n\n    if (error) {\n      valid = false;\n\n      if (!errorMessageNode) {\n        errorMessageNode = domify('<div></div>');\n\n        domClasses(errorMessageNode).add('bpp-error-message');\n\n        // insert errorMessageNode after controlNode\n        controlNode.parentNode.insertBefore(errorMessageNode, controlNode.nextSibling);\n      }\n\n      errorMessageNode.innerHTML = error;\n\n      domClasses(controlNode).add('invalid');\n    } else {\n      domClasses(controlNode).remove('invalid');\n\n      if (errorMessageNode) {\n        controlNode.parentNode.removeChild(errorMessageNode);\n      }\n    }\n  });\n\n  return valid;\n};\n\n\n/**\n * Check if the entry contains valid input\n */\nPropertiesPanel.prototype.validate = function(entry, values, entryNode) {\n  var self = this;\n\n  var current = this._current;\n\n  var valid = true;\n\n  entryNode = entryNode || domQuery('[data-entry=\"' + entry.id + '\"]', current.panel);\n\n  if (values instanceof Array) {\n    var listContainer = domQuery('[data-list-entry-container]', entryNode),\n        listEntryNodes = listContainer.children || [];\n\n    // create new elements\n    for (var i = 0; i < values.length; i++) {\n      var listValue = values[i];\n\n      if (entry.validateListItem) {\n\n        var validationErrors = entry.validateListItem(current.element, listValue, entryNode, i),\n            listEntryNode = listEntryNodes[i];\n\n        valid = self.applyValidationErrors(validationErrors, listEntryNode) && valid;\n      }\n    }\n  } else {\n    if (entry.validate) {\n      this.validationErrors = entry.validate(current.element, values, entryNode);\n\n      valid = self.applyValidationErrors(this.validationErrors, entryNode) && valid;\n    }\n  }\n\n  return valid;\n};\n\nPropertiesPanel.prototype.getEntry = function(id) {\n  return this._current && this._current.entries[id];\n};\n\nvar flattenDeep = require('lodash/array/flattenDeep'),\n    indexBy = require('lodash/collection/indexBy'),\n    map = require('lodash/collection/map');\n\nPropertiesPanel.prototype._create = function(element, tabs) {\n\n  if (!element) {\n    return null;\n  }\n\n  var containerNode = this._container;\n\n  var panelNode = this._createPanel(element, tabs);\n\n  containerNode.appendChild(panelNode);\n\n  var entries = extractEntries(tabs);\n  var groups = extractGroups(tabs);\n\n  return {\n    tabs: tabs,\n    groups: groups,\n    entries: entries,\n    element: element,\n    panel: panelNode\n  };\n};\n\n/**\n * Update variable parts of the entry node on element changes.\n *\n * @param {djs.model.Base} element\n * @param {EntryDescriptor} entry\n * @param {Object} values\n * @param {HTMLElement} entryNode\n * @param {Number} idx\n */\nPropertiesPanel.prototype._bindTemplate = function(element, entry, values, entryNode, idx) {\n\n  var eventBus = this._eventBus;\n\n  function isPropertyEditable(entry, propertyName) {\n    return eventBus.fire('propertiesPanel.isPropertyEditable', {\n      entry: entry,\n      propertyName: propertyName,\n      element: element\n    });\n  }\n\n  var inputNodes = getPropertyPlaceholders(entryNode);\n\n  forEach(inputNodes, function(node) {\n\n    var name,\n        newValue,\n        editable;\n\n    // we deal with an input element\n    if ('value' in node || isContentEditable(node) === 'true') {\n      name = domAttr(node, 'name') || domAttr(node, 'data-name');\n      newValue = values[name];\n\n      editable = isPropertyEditable(entry, name);\n      if (editable && entry.editable) {\n        editable = entry.editable(element, entryNode, node, name, newValue, idx);\n      }\n\n      domAttr(node, 'readonly', editable ? null : '');\n      domAttr(node, 'disabled', editable ? null : '');\n\n      // take full control over setting the value\n      // and possibly updating the input in entry#setControlValue\n      if (entry.setControlValue) {\n        entry.setControlValue(element, entryNode, node, name, newValue, idx);\n      } else if (isToggle(node)) {\n        setToggleValue(node, newValue);\n      } else if (isSelect(node)) {\n        setSelectValue(node, newValue);\n      } else {\n        setInputValue(node, newValue);\n      }\n    }\n\n    // we deal with some non-editable html element\n    else {\n      name = domAttr(node, 'data-value');\n      newValue = values[name];\n      if (entry.setControlValue) {\n        entry.setControlValue(element, entryNode, node, name, newValue, idx);\n      } else {\n        setTextValue(node, newValue);\n      }\n    }\n  });\n};\n\n// TODO(nikku): WTF freaking name? Change / clarify.\nPropertiesPanel.prototype._updateActivation = function(current) {\n  var self = this;\n\n  var eventBus = this._eventBus;\n\n  var element = current.element;\n\n  function isEntryVisible(entry) {\n    return eventBus.fire('propertiesPanel.isEntryVisible', {\n      entry: entry,\n      element: element\n    });\n  }\n\n  function isGroupVisible(group, element, groupNode) {\n    if (typeof group.enabled === 'function') {\n      return group.enabled(element, groupNode);\n    } else {\n      return true;\n    }\n  }\n\n  function isTabVisible(tab, element) {\n    if (typeof tab.enabled === 'function') {\n      return tab.enabled(element);\n    } else {\n      return true;\n    }\n  }\n\n  function toggleVisible(node, visible) {\n    domClasses(node).toggle(HIDE_CLASS, !visible);\n  }\n\n  // check whether the active tab is visible\n  // if not: set the first tab as active tab\n  function checkActiveTabVisibility(node, visible) {\n    var isActive = domClasses(node).has('bpp-active');\n    if (!visible && isActive) {\n      self.activateTab(current.tabs[0]);\n    }\n  }\n\n  function updateLabel(element, selector, text) {\n    var labelNode = domQuery(selector, element);\n\n    if (!labelNode) {\n      return;\n    }\n\n    labelNode.textContent = text;\n  }\n\n  var panelNode = current.panel;\n\n  forEach(current.tabs, function(tab) {\n\n    var tabNode = domQuery('[data-tab=' + tab.id + ']', panelNode);\n    var tabLinkNode = domQuery('[data-tab-target=' + tab.id + ']', panelNode).parentNode;\n\n    var tabVisible = false;\n\n    forEach(tab.groups, function(group) {\n\n      var groupVisible = false;\n\n      var groupNode = domQuery('[data-group=' + group.id + ']', tabNode);\n\n      forEach(group.entries, function(entry) {\n\n        var entryNode = domQuery('[data-entry=\"' + entry.id + '\"]', groupNode);\n\n        var entryVisible = isEntryVisible(entry);\n\n        groupVisible = groupVisible || entryVisible;\n\n        toggleVisible(entryNode, entryVisible);\n\n        var values = 'get' in entry ? entry.get(element, entryNode) : {};\n\n        if (values instanceof Array) {\n          var listEntryContainer = domQuery('[data-list-entry-container]', entryNode);\n          var existingElements = listEntryContainer.children || [];\n\n          for (var i = 0; i < values.length; i++) {\n            var listValue = values[i];\n            var listItemNode = existingElements[i];\n            if (!listItemNode) {\n              listItemNode = domify(entry.createListEntryTemplate(listValue, i, listEntryContainer));\n              listEntryContainer.appendChild(listItemNode);\n            }\n            domAttr(listItemNode, 'data-index', i);\n\n            self._bindTemplate(element, entry, listValue, listItemNode, i);\n          }\n\n          var entriesToRemove = existingElements.length - values.length;\n\n          for (var j = 0; j < entriesToRemove; j++) {\n            // remove orphaned element\n            listEntryContainer.removeChild(listEntryContainer.lastChild);\n          }\n\n        } else {\n          self._bindTemplate(element, entry, values, entryNode);\n        }\n\n        // update conditionally visible elements\n        self.updateState(entry, entryNode);\n        self.validate(entry, values, entryNode);\n\n        // remember initial state for later dirty checking\n        entry.oldValues = getFormControlValues(entryNode);\n      });\n\n      if (typeof group.label === 'function') {\n        updateLabel(groupNode, '.group-label', group.label(element, groupNode));\n      }\n\n      groupVisible = groupVisible && isGroupVisible(group, element, groupNode);\n\n      tabVisible = tabVisible || groupVisible;\n\n      toggleVisible(groupNode, groupVisible);\n    });\n\n    tabVisible = tabVisible && isTabVisible(tab, element);\n\n    toggleVisible(tabNode, tabVisible);\n    toggleVisible(tabLinkNode, tabVisible);\n\n    checkActiveTabVisibility(tabNode, tabVisible);\n  });\n\n  // inject elements id into header\n  updateLabel(panelNode, '[data-label-id]', getBusinessObject(element).id || '');\n};\n\nPropertiesPanel.prototype._createPanel = function(element, tabs) {\n  var self = this;\n\n  var panelNode = domify('<div class=\"bpp-properties\"></div>'),\n      headerNode = domify('<div class=\"bpp-properties-header\">' +\n        '<div class=\"label\" data-label-id></div>' +\n        '<div class=\"search\">' +\n          '<input type=\"search\" placeholder=\"Search for property\" />' +\n          '<button><span>Search</span></button>' +\n        '</div>' +\n      '</div>'),\n      tabBarNode = domify('<div class=\"bpp-properties-tab-bar\"></div>'),\n      tabLinksNode = domify('<ul class=\"bpp-properties-tabs-links\"></ul>'),\n      tabContainerNode = domify('<div class=\"bpp-properties-tabs-container\"></div>');\n\n  panelNode.appendChild(headerNode);\n\n  forEach(tabs, function(tab, tabIndex) {\n\n    if (!tab.id) {\n      throw new Error('tab must have an id');\n    }\n\n    var tabNode = domify('<div class=\"bpp-properties-tab\" data-tab=\"' + tab.id + '\"></div>'),\n        tabLinkNode = domify('<li class=\"bpp-properties-tab-link\">' +\n          '<a href data-tab-target=\"' + tab.id + '\">' + tab.label + '</a>' +\n        '</li>');\n\n    var groups = tab.groups;\n\n    forEach(groups, function(group) {\n\n      if (!group.id) {\n        throw new Error('group must have an id');\n      }\n\n      var groupNode = domify('<div class=\"bpp-properties-group\" data-group=\"' + group.id + '\">' +\n          '<span class=\"group-toggle\"></span>' +\n          '<span class=\"group-label\">' + group.label + '</span>' +\n        '</div>');\n\n      // TODO(nre): use event delegation to handle that...\n      groupNode.querySelector('.group-toggle').addEventListener('click', function(evt) {\n        domClasses(groupNode).toggle('group-closed');\n        evt.preventDefault();\n        evt.stopPropagation();\n      });\n      groupNode.addEventListener('click', function(evt) {\n        if (!evt.defaultPrevented && domClasses(groupNode).has('group-closed')) {\n          domClasses(groupNode).remove('group-closed');\n        }\n      });\n\n      forEach(group.entries, function(entry) {\n\n        if (!entry.id) {\n          throw new Error('entry must have an id');\n        }\n\n        var html = entry.html;\n\n        if (typeof html === 'string') {\n          html = domify(html);\n        }\n\n        // unwrap jquery\n        if (html.get && html.constructor.prototype.jquery) {\n          html = html.get(0);\n        }\n\n        var entryNode = domify('<div class=\"bpp-properties-entry\" data-entry=\"' + entry.id + '\"></div>');\n\n        forEach(entry.cssClasses || [], function(cssClass) {\n          domClasses(entryNode).add(cssClass);\n        });\n\n        entryNode.appendChild(html);\n\n        groupNode.appendChild(entryNode);\n\n        // update conditionally visible elements\n        self.updateState(entry, entryNode);\n      });\n\n      tabNode.appendChild(groupNode);\n    });\n\n    tabLinksNode.appendChild(tabLinkNode);\n    tabContainerNode.appendChild(tabNode);\n  });\n\n  tabBarNode.appendChild(tabLinksNode);\n\n  panelNode.appendChild(tabBarNode);\n  panelNode.appendChild(tabContainerNode);\n\n  return panelNode;\n};\n\n\n\nfunction setInputValue(node, value) {\n\n  var contentEditable = isContentEditable(node);\n\n  var oldValue = contentEditable ? node.innerText : node.value;\n\n  var selection;\n\n  // prevents input fields from having the value 'undefined'\n  if (value === undefined) {\n    value = '';\n  }\n\n  if (oldValue === value) {\n    return;\n  }\n\n  // update selection on undo/redo\n  if (document.activeElement === node) {\n    selection = updateSelection(getSelection(node), oldValue, value);\n  }\n\n  if (contentEditable) {\n    node.innerText = value;\n  } else {\n    node.value = value;\n  }\n\n  if (selection) {\n    setSelection(node, selection);\n  }\n}\n\nfunction setSelectValue(node, value) {\n  if (value !== undefined) {\n    node.value = value;\n  }\n}\n\nfunction setToggleValue(node, value) {\n  var nodeValue = node.value;\n\n  node.checked = (value === nodeValue) || (!domAttr(node, 'value') && value);\n}\n\nfunction setTextValue(node, value) {\n  node.textContent = value;\n}\n\nfunction getSelection(node) {\n\n  return isContentEditable(node) ? getContentEditableSelection(node) : {\n    start: node.selectionStart,\n    end: node.selectionEnd\n  };\n}\n\nfunction getContentEditableSelection(node) {\n\n  var selection = window.getSelection();\n\n  var focusNode = selection.focusNode,\n      focusOffset = selection.focusOffset,\n      anchorOffset = selection.anchorOffset;\n\n  if (!focusNode) {\n    throw new Error('not selected');\n  }\n\n  // verify we have selection on the current element\n  if (!node.contains(focusNode)) {\n    throw new Error('not selected');\n  }\n\n  return {\n    start: Math.min(focusOffset, anchorOffset),\n    end: Math.max(focusOffset, anchorOffset)\n  };\n}\n\nfunction setSelection(node, selection) {\n\n  if (isContentEditable(node)) {\n    setContentEditableSelection(node, selection);\n  } else {\n    node.selectionStart = selection.start;\n    node.selectionEnd = selection.end;\n  }\n}\n\nfunction setContentEditableSelection(node, selection) {\n\n  var focusNode,\n      domRange,\n      domSelection;\n\n  focusNode = node.firstChild || node,\n  domRange = document.createRange();\n  domRange.setStart(focusNode, selection.start);\n  domRange.setEnd(focusNode, selection.end);\n\n  domSelection = window.getSelection();\n  domSelection.removeAllRanges();\n  domSelection.addRange(domRange);\n}\n","'use strict';\n\nvar domQuery = require('min-dom/lib/query'),\n    domClear = require('min-dom/lib/clear'),\n    is = require('bpmn-js/lib/util/ModelUtil').is,\n    forEach = require('lodash/collection/forEach'),\n    domify = require('min-dom/lib/domify'),\n    Ids = require('ids');\n\nvar SPACE_REGEX = /\\s/;\n\n// for QName validation as per http://www.w3.org/TR/REC-xml/#NT-NameChar\nvar QNAME_REGEX = /^([a-z][\\w-.]*:)?[a-z_][\\w-.]*$/i;\n\n// for ID validation as per BPMN Schema (QName - Namespace)\nvar ID_REGEX = /^[a-z_][\\w-.]*$/i;\n\nvar PLACEHOLDER_REGEX = /\\$\\{([^\\}]*)\\}/g;\n\nfunction selectedOption(selectBox) {\n  if (selectBox.selectedIndex >= 0) {\n    return selectBox.options[selectBox.selectedIndex].value;\n  }\n}\n\nmodule.exports.selectedOption = selectedOption;\n\n\nfunction selectedType(elementSyntax, inputNode) {\n  var typeSelect = domQuery(elementSyntax, inputNode);\n  return selectedOption(typeSelect);\n}\n\nmodule.exports.selectedType = selectedType;\n\n\n/**\n * Retrieve the root element the document this\n * business object is contained in.\n *\n * @return {ModdleElement}\n */\nfunction getRoot(businessObject) {\n  var parent = businessObject;\n  while (parent.$parent) {\n    parent = parent.$parent;\n  }\n  return parent;\n}\n\nmodule.exports.getRoot = getRoot;\n\n\n/**\n * filters all elements in the list which have a given type.\n * removes a new list\n */\nfunction filterElementsByType(objectList, type) {\n  var list = objectList || [];\n  var result = [];\n  forEach(list, function(obj) {\n    if (is(obj, type)) {\n      result.push(obj);\n    }\n  });\n  return result;\n}\n\nmodule.exports.filterElementsByType = filterElementsByType;\n\n\nfunction findRootElementsByType(businessObject, referencedType) {\n  var root = getRoot(businessObject);\n\n  return filterElementsByType(root.rootElements, referencedType);\n}\n\nmodule.exports.findRootElementsByType = findRootElementsByType;\n\n\nfunction removeAllChildren(domElement) {\n  while (domElement.firstChild) {\n    domElement.removeChild(domElement.firstChild);\n  }\n}\n\nmodule.exports.removeAllChildren = removeAllChildren;\n\n\n/**\n * adds an empty option to the list\n */\nfunction addEmptyParameter(list) {\n  return list.push({ 'label': '', 'value': '', 'name': '' });\n}\n\nmodule.exports.addEmptyParameter = addEmptyParameter;\n\n\n/**\n * returns a list with all root elements for the given parameter 'referencedType'\n */\nfunction refreshOptionsModel(businessObject, referencedType) {\n  var model = [];\n  var referableObjects = findRootElementsByType(businessObject, referencedType);\n  forEach(referableObjects, function(obj) {\n    model.push({\n      label: (obj.name || '')  + ' (id='+obj.id+')',\n      value: obj.id,\n      name: obj.name\n    });\n  });\n  return model;\n}\n\nmodule.exports.refreshOptionsModel = refreshOptionsModel;\n\n\n/**\n * fills the drop down with options\n */\nfunction updateOptionsDropDown(domSelector, businessObject, referencedType, entryNode) {\n  var options = refreshOptionsModel(businessObject, referencedType);\n  addEmptyParameter(options);\n  var selectBox = domQuery(domSelector, entryNode);\n  domClear(selectBox);\n\n  forEach(options, function(option) {\n    var optionEntry = domify('<option value=\"' + option.value + '\">' + option.label + '</option>');\n    selectBox.appendChild(optionEntry);\n  });\n  return options;\n}\n\nmodule.exports.updateOptionsDropDown = updateOptionsDropDown;\n\n\n/**\n * checks whether the id value is valid\n *\n * @param {ModdleElement} bo\n * @param {String} idValue\n *\n * @return {String} error message\n */\nfunction isIdValid(bo, idValue) {\n  var assigned = bo.$model.ids.assigned(idValue);\n\n  var idExists = assigned && assigned !== bo;\n\n  if (!idValue || idExists) {\n    return 'Element must have an unique id.';\n  }\n\n  return validateId(idValue);\n}\n\nmodule.exports.isIdValid = isIdValid;\n\n\nfunction validateId(idValue) {\n\n  idValue = stripPlaceholders(idValue);\n\n  if (containsSpace(idValue)) {\n    return 'Id must not contain spaces.';\n  }\n\n  if (!ID_REGEX.test(idValue)) {\n\n    if (QNAME_REGEX.test(idValue)) {\n      return 'Id must not contain prefix.';\n    }\n\n    return 'Id must be a valid QName.';\n  }\n}\n\nmodule.exports.validateId = validateId;\n\n\nfunction containsSpace(value) {\n  return SPACE_REGEX.test(value);\n}\n\nmodule.exports.containsSpace = containsSpace;\n\n\nfunction stripPlaceholders(idValue) {\n\n  // replace expression e.g. ${VERSION_TAG}\n  // use only the content between ${}\n  // for the REGEX check\n  return idValue.replace(PLACEHOLDER_REGEX, '$1');\n}\n\n/**\n * generate a semantic id with given prefix\n */\nfunction nextId(prefix) {\n  var ids = new Ids([32,32,1]);\n\n  return ids.nextPrefixed(prefix);\n}\n\nmodule.exports.nextId = nextId;\n\n\nfunction triggerClickEvent(element) {\n  var evt;\n  var eventType = 'click';\n\n  if (document.createEvent) {\n    try {\n      // Chrome, Safari, Firefox\n      evt = new MouseEvent((eventType), { view: window, bubbles: true, cancelable: true });\n    } catch (e) {\n      // IE 11, PhantomJS (wat!)\n      evt = document.createEvent('MouseEvent');\n\n      evt.initEvent((eventType), true, true);\n    }\n    return element.dispatchEvent(evt);\n  } else {\n    // Welcome IE\n    evt = document.createEventObject();\n\n    return element.fireEvent('on' + eventType, evt);\n  }\n}\n\nmodule.exports.triggerClickEvent = triggerClickEvent;\n","'use strict';\n\nvar elementHelper = require('../helper/ElementHelper');\n\n/**\n * A handler capable of creating a new element under a provided parent\n * and updating / creating a reference to it in one atomic action.\n *\n * @class\n * @constructor\n */\nfunction CreateAndReferenceElementHandler(elementRegistry, bpmnFactory) {\n  this._elementRegistry = elementRegistry;\n  this._bpmnFactory = bpmnFactory;\n}\n\nCreateAndReferenceElementHandler.$inject = [ 'elementRegistry', 'bpmnFactory' ];\n\nmodule.exports = CreateAndReferenceElementHandler;\n\nfunction ensureNotNull(prop, name) {\n  if (!prop) {\n    throw new Error(name + ' required');\n  }\n  return prop;\n}\n\n////// api /////////////////////////////////////////////\n\n/**\n * Creates a new element under a provided parent and updates / creates a reference to it in\n * one atomic action.\n *\n * @method  CreateAndReferenceElementHandler#execute\n *\n * @param {Object} context\n * @param {djs.model.Base} context.element which is the context for the reference\n * @param {moddle.referencingObject} context.referencingObject the object which creates the reference\n * @param {String} context.referenceProperty the property of the referencingObject which makes the reference\n * @param {moddle.newObject} context.newObject the new object to add\n * @param {moddle.newObjectContainer} context.newObjectContainer the container for the new object\n *\n * @returns {Array<djs.mode.Base>} the updated element\n */\nCreateAndReferenceElementHandler.prototype.execute = function(context) {\n\n  var referencingObject = ensureNotNull(context.referencingObject, 'referencingObject'),\n      referenceProperty = ensureNotNull(context.referenceProperty, 'referenceProperty'),\n      newObject = ensureNotNull(context.newObject, 'newObject'),\n      newObjectContainer = ensureNotNull(context.newObjectContainer, 'newObjectContainer'),\n      newObjectParent = ensureNotNull(context.newObjectParent, 'newObjectParent'),\n      changed = [ context.element ]; // this will not change any diagram-js elements\n\n  // create new object\n  var referencedObject = elementHelper\n                          .createElement(newObject.type, newObject.properties, newObjectParent, this._bpmnFactory);\n  context.referencedObject = referencedObject;\n\n  // add to containing list\n  newObjectContainer.push(referencedObject);\n\n  // adjust reference attribute\n  context.previousReference = referencingObject[referenceProperty];\n  referencingObject[referenceProperty] = referencedObject;\n\n  context.changed = changed;\n\n  // indicate changed on objects affected by the update\n  return changed;\n};\n\n/**\n * Reverts the update\n *\n * @method  CreateAndReferenceElementHandler#revert\n *\n * @param {Object} context\n *\n * @returns {djs.mode.Base} the updated element\n */\nCreateAndReferenceElementHandler.prototype.revert = function(context) {\n\n  var referencingObject = context.referencingObject,\n      referenceProperty = context.referenceProperty,\n      previousReference = context.previousReference,\n      referencedObject = context.referencedObject,\n      newObjectContainer = context.newObjectContainer;\n\n  // reset reference\n  referencingObject.set(referenceProperty, previousReference);\n\n  // remove new element\n  newObjectContainer.splice(newObjectContainer.indexOf(referencedObject), 1);\n\n  return context.changed;\n};\n","'use strict';\n\nvar forEach = require('lodash/collection/forEach');\n\nvar elementHelper = require('../helper/ElementHelper');\n\n/**\n * A handler that implements a BPMN 2.0 property update\n * for business objects which are not represented in the\n * diagram.\n *\n * This is useful in the context of the properties panel in\n * order to update child elements of elements visible in\n * the diagram.\n *\n * Example: perform an update of a specific event definition\n * of an intermediate event.\n *\n * @class\n * @constructor\n */\nfunction CreateBusinessObjectListHandler(elementRegistry, bpmnFactory) {\n  this._elementRegistry = elementRegistry;\n  this._bpmnFactory = bpmnFactory;\n}\n\nCreateBusinessObjectListHandler.$inject = [ 'elementRegistry', 'bpmnFactory' ];\n\nmodule.exports = CreateBusinessObjectListHandler;\n\nfunction ensureNotNull(prop, name) {\n  if (!prop) {\n    throw new Error(name + ' required');\n  }\n  return prop;\n\n}\nfunction ensureList(prop, name) {\n  if (!prop || Object.prototype.toString.call(prop) !== '[object Array]' ) {\n    throw new Error(name + ' needs to be a list');\n  }\n  return prop;\n}\n\n////// api /////////////////////////////////////////////\n\n/**\n * Creates a new element under a provided parent and updates / creates a reference to it in\n * one atomic action.\n *\n * @method  CreateBusinessObjectListHandler#execute\n *\n * @param {Object} context\n * @param {djs.model.Base} context.element which is the context for the reference\n * @param {moddle.referencingObject} context.referencingObject the object which creates the reference\n * @param {String} context.referenceProperty the property of the referencingObject which makes the reference\n * @param {moddle.newObject} context.newObject the new object to add\n * @param {moddle.newObjectContainer} context.newObjectContainer the container for the new object\n *\n * @return {Array<djs.mode.Base>} the updated element\n */\nCreateBusinessObjectListHandler.prototype.execute = function(context) {\n\n  var currentObject = ensureNotNull(context.currentObject, 'currentObject'),\n      propertyName = ensureNotNull(context.propertyName, 'propertyName'),\n      newObjects = ensureList(context.newObjects, 'newObjects'),\n      changed = [ context.element ]; // this will not change any diagram-js elements\n\n\n  var childObjects = [];\n  var self = this;\n\n  // create new array of business objects\n  forEach(newObjects, function(obj) {\n    var element = elementHelper.createElement(obj.type, obj.properties, currentObject, self._bpmnFactory);\n\n    childObjects.push(element);\n  });\n  context.childObject = childObjects;\n\n  // adjust array reference in the parent business object\n  context.previousChilds = currentObject[propertyName];\n  currentObject[propertyName] = childObjects;\n\n  context.changed = changed;\n\n  // indicate changed on objects affected by the update\n  return changed;\n};\n\n/**\n * Reverts the update\n *\n * @method  CreateBusinessObjectListHandler#revert\n *\n * @param {Object} context\n *\n * @return {djs.mode.Base} the updated element\n */\nCreateBusinessObjectListHandler.prototype.revert = function(context) {\n\n  var currentObject = context.currentObject,\n      propertyName = context.propertyName,\n      previousChilds = context.previousChilds;\n\n  // remove new element\n  currentObject.set(propertyName, previousChilds);\n\n  return context.changed;\n};\n","'use strict';\n\nvar forEach = require('lodash/collection/forEach');\n\n/**\n * A handler that combines and executes multiple commands.\n *\n * All updates are bundled on the command stack and executed in one step.\n * This also makes it possible to revert the changes in one step.\n *\n * Example use case: remove the camunda:formKey attribute and in addition\n * add all form fields needed for the camunda:formData property.\n *\n * @class\n * @constructor\n */\nfunction MultiCommandHandler(commandStack) {\n  this._commandStack = commandStack;\n}\n\nMultiCommandHandler.$inject = [ 'commandStack' ];\n\nmodule.exports = MultiCommandHandler;\n\nMultiCommandHandler.prototype.preExecute = function(context) {\n\n  var commandStack = this._commandStack;\n\n  forEach(context, function(command) {\n    commandStack.execute(command.cmd, command.context);\n  });\n};","'use strict';\n\nvar reduce = require('lodash/object/transform'),\n    is = require('bpmn-js/lib/util/ModelUtil').is,\n    keys = require('lodash/object/keys'),\n    forEach = require('lodash/collection/forEach');\n\n/**\n * A handler that implements a BPMN 2.0 property update\n * for business objects which are not represented in the\n * diagram.\n *\n * This is useful in the context of the properties panel in\n * order to update child elements of elements visible in\n * the diagram.\n *\n * Example: perform an update of a specific event definition\n * of an intermediate event.\n *\n * @class\n * @constructor\n */\nfunction UpdateBusinessObjectHandler(elementRegistry) {\n  this._elementRegistry = elementRegistry;\n}\n\nUpdateBusinessObjectHandler.$inject = [ 'elementRegistry' ];\n\nmodule.exports = UpdateBusinessObjectHandler;\n\n/**\n * returns the root element\n */\nfunction getRoot(businessObject) {\n  var parent = businessObject;\n  while (parent.$parent) {\n    parent = parent.$parent;\n  }\n  return parent;\n}\n\nfunction getProperties(businessObject, propertyNames) {\n  return reduce(propertyNames, function(result, key) {\n    result[key] = businessObject.get(key);\n    return result;\n  }, {});\n}\n\n\nfunction setProperties(businessObject, properties) {\n  forEach(properties, function(value, key) {\n    businessObject.set(key, value);\n  });\n}\n\n\n////// api /////////////////////////////////////////////\n\n/**\n * Updates a business object with a list of new properties\n *\n * @method  UpdateBusinessObjectHandler#execute\n *\n * @param {Object} context\n * @param {djs.model.Base} context.element the element which has a child business object updated\n * @param {moddle.businessObject} context.businessObject the businessObject to update\n * @param {Object} context.properties a list of properties to set on the businessObject\n *\n * @return {Array<djs.mode.Base>} the updated element\n */\nUpdateBusinessObjectHandler.prototype.execute = function(context) {\n\n  var element = context.element,\n      businessObject = context.businessObject,\n      rootElements = getRoot(businessObject).rootElements,\n      referenceType = context.referenceType,\n      referenceProperty = context.referenceProperty,\n      changed = [ element ]; // this will not change any diagram-js elements\n\n  if (!element) {\n    throw new Error('element required');\n  }\n\n  if (!businessObject) {\n    throw new Error('businessObject required');\n  }\n\n  var properties = context.properties,\n      oldProperties = context.oldProperties || getProperties(businessObject, keys(properties));\n\n  // check if there the update needs an external element for reference\n  if (typeof referenceType !== 'undefined' && typeof referenceProperty !== 'undefined') {\n    forEach(rootElements, function(rootElement) {\n      if (is(rootElement, referenceType)) {\n        if (rootElement.id === properties[referenceProperty]) {\n          properties[referenceProperty] = rootElement;\n        }\n      }\n    });\n  }\n\n  // update properties\n  setProperties(businessObject, properties);\n\n  // store old values\n  context.oldProperties = oldProperties;\n  context.changed = changed;\n\n  // indicate changed on objects affected by the update\n  return changed;\n};\n\n/**\n * Reverts the update\n *\n * @method  UpdateBusinessObjectHandler#revert\n *\n * @param {Object} context\n *\n * @return {djs.mode.Base} the updated element\n */\nUpdateBusinessObjectHandler.prototype.revert = function(context) {\n\n  var oldProperties = context.oldProperties,\n      businessObject = context.businessObject;\n\n  // update properties\n  setProperties(businessObject, oldProperties);\n\n  return context.changed;\n};\n","'use strict';\n\nvar forEach = require('lodash/collection/forEach');\n\n/**\n * A handler that implements a BPMN 2.0 property update\n * for business object lists which are not represented in the\n * diagram.\n *\n * This is useful in the context of the properties panel in\n * order to update child elements of elements visible in\n * the diagram.\n *\n * Example: perform an update of a specific event definition\n * of an intermediate event.\n *\n * @class\n * @constructor\n */\nfunction UpdateBusinessObjectListHandler(elementRegistry, bpmnFactory) {\n  this._elementRegistry = elementRegistry;\n  this._bpmnFactory = bpmnFactory;\n}\n\nUpdateBusinessObjectListHandler.$inject = [ 'elementRegistry', 'bpmnFactory' ];\n\nmodule.exports = UpdateBusinessObjectListHandler;\n\nfunction ensureNotNull(prop, name) {\n  if (!prop) {\n    throw new Error(name + 'required');\n  }\n  return prop;\n}\n\n////// api /////////////////////////////////////////////\n\n/**\n * Updates a element under a provided parent.\n */\nUpdateBusinessObjectListHandler.prototype.execute = function(context) {\n\n  var currentObject = ensureNotNull(context.currentObject, 'currentObject'),\n      propertyName = ensureNotNull(context.propertyName, 'propertyName'),\n      updatedObjectList = context.updatedObjectList,\n      objectsToRemove = context.objectsToRemove || [],\n      objectsToAdd = context.objectsToAdd || [],\n      changed = [ context.element], // this will not change any diagram-js elements\n      referencePropertyName;\n\n  if (context.referencePropertyName) {\n    referencePropertyName = context.referencePropertyName;\n  }\n\n  var objectList = currentObject[propertyName];\n  // adjust array reference in the parent business object\n  context.previousList = currentObject[propertyName];\n\n  if (updatedObjectList) {\n    currentObject[propertyName] = updatedObjectList;\n  } else {\n    var listCopy = [];\n    // remove all objects which should be removed\n    forEach(objectList, function(object) {\n      if (objectsToRemove.indexOf(object) == -1) {\n        listCopy.push(object);\n      }\n    });\n    // add all objects which should be added\n    listCopy = listCopy.concat(objectsToAdd);\n\n    // set property to new list\n    if (listCopy.length > 0 || !referencePropertyName) {\n\n      // as long as there are elements in the list update the list\n      currentObject[propertyName] = listCopy;\n    } else if (referencePropertyName) {\n\n      // remove the list when it is empty\n      var parentObject = currentObject.$parent;\n      parentObject.set(referencePropertyName, undefined);\n    }\n  }\n\n  context.changed = changed;\n\n  // indicate changed on objects affected by the update\n  return changed;\n};\n\n/**\n * Reverts the update\n *\n * @method  CreateBusinessObjectListHandler#revert\n *\n * @param {Object} context\n *\n * @return {djs.mode.Base} the updated element\n */\nUpdateBusinessObjectListHandler.prototype.revert = function(context) {\n\n  var currentObject = context.currentObject,\n      propertyName = context.propertyName,\n      previousList = context.previousList,\n      parentObject = currentObject.$parent;\n\n  if (context.referencePropertyName) {\n    parentObject.set(context.referencePropertyName, currentObject);\n  }\n\n  // remove new element\n  currentObject.set(propertyName, previousList);\n\n  return context.changed;\n};\n","'use strict';\n\nvar forEach = require('lodash/collection/forEach');\n\nvar HANDLERS = {\n  'properties-panel.update-businessobject': require('./UpdateBusinessObjectHandler'),\n  'properties-panel.create-and-reference': require('./CreateAndReferenceHandler'),\n  'properties-panel.create-businessobject-list': require('./CreateBusinessObjectListHandler'),\n  'properties-panel.update-businessobject-list': require('./UpdateBusinessObjectListHandler'),\n  'properties-panel.multi-command-executor': require('./MultiCommandHandler')\n};\n\n\nfunction CommandInitializer(eventBus, commandStack) {\n\n  eventBus.on('diagram.init', function() {\n    forEach(HANDLERS, function(handler, id) {\n      commandStack.registerHandler(id, handler);\n    });\n  });\n}\n\nCommandInitializer.$inject = [ 'eventBus', 'commandStack' ];\n\nmodule.exports = {\n  __init__: [ CommandInitializer ]\n};","'use strict';\n\nvar getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject,\n    cmdHelper = require('../helper/CmdHelper');\n\nvar entryFieldDescription = require('./EntryFieldDescription');\n\n\nvar checkbox = function(options, defaultParameters) {\n  var resource      = defaultParameters,\n      label         = options.label || resource.id,\n      canBeDisabled = !!options.disabled && typeof options.disabled === 'function',\n      canBeHidden   = !!options.hidden && typeof options.hidden === 'function',\n      description   = options.description;\n\n  resource.html =\n    '<input id=\"camunda-' + resource.id + '\" ' +\n         'type=\"checkbox\" ' +\n         'name=\"' + options.modelProperty + '\" ' +\n         (canBeDisabled ? 'data-disable=\"isDisabled\"' : '') +\n         (canBeHidden ? 'data-show=\"isHidden\"' : '') +\n         ' />' +\n    '<label for=\"camunda-' + resource.id + '\" ' +\n         (canBeDisabled ? 'data-disable=\"isDisabled\"' : '') +\n         (canBeHidden ? 'data-show=\"isHidden\"' : '') +\n         '>' + label + '</label>';\n\n  // add description below checkbox entry field\n  if (description) {\n    resource.html += entryFieldDescription(description);\n  }\n\n  resource.get = function(element) {\n    var bo = getBusinessObject(element),\n        res = {};\n\n    res[options.modelProperty] = bo.get(options.modelProperty);\n\n    return res;\n  };\n  resource.set = function(element, values) {\n    var res = {};\n\n    res[options.modelProperty] = !!values[options.modelProperty];\n\n    return cmdHelper.updateProperties(element, res);\n  };\n\n  if (typeof options.set === 'function') {\n    resource.set = options.set;\n  }\n\n  if (typeof options.get === 'function') {\n    resource.get = options.get;\n  }\n\n  if (canBeDisabled) {\n    resource.isDisabled = function() {\n      return options.disabled.apply(resource, arguments);\n    };\n  }\n\n  if (canBeHidden) {\n    resource.isHidden = function() {\n      return !options.hidden.apply(resource, arguments);\n    };\n  }\n\n  resource.cssClasses = ['bpp-checkbox'];\n\n  return resource;\n};\n\nmodule.exports = checkbox;\n","'use strict';\n\nvar assign = require('lodash/object/assign'),\n    find = require('lodash/collection/find');\n\nvar domQuery = require('min-dom/lib/query');\n\nvar selectEntryFactory = require('./SelectEntryFactory'),\n    entryFieldDescription = require('./EntryFieldDescription');\n\n\n/**\n * The combo box is a special implementation of the select entry and adds the option 'custom' to the\n * select box. If 'custom' is selected, an additional text input field is shown which allows to define\n * a custom value.\n *\n * @param  {Object} options\n * @param  {string} options.id\n * @param  {string} options.label\n * @param  {Array<Object>} options.selectOptions list of name/value pairs\n * @param  {string} options.modelProperty\n * @param  {function} options.get\n * @param  {function} options.set\n * @param  {string} [options.customValue] custom select option value (default: 'custom')\n * @param  {string} [options.customName] custom select option name visible in the select box (default: 'custom')\n *\n * @return {Object}\n */\nvar comboBox = function(options) {\n\n  var selectOptions = options.selectOptions,\n      modelProperty = options.modelProperty,\n      customValue   = options.customValue || 'custom',\n      customName    = options.customName || 'custom ' + modelProperty,\n      description   = options.description;\n\n  // check if a value is not a built in value\n  var isCustomValue = function(value) {\n    if (typeof value[modelProperty] === 'undefined') {\n      return false;\n    }\n\n    var isCustom = !find(selectOptions, function(option) {\n      return value[modelProperty] === option.value;\n    });\n\n    return isCustom;\n  };\n\n  var comboOptions = assign({}, options);\n\n  // true if the selected value in the select box is customValue\n  comboOptions.showCustomInput = function(element, node) {\n    var selectBox = domQuery('[data-entry=\"'+ options.id +'\"] select', node.parentNode);\n\n    if (selectBox) {\n      return selectBox.value === customValue;\n    }\n\n    return false;\n  };\n\n  comboOptions.get = function(element, node) {\n    var value = options.get(element, node);\n\n    var modifiedValues = {};\n\n    if (!isCustomValue(value)) {\n      modifiedValues[modelProperty] = value[modelProperty] || '';\n\n      return modifiedValues;\n    }\n\n    modifiedValues[modelProperty] = customValue;\n    modifiedValues['custom-'+modelProperty] = value[modelProperty];\n\n    return modifiedValues;\n  };\n\n  comboOptions.set = function(element, values, node) {\n    var modifiedValues = {};\n\n    // if the custom select option has been selected\n    // take the value from the text input field\n    if (values[modelProperty] === customValue) {\n      modifiedValues[modelProperty] = values['custom-' + modelProperty] || '';\n    }\n    else if (options.emptyParameter && values[modelProperty] === '') {\n      modifiedValues[modelProperty] = undefined;\n    } else {\n      modifiedValues[modelProperty] = values[modelProperty];\n    }\n    return options.set(element, modifiedValues, node);\n  };\n\n  comboOptions.selectOptions.push({ name: customName, value: customValue });\n\n  var comboBoxEntry = assign({}, selectEntryFactory(comboOptions, comboOptions));\n\n  comboBoxEntry.html += '<div class=\"bpp-field-wrapper bpp-combo-input\" ' +\n    'data-show=\"showCustomInput\"' +\n    '>' +\n    '<input id=\"camunda-' + options.id + '-input\" type=\"text\" name=\"custom-' + modelProperty+'\" ' +\n      ' />' +\n  '</div>';\n\n  // add description below combo box entry field\n  if (description) {\n    comboBoxEntry.html += entryFieldDescription(description);\n  }\n\n  return comboBoxEntry;\n};\n\nmodule.exports = comboBox;\n","'use strict';\n\nvar getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject;\n\n// input entities\nvar textInputField = require('./TextInputEntryFactory'),\n    checkboxField = require('./CheckboxEntryFactory'),\n    selectBoxField = require('./SelectEntryFactory'),\n    comboBoxField = require('./ComboEntryFactory'),\n    textBoxField = require('./TextBoxEntryFactory'),\n    validationAwareTextInputField = require('./ValidationAwareTextInput'),\n    tableField = require('./TableEntryFactory'),\n    labelEntry = require('./LabelFactory'),\n    link = require('./LinkEntryFactory');\n\nvar cmdHelper = require('../helper/CmdHelper');\n\n// helpers ////////////////////////////////////////\n\nfunction ensureNotNull(prop) {\n  if (!prop) {\n    throw new Error(prop + ' must be set.');\n  }\n\n  return prop;\n}\n\n/**\n * sets the default parameters which are needed to create an entry\n *\n * @param options\n * @returns {{id: *, description: (*|string), get: (*|Function), set: (*|Function),\n *            validate: (*|Function), html: string}}\n */\nvar setDefaultParameters = function( options ) {\n\n  // default method to fetch the current value of the input field\n  var defaultGet = function(element) {\n    var bo = getBusinessObject(element),\n        res = {},\n        prop = ensureNotNull(options.modelProperty);\n    res[prop] = bo.get(prop);\n\n    return res;\n  };\n\n// default method to set a new value to the input field\n  var defaultSet = function(element, values) {\n    var res = {},\n        prop = ensureNotNull(options.modelProperty);\n    if (values[prop] !== '') {\n      res[prop] = values[prop];\n    } else {\n      res[prop] = undefined;\n    }\n\n    return cmdHelper.updateProperties(element, res);\n  };\n\n// default validation method\n  var defaultValidate = function() {\n    return {};\n  };\n\n  return {\n    id : options.id,\n    description : ( options.description || '' ),\n    get : ( options.get || defaultGet ),\n    set : ( options.set || defaultSet ),\n    validate : ( options.validate || defaultValidate ),\n    html: ''\n  };\n};\n\nfunction EntryFactory() {\n\n}\n\n/**\n * Generates an text input entry object for a property panel.\n * options are:\n * - id: id of the entry - String\n *\n * - description: description of the property - String\n *\n * - label: label for the input field - String\n *\n * - set: setter method - Function\n *\n * - get: getter method - Function\n *\n * - validate: validation mehtod - Function\n *\n * - modelProperty: name of the model property - String\n *\n * - buttonAction: Object which contains the following properties: - Object\n * ---- name: name of the [data-action] callback - String\n * ---- method: callback function for [data-action] - Function\n *\n * - buttonShow: Object which contains the following properties: - Object\n * ---- name: name of the [data-show] callback - String\n * ---- method: callback function for [data-show] - Function\n *\n * @param options\n * @returns the propertyPanel entry resource object\n */\nEntryFactory.textField = function(options) {\n  return textInputField(options, setDefaultParameters(options));\n};\n\nEntryFactory.validationAwareTextField = function(options) {\n  return validationAwareTextInputField(options, setDefaultParameters(options));\n};\n\n/**\n * Generates a checkbox input entry object for a property panel.\n * options are:\n * - id: id of the entry - String\n *\n * - description: description of the property - String\n *\n * - label: label for the input field - String\n *\n * - set: setter method - Function\n *\n * - get: getter method - Function\n *\n * - validate: validation mehtod - Function\n *\n * - modelProperty: name of the model property - String\n *\n * @param options\n * @returns the propertyPanel entry resource object\n */\nEntryFactory.checkbox = function(options) {\n  return checkboxField(options, setDefaultParameters(options));\n};\n\nEntryFactory.textBox = function(options) {\n  return textBoxField(options, setDefaultParameters(options));\n};\n\nEntryFactory.selectBox = function(options) {\n  return selectBoxField(options, setDefaultParameters(options));\n};\n\nEntryFactory.comboBox = function(options) {\n  return comboBoxField(options);\n};\n\nEntryFactory.table = function(options) {\n  return tableField(options);\n};\n\nEntryFactory.label = function(options) {\n  return labelEntry(options);\n};\n\nEntryFactory.link = function(options) {\n  return link(options);\n};\n\nmodule.exports = EntryFactory;\n","'use strict';\n\nvar MARKDOWN_LINK_REGEX = /\\[([^\\)]+)\\]\\(([^\\]]+)\\)/g;\n\n/**\n * Replace MarkDown Link Syntax with HTML Link Syntax\n * [myLink](http://www.myLink.de) -> <a href=http://www.myLink.de>myLink</a>\n *\n * @param {String} value\n *\n * @return {String}\n */\nfunction linkify(text) {\n  return text.replace(MARKDOWN_LINK_REGEX, '<a href=\"$2\" target=\"_blank\">$1</a>');\n}\n\nmodule.exports = function entryFieldDescription(description) {\n  description = linkify(description);\n\n  return '<div class=\"bpp-field-description\">' + description + '</div>';\n};\n","'use strict';\n\n/**\n * The label factory provides a label entry. For the label text\n * it expects either a string provided by the options.labelText\n * parameter or it could be generated programmatically using a\n * function passed as the options.get parameter.\n *\n * @param  {Object} options\n * @param  {string} options.id\n * @param  {string} [options.labelText]\n * @param  {Function} [options.get]\n * @param  {Function} [options.showLabel]\n * @param  {Boolean} [options.divider] adds a divider at the top of the label if true; default: false\n */\nvar label = function(options) {\n  return {\n    id: options.id,\n    html: '<label data-value=\"label\" ' +\n            'data-show=\"showLabel\" ' +\n            'class=\"entry-label' + (options.divider ? ' divider' : '') + '\">' +\n          '</label>',\n    get: function(element, node) {\n      if (typeof options.get === 'function') {\n        return options.get(element, node);\n      }\n      return { label: options.labelText };\n    },\n    showLabel: function(element, node) {\n      if (typeof options.showLabel === 'function') {\n        return options.showLabel(element, node);\n      }\n      return true;\n    }\n  };\n};\n\nmodule.exports = label;\n","'use strict';\n\nvar utils = require('../Utils');\n\nvar entryFieldDescription = require('./EntryFieldDescription');\n\nvar link = function(options, defaultParameters) {\n\n  var id                  = options.id,\n      label               = options.label || id,\n      hideLink            = options.hideLink,\n      canBeHidden         = typeof hideLink === 'function',\n      getClickableElement = options.getClickableElement,\n      description         = options.description;\n\n  var resource = { id: id };\n\n  resource.html =\n    '<a data-action=\"linkSelected\" ' +\n    (canBeHidden ? 'data-show=\"hideLink\" ' : '') +\n    'class=\"bpp-entry-link' + (options.cssClasses ? ' ' + options.cssClasses : '') +\n    '\">' + label + '</a>';\n\n  // add description below link entry field\n  if (description) {\n    resource.html += entryFieldDescription(description);\n  }\n\n  resource.linkSelected = function(element, node, event, scopeNode) {\n    if (typeof getClickableElement === 'function') {\n\n      var link = getClickableElement.apply(resource, [ element, node, event, scopeNode ]);\n      link && utils.triggerClickEvent(link);\n    }\n\n    return false;\n  };\n\n  if (canBeHidden) {\n    resource.hideLink = function() {\n      return !hideLink.apply(resource, arguments);\n    };\n  }\n\n  return resource;\n};\n\nmodule.exports = link;\n","'use strict';\n\nvar domify = require('min-dom/lib/domify');\n\nvar forEach = require('lodash/collection/forEach');\n\nvar entryFieldDescription = require('./EntryFieldDescription');\n\n\nvar isList = function(list) {\n  return !(!list || Object.prototype.toString.call(list) !== '[object Array]');\n};\n\nvar addEmptyParameter = function(list) {\n  return list.concat([ { name: '', value: '' } ]);\n};\n\nvar createOption = function(option) {\n  return '<option value=\"' + option.value + '\">' + option.name + '</option>';\n};\n\n/**\n * @param  {Object} options\n * @param  {string} options.id\n * @param  {string} [options.label]\n * @param  {Array<Object>} options.selectOptions\n * @param  {string} options.modelProperty\n * @param  {boolean} options.emptyParameter\n * @param  {function} options.disabled\n * @param  {function} options.hidden\n * @param  {Object} defaultParameters\n *\n * @return {Object}\n */\nvar selectbox = function(options, defaultParameters) {\n  var resource = defaultParameters,\n      label = options.label || resource.id,\n      selectOptions = options.selectOptions || [ { name: '', value: '' } ],\n      modelProperty = options.modelProperty,\n      emptyParameter = options.emptyParameter,\n      canBeDisabled = !!options.disabled && typeof options.disabled === 'function',\n      canBeHidden = !!options.hidden && typeof options.hidden === 'function',\n      description = options.description;\n\n\n  if (emptyParameter) {\n    selectOptions = addEmptyParameter(selectOptions);\n  }\n\n\n  resource.html =\n    '<label for=\"camunda-' + resource.id + '\"' +\n    (canBeDisabled ? 'data-disable=\"isDisabled\" ' : '') +\n    (canBeHidden ? 'data-show=\"isHidden\" ' : '') +\n    '>' + label + '</label>' +\n    '<select id=\"camunda-' + resource.id + '-select\" name=\"' + modelProperty + '\"' +\n    (canBeDisabled ? 'data-disable=\"isDisabled\" ' : '') +\n    (canBeHidden ? 'data-show=\"isHidden\" ' : '') +\n    ' data-value>';\n\n  if (isList(selectOptions)) {\n    forEach(selectOptions, function(option) {\n      resource.html += '<option value=\"' + option.value + '\">' + (option.name || '') + '</option>';\n    });\n  }\n\n  resource.html += '</select>';\n\n  // add description below select box entry field\n  if (description && !typeof options.showCustomInput === 'function') {\n    resource.html += entryFieldDescription(description);\n  }\n\n  /**\n   * Fill the select box options dynamically.\n   *\n   * Calls the defined function #selectOptions in the entry to get the\n   * values for the options and set the value to the inputNode.\n   *\n   * @param {djs.model.Base} element\n   * @param {HTMLElement} entryNode\n   * @param {EntryDescriptor} inputNode\n   * @param {Object} inputName\n   * @param {Object} newValue\n   */\n  resource.setControlValue = function(element, entryNode, inputNode, inputName, newValue) {\n    if (typeof selectOptions === 'function') {\n\n      var options = selectOptions(element, inputNode);\n\n      if (options) {\n\n        // remove existing options\n        while (inputNode.firstChild) {\n          inputNode.removeChild(inputNode.firstChild);\n        }\n\n        // add options\n        forEach(options, function(option) {\n          var template = domify(createOption(option));\n\n          inputNode.appendChild(template);\n        });\n\n\n      }\n    }\n\n    // set select value\n    if (newValue !== undefined) {\n      inputNode.value = newValue;\n    }\n\n  };\n\n  if (canBeDisabled) {\n    resource.isDisabled = function() {\n      return options.disabled.apply(resource, arguments);\n    };\n  }\n\n  if (canBeHidden) {\n    resource.isHidden = function() {\n      return !options.hidden.apply(resource, arguments);\n    };\n  }\n\n  resource.cssClasses = ['bpp-dropdown'];\n\n  return resource;\n};\n\nmodule.exports = selectbox;\n","'use strict';\n\nvar cmdHelper = require('../helper/CmdHelper');\n\nvar domQuery = require('min-dom/lib/query'),\n    domAttr = require('min-dom/lib/attr'),\n    domClosest = require('min-dom/lib/closest');\n\nvar filter = require('lodash/collection/filter'),\n    forEach = require('lodash/collection/forEach'),\n    keys = require('lodash/object/keys');\n\nvar domify = require('min-dom/lib/domify');\n\nvar entryFieldDescription = require('./EntryFieldDescription');\n\nvar updateSelection = require('selection-update');\n\nvar TABLE_ROW_DIV_SNIPPET = '<div class=\"bpp-field-wrapper bpp-table-row\">';\nvar DELETE_ROW_BUTTON_SNIPPET = '<button class=\"clear\" data-action=\"deleteElement\">' +\n                                  '<span>X</span>' +\n                                '</button>';\n\nfunction createInputRowTemplate(properties, canRemove) {\n  var template = TABLE_ROW_DIV_SNIPPET;\n  template += createInputTemplate(properties, canRemove);\n  template += canRemove ? DELETE_ROW_BUTTON_SNIPPET : '';\n  template += '</div>';\n\n  return template;\n}\n\nfunction createInputTemplate(properties, canRemove) {\n  var columns = properties.length;\n  var template = '';\n  forEach(properties, function(prop) {\n    template += '<input class=\"bpp-table-row-columns-' + columns + ' ' +\n                               (canRemove ? 'bpp-table-row-removable' : '') + '\" ' +\n                       'id=\"camunda-table-row-cell-input-value\" ' +\n                       'type=\"text\" ' +\n                       'name=\"' + prop + '\" />';\n  });\n  return template;\n}\n\nfunction createLabelRowTemplate(labels) {\n  var template = TABLE_ROW_DIV_SNIPPET;\n  template += createLabelTemplate(labels);\n  template += '</div>';\n\n  return template;\n}\n\nfunction createLabelTemplate(labels) {\n  var columns = labels.length;\n  var template = '';\n  forEach(labels, function(label) {\n    template += '<label class=\"bpp-table-row-columns-' + columns + '\">' + label + '</label>';\n  });\n  return template;\n}\n\nfunction pick(elements, properties) {\n  return (elements || []).map(function(elem) {\n    var newElement = {};\n    forEach(properties, function(prop) {\n      newElement[prop] = elem[prop] || '';\n    });\n    return newElement;\n  });\n}\n\nfunction diff(element, node, values, oldValues, editable) {\n  return filter(values, function(value, idx) {\n    return !valueEqual(element, node, value, oldValues[idx], editable, idx);\n  });\n}\n\nfunction valueEqual(element, node, value, oldValue, editable, idx) {\n  if (value && !oldValue) {\n    return false;\n  }\n  var allKeys = keys(value).concat(keys(oldValue));\n\n  return allKeys.every(function(key) {\n    var n = value[key] || undefined;\n    var o = oldValue[key] || undefined;\n    return !editable(element, node, key, idx) || n === o;\n  });\n}\n\nfunction getEntryNode(node) {\n  return domClosest(node, '[data-entry]', true);\n}\n\nfunction getContainer(node) {\n  return domQuery('div[data-list-entry-container]', node);\n}\n\nfunction getSelection(node) {\n  return {\n    start: node.selectionStart,\n    end: node.selectionEnd\n  };\n}\n\nfunction setSelection(node, selection) {\n  node.selectionStart = selection.start;\n  node.selectionEnd = selection.end;\n}\n\n/**\n * @param  {Object} options\n * @param  {string} options.id\n * @param  {string} options.description\n * @param  {Array<string>} options.modelProperties\n * @param  {Array<string>} options.labels\n * @param  {Function} options.getElements - this callback function must return a list of business object items\n * @param  {Function} options.removeElement\n * @param  {Function} options.addElement\n * @param  {Function} options.updateElement\n * @param  {Function} options.editable\n * @param  {Function} options.setControlValue\n * @param  {Function} options.show\n *\n * @return {Object}\n */\nmodule.exports = function(options) {\n\n  var id              = options.id,\n      modelProperties = options.modelProperties,\n      labels          = options.labels,\n      description     = options.description;\n\n  var labelRow = createLabelRowTemplate(labels);\n\n  var getElements   = options.getElements;\n\n  var removeElement = options.removeElement,\n      canRemove     = typeof removeElement === 'function';\n\n  var addElement = options.addElement,\n      canAdd     = typeof addElement === 'function',\n      addLabel   = options.addLabel || 'Add Value';\n\n  var updateElement = options.updateElement,\n      canUpdate     = typeof updateElement === 'function';\n\n  var editable        = options.editable || function() { return true; },\n      setControlValue = options.setControlValue;\n\n  var show       = options.show,\n      canBeShown = typeof show === 'function';\n\n  var elements = function(element, node) {\n    return pick(getElements(element, node), modelProperties);\n  };\n\n  var factory = {\n    id: id,\n    html: ( canAdd ?\n          '<div class=\"bpp-table-add-row\" ' + (canBeShown ? 'data-show=\"show\"' : '') + '>' +\n            '<label>' + addLabel + '</label>' +\n            '<button class=\"add\" data-action=\"addElement\"><span>+</span></button>' +\n          '</div>' : '') +\n          '<div class=\"bpp-table\" data-show=\"showTable\">' +\n            '<div class=\"bpp-field-wrapper bpp-table-row\">' +\n               labelRow +\n            '</div>' +\n            '<div data-list-entry-container>' +\n            '</div>' +\n          '</div>' +\n\n          // add description below table entry field\n          ( description ? entryFieldDescription(description) : ''),\n\n    get: function(element, node) {\n      var boElements = elements(element, node, this.__invalidValues);\n\n      var invalidValues = this.__invalidValues;\n\n      delete this.__invalidValues;\n\n      forEach(invalidValues, function(value, idx) {\n        var element = boElements[idx];\n\n        forEach(modelProperties, function(prop) {\n          element[prop] = value[prop];\n        });\n      });\n\n      return boElements;\n    },\n\n    set: function(element, values, node) {\n      var action = this.__action || {};\n      delete this.__action;\n\n      if (action.id === 'delete-element') {\n        return removeElement(element, node, action.idx);\n      }\n      else if (action.id === 'add-element') {\n        return addElement(element, node);\n      }\n      else if (canUpdate) {\n        var commands = [],\n            valuesToValidate = values;\n\n        if (typeof options.validate !== 'function') {\n          valuesToValidate = diff(element, node, values, elements(element, node), editable);\n        }\n\n        var self = this;\n\n        forEach(valuesToValidate, function(value) {\n          var validationError,\n              idx = values.indexOf(value);\n\n          if (typeof options.validate === 'function') {\n            validationError = options.validate(element, value, node, idx);\n          }\n\n          if (!validationError) {\n            var cmd = updateElement(element, value, node, idx);\n\n            if (cmd) {\n              commands.push(cmd);\n            }\n          } else {\n            // cache invalid value in an object by index as key\n            self.__invalidValues = self.__invalidValues || {};\n            self.__invalidValues[idx] = value;\n\n            // execute a command, which does not do anything\n            commands.push(cmdHelper.updateProperties(element, {}));\n          }\n        });\n\n        return commands;\n      }\n    },\n    createListEntryTemplate: function(value, index, selectBox) {\n      return createInputRowTemplate(modelProperties, canRemove);\n    },\n\n    addElement: function(element, node, event, scopeNode) {\n      var template = domify(createInputRowTemplate(modelProperties, canRemove));\n\n      var container = getContainer(node);\n      container.appendChild(template);\n\n      this.__action = {\n        id: 'add-element'\n      };\n\n      return true;\n    },\n\n    deleteElement: function(element, node, event, scopeNode) {\n      var container = getContainer(node);\n      var rowToDelete = event.delegateTarget.parentNode;\n      var idx = parseInt(domAttr(rowToDelete, 'data-index'), 10);\n\n      container.removeChild(rowToDelete);\n\n      this.__action = {\n        id: 'delete-element',\n        idx: idx\n      };\n\n      return true;\n    },\n\n    editable: function(element, rowNode, input, prop, value, idx) {\n      var entryNode = domClosest(rowNode, '[data-entry]');\n      return editable(element, entryNode, prop, idx);\n    },\n\n    show: function(element, entryNode, node, scopeNode) {\n      entryNode = getEntryNode(entryNode);\n      return show(element, entryNode, node, scopeNode);\n    },\n\n    showTable: function(element, entryNode, node, scopeNode) {\n      entryNode = getEntryNode(entryNode);\n      var elems = elements(element, entryNode);\n      return elems && elems.length && (!canBeShown || show(element, entryNode, node, scopeNode));\n    },\n\n    validateListItem: function(element, value, node, idx) {\n      if (typeof options.validate === 'function') {\n        return options.validate(element, value, node, idx);\n      }\n    }\n\n  };\n\n  // Update/set the selection on the correct position.\n  // It's the same code like for an input value in the PropertiesPanel.js.\n  if (setControlValue) {\n    factory.setControlValue = function(element, rowNode, input, prop, value, idx) {\n      var entryNode = getEntryNode(rowNode);\n\n      var isReadOnly = domAttr(input, 'readonly');\n      var oldValue = input.value;\n\n      var selection;\n\n      // prevents input fields from having the value 'undefined'\n      if (value === undefined) {\n        value = '';\n      }\n\n      // when the attribute 'readonly' exists, ignore the comparison\n      // with 'oldValue' and 'value'\n      if (!!isReadOnly && oldValue === value) {\n        return;\n      }\n\n      // update selection on undo/redo\n      if (document.activeElement === input) {\n        selection = updateSelection(getSelection(input), oldValue, value);\n      }\n\n      setControlValue(element, entryNode, input, prop, value, idx);\n\n      if (selection) {\n        setSelection(input, selection);\n      }\n\n    };\n  }\n\n  return factory;\n\n};\n","'use strict';\n\nvar entryFieldDescription = require('./EntryFieldDescription');\n\n\nvar textBox = function(options, defaultParameters) {\n\n  var resource    = defaultParameters,\n      label       = options.label || resource.id,\n      canBeShown  = !!options.show && typeof options.show === 'function',\n      description = options.description;\n\n  resource.html =\n    '<label for=\"camunda-' + resource.id + '\" ' +\n    (canBeShown ? 'data-show=\"isShown\"' : '') +\n    '>' + label + '</label>' +\n    '<div class=\"bpp-field-wrapper\" ' +\n    (canBeShown ? 'data-show=\"isShown\"' : '') +\n    '>' +\n      '<div contenteditable=\"true\" id=\"camunda-' + resource.id + '\" ' +\n            'name=\"' + options.modelProperty + '\" />' +\n    '</div>';\n\n  // add description below text box entry field\n  if (description) {\n    resource.html += entryFieldDescription(description);\n  }\n\n  if (canBeShown) {\n    resource.isShown = function() {\n      return options.show.apply(resource, arguments);\n    };\n  }\n\n  resource.cssClasses = ['bpp-textbox'];\n\n  return resource;\n};\n\nmodule.exports = textBox;\n","'use strict';\n\nvar domQuery = require('min-dom/lib/query');\n\nvar entryFieldDescription = require('./EntryFieldDescription');\n\n\nvar textField = function(options, defaultParameters) {\n\n  // Default action for the button next to the input-field\n  var defaultButtonAction = function(element, inputNode) {\n    var input = domQuery('input[name=\"' + options.modelProperty + '\"]', inputNode);\n    input.value = '';\n\n    return true;\n  };\n\n  // default method to determine if the button should be visible\n  var defaultButtonShow = function(element, inputNode) {\n    var input = domQuery('input[name=\"' + options.modelProperty + '\"]', inputNode);\n\n    return input.value !== '';\n  };\n\n\n  var resource       = defaultParameters,\n      label          = options.label || resource.id,\n      dataValueLabel = options.dataValueLabel,\n      buttonLabel    = ( options.buttonLabel || 'X' ),\n      actionName     = ( typeof options.buttonAction != 'undefined' ) ? options.buttonAction.name : 'clear',\n      actionMethod   = ( typeof options.buttonAction != 'undefined' ) ? options.buttonAction.method : defaultButtonAction,\n      showName       = ( typeof options.buttonShow != 'undefined' ) ? options.buttonShow.name : 'canClear',\n      showMethod     = ( typeof options.buttonShow != 'undefined' ) ? options.buttonShow.method : defaultButtonShow,\n      canBeDisabled  = !!options.disabled && typeof options.disabled === 'function',\n      canBeHidden    = !!options.hidden && typeof options.hidden === 'function',\n      description    = options.description;\n\n  resource.html =\n    '<label for=\"camunda-' + resource.id + '\" ' +\n      (canBeDisabled ? 'data-disable=\"isDisabled\" ' : '') +\n      (canBeHidden ? 'data-show=\"isHidden\" ' : '') +\n      (dataValueLabel ? 'data-value=\"' + dataValueLabel + '\"' : '') + '>'+ label +'</label>' +\n    '<div class=\"bpp-field-wrapper\" ' +\n      (canBeDisabled ? 'data-disable=\"isDisabled\"' : '') +\n      (canBeHidden ? 'data-show=\"isHidden\"' : '') +\n      '>' +\n      '<input id=\"camunda-' + resource.id + '\" type=\"text\" name=\"' + options.modelProperty+'\" ' +\n        (canBeDisabled ? 'data-disable=\"isDisabled\"' : '') +\n        (canBeHidden ? 'data-show=\"isHidden\"' : '') +\n        ' />' +\n      '<button class=\"' + actionName + '\" data-action=\"' + actionName + '\" data-show=\"' + showName + '\" ' +\n        (canBeDisabled ? 'data-disable=\"isDisabled\"' : '') +\n        (canBeHidden ? ' data-show=\"isHidden\"' : '') + '>' +\n        '<span>' + buttonLabel + '</span>' +\n      '</button>' +\n    '</div>';\n\n  // add description below text input entry field\n  if (description) {\n    resource.html += entryFieldDescription(description);\n  }\n\n  resource[actionName] = actionMethod;\n  resource[showName] = showMethod;\n\n  if (canBeDisabled) {\n    resource.isDisabled = function() {\n      return options.disabled.apply(resource, arguments);\n    };\n  }\n\n  if (canBeHidden) {\n    resource.isHidden = function() {\n      return !options.hidden.apply(resource, arguments);\n    };\n  }\n\n  resource.cssClasses = ['bpp-textfield'];\n\n  return resource;\n};\n\nmodule.exports = textField;\n","'use strict';\n\nvar textField = require('./TextInputEntryFactory');\n\n/**\n * This function is a wrapper around TextInputEntryFactory.\n * It adds functionality to cache an invalid value entered in the\n * text input, instead of setting it on the business object.\n */\nvar validationAwareTextField = function(options, defaultParameters) {\n\n  var modelProperty = options.modelProperty;\n\n  defaultParameters.get = function(element, node) {\n    var value = this.__lastInvalidValue;\n\n    delete this.__lastInvalidValue;\n\n    var properties = {};\n\n    properties[modelProperty] = value !== undefined ? value : options.getProperty(element, node);\n\n    return properties;\n  };\n\n  defaultParameters.set = function(element, values, node) {\n    var validationErrors = validate.apply(this, [ element, values, node ]),\n        propertyValue = values[modelProperty];\n\n    // make sure we do not update the id\n    if (validationErrors && validationErrors[modelProperty]) {\n      this.__lastInvalidValue = propertyValue;\n\n      return options.setProperty(element, {}, node);\n    } else {\n      var properties = {};\n\n      properties[modelProperty] = propertyValue;\n\n      return options.setProperty(element, properties, node);\n    }\n  };\n\n  var validate = defaultParameters.validate = function(element, values, node) {\n    var value = values[modelProperty] || this.__lastInvalidValue;\n\n    var property = {};\n    property[modelProperty] = value;\n\n    return options.validate(element, property, node);\n  };\n\n  return textField(options, defaultParameters);\n};\n\nmodule.exports = validationAwareTextField;\n","'use strict';\n\nvar map = require('lodash/collection/map');\n\nvar extensionElementsHelper = require('./ExtensionElementsHelper');\n\n/**\n * Returns true if the attribute 'camunda:asyncBefore' is set\n * to true.\n *\n * @param  {ModdleElement} bo\n *\n * @return {boolean} a boolean value\n */\nfunction isAsyncBefore(bo) {\n  return !!(bo.get('camunda:asyncBefore') || bo.get('camunda:async'));\n}\n\nmodule.exports.isAsyncBefore = isAsyncBefore;\n\n/**\n * Returns true if the attribute 'camunda:asyncAfter' is set\n * to true.\n *\n * @param  {ModdleElement} bo\n *\n * @return {boolean} a boolean value\n */\nfunction isAsyncAfter(bo) {\n  return !!bo.get('camunda:asyncAfter');\n}\n\nmodule.exports.isAsyncAfter = isAsyncAfter;\n\n/**\n * Returns true if the attribute 'camunda:exclusive' is set\n * to true.\n *\n * @param  {ModdleElement} bo\n *\n * @return {boolean} a boolean value\n */\nfunction isExclusive(bo) {\n  return !!bo.get('camunda:exclusive');\n}\n\nmodule.exports.isExclusive = isExclusive;\n\n/**\n * Get first 'camunda:FailedJobRetryTimeCycle' from the business object.\n *\n * @param  {ModdleElement} bo\n *\n * @return {Array<ModdleElement>} a list of 'camunda:FailedJobRetryTimeCycle'\n */\nfunction getFailedJobRetryTimeCycle(bo) {\n  return (extensionElementsHelper.getExtensionElements(bo, 'camunda:FailedJobRetryTimeCycle') || [])[0];\n}\n\nmodule.exports.getFailedJobRetryTimeCycle = getFailedJobRetryTimeCycle;\n\n/**\n * Removes all existing 'camunda:FailedJobRetryTimeCycle' from the business object\n *\n * @param  {ModdleElement} bo\n *\n * @return {Array<ModdleElement>} a list of 'camunda:FailedJobRetryTimeCycle'\n */\nfunction removeFailedJobRetryTimeCycle(bo, element) {\n  var retryTimeCycles = extensionElementsHelper.getExtensionElements(bo, 'camunda:FailedJobRetryTimeCycle');\n  return map(retryTimeCycles, function(cycle) {\n    return extensionElementsHelper.removeEntry(bo, element, cycle);\n  });\n}\n\nmodule.exports.removeFailedJobRetryTimeCycle = removeFailedJobRetryTimeCycle;","'use strict';\n\nvar CmdHelper = {};\nmodule.exports = CmdHelper;\n\nCmdHelper.updateProperties = function(element, properties) {\n  return {\n    cmd: 'element.updateProperties',\n    context: { element: element, properties: properties }\n  };\n};\n\nCmdHelper.updateBusinessObject = function(element, businessObject, newProperties) {\n  return {\n    cmd: 'properties-panel.update-businessobject',\n    context: {\n      element: element,\n      businessObject: businessObject,\n      properties: newProperties\n    }\n  };\n};\n\nCmdHelper.addElementsTolist = function(element, businessObject, listPropertyName, objectsToAdd) {\n  return {\n    cmd: 'properties-panel.update-businessobject-list',\n    context: {\n      element: element,\n      currentObject: businessObject,\n      propertyName: listPropertyName,\n      objectsToAdd: objectsToAdd\n    }\n  };\n};\n\nCmdHelper.removeElementsFromList = function(element, businessObject, listPropertyName, referencePropertyName, objectsToRemove) {\n\n  return {\n    cmd: 'properties-panel.update-businessobject-list',\n    context: {\n      element: element,\n      currentObject: businessObject,\n      propertyName: listPropertyName,\n      referencePropertyName: referencePropertyName,\n      objectsToRemove: objectsToRemove\n    }\n  };\n};\n\n\nCmdHelper.addAndRemoveElementsFromList = function(element, businessObject, listPropertyName, referencePropertyName, objectsToAdd, objectsToRemove) {\n\n  return {\n    cmd: 'properties-panel.update-businessobject-list',\n    context: {\n      element: element,\n      currentObject: businessObject,\n      propertyName: listPropertyName,\n      referencePropertyName: referencePropertyName,\n      objectsToAdd: objectsToAdd,\n      objectsToRemove: objectsToRemove\n    }\n  };\n};\n\n\nCmdHelper.setList = function(element, businessObject, listPropertyName, updatedObjectList) {\n  return {\n    cmd: 'properties-panel.update-businessobject-list',\n    context: {\n      element: element,\n      currentObject: businessObject,\n      propertyName: listPropertyName,\n      updatedObjectList: updatedObjectList\n    }\n  };\n};\n","'use strict';\n\nvar ElementHelper = {};\nmodule.exports = ElementHelper;\n\n/**\n * Creates a new element and set the parent to it\n *\n * @method ElementHelper#createElement\n *\n * @param {String} elementType of the new element\n * @param {Object} properties of the new element in key-value pairs\n * @param {moddle.object} parent of the new element\n * @param {BpmnFactory} factory which creates the new element\n *\n * @returns {djs.model.Base} element which is created\n */\nElementHelper.createElement = function(elementType, properties, parent, factory) {\n  var element = factory.create(elementType, properties);\n  element.$parent = parent;\n\n  return element;\n};\n","'use strict';\n\nvar getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject,\n    is = require('bpmn-js/lib/util/ModelUtil').is,\n    forEach = require('lodash/collection/forEach');\n\nvar EventDefinitionHelper = {};\n\nmodule.exports = EventDefinitionHelper;\n\nEventDefinitionHelper.getEventDefinition = function(element, eventType) {\n\n  var bo = getBusinessObject(element),\n      eventDefinition = null;\n\n  if (bo.eventDefinitions) {\n    forEach(bo.eventDefinitions, function(event) {\n      if (is(event, eventType)) {\n        eventDefinition = event;\n      }\n    });\n  }\n\n  return eventDefinition;\n};\n\nEventDefinitionHelper.getTimerEventDefinition = function(element) {\n  return this.getEventDefinition(element, 'bpmn:TimerEventDefinition');\n};\n\nEventDefinitionHelper.getMessageEventDefinition = function(element) {\n  return this.getEventDefinition(element, 'bpmn:MessageEventDefinition');\n};\n\nEventDefinitionHelper.getSignalEventDefinition = function(element) {\n  return this.getEventDefinition(element, 'bpmn:SignalEventDefinition');\n};\n\nEventDefinitionHelper.getErrorEventDefinition = function(element) {\n  return this.getEventDefinition(element, 'bpmn:ErrorEventDefinition');\n};\n\nEventDefinitionHelper.getEscalationEventDefinition = function(element) {\n  return this.getEventDefinition(element, 'bpmn:EscalationEventDefinition');\n};\n\nEventDefinitionHelper.getCompensateEventDefinition = function(element) {\n  return this.getEventDefinition(element, 'bpmn:CompensateEventDefinition');\n};\n\nEventDefinitionHelper.getLinkEventDefinition = function(element) {\n  return this.getEventDefinition(element, 'bpmn:LinkEventDefinition');\n};\n\nEventDefinitionHelper.getConditionalEventDefinition = function(element) {\n  return this.getEventDefinition(element, 'bpmn:ConditionalEventDefinition');\n};\n","'use strict';\n\nvar cmdHelper = require('./CmdHelper'),\n    elementHelper = require('./ElementHelper');\n\nvar is = require('bpmn-js/lib/util/ModelUtil').is;\n\nvar ExtensionElementsHelper = {};\n\nvar getExtensionElements = function(bo) {\n  return bo.get('extensionElements');\n};\n\nExtensionElementsHelper.getExtensionElements = function(bo, type) {\n  var extensionElements = getExtensionElements(bo);\n  if (typeof extensionElements !== 'undefined') {\n    var extensionValues = extensionElements.get('values');\n    if (typeof extensionValues !== 'undefined') {\n      var elements = extensionValues.filter(function(value) {\n        return is(value, type);\n      });\n      if (elements.length) {\n        return elements;\n      }\n    }\n  }\n};\n\nExtensionElementsHelper.addEntry = function(bo, element, entry, bpmnFactory) {\n  var extensionElements = bo.get('extensionElements');\n\n  // if there is no extensionElements list, create one\n  if (!extensionElements) {\n    // TODO: Ask Daniel which operation costs more\n    extensionElements = elementHelper.createElement('bpmn:ExtensionElements', { values: [entry] }, bo, bpmnFactory);\n    return { extensionElements : extensionElements };\n  } else {\n    // add new failedJobRetryExtensionElement to existing extensionElements list\n    return cmdHelper.addElementsTolist(element, extensionElements, 'values', [entry]);\n  }\n};\n\nExtensionElementsHelper.removeEntry = function(bo, element, entry) {\n  var extensionElements = bo.get('extensionElements');\n\n  if ( !extensionElements ) {\n    // return an empty command when there is no extensionElements list\n    return {};\n  }\n\n  return cmdHelper.removeElementsFromList(element, extensionElements, 'values', 'extensionElements', [entry]);\n};\n\nmodule.exports = ExtensionElementsHelper;\n","'use strict';\n\nvar getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject,\n    getExtensionElements = require('./ExtensionElementsHelper').getExtensionElements;\n\nvar FormHelper = {};\n\nmodule.exports = FormHelper;\n\n/**\n * Return form data from business object or undefined if none exist\n *\n * @param  {djs.model.Base} element\n *\n * @return {ModdleElement|undefined} formData\n */\nFormHelper.getFormData = function(element) {\n  var bo = getBusinessObject(element);\n\n  var formData = getExtensionElements(bo, 'camunda:FormData');\n\n  if (typeof formData !== 'undefined') {\n    return formData[0];\n  }\n};\n\n\n/**\n * Return all form fields existing in the business object, and\n * an empty array if none exist.\n *\n * @param  {djs.model.Base} element\n *\n * @return {Array} a list of form field objects\n */\nFormHelper.getFormFields = function(element) {\n  var formData = this.getFormData(element);\n\n  if (typeof formData === 'undefined') {\n    return [];\n  }\n\n  return formData.fields;\n};\n\n\n/**\n * Get a form field from the business object at given index\n *\n * @param {djs.model.Base} element\n * @param {number} idx\n *\n * @return {ModdleElement} the form field\n */\nFormHelper.getFormField = function(element, idx) {\n\n  var formFields = this.getFormFields(element);\n\n  return formFields[idx];\n};\n\n\n/**\n * Get all constraints for a specific form field from the business object\n *\n * @param  {ModdleElement} formField\n *\n * @return {Array<ModdleElement>} a list of constraint objects\n */\nFormHelper.getConstraints = function(formField) {\n  if (formField && formField.validation && formField.validation.constraints) {\n    return formField.validation.constraints;\n  }\n  return [];\n};\n\n\n/**\n * Get all camunda:value objects for a specific form field from the business object\n *\n * @param  {ModdleElement} formField\n *\n * @return {Array<ModdleElement>} a list of camunda:value objects\n */\nFormHelper.getEnumValues = function(formField) {\n  if (formField && formField.values) {\n    return formField.values;\n  }\n  return [];\n};\n\n","'use strict';\n\nvar ModelUtil         = require('bpmn-js/lib/util/ModelUtil'),\n    is                = ModelUtil.is,\n    getBusinessObject = ModelUtil.getBusinessObject;\n\nvar eventDefinitionHelper = require('./EventDefinitionHelper');\nvar extensionsElementHelper = require('./ExtensionElementsHelper');\n\nvar ImplementationTypeHelper = {};\n\nmodule.exports = ImplementationTypeHelper;\n\n/**\n * Returns 'true' if the given element is 'camunda:ServiceTaskLike'\n *\n * @param {djs.model.Base} element\n *\n * @return {boolean} a boolean value\n */\nImplementationTypeHelper.isServiceTaskLike = function(element) {\n  return is(element, 'camunda:ServiceTaskLike');\n};\n\n/**\n * Returns 'true' if the given element is 'camunda:DmnCapable'\n *\n * @param {djs.model.Base} element\n *\n * @return {boolean} a boolean value\n */\nImplementationTypeHelper.isDmnCapable = function(element) {\n  return is(element, 'camunda:DmnCapable');\n};\n\n/**\n * Returns 'true' if the given element is 'camunda:ExternalCapable'\n *\n * @param {djs.model.Base} element\n *\n * @return {boolean} a boolean value\n */\nImplementationTypeHelper.isExternalCapable = function(element) {\n  return is(element, 'camunda:ExternalCapable');\n};\n\n/**\n * Returns 'true' if the given element is 'camunda:TaskListener'\n *\n * @param {djs.model.Base} element\n *\n * @return {boolean} a boolean value\n */\nImplementationTypeHelper.isTaskListener = function(element) {\n  return is(element, 'camunda:TaskListener');\n};\n\n/**\n * Returns 'true' if the given element is 'camunda:ExecutionListener'\n *\n * @param {djs.model.Base} element\n *\n * @return {boolean} a boolean value\n */\nImplementationTypeHelper.isExecutionListener = function(element) {\n  return is(element, 'camunda:ExecutionListener');\n};\n\n/**\n * Returns 'true' if the given element is 'camunda:ExecutionListener' or\n * 'camunda:TaskListener'\n *\n * @param {djs.model.Base} element\n *\n * @return {boolean} a boolean value\n */\nImplementationTypeHelper.isListener = function(element) {\n  return this.isTaskListener(element) || this.isExecutionListener(element);\n};\n\n/**\n * Returns 'true' if the given element is 'bpmn:SequenceFlow'\n *\n * @param {djs.model.Base} element\n *\n * @return {boolean} a boolean value\n */\nImplementationTypeHelper.isSequenceFlow = function(element) {\n  return is(element, 'bpmn:SequenceFlow');\n};\n\n/**\n * Get a 'camunda:ServiceTaskLike' business object.\n *\n * If the given element is not a 'camunda:ServiceTaskLike', then 'false'\n * is returned.\n *\n * @param {djs.model.Base} element\n *\n * @return {ModdleElement} the 'camunda:ServiceTaskLike' business object\n */\nImplementationTypeHelper.getServiceTaskLikeBusinessObject = function(element) {\n\n  if (is(element, 'bpmn:IntermediateThrowEvent') || is(element, 'bpmn:EndEvent')) {\n     /**\n      * change business object to 'messageEventDefinition' when\n      * the element is a message intermediate throw event or message end event\n      * because the camunda extensions (e.g. camunda:class) are in the message\n      * event definition tag and not in the intermediate throw event or end event tag\n      */\n    var messageEventDefinition = eventDefinitionHelper.getMessageEventDefinition(element);\n    if (messageEventDefinition) {\n      element = messageEventDefinition;\n    }\n  }\n\n  return this.isServiceTaskLike(element) && getBusinessObject(element);\n\n};\n\n/**\n * Returns the implementation type of the given element.\n *\n * Possible implementation types are:\n * - dmn\n * - connector\n * - external\n * - class\n * - expression\n * - delegateExpression\n * - script\n * - or undefined, when no matching implementation type is found\n *\n * @param  {djs.model.Base} element\n *\n * @return {String} the implementation type\n */\nImplementationTypeHelper.getImplementationType = function(element) {\n\n  var bo = this.getServiceTaskLikeBusinessObject(element);\n\n  if (!bo) {\n    if (this.isListener(element)) {\n      bo = element;\n    } else {\n      return;\n    }\n  }\n\n  if (this.isDmnCapable(bo)) {\n    var decisionRef = bo.get('camunda:decisionRef');\n    if (typeof decisionRef !== 'undefined') {\n      return 'dmn';\n    }\n  }\n\n  if (this.isServiceTaskLike(bo)) {\n    var connectors = extensionsElementHelper.getExtensionElements(bo, 'camunda:Connector');\n    if (typeof connectors !== 'undefined') {\n      return 'connector';\n    }\n  }\n\n  if (this.isExternalCapable(bo)) {\n    var type = bo.get('camunda:type');\n    if (type === 'external') {\n      return 'external';\n    }\n  }\n\n  var cls = bo.get('camunda:class');\n  if (typeof cls !== 'undefined') {\n    return 'class';\n  }\n\n  var expression = bo.get('camunda:expression');\n  if (typeof expression !== 'undefined') {\n    return 'expression';\n  }\n\n  var delegateExpression = bo.get('camunda:delegateExpression');\n  if (typeof delegateExpression !== 'undefined') {\n    return 'delegateExpression';\n  }\n\n  if (this.isListener(bo)) {\n    var script = bo.get('script');\n    if (typeof script !== 'undefined') {\n      return 'script';\n    }\n  }\n\n};\n","'use strict';\n\nvar ModelUtil         = require('bpmn-js/lib/util/ModelUtil'),\n    is                = ModelUtil.is,\n    getBusinessObject = ModelUtil.getBusinessObject;\n\nvar extensionElementsHelper = require('./ExtensionElementsHelper'),\n    implementationTypeHelper = require('./ImplementationTypeHelper');\n\nvar InputOutputHelper = {};\n\nmodule.exports = InputOutputHelper;\n\nfunction getElements(bo, type, prop) {\n  var elems = extensionElementsHelper.getExtensionElements(bo, type) || [];\n  return !prop ? elems : (elems[0] || {})[prop] || [];\n}\n\nfunction getParameters(element, prop, insideConnector) {\n  var inputOutput = InputOutputHelper.getInputOutput(element, insideConnector);\n  return (inputOutput && inputOutput.get(prop)) || [];\n}\n\n/**\n * Get a inputOutput from the business object\n *\n * @param {djs.model.Base} element\n * @param  {boolean} insideConnector\n *\n * @return {ModdleElement} the inputOutput object\n */\nInputOutputHelper.getInputOutput = function(element, insideConnector) {\n  if (!insideConnector) {\n    var bo = getBusinessObject(element);\n    return (getElements(bo, 'camunda:InputOutput') || [])[0];\n  }\n  var connector = this.getConnector(element);\n  return connector && connector.get('inputOutput');\n};\n\n/**\n * Get a connector from the business object\n *\n * @param {djs.model.Base} element\n *\n * @return {ModdleElement} the connector object\n */\nInputOutputHelper.getConnector = function(element) {\n  var bo = implementationTypeHelper.getServiceTaskLikeBusinessObject(element);\n  return bo && (getElements(bo, 'camunda:Connector') || [])[0];  \n};\n\n/**\n * Return all input parameters existing in the business object, and\n * an empty array if none exist.\n *\n * @param  {djs.model.Base} element\n * @param  {boolean} insideConnector\n *\n * @return {Array} a list of input parameter objects\n */\nInputOutputHelper.getInputParameters = function(element, insideConnector) {\n  return getParameters.apply(this, [ element, 'inputParameters', insideConnector ]);\n};\n\n/**\n * Return all output parameters existing in the business object, and\n * an empty array if none exist.\n *\n * @param  {djs.model.Base} element\n * @param  {boolean} insideConnector\n *\n * @return {Array} a list of output parameter objects\n */\nInputOutputHelper.getOutputParameters = function(element, insideConnector) {\n  return getParameters.apply(this, [ element, 'outputParameters', insideConnector ]);\n};\n\n/**\n * Get a input parameter from the business object at given index\n *\n * @param {djs.model.Base} element\n * @param  {boolean} insideConnector\n * @param {number} idx\n *\n * @return {ModdleElement} input parameter\n */\nInputOutputHelper.getInputParameter = function(element, insideConnector, idx) {\n  return this.getInputParameters(element, insideConnector)[idx];\n};\n\n/**\n * Get a output parameter from the business object at given index\n *\n * @param {djs.model.Base} element\n * @param  {boolean} insideConnector\n * @param {number} idx\n *\n * @return {ModdleElement} output parameter\n */\nInputOutputHelper.getOutputParameter = function(element, insideConnector, idx) {\n  return this.getOutputParameters(element, insideConnector)[idx];\n};\n\n/**\n * Returns 'true' if the given element supports inputOutput\n *\n * @param {djs.model.Base} element\n * @param  {boolean} insideConnector\n *\n * @return {boolean} a boolean value\n */\nInputOutputHelper.isInputOutputSupported = function(element, insideConnector) {\n  var bo = getBusinessObject(element);\n  return insideConnector ||\n         (is(bo, 'bpmn:FlowNode') &&\n         !is(bo, 'bpmn:StartEvent') &&\n         !is(bo, 'bpmn:BoundaryEvent') &&\n         !(is(bo, 'bpmn:SubProcess') && bo.get('triggeredByEvent')));\n};\n\n/**\n * Returns 'true' if the given element supports output parameters\n *\n * @param {djs.model.Base} element\n * @param  {boolean} insideConnector\n *\n * @return {boolean} a boolean value\n */\nInputOutputHelper.areOutputParametersSupported = function(element, insideConnector) {\n  var bo = getBusinessObject(element);\n  return insideConnector || (!is(bo, 'bpmn:EndEvent') && !bo.loopCharacteristics);\n};\n","'use strict';\n\nvar is = require('bpmn-js/lib/util/ModelUtil').is,\n    getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject,\n    cmdHelper = require('./CmdHelper');\n\n\nvar ParticipantHelper = {};\n\nmodule.exports = ParticipantHelper;\n\nParticipantHelper.modifyProcessBusinessObject = function(element, property, values) {\n  if ( !is(element, 'bpmn:Participant') ) {\n    return {};\n  }\n\n  var bo = getBusinessObject(element).get('processRef'),\n      properties = {};\n\n  properties[property] = values[property];\n\n  return cmdHelper.updateBusinessObject(element, bo, properties);\n};\n\nParticipantHelper.getProcessBusinessObject = function(element, propertyName) {\n  if ( !is(element, 'bpmn:Participant') ) {\n    return {};\n  }\n\n  var bo = getBusinessObject(element).get('processRef'),\n      properties = {};\n\n  properties[propertyName] = bo.get(propertyName);\n\n  return properties;\n};","module.exports = {\n  __depends__: [\n    require('./cmd'),\n    require('diagram-js/lib/i18n/translate')\n  ],\n  __init__: [ 'propertiesPanel' ],\n  propertiesPanel: [ 'type', require('./PropertiesPanel') ]\n};\n","'use strict';\n\nvar entryFactory = require('../../../factory/EntryFactory'),\n    cmdHelper = require('../../../helper/CmdHelper');\n\nvar ModelUtil = require('bpmn-js/lib/util/ModelUtil'),\n    is = ModelUtil.is,\n    getBusinessObject = ModelUtil.getBusinessObject;\n\n\nmodule.exports = function(group, element, bpmnFactory, translate) {\n\n  var getValue = function(businessObject) {\n    return function(element) {\n      var documentations = businessObject && businessObject.get('documentation'),\n          text = (documentations && documentations.length > 0) ? documentations[0].text : '';\n\n      return { documentation: text };\n    };\n  };\n\n  var setValue = function(businessObject) {\n    return function(element, values) {\n      var newObjectList = [];\n\n      if (typeof values.documentation !== 'undefined' && values.documentation !== '') {\n        newObjectList.push(bpmnFactory.create('bpmn:Documentation', {\n          text: values.documentation\n        }));\n      }\n\n      return cmdHelper.setList(element, businessObject, 'documentation', newObjectList);\n    };\n  };\n\n  // Element Documentation\n  var elementDocuEntry = entryFactory.textBox({\n    id: 'documentation',\n    label: translate('Element Documentation'),\n    modelProperty: 'documentation'\n  });\n\n  elementDocuEntry.set = setValue(getBusinessObject(element));\n\n  elementDocuEntry.get = getValue(getBusinessObject(element));\n\n  group.entries.push(elementDocuEntry);\n\n\n  var processRef;\n\n  // Process Documentation when having a Collaboration Diagram\n  if (is(element, 'bpmn:Participant')) {\n\n    processRef = getBusinessObject(element).processRef;\n\n    // do not show for collapsed Pools/Participants\n    if (processRef) {\n      var processDocuEntry = entryFactory.textBox({\n        id: 'process-documentation',\n        label: translate('Process Documentation'),\n        modelProperty: 'documentation'\n      });\n\n      processDocuEntry.set = setValue(processRef);\n\n      processDocuEntry.get = getValue(processRef);\n\n      group.entries.push(processDocuEntry);\n    }\n  }\n\n};\n","'use strict';\n\nvar is = require('bpmn-js/lib/util/ModelUtil').is,\n    isAny = require('bpmn-js/lib/features/modeling/util/ModelingUtil').isAny,\n    isEventSubProcess = require('bpmn-js/lib/util/DiUtil').isEventSubProcess,\n    getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject,\n    eventDefinitionHelper = require('../../../helper/EventDefinitionHelper');\n\nvar forEach = require('lodash/collection/forEach');\n\nvar message = require('./implementation/MessageEventDefinition'),\n    signal = require('./implementation/SignalEventDefinition'),\n    error = require('./implementation/ErrorEventDefinition'),\n    escalation = require('./implementation/EscalationEventDefinition'),\n    timer = require('./implementation/TimerEventDefinition'),\n    compensation = require('./implementation/CompensateEventDefinition'),\n    condition = require('./implementation/ConditionalEventDefinition');\n\n\nmodule.exports = function(group, element, bpmnFactory, elementRegistry, translate) {\n  var events = [\n    'bpmn:StartEvent',\n    'bpmn:EndEvent',\n    'bpmn:IntermediateThrowEvent',\n    'bpmn:BoundaryEvent',\n    'bpmn:IntermediateCatchEvent'\n  ];\n\n  // Message and Signal Event Definition\n  forEach(events, function(event) {\n    if (is(element, event)) {\n\n      var messageEventDefinition = eventDefinitionHelper.getMessageEventDefinition(element),\n          signalEventDefinition = eventDefinitionHelper.getSignalEventDefinition(element);\n\n      if (messageEventDefinition) {\n        message(group, element, bpmnFactory, messageEventDefinition);\n      }\n\n      if (signalEventDefinition) {\n        signal(group, element, bpmnFactory, signalEventDefinition);\n      }\n\n    }\n  });\n\n  // Special Case: Receive Task\n  if (is(element, 'bpmn:ReceiveTask')) {\n    message(group, element, bpmnFactory, getBusinessObject(element));\n  }\n\n  // Error Event Definition\n  var errorEvents = [\n    'bpmn:StartEvent',\n    'bpmn:BoundaryEvent',\n    'bpmn:EndEvent'\n  ];\n\n  forEach(errorEvents, function(event) {\n    if (is(element, event)) {\n\n      var errorEventDefinition = eventDefinitionHelper.getErrorEventDefinition(element);\n\n      if (errorEventDefinition) {\n        var isCatchingErrorEvent = is(element, 'bpmn:StartEvent') || is (element, 'bpmn:BoundaryEvent');\n\n        var showErrorCodeVariable = isCatchingErrorEvent,\n            showErrorMessageVariable = isCatchingErrorEvent;\n\n        error(group, element, bpmnFactory, errorEventDefinition, showErrorCodeVariable, showErrorMessageVariable);\n      }\n    }\n  });\n\n  // Escalation Event Definition\n  var escalationEvents = [\n    'bpmn:StartEvent',\n    'bpmn:BoundaryEvent',\n    'bpmn:IntermediateThrowEvent',\n    'bpmn:EndEvent'\n  ];\n\n  forEach(escalationEvents, function(event) {\n    if (is(element, event)) {\n\n      var showEscalationCodeVariable = is(element, 'bpmn:StartEvent') || is(element, 'bpmn:BoundaryEvent');\n\n      // get business object\n      var escalationEventDefinition = eventDefinitionHelper.getEscalationEventDefinition(element);\n\n      if (escalationEventDefinition) {\n        escalation(group, element, bpmnFactory, escalationEventDefinition, showEscalationCodeVariable);\n      }\n    }\n\n  });\n\n  // Timer Event Definition\n  var timerEvents = [\n    'bpmn:StartEvent',\n    'bpmn:BoundaryEvent',\n    'bpmn:IntermediateCatchEvent'\n  ];\n\n  forEach(timerEvents, function(event) {\n    if (is(element, event)) {\n\n      // get business object\n      var timerEventDefinition = eventDefinitionHelper.getTimerEventDefinition(element);\n\n      if (timerEventDefinition) {\n        timer(group, element, bpmnFactory, timerEventDefinition);\n      }\n    }\n  });\n\n  // Compensate Event Definition\n  var compensationEvents = [\n    'bpmn:EndEvent',\n    'bpmn:IntermediateThrowEvent'\n  ];\n\n  forEach(compensationEvents, function(event) {\n    if (is(element, event)) {\n\n      // get business object\n      var compensateEventDefinition = eventDefinitionHelper.getCompensateEventDefinition(element);\n\n      if (compensateEventDefinition) {\n        compensation(group, element, bpmnFactory, compensateEventDefinition, elementRegistry);\n      }\n    }\n  });\n\n\n  // Conditional Event Defintion\n  var conditionalEvents = [\n    'bpmn:BoundaryEvent',\n    'bpmn:IntermediateThrowEvent',\n    'bpmn:IntermediateCatchEvent'\n  ];\n\n  if (isAny(element, conditionalEvents) ||\n      (is(element, 'bpmn:StartEvent') && isEventSubProcess(element.parent))) {\n\n    // get business object\n    var conditionalEventDefinition = eventDefinitionHelper.getConditionalEventDefinition(element);\n\n    if (conditionalEventDefinition) {\n      condition(group, element, bpmnFactory, conditionalEventDefinition, elementRegistry);\n    }\n  }\n\n};\n","'use strict';\n\nvar is = require('bpmn-js/lib/util/ModelUtil').is,\n    getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject;\n\nvar entryFactory = require('../../../factory/EntryFactory');\n\nvar participantHelper = require('../../../helper/ParticipantHelper');\n\nmodule.exports = function(group, element, translate) {\n\n  var bo = getBusinessObject(element);\n\n  if (!bo) {\n    return;\n  }\n\n  if (is(element, 'bpmn:Process') || (is(element, 'bpmn:Participant') && bo.get('processRef'))) {\n\n    var executableEntry = entryFactory.checkbox({\n      id: 'process-is-executable',\n      label: translate('Executable'),\n      modelProperty: 'isExecutable'\n    });\n\n    // in participants we have to change the default behavior of set and get\n    if (is(element, 'bpmn:Participant')) {\n      executableEntry.get = function(element) {\n        return participantHelper.getProcessBusinessObject(element, 'isExecutable');\n      };\n\n      executableEntry.set = function(element, values) {\n        return participantHelper.modifyProcessBusinessObject(element, 'isExecutable', values);\n      };\n    }\n\n    group.entries.push(executableEntry);\n  }\n\n};\n","'use strict';\n\nvar entryFactory = require('../../../factory/EntryFactory'),\n    getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject,\n    utils = require('../../../Utils'),\n    cmdHelper = require('../../../helper/CmdHelper');\n\nmodule.exports = function(group, element, translate) {\n\n  // Id\n  group.entries.push(entryFactory.validationAwareTextField({\n    id: 'id',\n    label: translate('Id'),\n    modelProperty: 'id',\n    getProperty: function(element) {\n      return getBusinessObject(element).id;\n    },\n    setProperty: function(element, properties) {\n\n      element = element.labelTarget || element;\n\n      return cmdHelper.updateProperties(element, properties);\n    },\n    validate: function(element, values) {\n      var idValue = values.id;\n\n      var bo = getBusinessObject(element);\n\n      var idError = utils.isIdValid(bo, idValue);\n\n      return idError ? { id: idError } : {};\n    }\n  }));\n\n};\n","'use strict';\n\nvar is = require('bpmn-js/lib/util/ModelUtil').is,\n    getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject,\n    entryFactory = require('../../../factory/EntryFactory'),\n    cmdHelper = require('../../../helper/CmdHelper');\n\nvar forEach = require('lodash/collection/forEach');\n\nfunction getLinkEventDefinition(element) {\n\n  var bo = getBusinessObject(element);\n\n  var linkEventDefinition = null;\n  if (bo.eventDefinitions) {\n    forEach(bo.eventDefinitions, function(eventDefinition) {\n      if (is(eventDefinition, 'bpmn:LinkEventDefinition')) {\n        linkEventDefinition = eventDefinition;\n      }\n    });\n  }\n\n  return linkEventDefinition;\n}\n\nmodule.exports = function(group, element, translate) {\n  var linkEvents = [ 'bpmn:IntermediateThrowEvent', 'bpmn:IntermediateCatchEvent' ];\n\n  forEach(linkEvents, function(event) {\n    if (is(element, event)) {\n\n      var linkEventDefinition = getLinkEventDefinition(element);\n\n      if (linkEventDefinition) {\n        var entry = entryFactory.textField({\n          id: 'link-event',\n          label: translate('Link Name'),\n          modelProperty: 'link-name'\n        });\n\n        entry.get = function() {\n          return { 'link-name': linkEventDefinition.get('name') };\n        };\n\n        entry.set = function(element, values) {\n          var newProperties = {\n            name: values['link-name']\n          };\n          return cmdHelper.updateBusinessObject(element, linkEventDefinition, newProperties);\n        };\n\n        group.entries.push(entry);\n      }\n    }\n  });\n};\n\n","'use strict';\n\nvar nameEntryFactory = require('./implementation/Name'),\n    is = require('bpmn-js/lib/util/ModelUtil').is;\n\nmodule.exports = function(group, element, translate) {\n\n  if (!is(element, 'bpmn:Collaboration')) {\n\n    var options;\n    if (is(element, 'bpmn:TextAnnotation')) {\n      options = { modelProperty: 'text' };\n    }\n\n    // name\n    group.entries = group.entries.concat(nameEntryFactory(element, options, translate));\n\n  }\n\n};\n","'use strict';\n\nvar is = require('bpmn-js/lib/util/ModelUtil').is,\n    entryFactory = require('../../../factory/EntryFactory'),\n    participantHelper = require('../../../helper/ParticipantHelper'),\n    getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject,\n    nameEntryFactory = require('./implementation/Name'),\n    utils = require('../../../Utils');\n\nmodule.exports = function(group, element, translate) {\n  var businessObject = getBusinessObject(element);\n\n  if (is(element, 'bpmn:Process') || (is(element, 'bpmn:Participant') && businessObject.get('processRef'))) {\n\n    /**\n     * processId\n     */\n    if (is(element, 'bpmn:Participant')) {\n      var idEntry = entryFactory.validationAwareTextField({\n        id: 'process-id',\n        label: translate('Process Id'),\n        modelProperty: 'processId'\n      });\n\n      // in participants we have to change the default behavior of set and get\n      idEntry.get = function(element) {\n        var properties = participantHelper.getProcessBusinessObject(element, 'id');\n        return { processId: properties.id };\n      };\n\n      idEntry.set = function(element, values) {\n        return participantHelper.modifyProcessBusinessObject(element, 'id', { id: values.processId });\n      };\n\n      idEntry.validate = function(element, values) {\n        var idValue = values.processId;\n\n        var bo = getBusinessObject(element);\n\n        var processIdError = utils.isIdValid(bo.processRef, idValue);\n\n        return processIdError ? { processId: processIdError } : {};\n      };\n\n      group.entries.push(idEntry);\n\n\n      /**\n       * process name\n       */\n      var processNameEntry = nameEntryFactory(element, {\n        id: 'process-name',\n        label: translate('Process Name')\n      })[0];\n\n      // in participants we have to change the default behavior of set and get\n      processNameEntry.get = function(element) {\n        return participantHelper.getProcessBusinessObject(element, 'name');\n      };\n\n      processNameEntry.set = function(element, values) {\n        return participantHelper.modifyProcessBusinessObject(element, 'name', values);\n      };\n\n      group.entries.push(processNameEntry);\n    }\n  }\n};\n","'use strict';\n\nvar entryFactory = require('../../../../factory/EntryFactory');\n\nvar cmdHelper = require('../../../../helper/CmdHelper'),\n    eventDefinitionHelper = require('../../../../helper/EventDefinitionHelper'),\n    utils = require('../../../../Utils');\n\nvar getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject,\n    is = require('bpmn-js/lib/util/ModelUtil').is;\n\nvar forEach = require('lodash/collection/forEach'),\n    find = require('lodash/collection/find'),\n    filter = require('lodash/collection/filter');\n\n\nfunction getContainedActivities(element) {\n  return getFlowElements(element, 'bpmn:Activity');\n}\n\nfunction getContainedBoundaryEvents(element) {\n  return getFlowElements(element, 'bpmn:BoundaryEvent');\n}\n\nfunction getFlowElements(element, type) {\n  return utils.filterElementsByType(element.flowElements, type);\n}\n\nfunction isCompensationEventAttachedToActivity(activity, boundaryEvents) {\n  var activityId = activity.id;\n  var boundaryEvent = find(boundaryEvents, function(boundaryEvent) {\n    var compensateEventDefinition = eventDefinitionHelper.getCompensateEventDefinition(boundaryEvent);\n    var attachedToRef = boundaryEvent.attachedToRef;\n    return compensateEventDefinition && attachedToRef && attachedToRef.id === activityId;\n  });\n  return !!boundaryEvent;\n}\n\n// subprocess: only when it is not triggeredByEvent\n// activity: only when it attach a compensation boundary event\n// callActivity: no limitation\nfunction canActivityBeCompensated(activity, boundaryEvents) {\n  return (is(activity, 'bpmn:SubProcess') && !activity.triggeredByEvent) ||\n          is(activity, 'bpmn:CallActivity') ||\n          isCompensationEventAttachedToActivity(activity, boundaryEvents);\n}\n\nfunction getActivitiesForCompensation(element) {\n  var boundaryEvents = getContainedBoundaryEvents(element);\n  return filter(getContainedActivities(element), function(activity) {\n    return canActivityBeCompensated(activity, boundaryEvents);\n  });\n}\n\nfunction getActivitiesForActivityRef(element) {\n  var bo = getBusinessObject(element);\n  var parent = bo.$parent;\n\n  var activitiesForActivityRef = getActivitiesForCompensation(parent);\n\n  // if throwing compensation event is in an event sub process:\n  // get also all activities outside of the event sub process\n  if (is(parent, 'bpmn:SubProcess') && parent.triggeredByEvent) {\n    parent = parent.$parent;\n    if (parent) {\n      activitiesForActivityRef = activitiesForActivityRef.concat(getActivitiesForCompensation(parent));\n    }\n\n  }\n\n  return activitiesForActivityRef;\n}\n\nfunction createActivityRefOptions(element) {\n  var options = [ { value: '' } ];\n\n  var activities = getActivitiesForActivityRef(element);\n  forEach(activities, function(activity) {\n    var activityId = activity.id;\n    var name = (activity.name ? (activity.name + ' ') : '') + '(id=' + activityId + ')';\n    options.push({ value: activityId, name: name });\n  });\n\n  return options;\n}\n\n\nmodule.exports = function(group, element, bpmnFactory, compensateEventDefinition, elementRegistry) {\n\n  group.entries.push(entryFactory.checkbox({\n    id: 'wait-for-completion',\n    label: 'Wait for Completion',\n    modelProperty: 'waitForCompletion',\n\n    get: function(element, node) {\n      return {\n        waitForCompletion: compensateEventDefinition.waitForCompletion\n      };\n    },\n\n    set: function(element, values) {\n      values.waitForCompletion = values.waitForCompletion || false;\n      return cmdHelper.updateBusinessObject(element, compensateEventDefinition, values);\n    }\n  }));\n\n  group.entries.push(entryFactory.selectBox({\n    id: 'activity-ref',\n    label: 'Activity Ref',\n    selectOptions: createActivityRefOptions(element),\n    modelProperty: 'activityRef',\n\n    get: function(element, node) {\n      var activityRef = compensateEventDefinition.activityRef;\n      activityRef = activityRef && activityRef.id;\n      return {\n        activityRef: activityRef || ''\n      };\n    },\n\n    set: function(element, values) {\n      var activityRef = values.activityRef || undefined;\n      activityRef = activityRef && getBusinessObject(elementRegistry.get(activityRef));\n      return cmdHelper.updateBusinessObject(element, compensateEventDefinition, {\n        activityRef: activityRef\n      });\n    }\n  }));\n\n};\n","'use strict';\n\nvar entryFactory = require('../../../../factory/EntryFactory'),\n    elementHelper = require('../../../../helper/ElementHelper'),\n    cmdHelper = require('../../../../helper/CmdHelper');\n\nfunction createFormalExpression(parent, body, bpmnFactory) {\n  body = body || undefined;\n  return elementHelper.createElement('bpmn:FormalExpression', { body: body }, parent, bpmnFactory);\n}\n\nmodule.exports = function(group, element, bpmnFactory, conditionalEventDefinition) {\n\n  var getValue = function(modelProperty) {\n    return function(element) {\n      var modelPropertyValue = conditionalEventDefinition.get('camunda:' + modelProperty);\n      var value = {};\n\n      value[modelProperty] = modelPropertyValue;\n      return value;\n    };\n  };\n\n  var setValue = function(modelProperty) {\n    return function(element, values) {\n      var props = {};\n\n      props['camunda:' + modelProperty] = values[modelProperty] || undefined;\n\n      return cmdHelper.updateBusinessObject(element, conditionalEventDefinition, props);\n    };\n  };\n\n  group.entries.push(entryFactory.textField({\n    id: 'condition',\n    label: 'Condition',\n    modelProperty: 'condition',\n    get: function(element) {\n      var condition = conditionalEventDefinition.get('condition'),\n          body = condition && condition.get('body');\n\n      return { condition: body || '' };\n    },\n    set: function(element, values) {\n      var condition = conditionalEventDefinition.get('condition');\n\n      // remove condition expression from the business object when text field is empty\n      if (values.condition === '') {\n        return cmdHelper.updateBusinessObject(element, conditionalEventDefinition, { condition: undefined });\n      }\n\n      // if no condition expression is set yet, create one\n      if (!condition) {\n        condition = createFormalExpression(conditionalEventDefinition, values.condition, bpmnFactory);\n\n        return cmdHelper.updateBusinessObject(element, conditionalEventDefinition, { condition: condition });\n\n      // if a condition expression and a text field value exists, update business object\n      } else {\n        return cmdHelper.updateBusinessObject(element, condition, {\n          body: values.condition || undefined\n        });\n      }\n    },\n    validate: function(element, values) {\n      if (values['condition'] === '') {\n        return { condition: 'Must provide a value' };\n      }\n    }\n  }));\n\n  group.entries.push(entryFactory.textField({\n    id : 'variableName',\n    label : 'Variable Name',\n    modelProperty : 'variableName',\n\n    get: getValue('variableName'),\n    set: setValue('variableName')\n  }));\n\n  group.entries.push(entryFactory.textField({\n    id : 'variableEvent',\n    label : 'Variable Event',\n    description: 'Specify more than one variable change event as a comma separated list.',\n    modelProperty : 'variableEvent',\n\n    get: getValue('variableEvent'),\n    set: setValue('variableEvent')\n  }));\n\n};\n","'use strict';\n\nvar entryFactory = require('../../../../factory/EntryFactory');\n\nvar cmdHelper = require('../../../../helper/CmdHelper');\n\n/**\n * Create an entry to modify a property of an element which\n * is referenced by a event definition.\n *\n * @param  {djs.model.Base} element\n * @param  {ModdleElement} definition\n * @param  {BpmnFactory} bpmnFactory\n * @param  {Object} options\n * @param  {string} options.id the id of the entry\n * @param  {string} options.label the label of the entry\n * @param  {string} options.referenceProperty the name of referencing property\n * @param  {string} options.modelProperty the name of property to modify\n * @param  {string} options.shouldValidate a flag indicate whether to validate or not\n *\n * @return {Array<Object>} return an array containing the entries\n */\nmodule.exports = function(element, definition, bpmnFactory, options) {\n\n  var id = options.id || 'element-property';\n  var label = options.label;\n  var referenceProperty = options.referenceProperty;\n  var modelProperty = options.modelProperty || 'name';\n  var shouldValidate = options.shouldValidate || false;\n\n  var entry = entryFactory.textField({\n    id: id,\n    label: label,\n    modelProperty: modelProperty,\n\n    get: function(element, node) {\n      var reference = definition.get(referenceProperty);\n      var props = {};\n      props[modelProperty] = reference && reference.get(modelProperty);\n      return props;\n    },\n\n    set: function(element, values, node) {\n      var reference = definition.get(referenceProperty);\n      var props = {};\n      props[modelProperty] = values[modelProperty] || undefined;\n      return cmdHelper.updateBusinessObject(element, reference, props);\n    },\n\n    hidden: function(element, node) {\n      return !definition.get(referenceProperty);\n    }\n  });\n\n  if (shouldValidate) {\n    entry.validate = function(element, values, node) {\n      var reference = definition.get(referenceProperty);\n      if (reference && !values[modelProperty]) {\n        var validationErrors = {};\n        validationErrors[modelProperty] = 'Must provide a value';\n        return validationErrors;\n      }\n    };\n  }\n\n  return [ entry ];\n};\n","'use strict';\n\nvar entryFactory = require('../../../../factory/EntryFactory'),\n    cmdHelper = require('../../../../helper/CmdHelper');\n\nvar eventDefinitionReference = require('./EventDefinitionReference'),\n    elementReferenceProperty = require('./ElementReferenceProperty');\n\n\nmodule.exports = function(group, element, bpmnFactory, errorEventDefinition, showErrorCodeVariable,\n  showErrorMessageVariable) {\n\n\n  var getValue = function(modelProperty) {\n    return function(element) {\n      var modelPropertyValue = errorEventDefinition.get('camunda:' + modelProperty);\n      var value = {};\n\n      value[modelProperty] = modelPropertyValue;\n      return value;\n    };\n  };\n\n  var setValue = function(modelProperty) {\n    return function(element, values) {\n      var props = {};\n\n      props['camunda:' + modelProperty] = values[modelProperty] || undefined;\n\n      return cmdHelper.updateBusinessObject(element, errorEventDefinition, props);\n    };\n  };\n\n\n  group.entries = group.entries.concat(eventDefinitionReference(element, errorEventDefinition, bpmnFactory, {\n    label: 'Error',\n    elementName: 'error',\n    elementType: 'bpmn:Error',\n    referenceProperty: 'errorRef',\n    newElementIdPrefix: 'Error_'\n  }));\n\n\n  group.entries = group.entries.concat(elementReferenceProperty(element, errorEventDefinition, bpmnFactory, {\n    id: 'error-element-name',\n    label: 'Error Name',\n    referenceProperty: 'errorRef',\n    modelProperty: 'name',\n    shouldValidate: true\n  }));\n\n\n  group.entries = group.entries.concat(elementReferenceProperty(element, errorEventDefinition, bpmnFactory, {\n    id: 'error-element-code',\n    label: 'Error Code',\n    referenceProperty: 'errorRef',\n    modelProperty: 'errorCode'\n  }));\n\n\n  if (showErrorCodeVariable) {\n    group.entries.push(entryFactory.textField({\n      id : 'errorCodeVariable',\n      label : 'Error Code Variable',\n      modelProperty : 'errorCodeVariable',\n\n      get: getValue('errorCodeVariable'),\n      set: setValue('errorCodeVariable')\n    }));\n  }\n\n  if (showErrorMessageVariable) {\n    group.entries.push(entryFactory.textField({\n      id : 'errorMessageVariable',\n      label : 'Error Message Variable',\n      modelProperty : 'errorMessageVariable',\n\n      get: getValue('errorMessageVariable'),\n      set: setValue('errorMessageVariable')\n    }));\n  }\n\n};\n","'use strict';\n\nvar entryFactory = require('../../../../factory/EntryFactory'),\n    cmdHelper = require('../../../../helper/CmdHelper');\n\nvar eventDefinitionReference = require('./EventDefinitionReference'),\n    elementReferenceProperty = require('./ElementReferenceProperty');\n\n\nmodule.exports = function(group, element, bpmnFactory, escalationEventDefinition, showEscalationCodeVariable) {\n\n  group.entries = group.entries.concat(eventDefinitionReference(element, escalationEventDefinition, bpmnFactory, {\n    label: 'Escalation',\n    elementName: 'escalation',\n    elementType: 'bpmn:Escalation',\n    referenceProperty: 'escalationRef',\n    newElementIdPrefix: 'Escalation_'\n  }));\n\n\n  group.entries = group.entries.concat(elementReferenceProperty(element, escalationEventDefinition, bpmnFactory, {\n    id: 'escalation-element-name',\n    label: 'Escalation Name',\n    referenceProperty: 'escalationRef',\n    modelProperty: 'name',\n    shouldValidate: true\n  }));\n\n\n  group.entries = group.entries.concat(elementReferenceProperty(element, escalationEventDefinition, bpmnFactory, {\n    id: 'escalation-element-code',\n    label: 'Escalation Code',\n    referenceProperty: 'escalationRef',\n    modelProperty: 'escalationCode'\n  }));\n\n\n  if (showEscalationCodeVariable) {\n    group.entries.push(entryFactory.textField({\n      id : 'escalationCodeVariable',\n      label : 'Escalation Code Variable',\n      modelProperty : 'escalationCodeVariable',\n\n      get: function(element) {\n        var codeVariable = escalationEventDefinition.get('camunda:escalationCodeVariable');\n        return {\n          escalationCodeVariable: codeVariable\n        };\n      },\n\n      set: function(element, values) {\n        return cmdHelper.updateBusinessObject(element, escalationEventDefinition, {\n          'camunda:escalationCodeVariable': values.escalationCodeVariable || undefined\n        });\n      }\n    }));\n  }\n};\n","'use strict';\n\nvar cmdHelper = require('../../../../helper/CmdHelper');\n\nvar domQuery = require('min-dom/lib/query'),\n    domify = require('min-dom/lib/domify'),\n    domAttr = require('min-dom/lib/attr');\n\nvar forEach = require('lodash/collection/forEach'),\n    find = require('lodash/collection/find');\n\nvar elementHelper = require('../../../../helper/ElementHelper');\nvar utils = require('../../../../Utils');\n\nvar selector = 'select[name=selectedElement]';\n\n/**\n * Get select box containing all elements.\n *\n * @param {DOMElement} node\n *\n * @return {DOMElement} the select box\n */\nfunction getSelectBox(node) {\n  return domQuery(selector, node.parentElement);\n}\n\n/**\n * Find element by given id.\n *\n * @param {ModdleElement} eventDefinition\n *\n * @return {ModdleElement} an element\n */\nfunction findElementById(eventDefinition, type, id) {\n  var elements = utils.findRootElementsByType(eventDefinition, type);\n  return find(elements, function(element) {\n    return element.id === id;\n  });\n}\n\n/**\n * Create an entry to modify the reference to an element from an\n * event definition.\n *\n * @param  {djs.model.Base} element\n * @param  {ModdleElement} definition\n * @param  {BpmnFactory} bpmnFactory\n * @param  {Object} options\n * @param  {string} options.label the label of the entry\n * @param  {string} options.description the description of the entry\n * @param  {string} options.elementName the name of the element\n * @param  {string} options.elementType the type of the element\n * @param  {string} options.referenceProperty the name of referencing property\n * @param  {string} options.newElementIdPrefix the prefix of a new created element\n *\n * @return {Array<Object>} return an array containing the entries\n */\nmodule.exports = function(element, definition, bpmnFactory, options) {\n\n  var elementName       = options.elementName || '',\n      elementType       = options.elementType,\n      referenceProperty = options.referenceProperty;\n\n  var newElementIdPrefix = options.newElementIdPrefix || 'elem_';\n\n  var label       = options.label || '',\n      description = options.description || '';\n\n  var entries = [];\n\n  entries.push({\n\n    id: 'event-definitions-' + elementName,\n    description: description,\n    html: '<div class=\"bpp-row bpp-select\">' +\n             '<label for=\"camunda-' + elementName + '\">' + label + '</label>' +\n             '<div class=\"bpp-field-wrapper\">' +\n               '<select id=\"camunda-' + elementName + '\" name=\"selectedElement\" data-value>' +\n               '</select>' +\n               '<button class=\"add\" id=\"addElement\" data-action=\"addElement\"><span>+</span></button>' +\n             '</div>' +\n          '</div>',\n\n    get: function(element, entryNode) {\n      utils.updateOptionsDropDown(selector, definition, elementType, entryNode);\n      var reference = definition.get(referenceProperty);\n      return {\n        selectedElement: (reference && reference.id) || ''\n      };\n    },\n\n    set: function(element, values) {\n      var selection = values.selectedElement;\n\n      var props = {};\n\n      if (!selection || typeof selection === 'undefined') {\n        // remove reference to element\n        props[referenceProperty] = undefined;\n        return cmdHelper.updateBusinessObject(element, definition, props);\n      }\n\n      var commands = [];\n\n      var selectedElement = findElementById(definition, elementType, selection);\n      if (!selectedElement) {\n        var root = utils.getRoot(definition);\n\n        // create a new element\n        selectedElement = elementHelper.createElement(elementType, { name: selection }, root, bpmnFactory);\n        commands.push(cmdHelper.addAndRemoveElementsFromList(element, root, 'rootElements', null, [ selectedElement ]));\n      }\n\n      // update reference to element\n      props[referenceProperty] = selectedElement;\n      commands.push(cmdHelper.updateBusinessObject(element, definition, props));\n\n      return commands;\n    },\n\n    addElement: function(element, inputNode) {\n      // note: this generated id will be used as name\n      // of the element and not as id\n      var id = utils.nextId(newElementIdPrefix);\n\n      var optionTemplate = domify('<option value=\"' + id + '\"> (id='+id+')' + '</option>');\n\n      // add new option\n      var selectBox = getSelectBox(inputNode);\n      selectBox.insertBefore(optionTemplate, selectBox.firstChild);\n\n      // select new element in the select box\n      forEach(selectBox, function(option) {\n        if (option.value === id) {\n          domAttr(option, 'selected', 'selected');\n        } else {\n          domAttr(option, 'selected', null);\n        }\n      });\n\n      return true;\n    }\n\n  });\n\n  return entries;\n\n};\n","'use strict';\n\nvar eventDefinitionReference = require('./EventDefinitionReference'),\n    elementReferenceProperty = require('./ElementReferenceProperty');\n\n\nmodule.exports = function(group, element, bpmnFactory, messageEventDefinition) {\n\n  group.entries = group.entries.concat(eventDefinitionReference(element, messageEventDefinition, bpmnFactory, {\n    label: 'Message',\n    elementName: 'message',\n    elementType: 'bpmn:Message',\n    referenceProperty: 'messageRef',\n    newElementIdPrefix: 'Message_'\n  }));\n\n\n  group.entries = group.entries.concat(elementReferenceProperty(element, messageEventDefinition, bpmnFactory, {\n    id: 'message-element-name',\n    label: 'Message Name',\n    referenceProperty: 'messageRef',\n    modelProperty: 'name',\n    shouldValidate: true\n  }));\n\n};\n","'use strict';\n\nvar entryFactory = require('../../../../factory/EntryFactory');\n\n/**\n * Create an entry to modify the name of an an element.\n *\n * @param  {djs.model.Base} element\n * @param  {Object} options\n * @param  {string} options.id the id of the entry\n * @param  {string} options.label the label of the entry\n *\n * @return {Array<Object>} return an array containing\n *                         the entry to modify the name\n */\nmodule.exports = function(element, options, translate) {\n\n  options = options || {};\n  var id = options.id || 'name',\n      label = options.label || translate('Name'),\n      modelProperty = options.modelProperty || 'name';\n\n  var nameEntry = entryFactory.textBox({\n    id: id,\n    label: label,\n    modelProperty: modelProperty\n  });\n\n  return [ nameEntry ];\n\n};\n","'use strict';\n\nvar eventDefinitionReference = require('./EventDefinitionReference'),\n    elementReferenceProperty = require('./ElementReferenceProperty');\n\n\nmodule.exports = function(group, element, bpmnFactory, signalEventDefinition) {\n\n  group.entries = group.entries.concat(eventDefinitionReference(element, signalEventDefinition, bpmnFactory, {\n    label: 'Signal',\n    elementName: 'signal',\n    elementType: 'bpmn:Signal',\n    referenceProperty: 'signalRef',\n    newElementIdPrefix: 'Signal_'\n  }));\n\n\n  group.entries = group.entries.concat(elementReferenceProperty(element, signalEventDefinition, bpmnFactory, {\n    id: 'signal-element-name',\n    label: 'Signal Name',\n    referenceProperty: 'signalRef',\n    modelProperty: 'name',\n    shouldValidate: true\n  }));\n\n};\n","'use strict';\n\nvar elementHelper = require('../../../../helper/ElementHelper'),\n    cmdHelper = require('../../../../helper/CmdHelper');\n\nvar entryFactory = require('../../../../factory/EntryFactory');\n\n/**\n * Get the timer definition type for a given timer event definition.\n *\n * @param {ModdleElement<bpmn:TimerEventDefinition>} timer\n *\n * @return {string|undefined} the timer definition type\n */\nfunction getTimerDefinitionType(timer) {\n  var timeDate = timer.get('timeDate');\n  if (typeof timeDate !== 'undefined') {\n    return 'timeDate';\n  }\n\n  var timeCycle = timer.get('timeCycle');\n  if (typeof timeCycle !== 'undefined') {\n    return 'timeCycle';\n  }\n\n  var timeDuration = timer.get('timeDuration');\n  if (typeof timeDuration !== 'undefined') {\n    return 'timeDuration';\n  }\n}\n\n/**\n * Creates 'bpmn:FormalExpression' element.\n *\n * @param {ModdleElement} parent\n * @param {string} body\n * @param {BpmnFactory} bpmnFactory\n *\n * @return {ModdleElement<bpmn:FormalExpression>} a formal expression\n */\nfunction createFormalExpression(parent, body, bpmnFactory) {\n  body = body || undefined;\n  return elementHelper.createElement('bpmn:FormalExpression', { body: body }, parent, bpmnFactory);\n}\n\nfunction TimerEventDefinition(group, element, bpmnFactory, timerEventDefinition) {\n\n  var selectOptions = [\n    { value: 'timeDate', name: 'Date' },\n    { value: 'timeDuration', name: 'Duration' },\n    { value: 'timeCycle', name: 'Cycle' }\n  ];\n\n  group.entries.push(entryFactory.selectBox({\n    id: 'timer-event-definition-type',\n    label: 'Timer Definition Type',\n    selectOptions: selectOptions,\n    emptyParameter: true,\n    modelProperty: 'timerDefinitionType',\n\n    get: function(element, node) {\n      return {\n        timerDefinitionType: getTimerDefinitionType(timerEventDefinition) || ''\n      };\n    },\n\n    set: function(element, values) {\n      var props = {\n        timeDuration: undefined,\n        timeDate: undefined,\n        timeCycle: undefined\n      };\n\n      var newType = values.timerDefinitionType;\n      if (values.timerDefinitionType) {\n        var oldType = getTimerDefinitionType(timerEventDefinition);\n\n        var value;\n        if (oldType) {\n          var definition = timerEventDefinition.get(oldType);\n          value = definition.get('body');\n        }\n\n        props[newType] = createFormalExpression(timerEventDefinition, value, bpmnFactory);\n      }\n\n      return cmdHelper.updateBusinessObject(element, timerEventDefinition, props);\n    }\n\n  }));\n\n\n  group.entries.push(entryFactory.textField({\n    id: 'timer-event-definition',\n    label: 'Timer Definition',\n    modelProperty: 'timerDefinition',\n\n    get: function(element, node) {\n      var type = getTimerDefinitionType(timerEventDefinition);\n      var definition = type && timerEventDefinition.get(type);\n      var value = definition && definition.get('body');\n      return {\n        timerDefinition: value\n      };\n    },\n\n    set: function(element, values) {\n      var type = getTimerDefinitionType(timerEventDefinition);\n      var definition = type && timerEventDefinition.get(type);\n\n      if (definition) {\n        return cmdHelper.updateBusinessObject(element, definition, {\n          body: values.timerDefinition || undefined\n        });\n      }\n    },\n\n    validate: function(element) {\n      var type = getTimerDefinitionType(timerEventDefinition);\n      var definition = type && timerEventDefinition.get(type);\n      if (definition) {\n        var value = definition.get('body');\n        if (!value) {\n          return {\n            timerDefinition: 'Must provide a value'\n          };\n        }\n      }\n    },\n\n    hidden: function(element) {\n      return !getTimerDefinitionType(timerEventDefinition);\n    }\n\n  }));\n\n}\n\nmodule.exports = TimerEventDefinition;\n","'use strict';\n\nvar inherits = require('inherits');\n\nvar PropertiesActivator = require('../../PropertiesActivator');\n\nvar asyncCapableHelper = require('../../helper/AsyncCapableHelper'),\n    ImplementationTypeHelper = require('../../helper/ImplementationTypeHelper');\n\nvar is = require('bpmn-js/lib/util/ModelUtil').is;\n\n// bpmn properties\nvar processProps = require('../bpmn/parts/ProcessProps'),\n    eventProps = require('../bpmn/parts/EventProps'),\n    linkProps = require('../bpmn/parts/LinkProps'),\n    documentationProps = require('../bpmn/parts/DocumentationProps'),\n    idProps = require('../bpmn/parts/IdProps'),\n    nameProps = require('../bpmn/parts/NameProps'),\n    executableProps = require('../bpmn/parts/ExecutableProps');\n\n// camunda properties\nvar serviceTaskDelegateProps = require('./parts/ServiceTaskDelegateProps'),\n    userTaskProps = require('./parts/UserTaskProps'),\n    asynchronousContinuationProps = require('./parts/AsynchronousContinuationProps'),\n    callActivityProps = require('./parts/CallActivityProps'),\n    multiInstanceProps = require('./parts/MultiInstanceLoopProps'),\n    sequenceFlowProps = require('./parts/SequenceFlowProps'),\n    scriptProps = require('./parts/ScriptTaskProps'),\n    formProps = require('./parts/FormProps'),\n    startEventInitiator = require('./parts/StartEventInitiator'),\n    variableMapping = require('./parts/VariableMappingProps'),\n    versionTag = require('./parts/VersionTagProps');\n\nvar listenerProps = require('./parts/ListenerProps'),\n    listenerDetails = require('./parts/ListenerDetailProps'),\n    listenerFields = require('./parts/ListenerFieldInjectionProps');\n\nvar elementTemplateChooserProps = require('./element-templates/parts/ChooserProps'),\n    elementTemplateCustomProps = require('./element-templates/parts/CustomProps');\n\n// Input/Output\nvar inputOutput = require('./parts/InputOutputProps'),\n    inputOutputParameter = require('./parts/InputOutputParameterProps');\n\n// Connector\nvar connectorDetails = require('./parts/ConnectorDetailProps'),\n    connectorInputOutput = require('./parts/ConnectorInputOutputProps'),\n    connectorInputOutputParameter = require('./parts/ConnectorInputOutputParameterProps');\n\n// properties\nvar properties = require('./parts/PropertiesProps');\n\n// job configuration\nvar jobConfiguration = require('./parts/JobConfigurationProps');\n\n// history time to live\nvar historyTimeToLive = require('./parts/HistoryTimeToLiveProps');\n\n// external task configuration\nvar externalTaskConfiguration = require('./parts/ExternalTaskConfigurationProps');\n\n// field injection\nvar fieldInjections = require('./parts/FieldInjectionProps');\n\nvar getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject,\n    eventDefinitionHelper = require('../../helper/EventDefinitionHelper'),\n    implementationTypeHelper = require('../../helper/ImplementationTypeHelper');\n\n// helpers ////////////////////////////////////////\n\nvar isExternalTaskPriorityEnabled = function(element) {\n  var businessObject = getBusinessObject(element);\n\n  // show only if element is a process, a participant ...\n  if (is(element, 'bpmn:Process') || is(element, 'bpmn:Participant') && businessObject.get('processRef'))  {\n    return true;\n  }\n\n  var externalBo = ImplementationTypeHelper.getServiceTaskLikeBusinessObject(element),\n      isExternalTask = ImplementationTypeHelper.getImplementationType(externalBo) === 'external';\n\n  // ... or an external task with selected external implementation type\n  return !!ImplementationTypeHelper.isExternalCapable(externalBo) && isExternalTask;\n};\n\nvar isJobConfigEnabled = function(element) {\n  var businessObject = getBusinessObject(element);\n\n  if (is(element, 'bpmn:Process') || is(element, 'bpmn:Participant') && businessObject.get('processRef'))  {\n    return true;\n  }\n\n  // async behavior\n  var bo = getBusinessObject(element);\n  if (asyncCapableHelper.isAsyncBefore(bo) || asyncCapableHelper.isAsyncAfter(bo)) {\n    return true;\n  }\n\n  // timer definition\n  if (is(element, 'bpmn:Event'))  {\n    return !!eventDefinitionHelper.getTimerEventDefinition(element);\n  }\n\n  return false;\n};\n\nvar getInputOutputParameterLabel = function(param, translate) {\n\n  if (is(param, 'camunda:InputParameter')) {\n    return translate('Input Parameter');\n  }\n\n  if (is(param, 'camunda:OutputParameter')) {\n    return translate('Output Parameter');\n  }\n\n  return '';\n};\n\nvar getListenerLabel = function(param, translate) {\n\n  if (is(param, 'camunda:ExecutionListener')) {\n    return translate('Execution Listener');\n  }\n\n  if (is(param, 'camunda:TaskListener')) {\n    return translate('Task Listener');\n  }\n\n  return '';\n};\n\nfunction createGeneralTabGroups(element, bpmnFactory, elementRegistry, elementTemplates, translate) {\n\n  var generalGroup = {\n    id: 'general',\n    label: translate('General'),\n    entries: []\n  };\n  idProps(generalGroup, element, translate);\n  nameProps(generalGroup, element, translate);\n  processProps(generalGroup, element, translate);\n  versionTag(generalGroup, element, translate);\n  executableProps(generalGroup, element, translate);\n  elementTemplateChooserProps(generalGroup, element, elementTemplates, translate);\n\n  var customFieldsGroups = elementTemplateCustomProps(element, elementTemplates, bpmnFactory, translate);\n\n  var detailsGroup = {\n    id: 'details',\n    label: translate('Details'),\n    entries: []\n  };\n  serviceTaskDelegateProps(detailsGroup, element, bpmnFactory, translate);\n  userTaskProps(detailsGroup, element, translate);\n  scriptProps(detailsGroup, element, bpmnFactory, translate);\n  linkProps(detailsGroup, element, translate);\n  callActivityProps(detailsGroup, element, bpmnFactory, translate);\n  eventProps(detailsGroup, element, bpmnFactory, elementRegistry, translate);\n  sequenceFlowProps(detailsGroup, element, bpmnFactory, translate);\n  startEventInitiator(detailsGroup, element, translate); // this must be the last element of the details group!\n\n  var multiInstanceGroup = {\n    id: 'multiInstance',\n    label: translate('Multi Instance'),\n    entries: []\n  };\n  multiInstanceProps(multiInstanceGroup, element, bpmnFactory, translate);\n\n  var asyncGroup = {\n    id : 'async',\n    label: translate('Asynchronous Continuations'),\n    entries : []\n  };\n  asynchronousContinuationProps(asyncGroup, element, bpmnFactory, translate);\n\n  var jobConfigurationGroup = {\n    id : 'jobConfiguration',\n    label : translate('Job Configuration'),\n    entries : [],\n    enabled: isJobConfigEnabled\n  };\n  jobConfiguration(jobConfigurationGroup, element, bpmnFactory, translate);\n\n  var externalTaskGroup = {\n    id : 'externalTaskConfiguration',\n    label : translate('External Task Configuration'),\n    entries : [],\n    enabled: isExternalTaskPriorityEnabled\n  };\n  externalTaskConfiguration(externalTaskGroup, element, bpmnFactory, translate);\n\n  var documentationGroup = {\n    id: 'documentation',\n    label: translate('Documentation'),\n    entries: []\n  };\n  documentationProps(documentationGroup, element, bpmnFactory, translate);\n\n\n  var historyTimeToLiveGroup = {\n    id: 'historyConfiguration',\n    label: translate('History Configuration'),\n    entries: []\n  };\n  historyTimeToLive(historyTimeToLiveGroup, element, bpmnFactory, translate);\n\n  var groups = [];\n  groups.push(generalGroup);\n  customFieldsGroups.forEach(function(group) {\n    groups.push(group);\n  });\n  groups.push(detailsGroup);\n  groups.push(externalTaskGroup);\n  groups.push(multiInstanceGroup);\n  groups.push(asyncGroup);\n  groups.push(jobConfigurationGroup);\n  groups.push(documentationGroup);\n  groups.push(historyTimeToLiveGroup);\n\n  return groups;\n}\n\nfunction createVariablesTabGroups(element, bpmnFactory, elementRegistry, translate) {\n  var variablesGroup = {\n    id : 'variables',\n    label : translate('Variables'),\n    entries: []\n  };\n  variableMapping(variablesGroup, element, bpmnFactory, translate);\n\n  return [\n    variablesGroup\n  ];\n}\n\nfunction createFormsTabGroups(element, bpmnFactory, elementRegistry, translate) {\n  var formGroup = {\n    id : 'forms',\n    label : translate('Forms'),\n    entries: []\n  };\n  formProps(formGroup, element, bpmnFactory, translate);\n\n  return [\n    formGroup\n  ];\n}\n\nfunction createListenersTabGroups(element, bpmnFactory, elementRegistry, translate) {\n\n  var listenersGroup = {\n    id : 'listeners',\n    label: translate('Listeners'),\n    entries: []\n  };\n\n  var options = listenerProps(listenersGroup, element, bpmnFactory, translate);\n\n  var listenerDetailsGroup = {\n    id: 'listener-details',\n    entries: [],\n    enabled: function(element, node) {\n      return options.getSelectedListener(element, node);\n    },\n    label: function(element, node) {\n      var param = options.getSelectedListener(element, node);\n      return getListenerLabel(param, translate);\n    }\n  };\n\n  listenerDetails(listenerDetailsGroup, element, bpmnFactory, options, translate);\n\n  var listenerFieldsGroup = {\n    id: 'listener-fields',\n    label: translate('Field Injection'),\n    entries: [],\n    enabled: function(element, node) {\n      return options.getSelectedListener(element, node);\n    }\n  };\n\n  listenerFields(listenerFieldsGroup, element, bpmnFactory, options, translate);\n\n  return [\n    listenersGroup,\n    listenerDetailsGroup,\n    listenerFieldsGroup\n  ];\n}\n\nfunction createInputOutputTabGroups(element, bpmnFactory, elementRegistry, translate) {\n\n  var inputOutputGroup = {\n    id: 'input-output',\n    label: translate('Parameters'),\n    entries: []\n  };\n\n  var options = inputOutput(inputOutputGroup, element, bpmnFactory, translate);\n\n  var inputOutputParameterGroup = {\n    id: 'input-output-parameter',\n    entries: [],\n    enabled: function(element, node) {\n      return options.getSelectedParameter(element, node);\n    },\n    label: function(element, node) {\n      var param = options.getSelectedParameter(element, node);\n      return getInputOutputParameterLabel(param, translate);\n    }\n  };\n\n  inputOutputParameter(inputOutputParameterGroup, element, bpmnFactory, options, translate);\n\n  return [\n    inputOutputGroup,\n    inputOutputParameterGroup\n  ];\n}\n\nfunction createConnectorTabGroups(element, bpmnFactory, elementRegistry, translate) {\n  var connectorDetailsGroup = {\n    id: 'connector-details',\n    label: translate('Details'),\n    entries: []\n  };\n\n  connectorDetails(connectorDetailsGroup, element, bpmnFactory, translate);\n\n  var connectorInputOutputGroup = {\n    id: 'connector-input-output',\n    label: translate('Input/Output'),\n    entries: []\n  };\n\n  var options = connectorInputOutput(connectorInputOutputGroup, element, bpmnFactory, translate);\n\n  var connectorInputOutputParameterGroup = {\n    id: 'connector-input-output-parameter',\n    entries: [],\n    enabled: function(element, node) {\n      return options.getSelectedParameter(element, node);\n    },\n    label: function(element, node) {\n      var param = options.getSelectedParameter(element, node);\n      return getInputOutputParameterLabel(param, translate);\n    }\n  };\n\n  connectorInputOutputParameter(connectorInputOutputParameterGroup, element, bpmnFactory, options, translate);\n\n  return [\n    connectorDetailsGroup,\n    connectorInputOutputGroup,\n    connectorInputOutputParameterGroup\n  ];\n}\n\nfunction createFieldInjectionsTabGroups(element, bpmnFactory, elementRegistry, translate) {\n\n  var fieldGroup = {\n    id: 'field-injections-properties',\n    label: translate('Field Injections'),\n    entries: []\n  };\n\n  fieldInjections(fieldGroup, element, bpmnFactory, translate);\n\n  return [\n    fieldGroup\n  ];\n}\n\nfunction createExtensionElementsGroups(element, bpmnFactory, elementRegistry, translate) {\n\n  var propertiesGroup = {\n    id : 'extensionElements-properties',\n    label: translate('Properties'),\n    entries: []\n  };\n  properties(propertiesGroup, element, bpmnFactory, translate);\n\n  return [\n    propertiesGroup\n  ];\n}\n\n// Camunda Properties Provider /////////////////////////////////////\n\n\n/**\n * A properties provider for Camunda related properties.\n *\n * @param {EventBus} eventBus\n * @param {BpmnFactory} bpmnFactory\n * @param {ElementRegistry} elementRegistry\n * @param {ElementTemplates} elementTemplates\n */\nfunction CamundaPropertiesProvider(eventBus, bpmnFactory, elementRegistry, elementTemplates, translate) {\n\n  PropertiesActivator.call(this, eventBus);\n\n  this.getTabs = function(element) {\n\n    var generalTab = {\n      id: 'general',\n      label: translate('General'),\n      groups: createGeneralTabGroups(\n                  element, bpmnFactory,\n                  elementRegistry, elementTemplates, translate)\n    };\n\n    var variablesTab = {\n      id: 'variables',\n      label: translate('Variables'),\n      groups: createVariablesTabGroups(element, bpmnFactory, elementRegistry, translate)\n    };\n\n    var formsTab = {\n      id: 'forms',\n      label: translate('Forms'),\n      groups: createFormsTabGroups(element, bpmnFactory, elementRegistry, translate)\n    };\n\n    var listenersTab = {\n      id: 'listeners',\n      label: translate('Listeners'),\n      groups: createListenersTabGroups(element, bpmnFactory, elementRegistry, translate),\n      enabled: function(element) {\n        return !eventDefinitionHelper.getLinkEventDefinition(element)\n          || (!is(element, 'bpmn:IntermediateThrowEvent')\n          && eventDefinitionHelper.getLinkEventDefinition(element));\n      }\n    };\n\n    var inputOutputTab = {\n      id: 'input-output',\n      label: translate('Input/Output'),\n      groups: createInputOutputTabGroups(element, bpmnFactory, elementRegistry, translate)\n    };\n\n    var connectorTab = {\n      id: 'connector',\n      label: translate('Connector'),\n      groups: createConnectorTabGroups(element, bpmnFactory, elementRegistry, translate),\n      enabled: function(element) {\n        var bo = implementationTypeHelper.getServiceTaskLikeBusinessObject(element);\n        return bo && implementationTypeHelper.getImplementationType(bo) === 'connector';\n      }\n    };\n\n    var fieldInjectionsTab = {\n      id: 'field-injections',\n      label: translate('Field Injections'),\n      groups: createFieldInjectionsTabGroups(element, bpmnFactory, elementRegistry, translate)\n    };\n\n    var extensionsTab = {\n      id: 'extensionElements',\n      label: translate('Extensions'),\n      groups: createExtensionElementsGroups(element, bpmnFactory, elementRegistry, translate)\n    };\n\n    return [\n      generalTab,\n      variablesTab,\n      connectorTab,\n      formsTab,\n      listenersTab,\n      inputOutputTab,\n      fieldInjectionsTab,\n      extensionsTab\n    ];\n  };\n\n}\n\nCamundaPropertiesProvider.$inject = [\n  'eventBus',\n  'bpmnFactory',\n  'elementRegistry',\n  'elementTemplates',\n  'translate'\n];\n\ninherits(CamundaPropertiesProvider, PropertiesActivator);\n\nmodule.exports = CamundaPropertiesProvider;\n","'use strict';\n\nvar assign = require('lodash/object/assign');\n\n/**\n * Create an input parameter representing the given\n * binding and value.\n *\n * @param {PropertyBinding} binding\n * @param {String} value\n * @param {BpmnFactory} bpmnFactory\n *\n * @return {ModdleElement}\n */\nfunction createInputParameter(binding, value, bpmnFactory) {\n  var scriptFormat = binding.scriptFormat,\n      parameterValue,\n      parameterDefinition;\n\n  if (scriptFormat) {\n    parameterDefinition = bpmnFactory.create('camunda:Script', {\n      scriptFormat: scriptFormat,\n      value: value\n    });\n  } else {\n    parameterValue = value;\n  }\n\n  return bpmnFactory.create('camunda:InputParameter', {\n    name: binding.name,\n    value: parameterValue,\n    definition: parameterDefinition\n  });\n}\n\nmodule.exports.createInputParameter = createInputParameter;\n\n\n/**\n * Create an output parameter representing the given\n * binding and value.\n *\n * @param {PropertyBinding} binding\n * @param {String} value\n * @param {BpmnFactory} bpmnFactory\n *\n * @return {ModdleElement}\n */\nfunction createOutputParameter(binding, value, bpmnFactory) {\n  var scriptFormat = binding.scriptFormat,\n      parameterValue,\n      parameterDefinition;\n\n  if (scriptFormat) {\n    parameterDefinition = bpmnFactory.create('camunda:Script', {\n      scriptFormat: scriptFormat,\n      value: binding.source\n    });\n  } else {\n    parameterValue = binding.source;\n  }\n\n  return bpmnFactory.create('camunda:OutputParameter', {\n    name: value,\n    value: parameterValue,\n    definition: parameterDefinition\n  });\n}\n\nmodule.exports.createOutputParameter = createOutputParameter;\n\n\n/**\n * Create camunda property from the given binding.\n *\n * @param {PropertyBinding} binding\n * @param {String} value\n * @param {BpmnFactory} bpmnFactory\n *\n * @return {ModdleElement}\n */\nfunction createCamundaProperty(binding, value, bpmnFactory) {\n  return bpmnFactory.create('camunda:Property', {\n    name: binding.name,\n    value: value || ''\n  });\n}\n\nmodule.exports.createCamundaProperty = createCamundaProperty;\n\n\n/**\n * Create camunda:in element from given binding.\n *\n * @param {PropertyBinding} binding\n * @param {String} value\n * @param {BpmnFactory} bpmnFactory\n *\n * @return {ModdleElement}\n */\nfunction createCamundaIn(binding, value, bpmnFactory) {\n\n  var properties = createCamundaInOutAttrs(binding, value);\n\n  return bpmnFactory.create('camunda:In', properties);\n}\n\nmodule.exports.createCamundaIn = createCamundaIn;\n\n\n/**\n * Create camunda:in with businessKey element from given binding.\n *\n * @param {PropertyBinding} binding\n * @param {String} value\n * @param {BpmnFactory} bpmnFactory\n *\n * @return {ModdleElement}\n */\nfunction createCamundaInWithBusinessKey(binding, value, bpmnFactory) {\n  return bpmnFactory.create('camunda:In', {\n    businessKey: value\n  });\n}\n\nmodule.exports.createCamundaInWithBusinessKey = createCamundaInWithBusinessKey;\n\n\n/**\n * Create camunda:out element from given binding.\n *\n * @param {PropertyBinding} binding\n * @param {String} value\n * @param {BpmnFactory} bpmnFactory\n *\n * @return {ModdleElement}\n */\nfunction createCamundaOut(binding, value, bpmnFactory) {\n  var properties = createCamundaInOutAttrs(binding, value);\n\n  return bpmnFactory.create('camunda:Out', properties);\n}\n\nmodule.exports.createCamundaOut = createCamundaOut;\n\n\n/**\n * Create camunda:executionListener element containing an inline script from given binding.\n *\n * @param {PropertyBinding} binding\n * @param {String} value\n * @param {BpmnFactory} bpmnFactory\n *\n * @return {ModdleElement}\n */\nfunction createCamundaExecutionListenerScript(binding, value, bpmnFactory) {\n  var scriptFormat = binding.scriptFormat,\n      parameterValue,\n      parameterDefinition;\n\n  if (scriptFormat) {\n    parameterDefinition = bpmnFactory.create('camunda:Script', {\n      scriptFormat: scriptFormat,\n      value: value\n    });\n  } else {\n    parameterValue = value;\n  }\n\n  return bpmnFactory.create('camunda:ExecutionListener', {\n    event: binding.event,\n    value: parameterValue,\n    script: parameterDefinition\n  });\n}\n\nmodule.exports.createCamundaExecutionListenerScript = createCamundaExecutionListenerScript;\n\n/**\n * Create camunda:field element containing string or expression from given binding.\n *\n * @param {PropertyBinding} binding\n * @param {String} value\n * @param {BpmnFactory} bpmnFactory\n *\n * @return {ModdleElement}\n */\nfunction createCamundaFieldInjection(binding, value, bpmnFactory) {\n  var DEFAULT_PROPS = {\n    'string': undefined,\n    'expression': undefined,\n    'name': undefined\n  };\n\n  var props = assign({}, DEFAULT_PROPS);\n\n  if (!binding.expression) {\n    props.string = value;\n  } else {\n    props.expression = value;\n  }\n  props.name = binding.name;\n\n  return bpmnFactory.create('camunda:Field', props);\n}\nmodule.exports.createCamundaFieldInjection = createCamundaFieldInjection;\n\n\n/////////// helpers ////////////////////////////\n\n/**\n * Create properties for camunda:in and camunda:out types.\n */\nfunction createCamundaInOutAttrs(binding, value) {\n\n  var properties = {};\n\n  // camunda:in source(Expression) target\n  if (binding.target) {\n\n    properties.target = binding.target;\n\n    if (binding.expression) {\n      properties.sourceExpression = value;\n    } else {\n      properties.source = value;\n    }\n  } else\n\n  // camunda:(in|out) variables local\n  if (binding.variables) {\n    properties.variables = 'all';\n\n    if (binding.variables === 'local') {\n      properties.local = true;\n    }\n  }\n\n  // camunda:out source(Expression) target\n  else {\n    properties.target = value;\n\n    [ 'source', 'sourceExpression' ].forEach(function(k) {\n      if (binding[k]) {\n        properties[k] = binding[k];\n      }\n    });\n  }\n\n  return properties;\n}\n","'use strict';\n\nvar inherits = require('inherits');\n\nvar getTemplate = require('./Helper').getTemplate;\n\nvar PropertiesActivator = require('../../../PropertiesActivator');\n\nvar HIGHER_PRIORITY = 1100;\n\n/**\n * Applies template visibility settings.\n *\n * Controlled using `entriesVisible` on template config object:\n *\n * ```json\n *     \"entriesVisible\": {\n *       \"_all\": true|false,\n *       \"entryName\": true|false,\n *       ...\n *     }\n * ```\n *\n * @param {EventBus} eventBus\n * @param {ElementTemplates} elementTemplates\n */\nfunction CustomElementsPropertiesActivator(eventBus, elementTemplates) {\n  PropertiesActivator.call(this, eventBus, HIGHER_PRIORITY);\n\n  this.isEntryVisible = function(entry, element) {\n\n    var template = getTemplate(element, elementTemplates);\n\n    if (template && !isEntryVisible(entry, template)) {\n      return false;\n    }\n  };\n\n  this.isPropertyEditable = function(entry, propertyName, element) {\n\n    var template = getTemplate(element, elementTemplates);\n\n    if (template && !isEntryEditable(entry, template)) {\n      return false;\n    }\n  };\n}\n\nCustomElementsPropertiesActivator.$inject = [ 'eventBus', 'elementTemplates' ];\n\ninherits(CustomElementsPropertiesActivator, PropertiesActivator);\n\nmodule.exports = CustomElementsPropertiesActivator;\n\n\n\n////// helpers ////////////////////////////////////\n\n\nvar CUSTOM_PROPERTIES_PATTERN = /^custom-/;\n\nvar DEFAULT_ENTRIES_VISIBLE = {\n  _all: false,\n  id: true,\n  name: true\n};\n\nfunction isCustomEntry(entry) {\n  return CUSTOM_PROPERTIES_PATTERN.test(entry.id);\n}\n\nfunction isEntryVisible(entry, template) {\n\n  var entryId = entry.id;\n\n  if (entryId === 'elementTemplate-chooser' || isCustomEntry(entry)) {\n    return true;\n  }\n\n  var entriesVisible = template.entriesVisible || DEFAULT_ENTRIES_VISIBLE;\n\n  if (typeof entriesVisible === 'boolean') {\n    return entriesVisible;\n  }\n\n  var defaultVisible = entriesVisible._all || false,\n      entryVisible = entriesVisible[entryId];\n\n  // d = true, e = false => false\n  // d = false, e = true => true\n  // d = false, e = false\n  return (\n    (defaultVisible === true && entryVisible !== false) ||\n    (defaultVisible === false && entryVisible === true)\n  );\n}\n\nfunction isEntryEditable(entry, template) {\n\n  var property;\n\n  if (isCustomEntry(entry)) {\n    property = getProperty(template, entry);\n\n    return property && property.editable !== false;\n  }\n\n  return true;\n}\n\nfunction getProperty(template, entry) {\n\n  var index;\n  var idx = entry.id.replace('custom-' + template.id + '-', '');\n  if (idx.indexOf('-') !== -1) {\n    var indexes = idx.split('-');\n    if (indexes.length == 2) {\n      var scopeName = indexes[0].replace(/_/g, ':');\n      index = parseInt(indexes[1], 10);\n      if (scopeName && !isNaN(index)) {\n        return template.scopes[scopeName].properties[index];\n      }\n    }\n  } else {\n    index = parseInt(idx, 10);\n    if (!isNaN(index)) {\n      return template.properties[index];\n    }\n  }\n\n  throw new Error('cannot extract property index for entry <' + entry.id + '>');\n}\n","'use strict';\n\nvar values = require('lodash/object/values');\n\n/**\n * The guy knowing all configured element templates.\n *\n * This registry won't validate. Use the {@link Validator}\n * to verify a template is valid prior to adding it to\n * this registry.\n */\nfunction ElementTemplates() {\n\n  this._templates = {};\n\n  /**\n   * Sets the known element templates.\n   *\n   * @param {Array<TemplateDescriptor>} descriptors\n   *\n   * @return {ElementTemplates}\n   */\n  this.set = function(descriptors) {\n\n    var templates = this._templates = {};\n\n    descriptors.forEach(function(descriptor) {\n      templates[descriptor.id] = descriptor;\n    });\n\n    return this;\n  };\n\n  /**\n   * Get template descriptor with given id.\n   *\n   * @param {String} id\n   *\n   * @return {TemplateDescriptor}\n   */\n  this.get = function(id) {\n    return this._templates[id];\n  };\n\n  /**\n   * Return all known template descriptors.\n   *\n   * @return {Array<TemplateDescriptor>}\n   */\n  this.getAll = function() {\n    return values(this._templates);\n  };\n\n}\n\nmodule.exports = ElementTemplates;","'use strict';\n\nvar Validator = require('./Validator');\n\n/**\n * The guy responsible for template loading.\n *\n * Provide the actual templates via the `config.elementTemplates`.\n *\n * That configuration can either be an array of template\n * descriptors or a node style callback to retrieve\n * the templates asynchronously.\n *\n * @param {Array<TemplateDescriptor>|Function} loadTemplates\n * @param {EventBus} eventBus\n * @param {ElementTemplates} elementTemplates\n */\nfunction ElementTemplatesLoader(loadTemplates, eventBus, elementTemplates) {\n  this._loadTemplates = loadTemplates;\n  this._eventBus = eventBus;\n  this._elementTemplates = elementTemplates;\n\n  var self = this;\n\n  eventBus.on('diagram.init', function() {\n    self.reload();\n  });\n}\n\nmodule.exports = ElementTemplatesLoader;\n\nElementTemplatesLoader.$inject = [\n  'config.elementTemplates',\n  'eventBus',\n  'elementTemplates'\n];\n\n\nElementTemplatesLoader.prototype.reload = function() {\n\n  var self = this;\n\n  var loadTemplates = this._loadTemplates;\n\n  // no templates specified\n  if (typeof loadTemplates === 'undefined') {\n    return;\n  }\n\n  // template loader function specified\n  if (typeof loadTemplates === 'function') {\n\n    return loadTemplates(function(err, templates) {\n\n      if (err) {\n        return self.templateErrors([ err ]);\n      }\n\n      self.setTemplates(templates);\n    });\n  }\n\n  // templates array specified\n  if (loadTemplates.length) {\n    return this.setTemplates(loadTemplates);\n  }\n\n};\n\nElementTemplatesLoader.prototype.setTemplates = function(templates) {\n\n  var elementTemplates = this._elementTemplates;\n\n  var validator = new Validator().addAll(templates);\n\n  var errors = validator.getErrors(),\n      validTemplates = validator.getValidTemplates();\n\n  elementTemplates.set(validTemplates);\n\n  if (errors.length) {\n    this.templateErrors(errors);\n  }\n\n  this.templatesChanged();\n};\n\nElementTemplatesLoader.prototype.templatesChanged = function() {\n  this._eventBus.fire('elementTemplates.changed');\n};\n\nElementTemplatesLoader.prototype.templateErrors = function(errors) {\n  this._eventBus.fire('elementTemplates.errors', {\n    errors: errors\n  });\n};","'use strict';\n\nvar getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject;\n\nvar is = require('bpmn-js/lib/util/ModelUtil').is,\n    isAny = require('bpmn-js/lib/features/modeling/util/ModelingUtil').isAny;\n\nvar find = require('lodash/collection/find');\n\n\nvar TEMPLATE_ATTR = 'camunda:modelerTemplate';\n\n/**\n * The BPMN 2.0 extension attribute name under\n * which the element template is stored.\n *\n * @type {String}\n */\nmodule.exports.TEMPLATE_ATTR = TEMPLATE_ATTR;\n\n\n/**\n * Get template id for a given diagram element.\n *\n * @param {djs.model.Base} element\n *\n * @return {String}\n */\nfunction getTemplateId(element) {\n\n  var bo = getBusinessObject(element);\n\n  if (bo) {\n    return bo.get(TEMPLATE_ATTR);\n  }\n}\n\nmodule.exports.getTemplateId = getTemplateId;\n\n\n/**\n * Get template of a given element.\n *\n * @param {Element} element\n * @param {ElementTemplates} elementTemplates\n *\n * @return {TemplateDefinition}\n */\nfunction getTemplate(element, elementTemplates) {\n  var id = getTemplateId(element);\n\n  return id && elementTemplates.get(id);\n}\n\nmodule.exports.getTemplate = getTemplate;\n\n/**\n * Get default template for a given element.\n *\n * @param {Element} element\n * @param {ElementTemplates} elementTemplates\n *\n * @return {TemplateDefinition}\n */\nfunction getDefaultTemplate(element, elementTemplates) {\n\n  // return first default template, if any exists\n  return (\n    elementTemplates.getAll().filter(function(t) {\n      return isAny(element, t.appliesTo) && t.isDefault;\n    })\n  )[0];\n}\n\nmodule.exports.getDefaultTemplate = getDefaultTemplate;\n\n\n/**\n * Find extension with given type in\n * BPMN element, diagram element or ExtensionElement.\n *\n * @param {ModdleElement|djs.model.Base} element\n * @param {String} type\n *\n * @return {ModdleElement} the extension\n */\nfunction findExtension(element, type) {\n  var bo = getBusinessObject(element);\n\n  var extensionElements;\n\n  if (is(bo, 'bpmn:ExtensionElements')) {\n    extensionElements = bo;\n  } else {\n    extensionElements = bo.extensionElements;\n  }\n\n  if (!extensionElements) {\n    return null;\n  }\n\n  return find(extensionElements.get('values'), function(e) {\n    return is(e, type);\n  });\n}\n\nmodule.exports.findExtension = findExtension;\n\n\nfunction findExtensions(element, types) {\n  var extensionElements = getExtensionElements(element);\n\n  if (!extensionElements) {\n    return [];\n  }\n\n  return extensionElements.get('values').filter(function(e) {\n    return isAny(e, types);\n  });\n}\n\nmodule.exports.findExtensions = findExtensions;\n\n\nfunction findCamundaInOut(element, binding) {\n\n  var extensionElements = getExtensionElements(element);\n\n  if (!extensionElements) {\n    return;\n  }\n\n  var matcher;\n\n  if (binding.type === 'camunda:in') {\n    matcher = function(e) {\n      return is(e, 'camunda:In') && isInOut(e, binding);\n    };\n  } else\n  if (binding.type === 'camunda:out') {\n    matcher = function(e) {\n      return is(e, 'camunda:Out') && isInOut(e, binding);\n    };\n  } else\n  if (binding.type === 'camunda:in:businessKey') {\n    matcher = function(e) {\n      return is(e, 'camunda:In') && 'businessKey' in e;\n    };\n  }\n\n  return find(extensionElements.get('values'), matcher);\n}\n\nmodule.exports.findCamundaInOut = findCamundaInOut;\n\nfunction findCamundaProperty(camundaProperties, binding) {\n  return find(camundaProperties.get('values'), function(p) {\n    return p.name === binding.name;\n  });\n}\n\nmodule.exports.findCamundaProperty = findCamundaProperty;\n\n\nfunction findInputParameter(inputOutput, binding) {\n  var parameters = inputOutput.get('inputParameters');\n\n  return find(parameters, function(p) {\n    return p.name === binding.name;\n  });\n}\n\nmodule.exports.findInputParameter = findInputParameter;\n\n\nfunction findOutputParameter(inputOutput, binding) {\n  var parameters = inputOutput.get('outputParameters');\n\n  return find(parameters, function(p) {\n    var value = p.value;\n\n    if (!binding.scriptFormat) {\n      return value === binding.source;\n    }\n\n    var definition = p.definition;\n\n    if (!definition || binding.scriptFormat !== definition.scriptFormat) {\n      return false;\n    }\n\n    return definition.value === binding.source;\n  });\n}\n\nmodule.exports.findOutputParameter = findOutputParameter;\n\n\n\n//////// helpers /////////////////////////////////\n\nfunction getExtensionElements(element) {\n  var bo = getBusinessObject(element);\n\n  if (is(bo, 'bpmn:ExtensionElements')) {\n    return bo;\n  } else {\n    return bo.extensionElements;\n  }\n}\n\n\nfunction isInOut(element, binding) {\n\n  if (binding.type === 'camunda:in') {\n    // find based on target attribute\n    if (binding.target) {\n      return element.target === binding.target;\n    }\n  }\n\n  if (binding.type === 'camunda:out') {\n    // find based on source / sourceExpression\n    if (binding.source) {\n      return element.source === binding.source;\n    }\n\n    if (binding.sourceExpression) {\n      return element.sourceExpression === binding.sourceExpression;\n    }\n  }\n\n  // find based variables / local combination\n  if (binding.variables) {\n    return element.variables === 'all' && (\n      binding.variables !== 'local' || element.local\n    );\n  }\n}\n","'use strict';\n\nvar isArray = require('lodash/lang/isArray');\nvar isObject = require('lodash/lang/isObject');\n\nvar DROPDOWN_TYPE = 'Dropdown';\n\nvar VALID_TYPES = [ 'String', 'Text', 'Boolean', 'Hidden', DROPDOWN_TYPE ];\n\nvar PROPERTY_TYPE = 'property',\n    CAMUNDA_PROPERTY_TYPE = 'camunda:property',\n    CAMUNDA_INPUT_PARAMETER_TYPE = 'camunda:inputParameter',\n    CAMUNDA_OUTPUT_PARAMETER_TYPE = 'camunda:outputParameter',\n    CAMUNDA_IN_TYPE = 'camunda:in',\n    CAMUNDA_OUT_TYPE = 'camunda:out',\n    CAMUNDA_IN_BUSINESS_KEY_TYPE = 'camunda:in:businessKey',\n    CAMUNDA_EXECUTION_LISTENER = 'camunda:executionListener',\n    CAMUNDA_FIELD = 'camunda:field';\n\nvar VALID_BINDING_TYPES = [\n  PROPERTY_TYPE,\n  CAMUNDA_PROPERTY_TYPE,\n  CAMUNDA_INPUT_PARAMETER_TYPE,\n  CAMUNDA_OUTPUT_PARAMETER_TYPE,\n  CAMUNDA_IN_TYPE,\n  CAMUNDA_OUT_TYPE,\n  CAMUNDA_IN_BUSINESS_KEY_TYPE,\n  CAMUNDA_EXECUTION_LISTENER,\n  CAMUNDA_FIELD\n];\n\n\n/**\n * A element template validator.\n */\nfunction Validator() {\n\n  this._templatesById = {};\n\n  this._validTemplates = [];\n  this._errors = [];\n\n\n  /**\n   * Adds the templates.\n   *\n   * @param {Array<TemplateDescriptor>} templates\n   *\n   * @return {Validator} self\n   */\n  this.addAll = function(templates) {\n\n    if (!isArray(templates)) {\n      this._logError('templates must be []');\n    } else {\n      templates.forEach(this.add, this);\n    }\n\n    return this;\n  };\n\n  /**\n   * Add the given element template, if it is valid.\n   *\n   * @param {TemplateDescriptor} template\n   *\n   * @return {Validator} self\n   */\n  this.add = function(template) {\n\n    var err = this._validateTemplate(template);\n\n    if (!err) {\n      this._templatesById[template.id] = template;\n\n      this._validTemplates.push(template);\n    }\n\n    return this;\n  };\n\n  /**\n   * Validate given template and return error (if any).\n   *\n   * @param {TemplateDescriptor} template\n   *\n   * @return {Error} validation error, if any\n   */\n  this._validateTemplate = function(template) {\n\n    var err,\n        id = template.id,\n        appliesTo = template.appliesTo,\n        properties = template.properties,\n        scopes = template.scopes;\n\n    if (!id) {\n      return this._logError('missing template id');\n    }\n\n    if (id in this._templatesById) {\n      return this._logError('template id <' + id + '> already used');\n    }\n\n    if (!isArray(appliesTo)) {\n      err = this._logError('missing appliesTo=[]', template);\n    }\n\n    if (!isArray(properties)) {\n      err = this._logError('missing properties=[]', template);\n    } else {\n      if (!this._validateProperties(properties)) {\n        err = new Error('invalid properties');\n      }\n    }\n\n    if (scopes) {\n      err = this._validateScopes(template, scopes);\n    }\n\n    return err;\n  };\n\n  this._validateScopes = function(template, scopes) {\n\n    var err,\n        scope,\n        scopeName;\n\n    if (!isObject(scopes) || isArray(scopes)) {\n      return this._logError('invalid scopes, should be scopes={}', template);\n    }\n\n    for (scopeName in scopes) {\n      scope = scopes[scopeName];\n\n      if (!isObject(scope) || isArray(scope)) {\n        err = this._logError('invalid scope, should be scope={}', template);\n      }\n\n      if (!isArray(scope.properties)) {\n        err = this._logError(\n          'missing properties=[] in scope <' + scopeName + '>', template\n        );\n      } else {\n        if (!this._validateProperties(scope.properties)) {\n          err = new Error('invalid properties in scope <' + scopeName + '>');\n        }\n      }\n    }\n\n    return err;\n  };\n\n  /**\n   * Validate properties and return false if any is invalid.\n   *\n   * @param {Array<PropertyDescriptor>} properties\n   *\n   * @return {Boolean} true if all properties are valid\n   */\n  this._validateProperties = function(properties) {\n    var validProperties = properties.filter(this._validateProperty, this);\n\n    return properties.length === validProperties.length;\n  };\n\n  /**\n   * Validate property and return false, if there was\n   * a validation error.\n   *\n   * @param {PropertyDescriptor} property\n   *\n   * @return {Boolean} true if property is valid\n   */\n  this._validateProperty = function(property) {\n\n    var type = property.type,\n        binding = property.binding;\n\n    var err;\n\n    var bindingType = binding.type;\n\n    if (VALID_TYPES.indexOf(type) === -1) {\n      err = this._logError(\n              'invalid property type <' + type + '>; ' +\n              'must be any of { ' + VALID_TYPES.join(', ') + ' }');\n    }\n\n    if (type === DROPDOWN_TYPE && bindingType !== CAMUNDA_EXECUTION_LISTENER) {\n      if (!isArray(property.choices)) {\n        err = this._logError('must provide choices=[] with ' + DROPDOWN_TYPE + ' type');\n      } else\n\n      if (!property.choices.every(isDropdownChoiceValid)) {\n        err = this._logError(\n          '{ name, value } must be specified for ' +\n          DROPDOWN_TYPE + ' choices'\n        );\n      }\n    }\n\n    if (!binding) {\n      return this._logError('property missing binding');\n    }\n\n    if (VALID_BINDING_TYPES.indexOf(bindingType) === -1) {\n      err = this._logError(\n              'invalid property.binding type <' + bindingType + '>; ' +\n              'must be any of { ' + VALID_BINDING_TYPES.join(', ') + ' }');\n    }\n\n    if (bindingType === PROPERTY_TYPE ||\n        bindingType === CAMUNDA_PROPERTY_TYPE ||\n        bindingType === CAMUNDA_INPUT_PARAMETER_TYPE ||\n        bindingType === CAMUNDA_FIELD) {\n\n      if (!binding.name) {\n        err = this._logError(\n                'property.binding <' + bindingType + '> requires name');\n      }\n    }\n\n    if (bindingType === CAMUNDA_OUTPUT_PARAMETER_TYPE) {\n      if (!binding.source) {\n        err = this._logError(\n                'property.binding <' + bindingType + '> requires source');\n      }\n    }\n\n    if (bindingType === CAMUNDA_IN_TYPE) {\n\n      if (!binding.variables && !binding.target) {\n        err = this._logError(\n                'property.binding <' + bindingType + '> requires ' +\n                'variables or target');\n      }\n    }\n\n    if (bindingType === CAMUNDA_OUT_TYPE) {\n\n      if (!binding.variables && !binding.source && !binding.sourceExpression) {\n        err = this._logError(\n                'property.binding <' + bindingType + '> requires ' +\n                'variables, sourceExpression or source');\n      }\n    }\n\n    if (bindingType === CAMUNDA_EXECUTION_LISTENER) {\n\n      if (type !== 'Hidden') {\n        err = this._logError(\n                'invalid property type <' + type + '> for ' + CAMUNDA_EXECUTION_LISTENER + '; ' +\n                'must be <Hidden>');\n      }\n    }\n\n    return !err;\n  };\n\n\n  this._logError = function(err, template) {\n\n    if (typeof err === 'string') {\n      if (template) {\n        err = 'template(id: ' + template.id + ') ' + err;\n      }\n\n      err = new Error(err);\n    }\n\n    this._errors.push(err);\n\n    return err;\n  };\n\n  this.getErrors = function() {\n    return this._errors;\n  };\n\n  this.getValidTemplates = function() {\n    return this._validTemplates;\n  };\n}\n\nmodule.exports = Validator;\n\n\n//////// helpers ///////////////////////////////////\n\nfunction isDropdownChoiceValid(c) {\n  return 'name' in c && 'value' in c;\n}\n","'use strict';\n\nvar findExtension = require('../Helper').findExtension,\n    findExtensions = require('../Helper').findExtensions;\n\nvar createCamundaProperty = require('../CreateHelper').createCamundaProperty,\n    createInputParameter = require('../CreateHelper').createInputParameter,\n    createOutputParameter = require('../CreateHelper').createOutputParameter,\n    createCamundaIn = require('../CreateHelper').createCamundaIn,\n    createCamundaOut = require('../CreateHelper').createCamundaOut,\n    createCamundaInWithBusinessKey = require('../CreateHelper').createCamundaInWithBusinessKey,\n    createCamundaExecutionListenerScript = require('../CreateHelper').createCamundaExecutionListenerScript,\n    createCamundaFieldInjection = require('../CreateHelper').createCamundaFieldInjection;\n\nvar forEach = require('lodash/collection/forEach');\n\nvar CAMUNDA_SERVICE_TASK_LIKE = [\n  'camunda:class',\n  'camunda:delegateExpression',\n  'camunda:expression'\n];\n\n/**\n * A handler that changes the modeling template of a BPMN element.\n */\nfunction ChangeElementTemplateHandler(modeling, commandStack, bpmnFactory) {\n\n  function getOrCreateExtensionElements(element) {\n\n    var bo = element.businessObject;\n\n    var extensionElements = bo.extensionElements;\n\n    // add extension elements\n    if (!extensionElements) {\n      extensionElements = bpmnFactory.create('bpmn:ExtensionElements', {\n        values: []\n      });\n\n      modeling.updateProperties(element, {\n        extensionElements: extensionElements\n      });\n    }\n\n    return extensionElements;\n  }\n\n  function updateModelerTemplate(element, newTemplate) {\n    modeling.updateProperties(element, {\n      'camunda:modelerTemplate': newTemplate && newTemplate.id\n    });\n  }\n\n  function updateIoMappings(element, newTemplate, context) {\n\n    var newMappings = createInputOutputMappings(newTemplate, bpmnFactory),\n        oldMappings;\n\n    if (!newMappings) {\n      return;\n    }\n\n    if (context) {\n      commandStack.execute('properties-panel.update-businessobject', {\n        element: element,\n        businessObject: context,\n        properties: { inputOutput: newMappings }\n      });\n    } else {\n      context = getOrCreateExtensionElements(element);\n      oldMappings = findExtension(element, 'camunda:InputOutput');\n      commandStack.execute('properties-panel.update-businessobject-list', {\n        element: element,\n        currentObject: context,\n        propertyName: 'values',\n        objectsToAdd: [ newMappings ],\n        objectsToRemove: oldMappings ? [ oldMappings ] : []\n      });\n    }\n  }\n\n  function updateCamundaField(element, newTemplate, context) {\n\n    var newMappings = createCamundaFieldInjections(newTemplate, bpmnFactory),\n        oldMappings;\n\n    if (!newMappings) {\n      return;\n    }\n    if (context) {\n      commandStack.execute('properties-panel.update-businessobject', {\n        element: element,\n        businessObject: context,\n        properties: { field: newMappings }\n      });\n    } else {\n      context = getOrCreateExtensionElements(element);\n      oldMappings = findExtensions(element, ['camunda:Field']);\n\n      commandStack.execute('properties-panel.update-businessobject-list', {\n        element: element,\n        currentObject: context,\n        propertyName: 'values',\n        objectsToAdd: newMappings,\n        objectsToRemove: oldMappings ? oldMappings : []\n      });\n    }\n  }\n\n\n  function updateCamundaProperties(element, newTemplate, context) {\n\n    var newProperties = createCamundaProperties(newTemplate, bpmnFactory),\n        oldProperties;\n\n    if (!newProperties) {\n      return;\n    }\n\n    if (context) {\n      commandStack.execute('properties-panel.update-businessobject', {\n        element: element,\n        businessObject: context,\n        properties: { properties: newProperties }\n      });\n    } else {\n      context = getOrCreateExtensionElements(element);\n      oldProperties = findExtension(element, 'camunda:Properties');\n\n      commandStack.execute('properties-panel.update-businessobject-list', {\n        element: element,\n        currentObject: context,\n        propertyName: 'values',\n        objectsToAdd: [ newProperties ],\n        objectsToRemove: oldProperties ? [ oldProperties ] : []\n      });\n    }\n  }\n\n  function updateProperties(element, newTemplate, context) {\n\n    var newProperties = createBpmnPropertyUpdates(newTemplate, bpmnFactory);\n\n    var newPropertiesCount = Object.keys(newProperties).length;\n\n    if (!newPropertiesCount) {\n      return;\n    }\n\n    if (context) {\n      commandStack.execute('properties-panel.update-businessobject', {\n        element: element,\n        businessObject: context,\n        properties: newProperties\n      });\n    } else {\n      modeling.updateProperties(element, newProperties);\n    }\n  }\n\n  function updateInOut(element, newTemplate, context) {\n\n    var newInOut = createCamundaInOut(newTemplate, bpmnFactory),\n        oldInOut;\n\n    if (!newInOut) {\n      return;\n    }\n\n    if (context) {\n      commandStack.execute('properties-panel.update-businessobject', {\n        element: element,\n        businessObject: context,\n        properties: { inout: newInOut }\n      });\n    } else {\n      context = getOrCreateExtensionElements(element);\n      oldInOut = findExtensions(context, [ 'camunda:In', 'camunda:Out' ]);\n\n      commandStack.execute('properties-panel.update-businessobject-list', {\n        element: element,\n        currentObject: context,\n        propertyName: 'values',\n        objectsToAdd: newInOut,\n        objectsToRemove: oldInOut\n      });\n    }\n  }\n\n  function updateExecutionListener(element, newTemplate, context) {\n\n    var newExecutionListeners = createCamundaExecutionListeners(newTemplate, bpmnFactory),\n        oldExecutionsListeners;\n\n    if (!newExecutionListeners.length) {\n      return;\n    }\n\n    if (context) {\n      commandStack.execute('properties-panel.update-businessobject', {\n        element: element,\n        businessObject: context,\n        properties: { executionListener: newExecutionListeners }\n      });\n    } else {\n      context = getOrCreateExtensionElements(element);\n      oldExecutionsListeners = findExtensions(context, [ 'camunda:ExecutionListener' ]);\n\n      commandStack.execute('properties-panel.update-businessobject-list', {\n        element: element,\n        currentObject: context,\n        propertyName: 'values',\n        objectsToAdd: newExecutionListeners,\n        objectsToRemove: oldExecutionsListeners\n      });\n    }\n  }\n\n  /**\n   * Update / recreate a scoped element.\n   *\n   * @param {djs.model.Base} element the diagram parent element\n   * @param {String} scopeName name of the scope, i.e. camunda:Connector\n   * @param {Object} scopeDefinition\n   */\n  function updateScopeElements(element, scopeName, scopeDefinition) {\n\n    var scopeElement = bpmnFactory.create(scopeName);\n\n    // update camunda:inputOutput\n    updateIoMappings(element, scopeDefinition, scopeElement);\n\n    // update camunda:field\n    updateCamundaField(element, scopeDefinition, scopeElement);\n\n    // update camunda:properties\n    updateCamundaProperties(element, scopeDefinition, scopeElement);\n\n    // update other properties (bpmn:condition, camunda:async, ...)\n    updateProperties(element, scopeDefinition, scopeElement);\n\n    // update camunda:in and camunda:out\n    updateInOut(element, scopeDefinition, scopeElement);\n\n    // update camunda:executionListener\n    updateExecutionListener(element, scopeDefinition, scopeElement);\n\n    var extensionElements = getOrCreateExtensionElements(element);\n    var oldScope = findExtension(extensionElements, scopeName);\n\n    commandStack.execute('properties-panel.update-businessobject-list', {\n      element: element,\n      currentObject: extensionElements,\n      propertyName: 'values',\n      objectsToAdd: [ scopeElement ],\n      objectsToRemove: oldScope ? [ oldScope ] : []\n    });\n  }\n\n  /**\n   * Compose an element template change action, updating all\n   * necessary underlying properties.\n   *\n   * @param {Object} context\n   * @param {Object} context.element\n   * @param {Object} context.oldTemplate\n   * @param {Object} context.newTemplate\n   */\n  this.preExecute = function(context) {\n\n    var element = context.element,\n        newTemplate = context.newTemplate;\n\n    // update camunda:modelerTemplate attribute\n    updateModelerTemplate(element, newTemplate);\n\n    if (newTemplate) {\n\n      // update camunda:inputOutput\n      updateIoMappings(element, newTemplate);\n\n      // update camunda:field\n      updateCamundaField(element, newTemplate);\n\n      // update camunda:properties\n      updateCamundaProperties(element, newTemplate);\n\n      // update other properties (bpmn:condition, camunda:async, ...)\n      updateProperties(element, newTemplate);\n\n      // update camunda:in and camunda:out\n      updateInOut(element, newTemplate);\n\n      // update camunda:executionListener\n      updateExecutionListener(element, newTemplate);\n\n      // loop on scopes properties\n      forEach(newTemplate.scopes, function(scopeDefinition, scopeName) {\n        updateScopeElements(element, scopeName, scopeDefinition);\n      });\n\n    }\n  };\n}\n\nChangeElementTemplateHandler.$inject = [ 'modeling', 'commandStack', 'bpmnFactory' ];\n\nmodule.exports = ChangeElementTemplateHandler;\n\n\n\n/////// helpers /////////////////////////////\n\nfunction createBpmnPropertyUpdates(template, bpmnFactory) {\n\n  var propertyUpdates = {};\n\n  template.properties.forEach(function(p) {\n\n    var binding = p.binding,\n        bindingTarget = binding.name,\n        propertyValue;\n\n    if (binding.type === 'property') {\n\n      if (bindingTarget === 'conditionExpression') {\n        propertyValue = bpmnFactory.create('bpmn:FormalExpression', {\n          body: p.value,\n          language: binding.scriptFormat\n        });\n      } else {\n        propertyValue = p.value;\n      }\n\n      // assigning camunda:async to true|false\n      // assigning bpmn:conditionExpression to { $type: 'bpmn:FormalExpression', ... }\n      propertyUpdates[bindingTarget] = propertyValue;\n\n      // make sure we unset other \"implementation types\"\n      // when applying a camunda:class template onto a preconfigured\n      // camunda:delegateExpression element\n      if (CAMUNDA_SERVICE_TASK_LIKE.indexOf(bindingTarget) !== -1) {\n        CAMUNDA_SERVICE_TASK_LIKE.forEach(function(prop) {\n          if (prop !== bindingTarget) {\n            propertyUpdates[prop] = undefined;\n          }\n        });\n      }\n    }\n  });\n\n  return propertyUpdates;\n}\n\nfunction createCamundaFieldInjections(template, bpmnFactory) {\n  var injections = [];\n\n  template.properties.forEach(function(p) {\n    var binding = p.binding,\n        bindingType  = binding.type;\n    if (bindingType === 'camunda:field') {\n      injections.push(createCamundaFieldInjection(\n        binding, p.value, bpmnFactory\n      ));\n    }\n  });\n\n  if (injections.length) {\n    return injections;\n  }\n}\n\nfunction createCamundaProperties(template, bpmnFactory) {\n\n  var properties = [];\n\n  template.properties.forEach(function(p) {\n    var binding = p.binding,\n        bindingType  = binding.type;\n\n    if (bindingType === 'camunda:property') {\n      properties.push(createCamundaProperty(\n        binding, p.value, bpmnFactory\n      ));\n    }\n  });\n\n  if (properties.length) {\n    return bpmnFactory.create('camunda:Properties', {\n      values: properties\n    });\n  }\n}\n\nfunction createInputOutputMappings(template, bpmnFactory) {\n\n  var inputParameters = [],\n      outputParameters = [];\n\n  template.properties.forEach(function(p) {\n    var binding = p.binding,\n        bindingType = binding.type;\n\n    if (bindingType === 'camunda:inputParameter') {\n      inputParameters.push(createInputParameter(\n        binding, p.value, bpmnFactory\n      ));\n    }\n\n    if (bindingType === 'camunda:outputParameter') {\n      outputParameters.push(createOutputParameter(\n        binding, p.value, bpmnFactory\n      ));\n    }\n  });\n\n  // do we need to create new ioMappings (?)\n  if (outputParameters.length || inputParameters.length) {\n    return bpmnFactory.create('camunda:InputOutput', {\n      inputParameters: inputParameters,\n      outputParameters: outputParameters\n    });\n  }\n}\n\nfunction createCamundaInOut(template, bpmnFactory) {\n\n  var inOuts = [];\n\n  template.properties.forEach(function(p) {\n    var binding = p.binding,\n        bindingType  = binding.type;\n\n    if (bindingType === 'camunda:in') {\n      inOuts.push(createCamundaIn(\n        binding, p.value, bpmnFactory\n      ));\n    } else\n    if (bindingType === 'camunda:out') {\n      inOuts.push(createCamundaOut(\n        binding, p.value, bpmnFactory\n      ));\n    } else\n    if (bindingType === 'camunda:in:businessKey') {\n      inOuts.push(createCamundaInWithBusinessKey(\n        binding, p.value, bpmnFactory\n      ));\n    }\n  });\n\n  return inOuts;\n}\n\n\nfunction createCamundaExecutionListeners(template, bpmnFactory) {\n\n  var executionListener = [];\n\n  template.properties.forEach(function(p) {\n    var binding = p.binding,\n        bindingType  = binding.type;\n\n    if (bindingType === 'camunda:executionListener') {\n      executionListener.push(createCamundaExecutionListenerScript(\n        binding, p.value, bpmnFactory\n      ));\n    }\n  });\n\n  return executionListener;\n}\n","'use strict';\n\nvar ChangeElementTemplateHandler = require('./ChangeElementTemplateHandler');\n\nvar getTemplate = require('../Helper').getTemplate,\n    getDefaultTemplate = require('../Helper').getDefaultTemplate;\n\nfunction registerHandlers(commandStack, elementTemplates, eventBus, elementRegistry) {\n  commandStack.registerHandler(\n    'propertiesPanel.camunda.changeTemplate',\n    ChangeElementTemplateHandler\n  );\n\n  // apply default element templates on shape creation\n  eventBus.on([ 'commandStack.shape.create.postExecuted' ], function(context) {\n    applyDefaultTemplate(context.context.shape, elementTemplates, commandStack);\n  });\n\n  // apply default element templates on connection creation\n  eventBus.on([ 'commandStack.connection.create.postExecuted' ], function(context) {\n    applyDefaultTemplate(context.context.connection, elementTemplates, commandStack);\n  });\n}\n\nregisterHandlers.$inject = [ 'commandStack', 'elementTemplates', 'eventBus', 'elementRegistry' ];\n\n\nmodule.exports = {\n  __init__: [ registerHandlers ]\n};\n\n\nfunction applyDefaultTemplate(element, elementTemplates, commandStack) {\n\n  if (!getTemplate(element, elementTemplates)\n      && getDefaultTemplate(element, elementTemplates)) {\n\n    var command = 'propertiesPanel.camunda.changeTemplate';\n    var commandContext = {\n      element: element,\n      newTemplate: getDefaultTemplate(element, elementTemplates)\n    };\n\n    commandStack.execute(command, commandContext);\n  }\n}\n","module.exports = {\n  __depends__: [\n    require('./cmd'),\n    require('diagram-js/lib/i18n/translate')\n  ],\n  __init__: [\n    'customElementsPropertiesActivator',\n    'elementTemplatesLoader'\n  ],\n  customElementsPropertiesActivator: [ 'type', require('./CustomElementsPropertiesActivator') ],\n  elementTemplates: [ 'type', require('./ElementTemplates') ],\n  elementTemplatesLoader: [ 'type', require('./ElementTemplatesLoader') ]\n};\n","'use strict';\n\nvar entryFactory = require('../../../../factory/EntryFactory'),\n    is = require('bpmn-js/lib/util/ModelUtil').is,\n    getTemplate = require('../Helper').getTemplate,\n    getTemplateId = require('../Helper').getTemplateId;\n\nvar find = require('lodash/collection/find');\n\nvar TEMPLATE_ATTR = require('../Helper').TEMPLATE_ATTR;\n\nfunction isAny(element, types) {\n  return types.reduce(function(result, type) {\n    return result || is(element, type);\n  }, false);\n}\n\n\nmodule.exports = function(group, element, elementTemplates, translate) {\n\n  var options = getTemplateOptions(element, elementTemplates);\n\n  if (options.length === 1 && !options[0].isDefault) {\n    return;\n  }\n\n  // select element template (via dropdown)\n  group.entries.push(entryFactory.selectBox({\n    id: 'elementTemplate-chooser',\n    label: translate('Element Template'),\n    modelProperty: 'camunda:modelerTemplate',\n    selectOptions: options,\n    set: function(element, properties) {\n      return applyTemplate(element, properties[TEMPLATE_ATTR], elementTemplates);\n    },\n    disabled: function() {\n      var template = getTemplate(element, elementTemplates);\n\n      return template && isDefaultTemplate(template);\n    }\n  }));\n\n};\n\n\n////// helpers //////////////////////////////////////\n\nfunction applyTemplate(element, newTemplateId, elementTemplates) {\n\n  // cleanup\n  // clear input output mappings\n  // undo changes to properties defined in template\n\n  // re-establish\n  // set input output mappings\n  // apply changes to properties as defined in new template\n\n  var oldTemplate = getTemplate(element, elementTemplates),\n      newTemplate = elementTemplates.get(newTemplateId);\n\n  if (oldTemplate === newTemplate) {\n    return;\n  }\n\n  return {\n    cmd: 'propertiesPanel.camunda.changeTemplate',\n    context: {\n      element: element,\n      oldTemplate: oldTemplate,\n      newTemplate: newTemplate\n    }\n  };\n}\n\nfunction getTemplateOptions(element, elementTemplates) {\n\n  var currentTemplateId = getTemplateId(element);\n\n  var emptyOption = {\n    name: '',\n    value: ''\n  };\n\n  var allOptions = elementTemplates.getAll().reduce(function(templates, t) {\n    if (!isAny(element, t.appliesTo)) {\n      return templates;\n    }\n\n    return templates.concat({\n      name: t.name,\n      value: t.id,\n      isDefault: t.isDefault\n    });\n  }, [ emptyOption ]);\n\n\n  var defaultOption = find(allOptions, function(option) {\n    return isDefaultTemplate(option);\n  });\n\n  var currentOption = find(allOptions, function(option) {\n    return option.value === currentTemplateId;\n  });\n\n  if (currentTemplateId && !currentOption) {\n    currentOption = unknownTemplate(currentTemplateId);\n\n    allOptions.push(currentOption);\n  }\n\n  if (!defaultOption) {\n\n    // return all options, including empty\n    // and optionally unknownTemplate option\n    return allOptions;\n  }\n\n  // special limited handling for\n  // default options\n\n  var options = [];\n\n  // current template not set\n  if (!currentTemplateId) {\n    options.push({\n      name: '',\n      value: ''\n    });\n  }\n\n  // current template not default\n  if (currentOption && currentOption !== defaultOption) {\n    options.push(currentOption);\n  }\n\n  options.push(defaultOption);\n\n  // [ (empty), (current), defaultOption ]\n  return options;\n}\n\nfunction unknownTemplate(templateId) {\n  return {\n    name: '[unknown template: ' + templateId + ']',\n    value: templateId\n  };\n}\n\nfunction isDefaultTemplate(elementTemplate) {\n  return elementTemplate.isDefault;\n}","'use strict';\n\nvar assign = require('lodash/object/assign');\n\nvar entryFactory = require('../../../../factory/EntryFactory'),\n    getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject,\n    getTemplate = require('../Helper').getTemplate,\n    cmdHelper = require('../../../../helper/CmdHelper'),\n    elementHelper = require('../../../../helper/ElementHelper');\n\nvar findExtension = require('../Helper').findExtension,\n    findExtensions = require('../Helper').findExtensions,\n    findInputParameter = require('../Helper').findInputParameter,\n    findOutputParameter = require('../Helper').findOutputParameter,\n    findCamundaProperty = require('../Helper').findCamundaProperty,\n    findCamundaInOut = require('../Helper').findCamundaInOut;\n\nvar createCamundaProperty = require('../CreateHelper').createCamundaProperty,\n    createInputParameter = require('../CreateHelper').createInputParameter,\n    createOutputParameter = require('../CreateHelper').createOutputParameter,\n    createCamundaIn = require('../CreateHelper').createCamundaIn,\n    createCamundaOut = require('../CreateHelper').createCamundaOut,\n    createCamundaInWithBusinessKey = require('../CreateHelper').createCamundaInWithBusinessKey,\n    createCamundaFieldInjection = require('../CreateHelper').createCamundaFieldInjection;\n\nvar CAMUNDA_PROPERTY_TYPE = 'camunda:property',\n    CAMUNDA_INPUT_PARAMETER_TYPE = 'camunda:inputParameter',\n    CAMUNDA_OUTPUT_PARAMETER_TYPE = 'camunda:outputParameter',\n    CAMUNDA_IN_TYPE = 'camunda:in',\n    CAMUNDA_OUT_TYPE = 'camunda:out',\n    CAMUNDA_IN_BUSINESS_KEY_TYPE = 'camunda:in:businessKey',\n    CAMUNDA_EXECUTION_LISTENER_TYPE = 'camunda:executionListener',\n    CAMUNDA_FIELD = 'camunda:field';\n\nvar BASIC_MODDLE_TYPES = [\n  'Boolean',\n  'Integer',\n  'String'\n];\n\nvar EXTENSION_BINDING_TYPES = [\n  CAMUNDA_PROPERTY_TYPE,\n  CAMUNDA_INPUT_PARAMETER_TYPE,\n  CAMUNDA_OUTPUT_PARAMETER_TYPE,\n  CAMUNDA_IN_TYPE,\n  CAMUNDA_OUT_TYPE,\n  CAMUNDA_IN_BUSINESS_KEY_TYPE,\n  CAMUNDA_FIELD\n];\n\nvar IO_BINDING_TYPES = [\n  CAMUNDA_INPUT_PARAMETER_TYPE,\n  CAMUNDA_OUTPUT_PARAMETER_TYPE\n];\n\nvar IN_OUT_BINDING_TYPES = [\n  CAMUNDA_IN_TYPE,\n  CAMUNDA_OUT_TYPE,\n  CAMUNDA_IN_BUSINESS_KEY_TYPE\n];\n\n/**\n * Injects custom properties into the given group.\n *\n * @param {GroupDescriptor} group\n * @param {djs.model.Base} element\n * @param {ElementTemplates} elementTemplates\n * @param {BpmnFactory} bpmnFactory\n */\nmodule.exports = function(element, elementTemplates, bpmnFactory, translate) {\n\n  var template = getTemplate(element, elementTemplates);\n\n  if (!template) {\n    return [];\n  }\n\n  var renderCustomField = function(id, p, idx) {\n    var propertyType = p.type;\n\n    var entryOptions = {\n      id: id,\n      description: p.description,\n      label: p.label,\n      modelProperty: id,\n      get: propertyGetter(id, p),\n      set: propertySetter(id, p, bpmnFactory),\n      validate: propertyValidator(id, p)\n    };\n\n    var entry;\n\n    if (propertyType === 'Boolean') {\n      entry = entryFactory.checkbox(entryOptions);\n    }\n\n    if (propertyType === 'String') {\n      entry = entryFactory.textField(entryOptions);\n    }\n\n    if (propertyType === 'Text') {\n      entry = entryFactory.textBox(entryOptions);\n    }\n\n    if (propertyType === 'Dropdown') {\n      entryOptions.selectOptions = p.choices;\n\n      entry = entryFactory.selectBox(entryOptions);\n    }\n\n    return entry;\n  };\n\n  var groups = [];\n  var id, entry;\n\n  var customFieldsGroup = {\n    id: 'customField',\n    label: translate('Custom Fields'),\n    entries: []\n  };\n  template.properties.forEach(function(p, idx) {\n\n    id = 'custom-' + template.id + '-' + idx;\n\n    entry = renderCustomField(id, p, idx);\n    if (entry) {\n      customFieldsGroup.entries.push(entry);\n    }\n  });\n  if (customFieldsGroup.entries.length > 0) {\n    groups.push(customFieldsGroup);\n  }\n\n  if (template.scopes) {\n    for (var scopeName in template.scopes) {\n\n      var scope = template.scopes[scopeName];\n      var idScopeName = scopeName.replace(/:/g, '_');\n\n      var customScopeFieldsGroup = {\n        id: 'customField-' + idScopeName,\n        label: translate('Custom Fields for scope: ') + scopeName,\n        entries: []\n      };\n\n      scope.properties.forEach(function(p, idx) {\n\n        var propertyId = 'custom-' + template.id + '-' + idScopeName + '-' + idx;\n\n        var scopedProperty = propertyWithScope(p, scopeName);\n\n        entry = renderCustomField(propertyId, scopedProperty, idx);\n        if (entry) {\n          customScopeFieldsGroup.entries.push(entry);\n        }\n      });\n\n      if (customScopeFieldsGroup.entries.length > 0) {\n        groups.push(customScopeFieldsGroup);\n      }\n    }\n  }\n\n  return groups;\n};\n\n\n/////// getters, setters and validators ///////////////\n\n\n/**\n * Return a getter that retrieves the given property.\n *\n * @param {String} name\n * @param {PropertyDescriptor} property\n *\n * @return {Function}\n */\nfunction propertyGetter(name, property) {\n\n  /* getter */\n  return function get(element) {\n    var value = getPropertyValue(element, property);\n\n    return objectWithKey(name, value);\n  };\n}\n\n/**\n * Return a setter that updates the given property.\n *\n * @param {String} name\n * @param {PropertyDescriptor} property\n * @param {BpmnFactory} bpmnFactory\n *\n * @return {Function}\n */\nfunction propertySetter(name, property, bpmnFactory) {\n\n  /* setter */\n  return function set(element, values) {\n\n    var value = values[name];\n\n    return setPropertyValue(element, property, value, bpmnFactory);\n  };\n}\n\n/**\n * Return a validator that ensures the property is ok.\n *\n * @param {String} name\n * @param {PropertyDescriptor} property\n *\n * @return {Function}\n */\nfunction propertyValidator(name, property) {\n\n  /* validator */\n  return function validate(element, values) {\n    var value = values[name];\n\n    var error = validateValue(value, property);\n\n    if (error) {\n      return objectWithKey(name, error);\n    }\n  };\n}\n\n\n//////// get, set and validate helpers ///////////////////\n\n/**\n * Return the value of the specified property descriptor,\n * on the passed diagram element.\n *\n * @param {djs.model.Base} element\n * @param {PropertyDescriptor} property\n *\n * @return {Any}\n */\nfunction getPropertyValue(element, property) {\n\n  var bo = getBusinessObject(element);\n\n  var binding = property.binding,\n      scope = property.scope;\n\n  var bindingType = binding.type,\n      bindingName = binding.name;\n\n  var propertyValue = property.value || '';\n\n  if (scope) {\n    bo = findExtension(bo, scope.name);\n    if (!bo) {\n      return propertyValue;\n    }\n  }\n\n  // property\n  if (bindingType === 'property') {\n\n    var value = bo.get(bindingName);\n\n    if (bindingName === 'conditionExpression') {\n      if (value) {\n        return value.body;\n      } else {\n        // return defined default\n        return propertyValue;\n      }\n    } else {\n      // return value; default to defined default\n      return typeof value !== 'undefined' ? value : propertyValue;\n    }\n  }\n\n  var camundaProperties,\n      camundaProperty;\n\n  if (bindingType === CAMUNDA_PROPERTY_TYPE) {\n    if (scope) {\n      camundaProperties = bo.get('properties');\n    } else {\n      camundaProperties = findExtension(bo, 'camunda:Properties');\n    }\n\n    if (camundaProperties) {\n      camundaProperty = findCamundaProperty(camundaProperties, binding);\n\n      if (camundaProperty) {\n        return camundaProperty.value;\n      }\n    }\n\n    return propertyValue;\n  }\n\n  var inputOutput,\n      ioParameter;\n\n  if (IO_BINDING_TYPES.indexOf(bindingType) !== -1) {\n\n    if (scope) {\n      inputOutput = bo.get('inputOutput');\n    } else {\n      inputOutput = findExtension(bo, 'camunda:InputOutput');\n    }\n\n    if (!inputOutput) {\n      // ioParameter cannot exist yet, return property value\n      return propertyValue;\n    }\n  }\n\n  // camunda input parameter\n  if (bindingType === CAMUNDA_INPUT_PARAMETER_TYPE) {\n    ioParameter = findInputParameter(inputOutput, binding);\n\n    if (ioParameter) {\n      if (binding.scriptFormat) {\n        if (ioParameter.definition) {\n          return ioParameter.definition.value;\n        }\n      } else {\n        return ioParameter.value || '';\n      }\n    }\n\n    return propertyValue;\n  }\n\n  // camunda output parameter\n  if (binding.type === CAMUNDA_OUTPUT_PARAMETER_TYPE) {\n    ioParameter = findOutputParameter(inputOutput, binding);\n\n    if (ioParameter) {\n      return ioParameter.name;\n    }\n\n    return propertyValue;\n  }\n\n\n  var ioElement;\n\n  if (IN_OUT_BINDING_TYPES.indexOf(bindingType) != -1) {\n    ioElement = findCamundaInOut(bo, binding);\n\n    if (ioElement) {\n      if (bindingType === CAMUNDA_IN_BUSINESS_KEY_TYPE) {\n        return ioElement.businessKey;\n      } else\n      if (bindingType === CAMUNDA_OUT_TYPE) {\n        return ioElement.target;\n      } else\n      if (bindingType === CAMUNDA_IN_TYPE) {\n        return ioElement[binding.expression ? 'sourceExpression' : 'source'];\n      }\n    }\n\n    return propertyValue;\n  }\n\n  if (bindingType === CAMUNDA_EXECUTION_LISTENER_TYPE) {\n    var executionListener;\n    if (scope) {\n      executionListener = bo.get('executionListener');\n    } else {\n      executionListener = findExtension(bo, 'camunda:ExecutionListener');\n    }\n\n    return executionListener.script.value;\n  }\n\n  var fieldInjection;\n  if (CAMUNDA_FIELD === bindingType) {\n    var fieldInjections = findExtensions(bo, [ 'camunda:Field' ]);\n    fieldInjections.forEach(function(item) {\n      if (item.name === binding.name) {\n        fieldInjection = item;\n      }\n    });\n    if (fieldInjection) {\n      return fieldInjection.string || fieldInjection.expression;\n    } else {\n      return '';\n    }\n  }\n\n  throw unknownPropertyBinding(property);\n}\n\nmodule.exports.getPropertyValue = getPropertyValue;\n\n\n/**\n * Return an update operation that changes the diagram\n * element's custom property to the given value.\n *\n * The response of this method will be processed via\n * {@link PropertiesPanel#applyChanges}.\n *\n * @param {djs.model.Base} element\n * @param {PropertyDescriptor} property\n * @param {String} value\n * @param {BpmnFactory} bpmnFactory\n *\n * @return {Object|Array<Object>} results to be processed\n */\nfunction setPropertyValue(element, property, value, bpmnFactory) {\n  var bo = getBusinessObject(element);\n\n  var binding = property.binding,\n      scope = property.scope;\n\n  var bindingType = binding.type,\n      bindingName = binding.name;\n\n  var propertyValue;\n\n  var updates = [];\n\n  var extensionElements;\n\n  if (EXTENSION_BINDING_TYPES.indexOf(bindingType) !== -1) {\n    extensionElements = bo.get('extensionElements');\n\n    // create extension elements, if they do not exist (yet)\n    if (!extensionElements) {\n      extensionElements = elementHelper.createElement('bpmn:ExtensionElements', null, element, bpmnFactory);\n\n      updates.push(cmdHelper.updateBusinessObject(\n        element, bo, objectWithKey('extensionElements', extensionElements)\n      ));\n    }\n  }\n\n  if (scope) {\n    bo = findExtension(bo, scope.name);\n    if (!bo) {\n      bo = elementHelper.createElement(scope.name, null, element, bpmnFactory);\n\n      updates.push(cmdHelper.addElementsTolist(\n        bo, extensionElements, 'values', [ bo ]\n      ));\n    }\n  }\n\n  // property\n  if (bindingType === 'property') {\n\n    if (bindingName === 'conditionExpression') {\n\n      propertyValue = elementHelper.createElement('bpmn:FormalExpression', {\n        body: value,\n        language: binding.scriptFormat\n      }, bo, bpmnFactory);\n    } else {\n\n      var moddlePropertyDescriptor = bo.$descriptor.propertiesByName[bindingName];\n\n      var moddleType = moddlePropertyDescriptor.type;\n\n      // make sure we only update String, Integer, Real and\n      // Boolean properties (do not accidentally override complex objects...)\n      if (BASIC_MODDLE_TYPES.indexOf(moddleType) === -1) {\n        throw new Error('cannot set moddle type <' + moddleType + '>');\n      }\n\n      if (moddleType === 'Boolean') {\n        propertyValue = !!value;\n      } else\n      if (moddleType === 'Integer') {\n        propertyValue = parseInt(value, 10);\n\n        if (isNaN(propertyValue)) {\n          // do not write NaN value\n          propertyValue = undefined;\n        }\n      } else {\n        propertyValue = value;\n      }\n    }\n\n    if (propertyValue !== undefined) {\n      updates.push(cmdHelper.updateBusinessObject(\n        element, bo, objectWithKey(bindingName, propertyValue)\n      ));\n    }\n  }\n\n  // camunda:property\n  var camundaProperties,\n      existingCamundaProperty,\n      newCamundaProperty;\n\n  if (bindingType === CAMUNDA_PROPERTY_TYPE) {\n\n    if (scope) {\n      camundaProperties = bo.get('properties');\n    } else {\n      camundaProperties = findExtension(extensionElements, 'camunda:Properties');\n    }\n\n    if (!camundaProperties) {\n      camundaProperties = elementHelper.createElement('camunda:Properties', null, bo, bpmnFactory);\n\n      if (scope) {\n        updates.push(cmdHelper.updateBusinessObject(\n          element, bo, { properties: camundaProperties }\n        ));\n      }\n      else {\n        updates.push(cmdHelper.addElementsTolist(\n          element, extensionElements, 'values', [ camundaProperties ]\n        ));\n      }\n    }\n\n    existingCamundaProperty = findCamundaProperty(camundaProperties, binding);\n\n    newCamundaProperty = createCamundaProperty(binding, value, bpmnFactory);\n\n    updates.push(cmdHelper.addAndRemoveElementsFromList(\n      element,\n      camundaProperties,\n      'values',\n      null,\n      [ newCamundaProperty ],\n      existingCamundaProperty ? [ existingCamundaProperty ] : []\n    ));\n  }\n\n  // camunda:inputParameter\n  // camunda:outputParameter\n  var inputOutput,\n      existingIoParameter,\n      newIoParameter;\n\n  if (IO_BINDING_TYPES.indexOf(bindingType) !== -1) {\n\n    if (scope) {\n      inputOutput = bo.get('inputOutput');\n    } else {\n      inputOutput = findExtension(extensionElements, 'camunda:InputOutput');\n    }\n\n    // create inputOutput element, if it do not exist (yet)\n    if (!inputOutput) {\n      inputOutput = elementHelper.createElement('camunda:InputOutput', null, bo, bpmnFactory);\n\n      if (scope) {\n        updates.push(cmdHelper.updateBusinessObject(\n          element, bo, { inputOutput: inputOutput }\n        ));\n      }\n      else {\n        updates.push(cmdHelper.addElementsTolist(\n          element, extensionElements, 'values', inputOutput\n        ));\n      }\n    }\n  }\n\n  if (bindingType === CAMUNDA_INPUT_PARAMETER_TYPE) {\n\n    existingIoParameter = findInputParameter(inputOutput, binding);\n\n    newIoParameter = createInputParameter(binding, value, bpmnFactory);\n\n    updates.push(cmdHelper.addAndRemoveElementsFromList(\n      element,\n      inputOutput,\n      'inputParameters',\n      null,\n      [ newIoParameter ],\n      existingIoParameter ? [ existingIoParameter ] : []\n    ));\n  }\n\n  if (bindingType === CAMUNDA_OUTPUT_PARAMETER_TYPE) {\n\n    existingIoParameter = findOutputParameter(inputOutput, binding);\n\n    newIoParameter = createOutputParameter(binding, value, bpmnFactory);\n\n    updates.push(cmdHelper.addAndRemoveElementsFromList(\n      element,\n      inputOutput,\n      'outputParameters',\n      null,\n      [ newIoParameter ],\n      existingIoParameter ? [ existingIoParameter ] : []\n    ));\n  }\n\n\n  // camunda:in\n  // camunda:out\n  // camunda:in:businessKey\n  var existingInOut,\n      newInOut;\n\n  if (IN_OUT_BINDING_TYPES.indexOf(bindingType) !== -1) {\n\n    existingInOut = findCamundaInOut(bo, binding);\n\n    if (bindingType === CAMUNDA_IN_TYPE) {\n      newInOut = createCamundaIn(binding, value, bpmnFactory);\n    } else\n    if (bindingType === CAMUNDA_OUT_TYPE) {\n      newInOut = createCamundaOut(binding, value, bpmnFactory);\n    } else {\n      newInOut = createCamundaInWithBusinessKey(binding, value, bpmnFactory);\n    }\n\n    updates.push(cmdHelper.addAndRemoveElementsFromList(\n      element,\n      extensionElements,\n      'values',\n      null,\n      [ newInOut ],\n      existingInOut ? [ existingInOut ] : []\n    ));\n  }\n\n  if (bindingType === CAMUNDA_FIELD) {\n    var existingFieldInjections = findExtensions(bo, [ 'camunda:Field' ]);\n    var newFieldInjections = [];\n    \n    if (existingFieldInjections.length > 0) {\n      existingFieldInjections.forEach(function(item) {\n        if (item.name === binding.name) {\n          newFieldInjections.push(createCamundaFieldInjection(binding, value, bpmnFactory));\n        } else {\n          newFieldInjections.push(item);\n        }\n      });\n    } else {\n      newFieldInjections.push(createCamundaFieldInjection(binding, value, bpmnFactory));\n    }\n\n    updates.push(cmdHelper.addAndRemoveElementsFromList(\n      element,\n      extensionElements,\n      'values',\n      null,\n      newFieldInjections,\n      existingFieldInjections ? existingFieldInjections : []\n    ));\n  }\n\n  if (updates.length) {\n    return updates;\n  }\n\n  // quick warning for better debugging\n  console.warn('no update', element, property, value);\n}\n\n/**\n * Validate value of a given property.\n *\n * @param {String} value\n * @param {PropertyDescriptor} property\n *\n * @return {Object} with validation errors\n */\nfunction validateValue(value, property) {\n\n  var constraints = property.constraints || {};\n\n  if (constraints.notEmpty && isEmpty(value)) {\n    return 'Must not be empty';\n  }\n\n  if (constraints.maxLength && value.length > constraints.maxLength) {\n    return 'Must have max length ' + constraints.maxLength;\n  }\n\n  if (constraints.minLength && value.length < constraints.minLength) {\n    return 'Must have min length ' + constraints.minLength;\n  }\n\n  var pattern = constraints.pattern,\n      message;\n\n  if (pattern) {\n\n    if (typeof pattern !== 'string') {\n      message = pattern.message;\n      pattern = pattern.value;\n    }\n\n    if (!matchesPattern(value, pattern)) {\n      return message || 'Must match pattern ' + pattern;\n    }\n  }\n}\n\n\n//////// misc helpers ///////////////////////////////\n\nfunction propertyWithScope(property, scopeName) {\n  if (!scopeName) {\n    return property;\n  }\n\n  return assign({}, property, {\n    scope: {\n      name: scopeName\n    }\n  });\n}\n\n/**\n * Return an object with a single key -> value association.\n *\n * @param {String} key\n * @param {Any} value\n *\n * @return {Object}\n */\nfunction objectWithKey(key, value) {\n  var obj = {};\n\n  obj[key] = value;\n\n  return obj;\n}\n\n/**\n * Does the given string match the specified pattern?\n *\n * @param {String} str\n * @param {String} pattern\n *\n * @return {Boolean}\n */\nfunction matchesPattern(str, pattern) {\n  var regexp = new RegExp(pattern);\n\n  return regexp.test(str);\n}\n\nfunction isEmpty(str) {\n  return !str || /^\\s*$/.test(str);\n}\n\n/**\n * Create a new {@link Error} indicating an unknown\n * property binding.\n *\n * @param {PropertyDescriptor} property\n *\n * @return {Error}\n */\nfunction unknownPropertyBinding(property) {\n  var binding = property.binding;\n\n  return new Error('unknown binding: <' + binding.type + '>');\n}\n","module.exports = {\n  __depends__: [\n    require('./element-templates'),\n    require('diagram-js/lib/i18n/translate')\n  ],\n  __init__: [ 'propertiesProvider' ],\n  propertiesProvider: [ 'type', require('./CamundaPropertiesProvider') ]\n};\n","'use strict';\n\nvar getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject,\n    is = require('bpmn-js/lib/util/ModelUtil').is,\n    asyncContinuation = require('./implementation/AsyncContinuation');\n\nmodule.exports = function(group, element, bpmnFactory, translate) {\n\n  if (is(element, 'camunda:AsyncCapable')) {\n\n    group.entries = group.entries.concat(asyncContinuation(element, bpmnFactory, {\n      getBusinessObject: getBusinessObject\n    }, translate));\n\n  }\n};","'use strict';\n\nvar getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject,\n    is = require('bpmn-js/lib/util/ModelUtil').is;\n\nvar entryFactory = require('../../../factory/EntryFactory');\n\nvar callable = require('./implementation/Callable');\n\nvar cmdHelper = require('../../../helper/CmdHelper');\n\nvar flattenDeep = require('lodash/array/flattenDeep');\nvar assign = require('lodash/object/assign');\n\nfunction getCallableType(element) {\n  var bo = getBusinessObject(element);\n\n  var boCalledElement = bo.get('calledElement'),\n      boCaseRef = bo.get('camunda:caseRef');\n\n  var callActivityType = '';\n  if (typeof boCalledElement !== 'undefined') {\n    callActivityType = 'bpmn';\n  } else\n\n  if (typeof boCaseRef !== 'undefined') {\n    callActivityType = 'cmmn';\n  }\n\n  return callActivityType;\n}\n\nvar DEFAULT_PROPS = {\n  calledElement: undefined,\n  'camunda:calledElementBinding': 'latest',\n  'camunda:calledElementVersion': undefined,\n  'camunda:calledElementTenantId': undefined,\n  'camunda:variableMappingClass' : undefined,\n  'camunda:variableMappingDelegateExpression' : undefined,\n  'camunda:caseRef': undefined,\n  'camunda:caseBinding': 'latest',\n  'camunda:caseVersion': undefined,\n  'camunda:caseTenantId': undefined\n};\n\nmodule.exports = function(group, element, bpmnFactory, translate) {\n\n  if (!is(element, 'camunda:CallActivity')) {\n    return;\n  }\n\n  group.entries.push(entryFactory.selectBox({\n    id : 'callActivity',\n    label: translate('CallActivity Type'),\n    selectOptions: [\n      { name: 'BPMN', value: 'bpmn' },\n      { name: 'CMMN', value: 'cmmn' }\n    ],\n    emptyParameter: true,\n    modelProperty: 'callActivityType',\n\n    get: function(element, node) {\n      return {\n        callActivityType: getCallableType(element)\n      };\n    },\n\n    set: function(element, values, node) {\n      var type = values.callActivityType;\n\n      var props = assign({}, DEFAULT_PROPS);\n\n      if (type === 'bpmn') {\n        props.calledElement = '';\n      }\n      else if (type === 'cmmn') {\n        props['camunda:caseRef'] = '';\n      }\n\n      return cmdHelper.updateProperties(element, props);\n    }\n\n  }));\n\n  group.entries.push(callable(element, bpmnFactory, {\n    getCallableType: getCallableType\n  }, translate));\n\n  group.entries = flattenDeep(group.entries);\n};\n","'use strict';\n\nvar ImplementationTypeHelper = require('../../../helper/ImplementationTypeHelper'),\n    InputOutputHelper        = require('../../../helper/InputOutputHelper');\n\nvar entryFactory            = require('../../../factory/EntryFactory'),\n    cmdHelper               = require('../../../helper/CmdHelper');\n\nfunction getImplementationType(element) {\n  return ImplementationTypeHelper.getImplementationType(element);\n}\n\nfunction getBusinessObject(element) {\n  return ImplementationTypeHelper.getServiceTaskLikeBusinessObject(element);\n}\n\nfunction getConnector(bo) {\n  return InputOutputHelper.getConnector(bo);\n}\n\nfunction isConnector(element) {\n  return getImplementationType(element) === 'connector';\n}\n\nmodule.exports = function(group, element, bpmnFactory, translate) {\n\n  group.entries.push(entryFactory.textField({\n    id: 'connectorId',\n    label: translate('Connector Id'),\n    modelProperty: 'connectorId',\n\n    get: function(element, node) {\n      var bo = getBusinessObject(element);\n      var connector = bo && getConnector(bo);\n      var value = connector && connector.get('connectorId');\n      return { connectorId: value };\n    },\n\n    set: function(element, values, node) {\n      var bo = getBusinessObject(element);\n      var connector = getConnector(bo);\n      return cmdHelper.updateBusinessObject(element, connector, {\n        connectorId: values.connectorId || undefined\n      });\n    },\n\n    validate: function(element, values, node) {\n      return isConnector(element) && !values.connectorId ? { connectorId: translate('Must provide a value') } : {};\n    },\n\n    hidden: function(element, node) {\n      return !isConnector(element);\n    }\n\n  }));\n\n};\n","'use strict';\n\nvar assign = require('lodash/object/assign');\n\nvar inputOutputParameter = require('./implementation/InputOutputParameter');\n\nmodule.exports = function(group, element, bpmnFactory, options, translate) {\n\n  options = assign({\n    idPrefix: 'connector-',\n    insideConnector: true\n  }, options);\n\n  group.entries = group.entries.concat(inputOutputParameter(element, bpmnFactory, options, translate));\n\n};\n","'use strict';\n\nvar inputOutput = require('./implementation/InputOutput');\n\nmodule.exports = function(group, element, bpmnFactory, translate) {\n\n  var inputOutputEntry = inputOutput(element, bpmnFactory, {\n    idPrefix: 'connector-',\n    insideConnector: true\n  }, translate);\n\n  group.entries = group.entries.concat(inputOutputEntry.entries);\n\n  return {\n    getSelectedParameter: inputOutputEntry.getSelectedParameter\n  };\n\n};\n","'use strict';\n\nvar is = require('bpmn-js/lib/util/ModelUtil').is,\n    getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject;\n\nvar ImplementationTypeHelper = require('../../../helper/ImplementationTypeHelper');\n\nvar externalTaskPriority = require('./implementation/ExternalTaskPriority');\n\nfunction getServiceTaskLikeBusinessObject(element) {\n  var bo = ImplementationTypeHelper.getServiceTaskLikeBusinessObject(element);\n\n  // if the element is not a serviceTaskLike element, fetch the normal business object\n  // This avoids the loss of the process / participant business object\n  if (!bo) {\n    bo = getBusinessObject(element);\n  }\n\n  return bo;\n}\n\nmodule.exports = function(group, element, bpmnFactory, translate) {\n\n  var bo = getServiceTaskLikeBusinessObject(element);\n\n  if (!bo) {\n    return;\n  }\n\n  if (is(bo, 'camunda:TaskPriorized') || (is(bo, 'bpmn:Participant')) && bo.get('processRef')) {\n    group.entries = group.entries.concat(externalTaskPriority(element, bpmnFactory, {\n      getBusinessObject: function(element) {\n        if (!is(bo, 'bpmn:Participant')) {\n          return bo;\n        }\n        return bo.get('processRef');\n      }\n    }, translate));\n  }\n};","'use strict';\n\nvar ImplementationTypeHelper = require('../../../helper/ImplementationTypeHelper');\n\nvar fieldInjection = require('./implementation/FieldInjection');\n\nmodule.exports = function(group, element, bpmnFactory, translate) {\n\n  var bo = ImplementationTypeHelper.getServiceTaskLikeBusinessObject(element);\n\n  if (!bo) {\n    return;\n  }\n\n  var fieldInjectionEntry = fieldInjection(element, bpmnFactory, translate, { businessObject: bo });\n\n  if (fieldInjectionEntry && fieldInjectionEntry.length > 0) {\n    group.entries = group.entries.concat(fieldInjectionEntry);\n  }\n\n};\n","'use strict';\n\nvar getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject,\n    getExtensionElements = require('../../../helper/ExtensionElementsHelper').getExtensionElements,\n    extensionElements = require('./implementation/ExtensionElements'),\n    properties = require('./implementation/Properties'),\n    entryFactory = require('../../../factory/EntryFactory'),\n    elementHelper = require('../../../helper/ElementHelper'),\n    cmdHelper = require('../../../helper/CmdHelper'),\n    formHelper = require('../../../helper/FormHelper'),\n    utils = require('../../../Utils'),\n    is = require('bpmn-js/lib/util/ModelUtil').is,\n    find = require('lodash/collection/find'),\n    each = require('lodash/collection/forEach');\n\nfunction generateValueId() {\n  return utils.nextId('Value_');\n}\n\n/**\n * Generate a form field specific textField using entryFactory.\n *\n * @param  {string} options.id\n * @param  {string} options.label\n * @param  {string} options.modelProperty\n * @param  {function} options.validate\n *\n * @return {Object} an entryFactory.textField object\n */\nfunction formFieldTextField(options, getSelectedFormField) {\n\n  var id = options.id,\n      label = options.label,\n      modelProperty = options.modelProperty,\n      validate = options.validate;\n\n  return entryFactory.textField({\n    id: id,\n    label: label,\n    modelProperty: modelProperty,\n    get: function(element, node) {\n      var selectedFormField = getSelectedFormField(element, node) || {},\n          values = {};\n\n      values[modelProperty] = selectedFormField[modelProperty];\n\n      return values;\n    },\n\n    set: function(element, values, node) {\n      var commands = [];\n\n      if (typeof options.set === 'function') {\n        var cmd = options.set(element, values, node);\n\n        if (cmd) {\n          commands.push(cmd);\n        }\n      }\n\n      var formField = getSelectedFormField(element, node),\n          properties = {};\n\n      properties[modelProperty] = values[modelProperty] || undefined;\n\n      commands.push(cmdHelper.updateBusinessObject(element, formField, properties));\n\n      return commands;\n    },\n    hidden: function(element, node) {\n      return !getSelectedFormField(element, node);\n    },\n    validate: validate\n  });\n}\n\nfunction ensureFormKeyAndDataSupported(element) {\n  return (is(element, 'bpmn:StartEvent') && !is(element.parent, 'bpmn:SubProcess')) ||\n      is(element, 'bpmn:UserTask');\n}\n\nmodule.exports = function(group, element, bpmnFactory, translate) {\n\n  if (!ensureFormKeyAndDataSupported(element)) {\n    return;\n  }\n\n\n  /**\n   * Return the currently selected form field querying the form field select box\n   * from the DOM.\n   *\n   * @param  {djs.model.Base} element\n   * @param  {DOMElement} node - DOM element of any form field text input\n   *\n   * @return {ModdleElement} the currently selected form field\n   */\n  function getSelectedFormField(element, node) {\n    var selected = formFieldsEntry.getSelected(element, node.parentNode);\n\n    if (selected.idx === -1) {\n      return;\n    }\n\n    return formHelper.getFormField(element, selected.idx);\n  }\n\n  //[FormKey] form key text input field\n  group.entries.push(entryFactory.textField({\n    id : 'form-key',\n    label : translate('Form Key'),\n    modelProperty: 'formKey',\n    get: function(element, node) {\n      var bo = getBusinessObject(element);\n\n      return {\n        formKey: bo.get('camunda:formKey')\n      };\n    },\n    set: function(element, values, node) {\n      var bo = getBusinessObject(element),\n          formKey = values.formKey || undefined;\n\n      return cmdHelper.updateBusinessObject(element, bo, { 'camunda:formKey': formKey });\n    }\n  }));\n\n  // [FormData] form field select box\n  var formFieldsEntry = extensionElements(element, bpmnFactory, {\n    id: 'form-fields',\n    label: translate('Form Fields'),\n    modelProperty: 'id',\n    prefix: 'FormField',\n    createExtensionElement: function(element, extensionElements, value) {\n      var bo = getBusinessObject(element), commands = [];\n\n      if (!extensionElements) {\n        extensionElements = elementHelper.createElement('bpmn:ExtensionElements', { values: [] }, bo, bpmnFactory);\n        commands.push(cmdHelper.updateProperties(element, { extensionElements: extensionElements }));\n      }\n\n      var formData = formHelper.getFormData(element);\n\n      if (!formData) {\n        formData = elementHelper.createElement('camunda:FormData', { fields: [] }, extensionElements, bpmnFactory);\n        commands.push(cmdHelper.addAndRemoveElementsFromList(\n            element,\n            extensionElements,\n            'values',\n            'extensionElements',\n            [formData],\n            []\n        ));\n      }\n\n      var field = elementHelper.createElement('camunda:FormField', { id: value }, formData, bpmnFactory);\n      if (typeof formData.fields !== 'undefined') {\n        commands.push(cmdHelper.addElementsTolist(element, formData, 'fields', [ field ]));\n      } else {\n        commands.push(cmdHelper.updateBusinessObject(element, formData, {\n          fields: [ field ]\n        }));\n      }\n      return commands;\n    },\n    removeExtensionElement: function(element, extensionElements, value, idx) {\n      var formData = getExtensionElements(getBusinessObject(element), 'camunda:FormData')[0],\n          entry = formData.fields[idx],\n          commands = [];\n\n      commands.push(cmdHelper.removeElementsFromList(element, formData, 'fields', null, [entry]));\n\n      if (entry.id === formData.get('businessKey')) {\n        commands.push(cmdHelper.updateBusinessObject(element, formData, { 'businessKey': undefined }));\n      }\n\n      return commands;\n    },\n    getExtensionElements: function(element) {\n      return formHelper.getFormFields(element);\n    },\n    hideExtensionElements: function(element, node) {\n      return false;\n    }\n  });\n  group.entries.push(formFieldsEntry);\n\n  // [FormData] business key form field select box\n  var formBusinessKeyFormFieldEntry = entryFactory.selectBox({\n    id: 'form-business-key',\n    label: translate('Business Key'),\n    modelProperty: 'businessKey',\n    selectOptions: function(element, inputNode) {\n      var selectOptions = [{ name: '', value: '' }];\n      var formFields = formHelper.getFormFields(element);\n      each(formFields, function(field) {\n        if (field.type !== 'boolean') {\n          selectOptions.push({ name: field.id, value: field.id });\n        }\n      });\n      return selectOptions;\n    },\n    get: function(element, node) {\n      var result = { businessKey: '' };\n      var bo = getBusinessObject(element);\n      var formDataExtension = getExtensionElements(bo, 'camunda:FormData');\n      if (formDataExtension) {\n        var formData = formDataExtension[0];\n        var storedValue = formData.get('businessKey');\n        result = { businessKey: storedValue };\n      }\n      return result;\n    },\n    set: function(element, values, node) {\n      var formData = getExtensionElements(getBusinessObject(element), 'camunda:FormData')[0];\n      return cmdHelper.updateBusinessObject(element, formData, { 'businessKey': values.businessKey || undefined });\n    },\n    hidden: function(element, node) {\n      var isStartEvent = is(element,'bpmn:StartEvent');\n      return !(isStartEvent && formHelper.getFormFields(element).length > 0);\n    }\n  });\n  group.entries.push(formBusinessKeyFormFieldEntry);\n\n  // [FormData] Form Field label\n  group.entries.push(entryFactory.label({\n    id: 'form-field-header',\n    labelText: translate('Form Field'),\n    showLabel: function(element, node) {\n      return !!getSelectedFormField(element, node);\n    }\n  }));\n\n  // [FormData] form field id text input field\n  group.entries.push(entryFactory.validationAwareTextField({\n    id: 'form-field-id',\n    label: translate('ID'),\n    modelProperty: 'id',\n\n    getProperty: function(element, node) {\n      var selectedFormField = getSelectedFormField(element, node) || {};\n\n      return selectedFormField.id;\n    },\n\n    setProperty: function(element, properties, node) {\n      var formField = getSelectedFormField(element, node);\n\n      return cmdHelper.updateBusinessObject(element, formField, properties);\n    },\n\n    hidden: function(element, node) {\n      return !getSelectedFormField(element, node);\n    },\n\n    validate: function(element, values, node) {\n\n      var formField = getSelectedFormField(element, node);\n\n      if (formField) {\n\n        var idValue = values.id;\n\n        if (!idValue || idValue.trim() === '') {\n          return { id: 'Form field id must not be empty' };\n        }\n\n        var formFields = formHelper.getFormFields(element);\n\n        var existingFormField = find(formFields, function(f) {\n          return f !== formField && f.id === idValue;\n        });\n\n        if (existingFormField) {\n          return { id: 'Form field id already used in form data.' };\n        }\n      }\n    }\n  }));\n\n  // [FormData] form field type combo box\n  group.entries.push(entryFactory.comboBox({\n    id: 'form-field-type',\n    label: translate('Type'),\n    selectOptions: [\n      { name: 'string', value: 'string' },\n      { name: 'long', value: 'long' },\n      { name: 'boolean', value: 'boolean' },\n      { name: 'date', value: 'date' },\n      { name: 'enum', value: 'enum' }\n    ],\n    modelProperty: 'type',\n    emptyParameter: true,\n\n    get: function(element, node) {\n      var selectedFormField = getSelectedFormField(element, node);\n\n      if (selectedFormField) {\n        return { type: selectedFormField.type };\n      } else {\n        return {};\n      }\n    },\n    set: function(element, values, node) {\n      var selectedFormField = getSelectedFormField(element, node),\n          formData = getExtensionElements(getBusinessObject(element), 'camunda:FormData')[0],\n          commands = [];\n\n      if (selectedFormField.type === 'enum' && values.type !== 'enum') {\n        // delete camunda:value objects from formField.values when switching from type enum\n        commands.push(cmdHelper.updateBusinessObject(element, selectedFormField, { values: undefined }));\n      }\n      if (values.type === 'boolean' && selectedFormField.get('id') === formData.get('businessKey')) {\n        commands.push(cmdHelper.updateBusinessObject(element, formData, { 'businessKey': undefined }));\n      }\n      commands.push(cmdHelper.updateBusinessObject(element, selectedFormField, values));\n\n      return commands;\n    },\n    hidden: function(element, node) {\n      return !getSelectedFormField(element, node);\n    }\n  }));\n\n  // [FormData] form field label text input field\n  group.entries.push(formFieldTextField({\n    id: 'form-field-label',\n    label: translate('Label'),\n    modelProperty: 'label'\n  }, getSelectedFormField));\n\n  // [FormData] form field defaultValue text input field\n  group.entries.push(formFieldTextField({\n    id: 'form-field-defaultValue',\n    label: translate('Default Value'),\n    modelProperty: 'defaultValue'\n  }, getSelectedFormField));\n\n\n  // [FormData] form field enum values label\n  group.entries.push(entryFactory.label({\n    id: 'form-field-enum-values-header',\n    labelText: translate('Values'),\n    divider: true,\n    showLabel: function(element, node) {\n      var selectedFormField = getSelectedFormField(element, node);\n\n      return selectedFormField && selectedFormField.type === 'enum';\n    }\n  }));\n\n  // [FormData] form field enum values table\n  group.entries.push(entryFactory.table({\n    id: 'form-field-enum-values',\n    labels: [ translate('Id'), translate('Name') ],\n    modelProperties: [ 'id', 'name' ],\n    show: function(element, node) {\n      var selectedFormField = getSelectedFormField(element, node);\n\n      return selectedFormField && selectedFormField.type === 'enum';\n    },\n    getElements: function(element, node) {\n      var selectedFormField = getSelectedFormField(element, node);\n\n      return formHelper.getEnumValues(selectedFormField);\n    },\n    addElement: function(element, node) {\n      var selectedFormField = getSelectedFormField(element, node),\n          id = generateValueId();\n\n      var enumValue = elementHelper.createElement('camunda:Value', { id: id, name: undefined },\n          getBusinessObject(element), bpmnFactory);\n\n      return cmdHelper.addElementsTolist(element, selectedFormField, 'values', [enumValue]);\n    },\n    removeElement: function(element, node, idx) {\n      var selectedFormField = getSelectedFormField(element, node),\n          enumValue = selectedFormField.values[idx];\n\n      return cmdHelper.removeElementsFromList(element, selectedFormField, 'values', null, [enumValue]);\n    },\n    updateElement: function(element, value, node, idx) {\n      var selectedFormField = getSelectedFormField(element, node),\n          enumValue = selectedFormField.values[idx];\n\n      value.name = value.name || undefined;\n      return cmdHelper.updateBusinessObject(element, enumValue, value);\n    },\n    validate: function(element, value, node, idx) {\n\n      var selectedFormField = getSelectedFormField(element, node),\n          enumValue = selectedFormField.values[idx];\n\n      if (enumValue) {\n        // check if id is valid\n        var validationError = utils.isIdValid(enumValue, value.id);\n\n        if (validationError) {\n          return { id: validationError };\n        }\n      }\n    }\n  }));\n\n  // [FormData] Validation label\n  group.entries.push(entryFactory.label({\n    id: 'form-field-validation-header',\n    labelText: translate('Validation'),\n    divider: true,\n    showLabel: function(element, node) {\n      return !!getSelectedFormField(element, node);\n    }\n  }));\n\n  // [FormData] form field constraints table\n  group.entries.push(entryFactory.table({\n    id: 'constraints-list',\n    modelProperties: [ 'name', 'config' ],\n    labels: [ translate('Name'), translate('Config') ],\n    addLabel: translate('Add Constraint'),\n    getElements: function(element, node) {\n      var formField = getSelectedFormField(element, node);\n\n      return formHelper.getConstraints(formField);\n    },\n    addElement: function(element, node) {\n\n      var commands = [],\n          formField = getSelectedFormField(element, node),\n          validation = formField.validation;\n\n      if (!validation) {\n        // create validation business object and add it to form data, if it doesn't exist\n        validation = elementHelper.createElement('camunda:Validation', {}, getBusinessObject(element), bpmnFactory);\n\n        commands.push(cmdHelper.updateBusinessObject(element, formField, { 'validation': validation }));\n      }\n\n      var newConstraint = elementHelper.createElement('camunda:Constraint',\n          { name: undefined, config: undefined }, validation, bpmnFactory);\n\n      commands.push(cmdHelper.addElementsTolist(element, validation, 'constraints', [ newConstraint ]));\n\n      return commands;\n    },\n    updateElement: function(element, value, node, idx) {\n      var formField = getSelectedFormField(element, node),\n          constraint = formHelper.getConstraints(formField)[idx];\n\n      value.name = value.name || undefined;\n      value.config = value.config || undefined;\n\n      return cmdHelper.updateBusinessObject(element, constraint, value);\n    },\n    removeElement: function(element, node, idx) {\n      var commands = [],\n          formField = getSelectedFormField(element, node),\n          constraints = formHelper.getConstraints(formField),\n          currentConstraint = constraints[idx];\n\n      commands.push(cmdHelper.removeElementsFromList(element, formField.validation,\n          'constraints', null, [ currentConstraint ]));\n\n      if (constraints.length === 1) {\n        // remove camunda:validation if the last existing constraint has been removed\n        commands.push(cmdHelper.updateBusinessObject(element, formField, { validation: undefined }));\n      }\n\n      return commands;\n    },\n    show: function(element, node) {\n      return !!getSelectedFormField(element, node);\n    }\n  }));\n\n  // [FormData] Properties label\n  group.entries.push(entryFactory.label({\n    id: 'form-field-properties-header',\n    labelText: translate('Properties'),\n    divider: true,\n    showLabel: function(element, node) {\n      return !!getSelectedFormField(element, node);\n    }\n  }));\n\n  // [FormData] camunda:properties table\n  group.entries.push(properties(element, bpmnFactory, {\n    id: 'form-field-properties',\n    modelProperties: [ 'id', 'value' ],\n    labels: [ translate('Id'), translate('Value') ],\n    getParent: function(element, node) {\n      return getSelectedFormField(element, node);\n    },\n    show: function(element, node) {\n      return !!getSelectedFormField(element, node);\n    }\n  }, translate));\n};\n","'use strict';\r\n\r\nvar is = require('bpmn-js/lib/util/ModelUtil').is,\r\n    getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject;\r\n\r\nvar historyTimeToLive = require('./implementation/HistoryTimeToLive');\r\n\r\nmodule.exports = function(group, element, bpmnFactory, translate) {\r\n  var businessObject = getBusinessObject(element);\r\n\r\n  if (is(element, 'camunda:Process') ||\r\n      is(element, 'bpmn:Participant') && businessObject.get('processRef')) {\r\n\r\n    group.entries = group.entries.concat(historyTimeToLive(element, bpmnFactory, {\r\n      getBusinessObject: function(element) {\r\n        var bo = getBusinessObject(element);\r\n\r\n        if (!is(bo, 'bpmn:Participant')) {\r\n          return bo;\r\n        }\r\n\r\n        return bo.get('processRef');\r\n      }\r\n    }, translate));\r\n\r\n  }\r\n};\r\n","'use strict';\n\nvar inputOutputParameter = require('./implementation/InputOutputParameter');\n\nvar assign = require('lodash/object/assign');\n\nmodule.exports = function(group, element, bpmnFactory, options, translate) {\n\n  group.entries = group.entries.concat(inputOutputParameter(element, bpmnFactory, assign({}, options), translate));\n\n};\n","'use strict';\n\nvar inputOutput = require('./implementation/InputOutput');\n\nmodule.exports = function(group, element, bpmnFactory, translate) {\n\n  var inputOutputEntry = inputOutput(element, bpmnFactory, {}, translate);\n\n  group.entries = group.entries.concat(inputOutputEntry.entries);\n\n  return {\n    getSelectedParameter: inputOutputEntry.getSelectedParameter\n  };\n\n};\n","'use strict';\n\nvar is = require('bpmn-js/lib/util/ModelUtil').is,\n    getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject;\n\nvar jobPriority = require('./implementation/JobPriority'),\n    jobRetryTimeCycle = require('./implementation/JobRetryTimeCycle');\n\nmodule.exports = function(group, element, bpmnFactory, translate) {\n  var businessObject = getBusinessObject(element);\n\n  if (is(element, 'camunda:JobPriorized') ||\n      is(element, 'bpmn:Participant') && businessObject.get('processRef')) {\n\n    group.entries = group.entries.concat(jobPriority(element, bpmnFactory, {\n      getBusinessObject: function(element) {\n        var bo = getBusinessObject(element);\n\n        if (!is(bo, 'bpmn:Participant')) {\n          return bo;\n        }\n\n        return bo.get('processRef');\n      }\n    }, translate));\n  }\n\n  if (is(element, 'camunda:AsyncCapable')) {\n    group.entries = group.entries.concat(jobRetryTimeCycle(element, bpmnFactory, {\n      getBusinessObject: getBusinessObject\n    }, translate));\n  }\n\n};\n","'use strict';\n\nvar entryFactory = require('../../../factory/EntryFactory');\n\nvar cmdHelper = require('../../../helper/CmdHelper'),\n    ImplementationTypeHelper = require('../../../helper/ImplementationTypeHelper'),\n\n    script = require('./implementation/Script')('scriptFormat', 'value', true);\n\n\nvar LISTENER_TYPE_LABEL = {\n  class: 'Java Class',\n  expression: 'Expression',\n  delegateExpression: 'Delegate Expression',\n  script: 'Script'\n};\n\nmodule.exports = function(group, element, bpmnFactory, options, translate) {\n\n  options = options || {};\n\n  var getSelectedListener = options.getSelectedListener;\n\n  var classProp = 'class',\n      expressionProp = 'expression',\n      delegateExpressionProp = 'delegateExpression',\n      scriptProp = 'script';\n\n  var executionListenerEventTypeOptions = ImplementationTypeHelper.isSequenceFlow(element) ? [\n    { name: 'take', value: 'take' }\n  ] : [\n    { name: 'start', value: 'start' },\n    { name: 'end', value: 'end' }\n  ];\n\n  var taskListenerEventTypeOptions = [\n    { name: 'create', value: 'create' },\n    { name: 'assignment', value: 'assignment' },\n    { name: 'complete', value: 'complete' },\n    { name: 'delete', value: 'delete' }\n  ];\n\n  var isSelected = function(element, node) {\n    return getSelectedListener(element, node);\n  };\n\n  group.entries.push(entryFactory.selectBox({\n    id: 'listener-event-type',\n    label: translate('Event Type'),\n    modelProperty: 'eventType',\n    emptyParameter: false,\n\n    get: function(element, node) {\n\n\n      var listener = getSelectedListener(element, node);\n\n      var eventType = listener && listener.get('event');\n\n      return {\n        eventType: eventType\n      };\n    },\n\n    set: function(element, values, node) {\n      var eventType = values.eventType;\n\n      return cmdHelper.updateBusinessObject(element, getSelectedListener(element, node), { event: eventType });\n    },\n\n    selectOptions: function(element, node) {\n      var eventTypeOptions;\n\n      var selectedListener = getSelectedListener(element, node);\n      if (ImplementationTypeHelper.isTaskListener(selectedListener)) {\n        eventTypeOptions = taskListenerEventTypeOptions;\n      } else if (ImplementationTypeHelper.isExecutionListener(selectedListener)) {\n        eventTypeOptions = executionListenerEventTypeOptions;\n      }\n\n      return eventTypeOptions;\n\n    },\n\n    hidden: function(element, node) {\n      return !isSelected(element, node);\n    }\n\n  }));\n\n\n  group.entries.push(entryFactory.selectBox({\n    id: 'listener-type',\n    label: translate('Listener Type'),\n    selectOptions: [\n      { value: classProp, name: translate('Java Class') },\n      { value: expressionProp, name: translate('Expression') },\n      { value: delegateExpressionProp, name: translate('Delegate Expression') },\n      { value: scriptProp, name: translate('Script') }\n    ],\n    modelProperty: 'listenerType',\n    emptyParameter: false,\n\n    get: function(element, node) {\n      var listener = getSelectedListener(element, node);\n      return {\n        listenerType: ImplementationTypeHelper.getImplementationType(listener)\n      };\n    },\n\n    set: function(element, values, node) {\n      var listener = getSelectedListener(element, node),\n          listenerType = values.listenerType || undefined,\n          update = {};\n\n      update[classProp] = listenerType === classProp ? '' : undefined;\n      update[expressionProp] = listenerType === expressionProp ? '' : undefined;\n      update[delegateExpressionProp] = listenerType === delegateExpressionProp ? '' : undefined;\n      update[scriptProp] = listenerType === scriptProp ? bpmnFactory.create('camunda:Script') : undefined;\n\n      return cmdHelper.updateBusinessObject(element, listener, update);\n    },\n\n    hidden: function(element, node) {\n      return !isSelected(element, node);\n    }\n\n  }));\n\n\n  group.entries.push(entryFactory.textField({\n    id: 'listener-value',\n    dataValueLabel: 'listenerValueLabel',\n    modelProperty: 'listenerValue',\n\n    get: function(element, node) {\n      var value = {},\n          listener = getSelectedListener(element, node),\n          listenerType = ImplementationTypeHelper.getImplementationType(listener);\n\n      value.listenerValueLabel = LISTENER_TYPE_LABEL[listenerType] || '';\n      value.listenerValue = (listener && listener.get(listenerType)) || undefined;\n\n      return value;\n    },\n\n    set: function(element, values, node) {\n      var update = {},\n          listener = getSelectedListener(element, node),\n          listenerType = ImplementationTypeHelper.getImplementationType(listener);\n\n      update[listenerType] = values.listenerValue || '';\n\n      return cmdHelper.updateBusinessObject(element, listener, update);\n    },\n\n    hidden: function(element, node) {\n      var listener = getSelectedListener(element, node);\n      return !listener || listener.script;\n    },\n\n    validate: function(element, values) {\n      var value = values.listenerValue,\n          validate = {};\n\n      if (!value) {\n        validate.listenerValue = translate('Must provide a value');\n      }\n\n      return validate;\n    }\n\n  }));\n\n\n  group.entries.push({\n    id: 'listener-script-value',\n    html: '<div data-show=\"isScript\">' +\n            script.template +\n          '</div>',\n\n    get: function(element, node) {\n      var listener = getSelectedListener(element, node);\n      return listener && listener.script ? script.get(element, listener.script) : {};\n    },\n\n    set: function(element, values, node) {\n      var listener = getSelectedListener(element, node);\n      var update = script.set(element, values, listener);\n      return cmdHelper.updateBusinessObject(element, listener.script, update);\n    },\n\n    validate: function(element, values, node) {\n      var listener = getSelectedListener(element, node);\n      return listener && listener.script ? script.validate(element, values) : {};\n    },\n\n    isScript: function(element, node) {\n      var listener = getSelectedListener(element, node);\n      return listener && listener.script;\n    },\n\n    script: script\n\n  });\n\n};\n","'use strict';\n\nvar assign = require('lodash/object/assign');\n\nvar fieldInjection = require('./implementation/FieldInjection');\n\nmodule.exports = function(group, element, bpmnFactory, options, translate) {\n\n  options = assign({\n    idPrefix: 'listener-',\n    insideListener: true\n  }, options);\n\n  var fieldInjectionEntry = fieldInjection(element, bpmnFactory, translate, options);\n\n  if (fieldInjectionEntry && fieldInjectionEntry.length > 0) {\n    group.entries = group.entries.concat(fieldInjectionEntry);\n  }\n\n};\n","'use strict';\n\nvar listener = require('./implementation/Listener');\n\nmodule.exports = function(group, element, bpmnFactory, translate) {\n\n  var listenerEntry = listener(element, bpmnFactory, {}, translate);\n\n  group.entries = group.entries.concat(listenerEntry.entries);\n\n  return {\n    getSelectedListener: listenerEntry.getSelectedListener\n  };\n\n};\n","'use strict';\n\nvar getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject,\n    is = require('bpmn-js/lib/util/ModelUtil').is;\n\nvar multiInstanceLoopCharacteristics = require('./implementation/MultiInstanceLoopCharacteristics');\n\nvar jobRetryTimeCycle = require('./implementation/JobRetryTimeCycle'),\n    asyncContinuation = require('./implementation/AsyncContinuation');\n\n\nfunction getLoopCharacteristics(element) {\n  var bo = getBusinessObject(element);\n  return bo.loopCharacteristics;\n}\n\n\nfunction ensureMultiInstanceSupported(element) {\n  var loopCharacteristics = getLoopCharacteristics(element);\n  return !!loopCharacteristics && is(loopCharacteristics, 'camunda:Collectable');\n}\n\nmodule.exports = function(group, element, bpmnFactory, translate) {\n\n  if (!ensureMultiInstanceSupported(element)) {\n    return;\n  }\n\n  // multi instance properties\n  group.entries = group.entries.concat(multiInstanceLoopCharacteristics(element, bpmnFactory, translate));\n\n  // async continuation ///////////////////////////////////////////////////////\n  group.entries = group.entries.concat(asyncContinuation(element, bpmnFactory, {\n    getBusinessObject: getLoopCharacteristics,\n    idPrefix: 'multiInstance-',\n    labelPrefix: translate('Multi Instance ')\n  }, translate));\n\n\n  // retry time cycle //////////////////////////////////////////////////////////\n  group.entries = group.entries.concat(jobRetryTimeCycle(element, bpmnFactory, {\n    getBusinessObject: getLoopCharacteristics,\n    idPrefix: 'multiInstance-',\n    labelPrefix: translate('Multi Instance ')\n  }, translate));\n};\n","'use strict';\n\nvar properties = require('./implementation/Properties'),\n    elementHelper = require('../../../helper/ElementHelper'),\n    cmdHelper = require('../../../helper/CmdHelper');\n\n\nmodule.exports = function(group, element, bpmnFactory, translate) {\n\n  var propertiesEntry = properties(element, bpmnFactory, {\n    id: 'properties',\n    modelProperties: [ 'name', 'value' ],\n    labels: [ translate('Name'), translate('Value') ],\n\n    getParent: function(element, node, bo) {\n      return bo.extensionElements;\n    },\n\n    createParent: function(element, bo) {\n      var parent = elementHelper.createElement('bpmn:ExtensionElements', { values: [] }, bo, bpmnFactory);\n      var cmd = cmdHelper.updateBusinessObject(element, bo, { extensionElements: parent });\n      return {\n        cmd: cmd,\n        parent: parent\n      };\n    }\n  }, translate);\n\n  if (propertiesEntry) {\n    group.entries.push(propertiesEntry);\n  }\n\n};\n","'use strict';\n\nvar getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject,\n    is = require('bpmn-js/lib/util/ModelUtil').is,\n    entryFactory = require('../../../factory/EntryFactory'),\n    cmdHelper = require('../../../helper/CmdHelper'),\n    script = require('./implementation/Script')('scriptFormat', 'script', false);\n\n\nmodule.exports = function(group, element, bpmnFactory, translate) {\n  var bo;\n\n  if (is(element, 'bpmn:ScriptTask')) {\n    bo = getBusinessObject(element);\n  }\n\n  if (!bo) {\n    return;\n  }\n\n  group.entries.push({\n    id: 'script-implementation',\n    label: translate('Script'),\n    html: script.template,\n\n    get: function(element) {\n      return script.get(element, bo);\n    },\n\n    set: function(element, values, containerElement) {\n      var properties = script.set(element, values, containerElement);\n\n      return cmdHelper.updateProperties(element, properties);\n    },\n\n    validate: function(element, values) {\n      return script.validate(element, values);\n    },\n\n    script : script,\n\n    cssClasses: ['bpp-textfield']\n\n  });\n\n  group.entries.push(entryFactory.textField({\n    id : 'scriptResultVariable',\n    label : translate('Result Variable'),\n    modelProperty : 'scriptResultVariable',\n\n    get: function(element, propertyName) {\n      var boResultVariable = bo.get('camunda:resultVariable');\n\n      return { scriptResultVariable : boResultVariable };\n    },\n\n    set: function(element, values, containerElement) {\n      return cmdHelper.updateProperties(element, {\n        'camunda:resultVariable': values.scriptResultVariable.length\n          ? values.scriptResultVariable\n          : undefined\n      });\n    }\n\n  }));\n\n};\n","'use strict';\n\nvar is = require('bpmn-js/lib/util/ModelUtil').is,\n    isAny = require('bpmn-js/lib/features/modeling/util/ModelingUtil').isAny,\n    getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject,\n    domQuery = require('min-dom/lib/query'),\n    cmdHelper = require('../../../helper/CmdHelper'),\n    elementHelper = require('../../../helper/ElementHelper'),\n    script = require('./implementation/Script')('language', 'body', true);\n\n\nmodule.exports = function(group, element, bpmnFactory, translate) {\n  var bo;\n\n  if (is(element, 'bpmn:SequenceFlow')) {\n    bo = getBusinessObject(element);\n  }\n\n  if (!bo) {\n    return;\n  }\n\n  if (!isConditionalSource(element.source)) {\n    return;\n  }\n\n  group.entries.push({\n    id: 'condition',\n    label: translate('Condition'),\n    html: '<div class=\"bpp-row\">' +\n              '<label for=\"cam-condition-type\">'+translate('Condition Type')+'</label>' +\n              '<div class=\"bpp-field-wrapper\">' +\n                '<select id=\"cam-condition-type\" name=\"conditionType\" data-value>' +\n                  '<option value=\"expression\">'+translate('Expression')+'</option>' +\n                  '<option value=\"script\">'+translate('Script')+'</option>' +\n                  '<option value=\"\" selected></option>' +\n                '</select>' +\n              '</div>' +\n            '</div>' +\n\n            // expression\n            '<div class=\"bpp-row\">' +\n              '<label for=\"cam-condition\" data-show=\"isExpression\">'+translate('Expression')+'</label>' +\n              '<div class=\"bpp-field-wrapper\" data-show=\"isExpression\">' +\n                '<input id=\"cam-condition\" type=\"text\" name=\"condition\" />' +\n                '<button class=\"clear\" data-action=\"clear\" data-show=\"canClear\">' +\n                  '<span>X</span>' +\n                '</button>' +\n              '</div>' +\n              '<div data-show=\"isScript\">' +\n                script.template +\n              '</div>' +\n            '</div>',\n\n    get: function(element, propertyName) {\n\n      // read values from xml:\n      var conditionExpression = bo.conditionExpression;\n\n      var values = {},\n          conditionType = '';\n\n      if (conditionExpression) {\n        var conditionLanguage = conditionExpression.language;\n        if (typeof conditionLanguage !== 'undefined') {\n          conditionType = 'script';\n          values = script.get(element, conditionExpression);\n        } else {\n          conditionType = 'expression';\n          values.condition = conditionExpression.get('body');\n        }\n      }\n\n      values.conditionType = conditionType;\n\n      return values;\n\n    },\n\n    set: function(element, values, containerElement) {\n      var conditionType = values.conditionType;\n      var commands = [];\n\n      var conditionProps = {\n        body: undefined\n      };\n\n      if (conditionType === 'script') {\n        conditionProps = script.set(element, values, containerElement);\n      } else {\n        var condition = values.condition;\n        conditionProps.body = condition;\n      }\n\n      var update = {\n        'conditionExpression': undefined\n      };\n\n      if (conditionType) {\n        update.conditionExpression = elementHelper.createElement(\n          'bpmn:FormalExpression',\n          conditionProps,\n          bo,\n          bpmnFactory\n        );\n\n        var source = element.source;\n\n        // if default-flow, remove default-property from source\n        if (source.businessObject.default === bo) {\n          commands.push(cmdHelper.updateProperties(source, { 'default': undefined }));\n        }\n      }\n\n      commands.push(cmdHelper.updateBusinessObject(element, bo, update));\n\n      return commands;\n    },\n\n    validate: function(element, values) {\n      var validationResult = {};\n\n      if (!values.condition && values.conditionType === 'expression') {\n        validationResult.condition = 'Must provide a value';\n      }\n      else if (values.conditionType === 'script') {\n        validationResult = script.validate(element, values);\n      }\n\n      return validationResult;\n    },\n\n    isExpression: function(element, inputNode) {\n      var conditionType = domQuery('select[name=conditionType]', inputNode);\n      if (conditionType.selectedIndex >= 0) {\n        return conditionType.options[conditionType.selectedIndex].value === 'expression';\n      }\n    },\n\n    isScript: function(element, inputNode) {\n      var conditionType = domQuery('select[name=conditionType]', inputNode);\n      if (conditionType.selectedIndex >= 0) {\n        return conditionType.options[conditionType.selectedIndex].value === 'script';\n      }\n    },\n\n    clear: function(element, inputNode) {\n      // clear text input\n      domQuery('input[name=condition]', inputNode).value='';\n\n      return true;\n    },\n\n    canClear: function(element, inputNode) {\n      var input = domQuery('input[name=condition]', inputNode);\n\n      return input.value !== '';\n    },\n\n    script : script,\n\n    cssClasses: [ 'bpp-textfield' ]\n  });\n};\n\n\n////// utilities //////////////////////////\n\nvar CONDITIONAL_SOURCES = [\n  'bpmn:Activity',\n  'bpmn:ExclusiveGateway',\n  'bpmn:InclusiveGateway',\n  'bpmn:ComplexGateway'\n];\n\nfunction isConditionalSource(element) {\n  return isAny(element, CONDITIONAL_SOURCES);\n}\n","'use strict';\n\nvar ImplementationTypeHelper = require('../../../helper/ImplementationTypeHelper'),\n    InputOutputHelper        = require('../../../helper/InputOutputHelper');\n\nvar implementationType = require('./implementation/ImplementationType'),\n    delegate           = require('./implementation/Delegate'),\n    external           = require('./implementation/External'),\n    callable           = require('./implementation/Callable'),\n    resultVariable     = require('./implementation/ResultVariable');\n\nvar entryFactory = require('../../../factory/EntryFactory');\n\nvar domQuery   = require('min-dom/lib/query'),\n    domClosest = require('min-dom/lib/closest'),\n    domClasses = require('min-dom/lib/classes');\n\nfunction getImplementationType(element) {\n  return ImplementationTypeHelper.getImplementationType(element);\n}\n\nfunction getBusinessObject(element) {\n  return ImplementationTypeHelper.getServiceTaskLikeBusinessObject(element);\n}\n\nfunction isDmnCapable(element) {\n  return ImplementationTypeHelper.isDmnCapable(element);\n}\n\nfunction isExternalCapable(element) {\n  return ImplementationTypeHelper.isExternalCapable(element);\n}\n\nfunction isServiceTaskLike(element) {\n  return ImplementationTypeHelper.isServiceTaskLike(element);\n}\n\nmodule.exports = function(group, element, bpmnFactory, translate) {\n\n  if (!isServiceTaskLike(getBusinessObject(element))) {\n    return;\n  }\n\n  var hasDmnSupport = isDmnCapable(element);\n  var hasExternalSupport = isExternalCapable(getBusinessObject(element));\n\n  // implementation type ////////////////////////////////////\n\n  group.entries = group.entries.concat(implementationType(element, bpmnFactory, {\n    getBusinessObject: getBusinessObject,\n    getImplementationType: getImplementationType,\n    hasDmnSupport: hasDmnSupport,\n    hasExternalSupport: hasExternalSupport,\n    hasServiceTaskLikeSupport: true\n  }, translate));\n\n\n  // delegate (class, expression, delegateExpression) //////////\n\n  group.entries = group.entries.concat(delegate(element, bpmnFactory, {\n    getBusinessObject: getBusinessObject,\n    getImplementationType: getImplementationType\n  }, translate));\n\n\n  // result variable /////////////////////////////////////////\n\n  group.entries = group.entries.concat(resultVariable(element, bpmnFactory, {\n    getBusinessObject: getBusinessObject,\n    getImplementationType: getImplementationType,\n    hideResultVariable: function(element, node) {\n      return getImplementationType(element) !== 'expression';\n    }\n  }, translate));\n\n  // external //////////////////////////////////////////////////\n\n  if (hasExternalSupport) {\n    group.entries = group.entries.concat(external(element, bpmnFactory, {\n      getBusinessObject: getBusinessObject,\n      getImplementationType: getImplementationType\n    }, translate));\n  }\n\n\n  // dmn ////////////////////////////////////////////////////////\n\n  if (hasDmnSupport) {\n    group.entries = group.entries.concat(callable(element, bpmnFactory, {\n      getCallableType: getImplementationType\n    }, translate));\n  }\n\n\n  // connector ////////////////////////////////////////////////\n\n  var isConnector = function(element) {\n    return getImplementationType(element) === 'connector';\n  };\n\n  group.entries.push(entryFactory.link({\n    id: 'configureConnectorLink',\n    label: translate('Configure Connector'),\n    getClickableElement: function(element, node) {\n      var panel = domClosest(node, 'div.bpp-properties-panel');\n      return domQuery('a[data-tab-target=\"connector\"]', panel);\n    },\n    hideLink: function(element, node) {\n      var link = domQuery('a', node);\n      link.innerHTML = link.textContent = '';\n      domClasses(link).remove('bpp-error-message');\n\n      if (isConnector(element)) {\n        var connectorId = InputOutputHelper.getConnector(element).get('connectorId');\n        if (connectorId) {\n          link.textContent = translate('Configure Connector');\n        } else {\n          link.innerHTML = '<span class=\"bpp-icon-warning\"></span> Must configure Connector';\n          domClasses(link).add('bpp-error-message');\n        }\n\n        return false;\n      }\n      return true;\n    }\n  }));\n\n};\n","'use strict';\n\nvar entryFactory = require('../../../factory/EntryFactory'),\n    is = require('bpmn-js/lib/util/ModelUtil').is,\n    getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject;\n\n\nmodule.exports = function(group, element, translate) {\n\n  var bo = getBusinessObject(element);\n\n  if (!bo) {\n    return;\n  }\n\n  if ( is(element, 'camunda:Initiator') && !is(element.parent, 'bpmn:SubProcess') ) {\n    group.entries.push(entryFactory.textField({\n      id: 'initiator',\n      label: translate('Initiator'),\n      modelProperty: 'initiator'\n    }));\n  }\n};\n","'use strict';\n\nvar is = require('bpmn-js/lib/util/ModelUtil').is,\n    entryFactory = require('../../../factory/EntryFactory');\n\n\nmodule.exports = function(group, element, translate) {\n  if (is(element, 'camunda:Assignable')) {\n\n    // Assignee\n    group.entries.push(entryFactory.textField({\n      id : 'assignee',\n      label : translate('Assignee'),\n      modelProperty : 'assignee'\n    }));\n\n    // Candidate Users\n    group.entries.push(entryFactory.textField({\n      id : 'candidateUsers',\n      label : translate('Candidate Users'),\n      modelProperty : 'candidateUsers'\n    }));\n\n    // Candidate Groups\n    group.entries.push(entryFactory.textField({\n      id : 'candidateGroups',\n      label : translate('Candidate Groups'),\n      modelProperty : 'candidateGroups'\n    }));\n\n    // Due Date\n    group.entries.push(entryFactory.textField({\n      id : 'dueDate',\n      description : translate('The due date as an EL expression (e.g. ${someDate} or an ISO date (e.g. 2015-06-26T09:54:00)'),\n      label : translate('Due Date'),\n      modelProperty : 'dueDate'\n    }));\n\n    // FollowUp Date\n    group.entries.push(entryFactory.textField({\n      id : 'followUpDate',\n      description : translate('The follow up date as an EL expression (e.g. ${someDate} or an ' +\n                    'ISO date (e.g. 2015-06-26T09:54:00)'),\n      label : translate('Follow Up Date'),\n      modelProperty : 'followUpDate'\n    }));\n\n    // priority\n    group.entries.push(entryFactory.textField({\n      id : 'priority',\n      label : translate('Priority'),\n      modelProperty : 'priority'\n    }));\n  }\n};\n","'use strict';\n\nvar is = require('bpmn-js/lib/util/ModelUtil').is,\n    getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject;\n\nvar filter = require('lodash/collection/filter');\n\nvar extensionElementsHelper = require('../../../helper/ExtensionElementsHelper'),\n    cmdHelper = require('../../../helper/CmdHelper'),\n    elementHelper = require('../../../helper/ElementHelper');\n\nvar extensionElementsEntry = require('./implementation/ExtensionElements');\n\nvar entryFactory = require('../../../factory/EntryFactory');\n\n\nvar inOutTypeOptions = [\n  {\n    name: 'Source',\n    value: 'source'\n  },\n  {\n    name: 'Source Expression',\n    value: 'sourceExpression'\n  },\n  {\n    name: 'All',\n    value: 'variables'\n  }\n];\n\n/**\n  * return depend on parameter 'type' camunda:in or camunda:out extension elements\n  */\nfunction getCamundaInOutMappings(element, type) {\n  var bo = getBusinessObject(element);\n  return extensionElementsHelper.getExtensionElements(bo, type) || [];\n}\n\n/**\n  * return depend on parameter 'type' camunda:in or camunda:out extension elements\n  * with source or sourceExpression attribute\n  */\nfunction getVariableMappings(element, type) {\n  var camundaMappings = getCamundaInOutMappings(element, type);\n  return filter(camundaMappings, function(mapping) {\n    return !mapping.businessKey;\n  });\n}\n\nfunction getInOutType(mapping) {\n  var inOutType = 'source';\n\n  if (mapping.variables === 'all') {\n    inOutType = 'variables';\n  }\n  else if (typeof mapping.source !== 'undefined') {\n    inOutType = 'source';\n  }\n  else if (typeof mapping.sourceExpression !== 'undefined') {\n    inOutType = 'sourceExpression';\n  }\n\n  return inOutType;\n}\n\nvar CAMUNDA_IN_EXTENSION_ELEMENT = 'camunda:In',\n    CAMUNDA_OUT_EXTENSION_ELEMENT = 'camunda:Out';\n\n\nmodule.exports = function(group, element, bpmnFactory, translate) {\n\n  if (!is(element, 'camunda:CallActivity')) {\n    return;\n  }\n\n  var isSelected = function(element, node) {\n    return !!getSelected(element, node);\n  };\n\n  var getSelected = function(element, node) {\n    var parentNode = node.parentNode;\n    var selection = inEntry.getSelected(element, parentNode);\n\n    var parameter = getVariableMappings(element, CAMUNDA_IN_EXTENSION_ELEMENT)[selection.idx];\n    if (!parameter && outEntry) {\n      selection = outEntry.getSelected(element, parentNode);\n      parameter = getVariableMappings(element, CAMUNDA_OUT_EXTENSION_ELEMENT)[selection.idx];\n    }\n    return parameter;\n  };\n\n  var setOptionLabelValue = function(type) {\n    return function(element, node, option, property, value, idx) {\n      var label = idx + ' : ';\n\n      var variableMappings = getVariableMappings(element, type);\n      var mappingValue = variableMappings[idx];\n      var mappingType = getInOutType(mappingValue);\n\n      if (mappingType === 'variables') {\n        label = label + 'all';\n      }\n      else if (mappingType === 'source') {\n        label = label + (mappingValue.source || '<empty>');\n      }\n      else if (mappingType === 'sourceExpression') {\n        label = label + (mappingValue.sourceExpression || '<empty>');\n      } else {\n        label = label + '<empty>';\n      }\n\n      option.text = label;\n    };\n  };\n\n  var newElement = function(type) {\n    return function(element, extensionElements, value) {\n      var newElem = elementHelper.createElement(type, { source : '' }, extensionElements, bpmnFactory);\n      return cmdHelper.addElementsTolist(element, extensionElements, 'values', [ newElem ]);\n    };\n  };\n\n  var removeElement = function(type) {\n    return function(element, extensionElements, value, idx) {\n      var variablesMappings= getVariableMappings(element, type);\n      var mapping = variablesMappings[idx];\n      if (mapping) {\n        return extensionElementsHelper.removeEntry(getBusinessObject(element), element, mapping);\n      }\n    };\n  };\n\n  // in mapping for source and sourceExpression ///////////////////////////////////////////////////////////////\n\n  var inEntry = extensionElementsEntry(element, bpmnFactory, {\n    id: 'variableMapping-in',\n    label: translate('In Mapping'),\n    modelProperty: 'source',\n    prefix: 'In',\n    idGeneration: false,\n    resizable: true,\n\n    createExtensionElement: newElement(CAMUNDA_IN_EXTENSION_ELEMENT),\n    removeExtensionElement: removeElement(CAMUNDA_IN_EXTENSION_ELEMENT),\n\n    getExtensionElements: function(element) {\n      return getVariableMappings(element, CAMUNDA_IN_EXTENSION_ELEMENT);\n    },\n\n    onSelectionChange: function(element, node, event, scope) {\n      outEntry && outEntry.deselect(element, node.parentNode);\n    },\n\n    setOptionLabelValue: setOptionLabelValue(CAMUNDA_IN_EXTENSION_ELEMENT)\n  });\n  group.entries.push(inEntry);\n\n  // out mapping for source and sourceExpression ///////////////////////////////////////////////////////\n\n  var outEntry = extensionElementsEntry(element, bpmnFactory, {\n    id: 'variableMapping-out',\n    label: translate('Out Mapping'),\n    modelProperty: 'source',\n    prefix: 'Out',\n    idGeneration: false,\n    resizable: true,\n\n    createExtensionElement: newElement(CAMUNDA_OUT_EXTENSION_ELEMENT),\n    removeExtensionElement: removeElement(CAMUNDA_OUT_EXTENSION_ELEMENT),\n\n    getExtensionElements: function(element) {\n      return getVariableMappings(element, CAMUNDA_OUT_EXTENSION_ELEMENT);\n    },\n\n    onSelectionChange: function(element, node, event, scope) {\n      inEntry.deselect(element, node.parentNode);\n    },\n\n    setOptionLabelValue: setOptionLabelValue(CAMUNDA_OUT_EXTENSION_ELEMENT)\n  });\n  group.entries.push(outEntry);\n\n  // label for selected mapping ///////////////////////////////////////////////////////\n\n  group.entries.push(entryFactory.label({\n    id: 'variableMapping-typeLabel',\n    get: function(element, node) {\n      var mapping = getSelected(element, node);\n\n      var value = '';\n      if (is(mapping, CAMUNDA_IN_EXTENSION_ELEMENT)) {\n        value = translate('In Mapping');\n      }\n      else if (is(mapping, CAMUNDA_OUT_EXTENSION_ELEMENT)) {\n        value = translate('Out Mapping');\n      }\n\n      return {\n        label: value\n      };\n    },\n\n    showLabel: function(element, node) {\n      return isSelected(element, node);\n    }\n  }));\n\n\n  group.entries.push(entryFactory.selectBox({\n    id: 'variableMapping-inOutType',\n    label: translate('Type'),\n    selectOptions: inOutTypeOptions,\n    modelProperty: 'inOutType',\n    get: function(element, node) {\n      var mapping = getSelected(element, node) || {};\n      return {\n        inOutType: getInOutType(mapping)\n      };\n    },\n    set: function(element, values, node) {\n      var inOutType = values.inOutType;\n\n      var props = {\n        'source' : undefined,\n        'sourceExpression' : undefined,\n        'variables' : undefined\n      };\n\n      if (inOutType === 'source') {\n        props.source = '';\n      }\n      else if (inOutType === 'sourceExpression') {\n        props.sourceExpression = '';\n      }\n      else if (inOutType === 'variables') {\n        props.variables = 'all';\n      }\n\n      var mapping = getSelected(element, node);\n      return cmdHelper.updateBusinessObject(element, mapping, props);\n    },\n    hidden: function(element, node) {\n      return !isSelected(element, node);\n    }\n\n  }));\n\n\n  group.entries.push(entryFactory.textField({\n    id: 'variableMapping-source',\n    dataValueLabel: 'sourceLabel',\n    modelProperty: 'source',\n    get: function(element, node) {\n      var mapping = getSelected(element, node) || {};\n\n      var label = '';\n      var inOutType = getInOutType(mapping);\n      if (inOutType === 'source') {\n        label = 'Source';\n      }\n      else if (inOutType === 'sourceExpression') {\n        label = 'Source Expression';\n      }\n\n      return {\n        source: mapping[inOutType],\n        sourceLabel: label\n      };\n    },\n    set: function(element, values, node) {\n      values.source = values.source || undefined;\n\n      var mapping = getSelected(element, node);\n      var inOutType = getInOutType(mapping);\n\n      var props = {};\n      props[inOutType] = values.source || '';\n\n      return cmdHelper.updateBusinessObject(element, mapping, props);\n    },\n    // one of both (source or sourceExpression) must have a value to make\n    // the configuration easier and more understandable\n    // it is not engine conform\n    validate: function(element, values, node) {\n      var mapping = getSelected(element, node);\n\n      var validation = {};\n      if (mapping) {\n        if (!values.source) {\n          validation.source = 'Mapping must have a ' + values.sourceLabel.toLowerCase() || 'value';\n        }\n      }\n\n      return validation;\n    },\n    hidden: function(element, node) {\n      var selectedMapping = getSelected(element, node);\n      return !selectedMapping || (selectedMapping && selectedMapping.variables);\n    }\n  }));\n\n\n  group.entries.push(entryFactory.textField({\n    id: 'variableMapping-target',\n    label: translate('Target'),\n    modelProperty: 'target',\n    get: function(element, node) {\n      return {\n        target: (getSelected(element, node) || {}).target\n      };\n    },\n    set: function(element, values, node) {\n      values.target = values.target || undefined;\n      var mapping = getSelected(element, node);\n      return cmdHelper.updateBusinessObject(element, mapping, values);\n    },\n    validate: function(element, values, node) {\n      var mapping = getSelected(element, node);\n\n      var validation = {};\n      if (mapping) {\n        var mappingType = getInOutType(mapping);\n        if (!values.target && mappingType !== 'variables') {\n          validation.target = 'Mapping must have a target';\n        }\n      }\n\n      return validation;\n    },\n    hidden: function(element, node) {\n      var selectedMapping = getSelected(element, node);\n      return !selectedMapping || (selectedMapping && selectedMapping.variables);\n    }\n  }));\n\n\n  group.entries.push(entryFactory.checkbox({\n    id: 'variableMapping-local',\n    label: translate('Local'),\n    modelProperty: 'local',\n    get: function(element, node) {\n      return {\n        local: (getSelected(element, node) || {}).local\n      };\n    },\n    set: function(element, values, node) {\n      values.local = values.local || false;\n      var mapping = getSelected(element, node);\n      return cmdHelper.updateBusinessObject(element, mapping, values);\n    },\n    hidden: function(element, node) {\n      return !isSelected(element, node);\n    }\n  }));\n\n};\n","'use strict';\n\nvar entryFactory = require('../../../factory/EntryFactory'),\n    cmdHelper = require('../../../helper/CmdHelper'),\n    is = require('bpmn-js/lib/util/ModelUtil').is,\n    getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject;\n\nmodule.exports = function(group, element, translate) {\n\n  var bo = getBusinessObject(element);\n\n  if (!bo) {\n    return;\n  }\n\n  if (is(element, 'bpmn:Process') || is(element, 'bpmn:Participant') && bo.get('processRef')) {\n    var versionTagEntry = entryFactory.textField({\n      id: 'versionTag',\n      label: translate('Version Tag'),\n      modelProperty: 'versionTag'\n    });\n\n    // in participants we have to change the default behavior of set and get\n    if (is(element, 'bpmn:Participant')) {\n      versionTagEntry.get = function(element) {\n        var processBo = bo.get('processRef');\n        \n        return {\n          versionTag: processBo.get('camunda:versionTag')\n        };\n      };\n\n      versionTagEntry.set = function(element, values) {\n        var processBo = bo.get('processRef');\n\n        return cmdHelper.updateBusinessObject(element, processBo, {\n          'camunda:versionTag': values.versionTag || undefined\n        });\n      };\n    }\n\n    group.entries.push(versionTagEntry);\n\n  }\n};\n","'use strict';\n\nvar assign = require('lodash/object/assign');\n\nvar entryFactory = require('../../../../factory/EntryFactory');\n\nvar asyncCapableHelper = require('../../../../helper/AsyncCapableHelper'),\n    eventDefinitionHelper = require('../../../../helper/EventDefinitionHelper'),\n    cmdHelper = require('../../../../helper/CmdHelper');\n\nfunction isAsyncBefore(bo) {\n  return asyncCapableHelper.isAsyncBefore(bo);\n}\n\nfunction isAsyncAfter(bo) {\n  return asyncCapableHelper.isAsyncAfter(bo);\n}\n\nfunction isExclusive(bo) {\n  return asyncCapableHelper.isExclusive(bo);\n}\n\nfunction removeFailedJobRetryTimeCycle(bo, element) {\n  return asyncCapableHelper.removeFailedJobRetryTimeCycle(bo, element);\n}\n\nfunction canRemoveFailedJobRetryTimeCycle(element) {\n  return !eventDefinitionHelper.getTimerEventDefinition(element);\n}\n\nmodule.exports = function(element, bpmnFactory, options, translate) {\n\n  var getBusinessObject = options.getBusinessObject;\n\n  var idPrefix = options.idPrefix || '',\n      labelPrefix = options.labelPrefix || '';\n\n\n  var asyncBeforeEntry = entryFactory.checkbox({\n    id: idPrefix + 'asyncBefore',\n    label: labelPrefix + translate('Asynchronous Before'),\n    modelProperty: 'asyncBefore',\n\n    get: function(element, node) {\n      var bo = getBusinessObject(element);\n      return {\n        asyncBefore: isAsyncBefore(bo)\n      };\n    },\n\n    set: function(element, values) {\n      var bo = getBusinessObject(element);\n      var asyncBefore = !!values.asyncBefore;\n\n      var props = {\n        'camunda:asyncBefore': asyncBefore,\n        'camunda:async': false\n      };\n\n      var commands = [];\n      if (!isAsyncAfter(bo) && !asyncBefore) {\n        props = assign({ 'camunda:exclusive' : true }, props);\n        if (canRemoveFailedJobRetryTimeCycle(element)) {\n          commands.push(removeFailedJobRetryTimeCycle(bo, element));\n        }\n      }\n\n      commands.push(cmdHelper.updateBusinessObject(element, bo, props));\n      return commands;\n    }\n  });\n\n\n  var asyncAfterEntry = entryFactory.checkbox({\n    id: idPrefix + 'asyncAfter',\n    label: labelPrefix + translate('Asynchronous After'),\n    modelProperty: 'asyncAfter',\n\n    get: function(element, node) {\n      var bo = getBusinessObject(element);\n      return {\n        asyncAfter: isAsyncAfter(bo)\n      };\n    },\n\n    set: function(element, values) {\n      var bo = getBusinessObject(element);\n      var asyncAfter = !!values.asyncAfter;\n\n      var props = {\n        'camunda:asyncAfter': asyncAfter\n      };\n\n      var commands = [];\n      if (!isAsyncBefore(bo) && !asyncAfter) {\n        props = assign({ 'camunda:exclusive' : true }, props);\n        if (canRemoveFailedJobRetryTimeCycle(element)) {\n          commands.push(removeFailedJobRetryTimeCycle(bo, element));\n        }\n      }\n\n      commands.push(cmdHelper.updateBusinessObject(element, bo, props));\n      return commands;\n    }\n  });\n\n\n  var exclusiveEntry = entryFactory.checkbox({\n    id: idPrefix + 'exclusive',\n    label: labelPrefix + translate('Exclusive'),\n    modelProperty: 'exclusive',\n\n    get: function(element, node) {\n      var bo = getBusinessObject(element);\n      return { exclusive: isExclusive(bo) };\n    },\n\n    set: function(element, values) {\n      var bo = getBusinessObject(element);\n      return cmdHelper.updateBusinessObject(element, bo, { 'camunda:exclusive': !!values.exclusive });\n    },\n\n    hidden: function(element) {\n      var bo = getBusinessObject(element);\n      return bo && !isAsyncAfter(bo) && !isAsyncBefore(bo);\n    }\n  });\n\n  return [ asyncBeforeEntry, asyncAfterEntry, exclusiveEntry ];\n};\n","'use strict';\n\nvar cmdHelper = require('../../../../helper/CmdHelper'),\n    entryFactory = require('../../../../factory/EntryFactory'),\n    elementHelper = require('../../../../helper/ElementHelper'),\n    extensionElementsHelper = require('../../../../helper/ExtensionElementsHelper');\n\n\nvar resultVariable = require('./ResultVariable');\n\nvar getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject;\nvar is = require('bpmn-js/lib/util/ModelUtil').is;\n\nvar forEach = require('lodash/collection/forEach');\n\nvar attributeInfo = {\n  bpmn: {\n    element: 'calledElement',\n    binding: 'camunda:calledElementBinding',\n    version: 'camunda:calledElementVersion',\n    tenantId: 'camunda:calledElementTenantId'\n  },\n\n  cmmn: {\n    element: 'camunda:caseRef',\n    binding: 'camunda:caseBinding',\n    version: 'camunda:caseVersion',\n    tenantId: 'camunda:caseTenantId'\n  },\n\n  dmn: {\n    element: 'camunda:decisionRef',\n    binding: 'camunda:decisionRefBinding',\n    version: 'camunda:decisionRefVersion',\n    tenantId: 'camunda:decisionRefTenantId'\n  }\n};\n\nvar bindingOptions = [\n  {\n    name: 'latest',\n    value: 'latest'\n  },\n  {\n    name: 'deployment',\n    value: 'deployment'\n  },\n  {\n    name: 'version',\n    value: 'version'\n  }\n];\n\nvar mapDecisionResultOptions = [\n  {\n    name: 'singleEntry',\n    value: 'singleEntry'\n  },\n  {\n    name:'singleResult',\n    value:'singleResult'\n  },\n  {\n    name:'collectEntries',\n    value:'collectEntries'\n  },\n  {\n    name:'resultList',\n    value:'resultList'\n  }\n];\n\nvar delegateVariableMappingOptions = [\n  {\n    name: 'variableMappingClass',\n    value: 'variableMappingClass'\n  },\n  {\n    name: 'variableMappingDelegateExpression',\n    value: 'variableMappingDelegateExpression'\n  }\n];\n\nfunction getCamundaInWithBusinessKey(element) {\n  var camundaIn = [],\n      bo = getBusinessObject(element);\n\n  var camundaInParams = extensionElementsHelper.getExtensionElements(bo, 'camunda:In');\n  if (camundaInParams) {\n    forEach(camundaInParams, function(param) {\n      if (param.businessKey) {\n        camundaIn.push(param);\n      }\n    });\n  }\n  return camundaIn;\n}\n\nfunction setBusinessKey(element, bpmnFactory) {\n  var bo = getBusinessObject(element);\n  var commands = [];\n\n  var extensionElements = bo.extensionElements;\n  if (!extensionElements) {\n    extensionElements = elementHelper.createElement('bpmn:ExtensionElements', { values: [] }, bo, bpmnFactory);\n    commands.push(cmdHelper.updateProperties(element, { extensionElements: extensionElements }));\n  }\n\n  var camundaIn = elementHelper.createElement(\n    'camunda:In',\n    { 'businessKey': '#{execution.processBusinessKey}' },\n    extensionElements,\n    bpmnFactory\n  );\n\n  commands.push(cmdHelper.addAndRemoveElementsFromList(\n    element,\n    extensionElements,\n    'values',\n    'extensionElements',\n    [ camundaIn ],[]\n  ));\n\n  return commands;\n}\n\nfunction deleteBusinessKey(element) {\n  var camundaInExtensions = getCamundaInWithBusinessKey(element);\n  var commands = [];\n  forEach(camundaInExtensions, function(elem) {\n    commands.push(extensionElementsHelper.removeEntry(getBusinessObject(element), element, elem));\n  });\n  return commands;\n}\n\nfunction isSupportedCallableType(type) {\n  return [ 'bpmn', 'cmmn', 'dmn' ].indexOf(type) !== -1;\n}\n\nmodule.exports = function(element, bpmnFactory, options, translate) {\n\n  var getCallableType = options.getCallableType;\n\n  var entries = [];\n\n  function getAttribute(element, prop) {\n    var type = getCallableType(element);\n    return (attributeInfo[type] || {})[prop];\n  }\n\n  function getCallActivityBindingValue(element) {\n    var type = getCallableType(element);\n    var bo = getBusinessObject(element);\n    var attr = (attributeInfo[type] || {}).binding;\n    return bo.get(attr);\n  }\n\n  function getDelegateVariableMappingType(element) {\n    var bo = getBusinessObject(element);\n\n    var boVariableMappingClass = bo.get('camunda:variableMappingClass'),\n        boVariableMappingDelegateExpression = bo.get('camunda:variableMappingDelegateExpression');\n\n    var delegateVariableMappingType = '';\n    if (typeof boVariableMappingClass !== 'undefined') {\n      delegateVariableMappingType = 'variableMappingClass';\n    } else\n\n    if (typeof boVariableMappingDelegateExpression !== 'undefined') {\n      delegateVariableMappingType = 'variableMappingDelegateExpression';\n    }\n\n    return delegateVariableMappingType;\n  }\n\n\n  entries.push(entryFactory.textField({\n    id: 'callable-element-ref',\n    dataValueLabel: 'callableElementLabel',\n    modelProperty: 'callableElementRef',\n\n    get: function(element, node) {\n      var callableElementRef;\n\n      var attr = getAttribute(element, 'element');\n      if (attr) {\n        var bo = getBusinessObject(element);\n        callableElementRef = bo.get(attr);\n      }\n\n      var label = '';\n      var type = getCallableType(element);\n      if (type === 'bpmn') {\n        label = translate('Called Element');\n      }\n      else if (type === 'cmmn') {\n        label = translate('Case Ref');\n      }\n      else if (type === 'dmn') {\n        label = translate('Decision Ref');\n      }\n\n      return {\n        callableElementRef: callableElementRef,\n        callableElementLabel: label\n      };\n    },\n\n    set: function(element, values, node) {\n      var newCallableElementRef = values.callableElementRef;\n      var attr = getAttribute(element, 'element');\n\n      var props = {};\n      props[attr] = newCallableElementRef || '';\n\n      return cmdHelper.updateProperties(element, props);\n    },\n\n    validate: function(element, values, node) {\n      var elementRef = values.callableElementRef;\n      var type = getCallableType(element);\n      return isSupportedCallableType(type) && !elementRef ? { callableElementRef: 'Value must provide a value.' } : {};\n    },\n\n    hidden: function(element, node) {\n      return !isSupportedCallableType(getCallableType(element));\n    }\n\n  }));\n\n\n  entries.push(entryFactory.selectBox({\n    id: 'callable-binding',\n    label: translate('Binding'),\n    selectOptions: bindingOptions,\n    modelProperty: 'callableBinding',\n\n    get: function(element, node) {\n      var callableBinding;\n\n      var attr = getAttribute(element, 'binding');\n      if (attr) {\n        var bo = getBusinessObject(element);\n        callableBinding = bo.get(attr) || 'latest';\n      }\n\n      return {\n        callableBinding: callableBinding\n      };\n    },\n\n    set: function(element, values, node) {\n      var binding = values.callableBinding;\n      var attr = getAttribute(element, 'binding'),\n          attrVer = getAttribute(element, 'version');\n\n      var props = {};\n      props[attr] = binding;\n      // set version value always on undefined to delete the existing value\n      props[attrVer] = undefined;\n\n      return cmdHelper.updateProperties(element, props);\n    },\n\n    hidden: function(element, node) {\n      return !isSupportedCallableType(getCallableType(element));\n    }\n\n  }));\n\n\n  entries.push(entryFactory.textField({\n    id: 'callable-version',\n    label: translate('Version'),\n    modelProperty: 'callableVersion',\n\n    get: function(element, node) {\n      var callableVersion;\n\n      var attr = getAttribute(element, 'version');\n      if (attr) {\n        var bo = getBusinessObject(element);\n        callableVersion = bo.get(attr);\n      }\n\n      return {\n        callableVersion: callableVersion\n      };\n    },\n\n    set: function(element, values, node) {\n      var version = values.callableVersion;\n      var attr = getAttribute(element, 'version');\n\n      var props = {};\n      props[attr] = version || undefined;\n\n      return cmdHelper.updateProperties(element, props);\n    },\n\n    validate: function(element, values, node) {\n      var version = values.callableVersion;\n\n      var type = getCallableType(element);\n      return isSupportedCallableType(type) && (getCallActivityBindingValue(element) === 'version') && !version ?\n             { callableVersion: translate('Value must provide a value.') } : {};\n    },\n\n    hidden: function(element, node) {\n      var type = getCallableType(element);\n      return !isSupportedCallableType(type) || getCallActivityBindingValue(element) !== 'version';\n    }\n\n  }));\n\n  entries.push(entryFactory.textField({\n    id: 'tenant-id',\n    label: translate('Tenant Id'),\n    modelProperty: 'tenantId',\n\n    get: function(element, node) {\n      var tenantId;\n\n      var attr = getAttribute(element, 'tenantId');\n      if (attr) {\n        var bo = getBusinessObject(element);\n        tenantId = bo.get(attr);\n      }\n\n      return {\n        tenantId: tenantId\n      };\n    },\n\n    set: function(element, values, node) {\n      var tenantId = values.tenantId;\n      var attr = getAttribute(element, 'tenantId');\n\n      var props = {};\n      props[attr] = tenantId || undefined;\n\n      return cmdHelper.updateProperties(element, props);\n    },\n\n    hidden: function(element, node) {\n      var type = getCallableType(element);\n      return !isSupportedCallableType(type);\n    }\n\n  }));\n\n  if (is(getBusinessObject(element), 'bpmn:CallActivity')) {\n    entries.push(entryFactory.checkbox({\n      id: 'callable-business-key',\n      label: translate('Business Key'),\n      modelProperty: 'callableBusinessKey',\n\n      get: function(element, node) {\n        var camundaIn = getCamundaInWithBusinessKey(element);\n        return {\n          callableBusinessKey: !!(camundaIn && camundaIn.length > 0)\n        };\n      },\n\n      set: function(element, values, node) {\n        if (values.callableBusinessKey) {\n          return setBusinessKey(element, bpmnFactory);\n        } else {\n          return deleteBusinessKey(element);\n        }\n      }\n    }));\n  }\n\n\n  entries = entries.concat(resultVariable(element, bpmnFactory, {\n    id: 'dmn-resultVariable',\n    getBusinessObject: getBusinessObject,\n    getImplementationType: getCallableType,\n    hideResultVariable: function(element, node) {\n      return getCallableType(element) !== 'dmn';\n    }\n  }, translate));\n\n  entries.push(entryFactory.selectBox({\n    id: 'dmn-map-decision-result',\n    label: translate('Map Decision Result'),\n    selectOptions: mapDecisionResultOptions,\n    modelProperty: 'mapDecisionResult',\n\n    get: function(element, node) {\n      var bo = getBusinessObject(element);\n      return {\n        mapDecisionResult: bo.get('camunda:mapDecisionResult') || 'resultList'\n      };\n    },\n\n    set: function(element, values, node) {\n      return cmdHelper.updateProperties(element, {\n        'camunda:mapDecisionResult': values.mapDecisionResult || 'resultList'\n      });\n    },\n\n    hidden: function(element, node) {\n      var bo = getBusinessObject(element);\n      var resultVariable = bo.get('camunda:resultVariable');\n      return !(getCallableType(element) === 'dmn' && typeof resultVariable !== 'undefined');\n    }\n\n  }));\n\n\n  entries.push(entryFactory.selectBox({\n    id: 'delegateVariableMappingType',\n    label: translate('Delegate Variable Mapping'),\n    selectOptions: delegateVariableMappingOptions,\n    emptyParameter: true,\n    modelProperty: 'delegateVariableMappingType',\n\n    get: function(element, node) {\n      return {\n        delegateVariableMappingType : getDelegateVariableMappingType(element)\n      };\n    },\n\n    set: function(element, values, node) {\n      var delegateVariableMappingType = values.delegateVariableMappingType;\n\n      var props = {\n        'camunda:variableMappingClass' : undefined,\n        'camunda:variableMappingDelegateExpression' : undefined\n      };\n\n      if (delegateVariableMappingType === 'variableMappingClass') {\n        props['camunda:variableMappingClass'] = '';\n      }\n      else if (delegateVariableMappingType === 'variableMappingDelegateExpression') {\n        props['camunda:variableMappingDelegateExpression'] = '';\n      }\n\n      return cmdHelper.updateProperties(element, props);\n    },\n\n    hidden: function(element, node) {\n      return (getCallableType(element) !== 'bpmn');\n    }\n\n  }));\n\n  entries.push(entryFactory.textField({\n    id: 'delegateVariableMapping',\n    dataValueLabel: 'delegateVariableMappingLabel',\n    modelProperty: 'delegateVariableMapping',\n\n    get: function(element, node) {\n      var bo = getBusinessObject(element);\n\n      var label = '';\n      var delegateVariableMapping = undefined;\n      var type = getDelegateVariableMappingType(element);\n\n      if (type === 'variableMappingClass') {\n        label = translate('Class');\n        delegateVariableMapping = bo.get('camunda:variableMappingClass');\n      }\n      else if (type === 'variableMappingDelegateExpression') {\n        label = translate('Delegate Expression');\n        delegateVariableMapping = bo.get('camunda:variableMappingDelegateExpression');\n      }\n\n      return {\n        delegateVariableMapping: delegateVariableMapping,\n        delegateVariableMappingLabel: label\n      };\n    },\n\n    set: function(element, values, node) {\n      var delegateVariableMapping = values.delegateVariableMapping;\n\n      var attr = 'camunda:' + getDelegateVariableMappingType(element);\n\n      var props = {};\n      props[attr] = delegateVariableMapping || undefined;\n\n      return cmdHelper.updateProperties(element, props);\n    },\n\n    validate: function(element, values, node) {\n      var delegateVariableMapping = values.delegateVariableMapping;\n      return (getCallableType(element) === 'bpmn') && !delegateVariableMapping ?\n        { delegateVariableMapping: translate('Must provide a value.') } : {};\n    },\n\n    hidden: function(element, node) {\n      return !(getCallableType(element) === 'bpmn' && getDelegateVariableMappingType(element) !== '');\n    }\n\n  }));\n\n  return entries;\n};\n","'use strict';\n\nvar entryFactory = require('../../../../factory/EntryFactory'),\n    cmdHelper    = require('../../../../helper/CmdHelper');\n\nvar DELEGATE_TYPES = [\n  'class',\n  'expression',\n  'delegateExpression'\n];\n\nvar PROPERTIES = {\n  class: 'camunda:class',\n  expression: 'camunda:expression',\n  delegateExpression: 'camunda:delegateExpression'\n};\n\nfunction isDelegate(type) {\n  return DELEGATE_TYPES.indexOf(type) !== -1;\n}\n\nfunction getAttribute(type) {\n  return PROPERTIES[type];\n}\n\n\nmodule.exports = function(element, bpmnFactory, options, translate) {\n\n  var getImplementationType = options.getImplementationType,\n      getBusinessObject     = options.getBusinessObject;\n\n  function getDelegationLabel(type) {\n    switch (type) {\n    case 'class':\n      return translate('Java Class');\n    case 'expression':\n      return translate('Expression');\n    case 'delegateExpression':\n      return translate('Delegate Expression');\n    default:\n      return '';\n    }\n  }\n\n  var delegateEntry = entryFactory.textField({\n    id: 'delegate',\n    label: translate('Value'),\n    dataValueLabel: 'delegationLabel',\n    modelProperty: 'delegate',\n\n    get: function(element, node) {\n      var bo = getBusinessObject(element);\n      var type = getImplementationType(element);\n      var attr = getAttribute(type);\n      var label = getDelegationLabel(type);\n      return {\n        delegate: bo.get(attr),\n        delegationLabel: label\n      };\n    },\n\n    set: function(element, values, node) {\n      var bo = getBusinessObject(element);\n      var type = getImplementationType(element);\n      var attr = getAttribute(type);\n      var prop = {};\n      prop[attr] = values.delegate || '';\n      return cmdHelper.updateBusinessObject(element, bo, prop);\n    },\n\n    validate: function(element, values, node) {\n      return isDelegate(getImplementationType(element)) && !values.delegate ? { delegate: 'Must provide a value' } : {};\n    },\n\n    hidden: function(element, node) {\n      return !isDelegate(getImplementationType(element));\n    }\n\n  });\n\n  return [ delegateEntry ];\n\n};\n","'use strict';\n\nvar getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject;\n\nvar domQuery = require('min-dom/lib/query'),\n    domClosest = require('min-dom/lib/closest'),\n    domify = require('min-dom/lib/domify'),\n    forEach = require('lodash/collection/forEach');\n\nvar elementHelper = require('../../../../helper/ElementHelper'),\n    cmdHelper = require('../../../../helper/CmdHelper'),\n    utils = require('../../../../Utils');\n\nfunction getSelectBox(node, id) {\n  var currentTab = domClosest(node, 'div.bpp-properties-tab');\n  var query = 'select[name=selectedExtensionElement]' + (id ? '[id=cam-extensionElements-' + id + ']' : '');\n  return domQuery(query, currentTab);\n}\n\nfunction getSelected(node, id) {\n  var selectBox = getSelectBox(node, id);\n  return {\n    value: (selectBox || {}).value,\n    idx: (selectBox || {}).selectedIndex\n  };\n}\n\nfunction generateElementId(prefix) {\n  prefix = prefix + '_';\n  return utils.nextId(prefix);\n}\n\nvar CREATE_EXTENSION_ELEMENT_ACTION = 'create-extension-element',\n    REMOVE_EXTENSION_ELEMENT_ACTION = 'remove-extension-element';\n\nmodule.exports = function(element, bpmnFactory, options, translate) {\n\n  var id     = options.id,\n      prefix = options.prefix || 'elem',\n      label  = options.label || id,\n      idGeneration = (options.idGeneration === false) ? options.idGeneration : true,\n      businessObject = options.businessObject || getBusinessObject(element);\n\n  var modelProperty = options.modelProperty || 'id';\n\n  var getElements = options.getExtensionElements;\n\n  var createElement = options.createExtensionElement,\n      canCreate     = typeof createElement === 'function';\n\n  var removeElement = options.removeExtensionElement,\n      canRemove     = typeof removeElement === 'function';\n\n  var onSelectionChange = options.onSelectionChange;\n\n  var hideElements = options.hideExtensionElements,\n      canBeHidden  = typeof hideElements === 'function';\n\n  var setOptionLabelValue = options.setOptionLabelValue;\n\n  var defaultSize = options.size || 5,\n      resizable   = options.resizable;\n\n  var reference = options.reference || undefined;\n\n  var selectionChanged = function(element, node, event, scope) {\n    if (typeof onSelectionChange === 'function') {\n      return onSelectionChange(element, node, event, scope);\n    }\n  };\n\n  var createOption = function(value) {\n    return '<option value=\"' + value + '\" data-value data-name=\"extensionElementValue\">' + value + '</option>';\n  };\n\n  var initSelectionSize = function(selectBox, optionsLength) {\n    if (resizable) {\n      selectBox.size = optionsLength > defaultSize ? optionsLength : defaultSize;\n    }\n  };\n\n  return {\n    id: id,\n    html: '<div class=\"bpp-row bpp-element-list\" ' +\n            (canBeHidden ? 'data-show=\"hideElements\"' : '') + '>' +\n            '<label for=\"cam-extensionElements-' + id + '\">' + label + '</label>' +\n            '<div class=\"bpp-field-wrapper\">' +\n              '<select id=\"cam-extensionElements-' + id + '\"' +\n                      'name=\"selectedExtensionElement\" ' +\n                      'size=\"' + defaultSize + '\" ' +\n                      'data-list-entry-container ' +\n                      'data-on-change=\"selectElement\">' +\n              '</select>' +\n              (canCreate ? '<button class=\"add\" ' +\n                                   'id=\"cam-extensionElements-create-' + id + '\" ' +\n                                   'data-action=\"createElement\">' +\n                             '<span>+</span>' +\n                           '</button>' : '') +\n              (canRemove ? '<button class=\"clear\" ' +\n                                   'id=\"cam-extensionElements-remove-' + id + '\" ' +\n                                   'data-action=\"removeElement\" ' +\n                                   'data-disable=\"disableRemove\">' +\n                             '<span>-</span>' +\n                           '</button>' : '') +\n            '</div>' +\n          '</div>',\n\n    get: function(element, node) {\n      var elements = getElements(element, node);\n\n      var result = [];\n      forEach(elements, function(elem) {\n        result.push({\n          extensionElementValue: elem.get(modelProperty)\n        });\n      });\n\n      var selectBox = getSelectBox(node.parentNode, id);\n      initSelectionSize(selectBox, result.length);\n\n      return result;\n    },\n\n    set: function(element, values, node) {\n      var action = this.__action;\n      delete this.__action;\n\n      businessObject = businessObject || getBusinessObject(element);\n\n      var bo =\n        (reference && businessObject.get(reference))\n          ? businessObject.get(reference)\n          : businessObject;\n\n      var extensionElements = bo.get('extensionElements');\n\n      if (action.id === CREATE_EXTENSION_ELEMENT_ACTION) {\n        var commands = [];\n        if (!extensionElements) {\n          extensionElements = elementHelper.createElement('bpmn:ExtensionElements', { values: [] }, bo, bpmnFactory);\n          commands.push(cmdHelper.updateBusinessObject(element, bo, { extensionElements: extensionElements }));\n        }\n        commands.push(createElement(element, extensionElements, action.value, node));\n        return commands;\n\n      }\n      else if (action.id === REMOVE_EXTENSION_ELEMENT_ACTION) {\n        return removeElement(element, extensionElements, action.value, action.idx, node);\n      }\n\n    },\n\n    createListEntryTemplate: function(value, index, selectBox) {\n      initSelectionSize(selectBox, selectBox.options.length + 1);\n      return createOption(value.extensionElementValue);\n    },\n\n    deselect: function(element, node) {\n      var selectBox = getSelectBox(node, id);\n      selectBox.selectedIndex = -1;\n    },\n\n    getSelected: function(element, node) {\n      return getSelected(node, id);\n    },\n\n    setControlValue: function(element, node, option, property, value, idx) {\n      node.value = value;\n\n      if (!setOptionLabelValue) {\n        node.text = value;\n      } else {\n        setOptionLabelValue(element, node, option, property, value, idx);\n      }\n    },\n\n    createElement: function(element, node) {\n      // create option template\n      var generatedId;\n      if (idGeneration) {\n        generatedId = generateElementId(prefix);\n      }\n\n      var selectBox = getSelectBox(node, id);\n      var template = domify(createOption(generatedId));\n\n      // add new empty option as last child element\n      selectBox.appendChild(template);\n\n      // select last child element\n      selectBox.lastChild.selected = 'selected';\n      selectionChanged(element, node);\n\n      // update select box size\n      initSelectionSize(selectBox, selectBox.options.length);\n\n      this.__action = {\n        id: CREATE_EXTENSION_ELEMENT_ACTION,\n        value: generatedId\n      };\n\n      return true;\n    },\n\n    removeElement: function(element, node) {\n      var selection = getSelected(node, id);\n\n      var selectBox = getSelectBox(node, id);\n      selectBox.removeChild(selectBox.options[selection.idx]);\n\n      // update select box size\n      initSelectionSize(selectBox, selectBox.options.length);\n\n      this.__action = {\n        id: REMOVE_EXTENSION_ELEMENT_ACTION,\n        value: selection.value,\n        idx: selection.idx\n      };\n\n      return true;\n    },\n\n    hideElements: function(element, entryNode, node, scopeNode) {\n      return !hideElements(element, entryNode, node, scopeNode);\n    },\n\n    disableRemove: function(element, entryNode, node, scopeNode) {\n      return (getSelected(entryNode, id) || {}).idx < 0;\n    },\n\n    selectElement: selectionChanged\n  };\n\n};\n","'use strict';\n\nvar entryFactory = require('../../../../factory/EntryFactory'),\n    cmdHelper    = require('../../../../helper/CmdHelper');\n\nmodule.exports = function(element, bpmnFactory, options, translate) {\n\n  var getImplementationType = options.getImplementationType,\n      getBusinessObject     = options.getBusinessObject;\n\n  function isExternal(element) {\n    return getImplementationType(element) === 'external';\n  }\n\n  var topicEntry = entryFactory.textField({\n    id: 'externalTopic',\n    label: translate('Topic'),\n    modelProperty: 'externalTopic',\n\n    get: function(element, node) {\n      var bo = getBusinessObject(element);\n      return { externalTopic: bo.get('camunda:topic') };\n    },\n\n    set: function(element, values, node) {\n      var bo = getBusinessObject(element);\n      return cmdHelper.updateBusinessObject(element, bo, {\n        'camunda:topic': values.externalTopic\n      });\n    },\n\n    validate: function(element, values, node) {\n      return isExternal(element) && !values.externalTopic ? { externalTopic: 'Must provide a value' } : {};\n    },\n\n    hidden: function(element, node) {\n      return !isExternal(element);\n    }\n\n  });\n\n  return [ topicEntry ];\n\n};\n","'use strict';\n\nvar entryFactory = require('../../../../factory/EntryFactory');\n\nvar cmdHelper = require('../../../../helper/CmdHelper');\n\nmodule.exports = function(element, bpmnFactory, options, translate) {\n\n  var getBusinessObject = options.getBusinessObject;\n\n  var externalTaskPriorityEntry = entryFactory.textField({\n    id: 'externalTaskPriority',\n    label: translate('Task Priority'),\n    modelProperty: 'taskPriority',\n\n    get: function(element, node) {\n      var bo = getBusinessObject(element);\n      return {\n        taskPriority: bo.get('camunda:taskPriority')\n      };\n    },\n\n    set: function(element, values) {\n      var bo = getBusinessObject(element);\n      return cmdHelper.updateBusinessObject(element, bo, {\n        'camunda:taskPriority': values.taskPriority || undefined\n      });\n    }\n\n  });\n\n  return [ externalTaskPriorityEntry ];\n\n};\n","'use strict';\n\nvar extensionElementsHelper = require('../../../../helper/ExtensionElementsHelper'),\n    elementHelper = require('../../../../helper/ElementHelper'),\n    cmdHelper = require('../../../../helper/CmdHelper');\n\nvar utils = require('../../../../Utils');\n\nvar entryFactory = require('../../../../factory/EntryFactory');\n\nvar extensionElementsEntry = require('./ExtensionElements');\n\nvar ModelUtil         = require('bpmn-js/lib/util/ModelUtil'),\n    getBusinessObject = ModelUtil.getBusinessObject;\n\nvar assign = require('lodash/object/assign');\n\n\nvar DEFAULT_PROPS = {\n  'stringValue': undefined,\n  'string': undefined,\n  'expression': undefined\n};\n\nvar CAMUNDA_FIELD_EXTENSION_ELEMENT = 'camunda:Field';\n\nmodule.exports = function(element, bpmnFactory, translate, options) {\n\n  options = options || {};\n\n  var insideListener = !!options.insideListener,\n      idPrefix        = options.idPrefix || '',\n      getSelectedListener = options.getSelectedListener,\n      businessObject = options.businessObject || getBusinessObject(element);\n\n  var entries = [];\n\n  var isSelected = function(element, node) {\n    return getSelectedField(element, node);\n  };\n\n  function getSelectedField(element, node) {\n    var selected = fieldEntry.getSelected(element, node.parentNode);\n\n    if (selected.idx === -1) {\n      return;\n    }\n\n    var fields = getCamundaFields(element, node);\n\n    return fields[selected.idx];\n  }\n\n  function getCamundaFields(element, node) {\n    if (!insideListener) {\n      return (\n        businessObject &&\n        extensionElementsHelper.getExtensionElements(businessObject, CAMUNDA_FIELD_EXTENSION_ELEMENT)\n      ) || [];\n    }\n    return getCamundaListenerFields(element, node);\n  }\n\n  function getCamundaListenerFields(element, node) {\n    var selectedListener = getSelectedListener(element, node);\n    return selectedListener && selectedListener.fields || [];\n  }\n\n  function getFieldType(bo) {\n    var fieldType = 'string';\n\n    var expressionValue = bo && bo.expression;\n    var stringValue = bo && (bo.string || bo.stringValue);\n\n    if (typeof stringValue !== 'undefined') {\n      fieldType = 'string';\n    } else if (typeof expressionValue !== 'undefined') {\n      fieldType = 'expression';\n    }\n\n    return fieldType;\n  }\n\n  var setOptionLabelValue = function() {\n    return function(element, node, option, property, value, idx) {\n      var camundaFields = getCamundaFields(element, node);\n      var field = camundaFields[idx];\n\n      value = (field.name) ? field.name : '<empty>';\n\n      var label = idx + ' : ' + value;\n\n      option.text = label;\n    };\n  };\n\n  var newElement = function() {\n    return function(element, extensionElements, value, node) {\n\n      var props = {\n        name: '',\n        string: ''\n      };\n\n      var newFieldElem;\n\n      if (!insideListener) {\n\n        newFieldElem = elementHelper.createElement(CAMUNDA_FIELD_EXTENSION_ELEMENT, props, extensionElements, bpmnFactory);\n        return cmdHelper.addElementsTolist(element, extensionElements, 'values', [ newFieldElem ]);\n\n      } else {\n\n        var selectedListener = getSelectedListener(element, node);\n        newFieldElem = elementHelper.createElement(CAMUNDA_FIELD_EXTENSION_ELEMENT, props, selectedListener, bpmnFactory);\n        return cmdHelper.addElementsTolist(element, selectedListener, 'fields', [ newFieldElem ]);\n\n      }\n\n    };\n  };\n\n  var removeElement = function() {\n    return function(element, extensionElements, value, idx, node) {\n      var camundaFields= getCamundaFields(element, node);\n      var field = camundaFields[idx];\n      if (field) {\n        if (!insideListener) {\n          return extensionElementsHelper.removeEntry(businessObject, element, field);\n        }\n        var selectedListener = getSelectedListener(element, node);\n        return cmdHelper.removeElementsFromList(element, selectedListener, 'fields', null, [ field ]);\n      }\n    };\n  };\n\n\n  var fieldEntry = extensionElementsEntry(element, bpmnFactory, {\n    id : idPrefix + 'fields',\n    label : translate('Fields'),\n    modelProperty: 'fieldName',\n    idGeneration: 'false',\n\n    businessObject: businessObject,\n\n    createExtensionElement: newElement(),\n    removeExtensionElement: removeElement(),\n\n    getExtensionElements: function(element, node) {\n      return getCamundaFields(element, node);\n    },\n\n    setOptionLabelValue: setOptionLabelValue()\n\n  });\n  entries.push(fieldEntry);\n\n\n  entries.push(entryFactory.validationAwareTextField({\n    id: idPrefix + 'field-name',\n    label: translate('Name'),\n    modelProperty: 'fieldName',\n\n    getProperty: function(element, node) {\n      return (getSelectedField(element, node) || {}).name;\n    },\n\n    setProperty: function(element, values, node) {\n      var selectedField = getSelectedField(element, node);\n      return cmdHelper.updateBusinessObject(element, selectedField, { name : values.fieldName });\n    },\n\n    validate: function(element, values, node) {\n      var bo = getSelectedField(element, node);\n\n      var validation = {};\n      if (bo) {\n        var nameValue = values.fieldName;\n\n        if (nameValue) {\n          if (utils.containsSpace(nameValue)) {\n            validation.fieldName = translate('Name must not contain spaces');\n          }\n        } else {\n          validation.fieldName = translate('Parameter must have a name');\n        }\n      }\n\n      return validation;\n    },\n\n    hidden: function(element, node) {\n      return !isSelected(element, node);\n    }\n\n  }));\n\n  var fieldTypeOptions = [\n    {\n      name: translate('String'),\n      value: 'string'\n    },\n    {\n      name: translate('Expression'),\n      value: 'expression'\n    }\n  ];\n\n  entries.push(entryFactory.selectBox({\n    id: idPrefix + 'field-type',\n    label: translate('Type'),\n    selectOptions: fieldTypeOptions,\n    modelProperty: 'fieldType',\n\n    get: function(element, node) {\n      var bo = getSelectedField(element, node);\n\n      var fieldType = getFieldType(bo);\n\n      return {\n        fieldType: fieldType\n      };\n    },\n\n    set: function(element, values, node) {\n      var props = assign({}, DEFAULT_PROPS);\n\n      var fieldType = values.fieldType;\n\n      if (fieldType === 'string') {\n        props.string = '';\n      }\n      else if (fieldType === 'expression') {\n        props.expression = '';\n      }\n\n      return cmdHelper.updateBusinessObject(element, getSelectedField(element, node), props);\n    },\n\n    hidden: function(element, node) {\n      return !isSelected(element, node);\n    }\n\n  }));\n\n\n  entries.push(entryFactory.textBox({\n    id: idPrefix + 'field-value',\n    label: translate('Value'),\n    modelProperty: 'fieldValue',\n\n    get: function(element, node) {\n      var bo = getSelectedField(element, node);\n      var fieldType = getFieldType(bo);\n\n      var fieldValue;\n\n      if (fieldType === 'string') {\n        fieldValue = bo && (bo.string || bo.stringValue);\n      }\n      else if (fieldType === 'expression') {\n        fieldValue = bo && bo.expression;\n      }\n\n      return {\n        fieldValue: fieldValue\n      };\n    },\n\n    set: function(element, values, node) {\n      var bo = getSelectedField(element, node);\n      var fieldType = getFieldType(bo);\n\n      var props = assign({}, DEFAULT_PROPS);\n\n      var fieldValue = values.fieldValue || undefined;\n\n      if (fieldType === 'string') {\n        props.string = fieldValue;\n      }\n      else if (fieldType === 'expression') {\n        props.expression = fieldValue;\n      }\n\n      return cmdHelper.updateBusinessObject(element, bo, props);\n\n    },\n\n    validate: function(element, values, node) {\n      var bo = getSelectedField(element, node);\n\n      var validation = {};\n      if (bo) {\n        if (!values.fieldValue) {\n          validation.fieldValue = translate('Must provide a value');\n        }\n      }\n\n      return validation;\n    },\n\n    show: function(element, node) {\n      return isSelected(element, node);\n    }\n\n  }));\n\n  return entries;\n\n};\n","'use strict';\r\n\r\nvar entryFactory = require('../../../../factory/EntryFactory');\r\n\r\nvar cmdHelper = require('../../../../helper/CmdHelper');\r\n\r\nmodule.exports = function(element, bpmnFactory, options, translate) {\r\n\r\n  var getBusinessObject = options.getBusinessObject;\r\n\r\n  var historyTimeToLiveEntry = entryFactory.textField({\r\n    id: 'historyTimeToLive',\r\n    label: translate('History Time To Live'),\r\n    modelProperty: 'historyTimeToLive',\r\n\r\n    get: function(element, node) {\r\n      var bo = getBusinessObject(element);\r\n      var historyTimeToLive = bo.get('camunda:historyTimeToLive');\r\n\r\n      return {\r\n        historyTimeToLive: historyTimeToLive ? historyTimeToLive : ''\r\n      };\r\n    },\r\n\r\n    set: function(element, values) {\r\n      var bo = getBusinessObject(element);\r\n      return cmdHelper.updateBusinessObject(element, bo, {\r\n        'camunda:historyTimeToLive': values.historyTimeToLive || undefined\r\n      });\r\n    }    \r\n    \r\n  });\r\n\r\n  return [ historyTimeToLiveEntry ];\r\n};\r\n","'use strict';\n\nvar entryFactory = require('../../../../factory/EntryFactory'),\n    cmdHelper = require('../../../../helper/CmdHelper'),\n    extensionElementsHelper = require('../../../../helper/ExtensionElementsHelper'),\n    elementHelper = require('../../../../helper/ElementHelper');\n\nvar assign = require('lodash/object/assign');\nvar map = require('lodash/collection/map');\n\nvar DEFAULT_DELEGATE_PROPS = [ 'class', 'expression', 'delegateExpression' ];\n\nvar DELEGATE_PROPS = {\n  'camunda:class': undefined,\n  'camunda:expression': undefined,\n  'camunda:delegateExpression': undefined,\n  'camunda:resultVariable': undefined\n};\n\nvar DMN_CAPABLE_PROPS = {\n  'camunda:decisionRef': undefined,\n  'camunda:decisionRefBinding': 'latest',\n  'camunda:decisionRefVersion': undefined,\n  'camunda:mapDecisionResult': 'resultList',\n  'camunda:decisionRefTenantId': undefined\n};\n\n\nvar EXTERNAL_CAPABLE_PROPS = {\n  'camunda:type': undefined,\n  'camunda:topic': undefined\n};\n\nmodule.exports = function(element, bpmnFactory, options, translate) {\n\n  var DEFAULT_OPTIONS = [\n    { value: 'class', name: translate('Java Class') },\n    { value: 'expression', name: translate('Expression') },\n    { value: 'delegateExpression', name: translate('Delegate Expression') }\n  ];\n\n  var DMN_OPTION = [\n    { value: 'dmn', name: translate('DMN') }\n  ];\n\n  var EXTERNAL_OPTION = [\n    { value: 'external', name: translate('External') }\n  ];\n\n  var CONNECTOR_OPTION = [\n    { value: 'connector', name: translate('Connector') }\n  ];\n\n  var SCRIPT_OPTION = [\n    { value: 'script', name: translate('Script') }\n  ];\n\n  var getType           = options.getImplementationType,\n      getBusinessObject = options.getBusinessObject;\n\n  var hasDmnSupport             = options.hasDmnSupport,\n      hasExternalSupport        = options.hasExternalSupport,\n      hasServiceTaskLikeSupport = options.hasServiceTaskLikeSupport,\n      hasScriptSupport          = options.hasScriptSupport;\n\n  var entries = [];\n\n  var selectOptions = DEFAULT_OPTIONS.concat([]);\n\n  if (hasDmnSupport) {\n    selectOptions = selectOptions.concat(DMN_OPTION);\n  }\n\n  if (hasExternalSupport) {\n    selectOptions = selectOptions.concat(EXTERNAL_OPTION);\n  }\n\n  if (hasServiceTaskLikeSupport) {\n    selectOptions = selectOptions.concat(CONNECTOR_OPTION);\n  }\n\n  if (hasScriptSupport) {\n    selectOptions = selectOptions.concat(SCRIPT_OPTION);\n  }\n\n  selectOptions.push({ value: '' });\n\n  entries.push(entryFactory.selectBox({\n    id : 'implementation',\n    label: translate('Implementation'),\n    selectOptions: selectOptions,\n    modelProperty: 'implType',\n\n    get: function(element, node) {\n      return {\n        implType: getType(element) || ''\n      };\n    },\n\n    set: function(element, values, node) {\n      var bo = getBusinessObject(element);\n      var oldType = getType(element);\n      var newType = values.implType;\n\n      var props = assign({}, DELEGATE_PROPS);\n\n      if (DEFAULT_DELEGATE_PROPS.indexOf(newType) !== -1) {\n\n        var newValue = '';\n        if (DEFAULT_DELEGATE_PROPS.indexOf(oldType) !== -1) {\n          newValue = bo.get('camunda:' + oldType);\n        }\n        props['camunda:' + newType] = newValue;\n      }\n\n      if (hasDmnSupport) {\n        props = assign(props, DMN_CAPABLE_PROPS);\n        if (newType === 'dmn') {\n          props['camunda:decisionRef'] = '';\n        }\n      }\n\n      if (hasExternalSupport) {\n        props = assign(props, EXTERNAL_CAPABLE_PROPS);\n        if (newType === 'external') {\n          props['camunda:type'] = 'external';\n          props['camunda:topic'] = '';\n        }\n      }\n\n      if (hasScriptSupport) {      \n        props['camunda:script'] = undefined;\n\n        if (newType === 'script') {\n          props['camunda:script'] = elementHelper.createElement('camunda:Script', {}, bo, bpmnFactory);\n        }\n      }\n\n      var commands = [];\n      commands.push(cmdHelper.updateBusinessObject(element, bo, props));\n\n      if (hasServiceTaskLikeSupport) {\n        var connectors = extensionElementsHelper.getExtensionElements(bo, 'camunda:Connector');\n        commands.push(map(connectors, function(connector) {\n          return extensionElementsHelper.removeEntry(bo, element, connector);\n        }));\n\n        if (newType === 'connector') {\n          var extensionElements = bo.get('extensionElements');\n          if (!extensionElements) {\n            extensionElements = elementHelper.createElement('bpmn:ExtensionElements', { values: [] }, bo, bpmnFactory);\n            commands.push(cmdHelper.updateBusinessObject(element, bo, { extensionElements: extensionElements }));\n          }\n          var connector = elementHelper.createElement('camunda:Connector', {}, extensionElements, bpmnFactory);\n          commands.push(cmdHelper.addAndRemoveElementsFromList(\n            element,\n            extensionElements,\n            'values',\n            'extensionElements',\n            [ connector ],\n            []\n          ));\n        }\n      }\n\n      return commands;\n\n    }\n  }));\n\n  return entries;\n\n};\n","'use strict';\n\nvar getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject;\n\nvar elementHelper = require('../../../../helper/ElementHelper'),\n    extensionElementsHelper = require('../../../../helper/ExtensionElementsHelper'),\n    inputOutputHelper = require('../../../../helper/InputOutputHelper'),\n    cmdHelper = require('../../../../helper/CmdHelper');\n\nvar extensionElementsEntry = require('./ExtensionElements');\n\n\nfunction getInputOutput(element, insideConnector) {\n  return inputOutputHelper.getInputOutput(element, insideConnector);\n}\n\nfunction getConnector(element) {\n  return inputOutputHelper.getConnector(element);\n}\n\nfunction getInputParameters(element, insideConnector) {\n  return inputOutputHelper.getInputParameters(element, insideConnector);\n}\n\nfunction getOutputParameters(element, insideConnector) {\n  return inputOutputHelper.getOutputParameters(element, insideConnector);\n}\n\nfunction getInputParameter(element, insideConnector, idx) {\n  return inputOutputHelper.getInputParameter(element, insideConnector, idx);\n}\n\nfunction getOutputParameter(element, insideConnector, idx) {\n  return inputOutputHelper.getOutputParameter(element, insideConnector, idx);\n}\n\n\nfunction createElement(type, parent, factory, properties) {\n  return elementHelper.createElement(type, properties, parent, factory);\n}\n\nfunction createInputOutput(parent, bpmnFactory, properties) {\n  return createElement('camunda:InputOutput', parent, bpmnFactory, properties);\n}\n\nfunction createParameter(type, parent, bpmnFactory, properties) {\n  return createElement(type, parent, bpmnFactory, properties);\n}\n\n\nfunction ensureInputOutputSupported(element, insideConnector) {\n  return inputOutputHelper.isInputOutputSupported(element, insideConnector);\n}\n\nfunction ensureOutparameterSupported(element, insideConnector) {\n  return inputOutputHelper.areOutputParametersSupported(element, insideConnector);\n}\n\nmodule.exports = function(element, bpmnFactory, options, translate) {\n\n  var TYPE_LABEL = {\n    'camunda:Map': translate('Map'),\n    'camunda:List': translate('List'),\n    'camunda:Script': translate('Script')\n  };\n\n  options = options || {};\n\n  var insideConnector = !!options.insideConnector,\n      idPrefix        = options.idPrefix || '';\n\n  var getSelected = function(element, node) {\n    var selection = (inputEntry && inputEntry.getSelected(element, node)) || { idx: -1 };\n\n    var parameter = getInputParameter(element, insideConnector, selection.idx);\n    if (!parameter && outputEntry) {\n      selection = outputEntry.getSelected(element, node);\n      parameter = getOutputParameter(element, insideConnector, selection.idx);\n    }\n    return parameter;\n  };\n\n  var result = {\n    getSelectedParameter: getSelected\n  };\n\n  var entries = result.entries = [];\n\n  if (!ensureInputOutputSupported(element)) {\n    return result;\n  }\n\n  var newElement = function(type, prop, factory) {\n\n    return function(element, extensionElements, value) {\n      var commands = [];\n\n      var inputOutput = getInputOutput(element, insideConnector);\n      if (!inputOutput) {\n        var parent = !insideConnector ? extensionElements : getConnector(element);\n        inputOutput = createInputOutput(parent, bpmnFactory, {\n          inputParameters: [],\n          outputParameters: []\n        });\n\n        if (!insideConnector) {\n          commands.push(cmdHelper.addAndRemoveElementsFromList(\n            element,\n            extensionElements,\n            'values',\n            'extensionElements',\n            [ inputOutput ],\n            []\n          ));\n        } else {\n          commands.push(cmdHelper.updateBusinessObject(element, parent, { inputOutput: inputOutput }));\n        }\n      }\n\n      var newElem = createParameter(type, inputOutput, bpmnFactory, { name: value });\n      commands.push(cmdHelper.addElementsTolist(element, inputOutput, prop, [ newElem ]));\n\n      return commands;\n    };\n  };\n\n  var removeElement = function(getter, prop, otherProp) {\n    return function(element, extensionElements, value, idx) {\n      var inputOutput = getInputOutput(element, insideConnector);\n      var parameter = getter(element, insideConnector, idx);\n\n      var commands = [];\n      commands.push(cmdHelper.removeElementsFromList(element, inputOutput, prop, null, [ parameter ]));\n\n      var firstLength = inputOutput.get(prop).length-1;\n      var secondLength = (inputOutput.get(otherProp) || []).length;\n\n      if (!firstLength && !secondLength) {\n\n        if (!insideConnector) {\n          commands.push(extensionElementsHelper.removeEntry(getBusinessObject(element), element, inputOutput));\n        } else {\n          var connector = getConnector(element);\n          commands.push(cmdHelper.updateBusinessObject(element, connector, { inputOutput: undefined }));\n        }\n\n      }\n\n      return commands;\n    };\n  };\n\n  var setOptionLabelValue = function(getter) {\n    return function(element, node, option, property, value, idx) {\n      var parameter = getter(element, insideConnector, idx);\n\n      var suffix = 'Text';\n\n      var definition = parameter.get('definition');\n      if (typeof definition !== 'undefined') {\n        var type = definition.$type;\n        suffix = TYPE_LABEL[type];\n      }\n\n      option.text = (value || '') + ' : ' + suffix;\n    };\n  };\n\n\n  // input parameters ///////////////////////////////////////////////////////////////\n\n  var inputEntry = extensionElementsEntry(element, bpmnFactory, {\n    id: idPrefix + 'inputs',\n    label: translate('Input Parameters'),\n    modelProperty: 'name',\n    prefix: 'Input',\n    resizable: true,\n\n    createExtensionElement: newElement('camunda:InputParameter', 'inputParameters'),\n    removeExtensionElement: removeElement(getInputParameter, 'inputParameters', 'outputParameters'),\n\n    getExtensionElements: function(element) {\n      return getInputParameters(element, insideConnector);\n    },\n\n    onSelectionChange: function(element, node, event, scope) {\n      outputEntry && outputEntry.deselect(element, node);\n    },\n\n    setOptionLabelValue: setOptionLabelValue(getInputParameter)\n\n  });\n  entries.push(inputEntry);\n\n\n  // output parameters ///////////////////////////////////////////////////////\n\n  if (ensureOutparameterSupported(element, insideConnector)) {\n    var outputEntry = extensionElementsEntry(element, bpmnFactory, {\n      id: idPrefix + 'outputs',\n      label: translate('Output Parameters'),\n      modelProperty: 'name',\n      prefix: 'Output',\n      resizable: true,\n\n      createExtensionElement: newElement('camunda:OutputParameter', 'outputParameters'),\n      removeExtensionElement: removeElement(getOutputParameter, 'outputParameters', 'inputParameters'),\n\n      getExtensionElements: function(element) {\n        return getOutputParameters(element, insideConnector);\n      },\n\n      onSelectionChange: function(element, node, event, scope) {\n        inputEntry.deselect(element, node);\n      },\n\n      setOptionLabelValue: setOptionLabelValue(getOutputParameter)\n\n    });\n    entries.push(outputEntry);\n  }\n\n  return result;\n\n};\n","'use strict';\n\nvar is = require('bpmn-js/lib/util/ModelUtil').is;\n\nvar elementHelper = require('../../../../helper/ElementHelper'),\n    inputOutputHelper = require('../../../../helper/InputOutputHelper'),\n    cmdHelper = require('../../../../helper/CmdHelper'),\n    utils = require('../../../../Utils');\n\nvar entryFactory = require('../../../../factory/EntryFactory'),\n    script = require('./Script')('scriptFormat', 'value', true);\n\n\nfunction createElement(type, parent, factory, properties) {\n  return elementHelper.createElement(type, properties, parent, factory);\n}\n\nfunction isScript(elem) {\n  return is(elem, 'camunda:Script');\n}\n\nfunction isList(elem) {\n  return is(elem, 'camunda:List');\n}\n\nfunction isMap(elem) {\n  return is(elem, 'camunda:Map');\n}\n\nfunction ensureInputOutputSupported(element, insideConnector) {\n  return inputOutputHelper.isInputOutputSupported(element, insideConnector);\n}\n\nmodule.exports = function(element, bpmnFactory, options, translate) {\n\n  var typeInfo = {\n    'camunda:Map': {\n      value: 'map',\n      label: translate('Map')\n    },\n    'camunda:List': {\n      value: 'list',\n      label: translate('List')\n    },\n    'camunda:Script': {\n      value: 'script',\n      label: translate('Script')\n    }\n  };\n\n  options = options || {};\n\n  var insideConnector = !!options.insideConnector,\n      idPrefix        = options.idPrefix || '';\n\n  var getSelected = options.getSelectedParameter;\n\n  if (!ensureInputOutputSupported(element, insideConnector)) {\n    return [];\n  }\n\n  var entries = [];\n\n  var isSelected = function(element, node) {\n    return getSelected(element, node);\n  };\n\n\n  // parameter name ////////////////////////////////////////////////////////\n\n  entries.push(entryFactory.validationAwareTextField({\n    id: idPrefix + 'parameterName',\n    label: 'Name',\n    modelProperty: 'name',\n\n    getProperty: function(element, node) {\n      return (getSelected(element, node) || {}).name;\n    },\n\n    setProperty: function(element, values, node) {\n      var param = getSelected(element, node);\n      return cmdHelper.updateBusinessObject(element, param, values);\n    },\n\n    validate: function(element, values, node) {\n      var bo = getSelected(element, node);\n\n      var validation = {};\n      if (bo) {\n        var nameValue = values.name;\n\n        if (nameValue) {\n          if (utils.containsSpace(nameValue)) {\n            validation.name = 'Name must not contain spaces';\n          }\n        } else {\n          validation.name = 'Parameter must have a name';\n        }\n      }\n\n      return validation;\n    },\n\n    hidden: function(element, node) {\n      return !isSelected(element, node);\n    }\n  }));\n\n\n  // parameter type //////////////////////////////////////////////////////\n\n  var selectOptions = [\n    { value: 'text', name: 'Text' },\n    { value: 'script', name: 'Script' },\n    { value: 'list', name: 'List' },\n    { value: 'map', name: 'Map' }\n  ];\n\n  entries.push(entryFactory.selectBox({\n    id : idPrefix + 'parameterType',\n    label: 'Type',\n    selectOptions: selectOptions,\n    modelProperty: 'parameterType',\n\n    get: function(element, node) {\n      var bo = getSelected(element, node);\n\n      var parameterType = 'text';\n\n      if (typeof bo !== 'undefined') {\n        var definition = bo.get('definition');\n        if (typeof definition !== 'undefined') {\n          var type = definition.$type;\n          parameterType = typeInfo[type].value;\n        }\n      }\n\n      return {\n        parameterType: parameterType\n      };\n    },\n\n    set: function(element, values, node) {\n      var bo = getSelected(element, node);\n\n      var properties = {\n        value: undefined,\n        definition: undefined\n      };\n\n      var createParameterTypeElem = function(type) {\n        return createElement(type, bo, bpmnFactory);\n      };\n\n      var parameterType = values.parameterType;\n\n      if (parameterType === 'script') {\n        properties.definition = createParameterTypeElem('camunda:Script');\n      }\n      else if (parameterType === 'list') {\n        properties.definition = createParameterTypeElem('camunda:List');\n      }\n      else if (parameterType === 'map') {\n        properties.definition = createParameterTypeElem('camunda:Map');\n      }\n\n      return cmdHelper.updateBusinessObject(element, bo, properties);\n    },\n\n    show: function(element, node) {\n      return isSelected(element, node);\n    }\n\n  }));\n\n\n  // parameter value (type = text) ///////////////////////////////////////////////////////\n\n  entries.push(entryFactory.textBox({\n    id : idPrefix + 'parameterType-text',\n    label : 'Value',\n    modelProperty: 'value',\n    get: function(element, node) {\n      return {\n        value: (getSelected(element, node) || {}).value\n      };\n    },\n\n    set: function(element, values, node) {\n      var param = getSelected(element, node);\n      values.value = values.value || undefined;\n      return cmdHelper.updateBusinessObject(element, param, values);\n    },\n\n    show: function(element, node) {\n      var bo = getSelected(element, node);\n      return bo && !bo.definition;\n    }\n\n  }));\n\n\n  // parameter value (type = script) ///////////////////////////////////////////////////////\n\n  entries.push({\n    id: idPrefix + 'parameterType-script',\n    html: '<div data-show=\"isScript\">' +\n            script.template +\n          '</div>',\n    get: function(element, node) {\n      var bo = getSelected(element, node);\n      return bo && isScript(bo.definition) ? script.get(element, bo.definition) : {};\n    },\n\n    set: function(element, values, node) {\n      var bo = getSelected(element, node);\n      var update = script.set(element, values);\n      return cmdHelper.updateBusinessObject(element, bo.definition, update);\n    },\n\n    validate: function(element, values, node) {\n      var bo = getSelected(element, node);\n      return bo && isScript(bo.definition) ? script.validate(element, bo.definition) : {};\n    },\n\n    isScript: function(element, node) {\n      var bo = getSelected(element, node);\n      return bo && isScript(bo.definition);\n    },\n\n    script: script\n\n  });\n\n\n  // parameter value (type = list) ///////////////////////////////////////////////////////\n\n  entries.push(entryFactory.table({\n    id: idPrefix + 'parameterType-list',\n    modelProperties: [ 'value' ],\n    labels: [ 'Value' ],\n\n    getElements: function(element, node) {\n      var bo = getSelected(element, node);\n\n      if (bo && isList(bo.definition)) {\n        return bo.definition.items;\n      }\n\n      return [];\n    },\n\n    updateElement: function(element, values, node, idx) {\n      var bo = getSelected(element, node);\n      var item = bo.definition.items[idx];\n      return cmdHelper.updateBusinessObject(element, item, values);\n    },\n\n    addElement: function(element, node) {\n      var bo = getSelected(element, node);\n      var newValue = createElement('camunda:Value', bo.definition, bpmnFactory, { value: undefined });\n      return cmdHelper.addElementsTolist(element, bo.definition, 'items', [ newValue ]);\n    },\n\n    removeElement: function(element, node, idx) {\n      var bo = getSelected(element, node);\n      return cmdHelper.removeElementsFromList(element, bo.definition, 'items', null, [ bo.definition.items[idx] ]);\n    },\n\n    editable: function(element, node, prop, idx) {\n      var bo = getSelected(element, node);\n      var item = bo.definition.items[idx];\n      return !isMap(item) && !isList(item) && !isScript(item);\n    },\n\n    setControlValue: function(element, node, input, prop, value, idx) {\n      var bo = getSelected(element, node);\n      var item = bo.definition.items[idx];\n\n      if (!isMap(item) && !isList(item) && !isScript(item)) {\n        input.value = value;\n      } else {\n        input.value = typeInfo[item.$type].label;\n      }\n    },\n\n    show: function(element, node) {\n      var bo = getSelected(element, node);\n      return bo && bo.definition && isList(bo.definition);\n    }\n\n  }));\n\n\n  // parameter value (type = map) ///////////////////////////////////////////////////////\n\n  entries.push(entryFactory.table({\n    id: idPrefix + 'parameterType-map',\n    modelProperties: [ 'key', 'value' ],\n    labels: [ 'Key', 'Value' ],\n    addLabel: 'Add Entry',\n\n    getElements: function(element, node) {\n      var bo = getSelected(element, node);\n\n      if (bo && isMap(bo.definition)) {\n        return bo.definition.entries;\n      }\n\n      return [];\n    },\n\n    updateElement: function(element, values, node, idx) {\n      var bo = getSelected(element, node);\n      var entry = bo.definition.entries[idx];\n\n      if (isMap(entry.definition) || isList(entry.definition) || isScript(entry.definition)) {\n        values = {\n          key: values.key\n        };\n      }\n\n      return cmdHelper.updateBusinessObject(element, entry, values);\n    },\n\n    addElement: function(element, node) {\n      var bo = getSelected(element, node);\n      var newEntry = createElement('camunda:Entry', bo.definition, bpmnFactory, { key: undefined, value: undefined });\n      return cmdHelper.addElementsTolist(element, bo.definition, 'entries', [ newEntry ]);\n    },\n\n    removeElement: function(element, node, idx) {\n      var bo = getSelected(element, node);\n      return cmdHelper.removeElementsFromList(element, bo.definition, 'entries', null, [ bo.definition.entries[idx] ]);\n    },\n\n    editable: function(element, node, prop, idx) {\n      var bo = getSelected(element, node);\n      var entry = bo.definition.entries[idx];\n      return prop === 'key' || (!isMap(entry.definition) && !isList(entry.definition) && !isScript(entry.definition));\n    },\n\n    setControlValue: function(element, node, input, prop, value, idx) {\n      var bo = getSelected(element, node);\n      var entry = bo.definition.entries[idx];\n\n      if (prop === 'key' || (!isMap(entry.definition) && !isList(entry.definition) && !isScript(entry.definition))) {\n        input.value = value;\n      } else {\n        input.value = typeInfo[entry.definition.$type].label;\n      }\n    },\n\n    show: function(element, node) {\n      var bo = getSelected(element, node);\n      return bo && bo.definition && isMap(bo.definition);\n    }\n\n  }));\n\n  return entries;\n\n};\n","'use strict';\n\nvar entryFactory = require('../../../../factory/EntryFactory');\n\nvar cmdHelper = require('../../../../helper/CmdHelper');\n\nmodule.exports = function(element, bpmnFactory, options, translate) {\n\n  var getBusinessObject = options.getBusinessObject;\n\n  var jobPriorityEntry = entryFactory.textField({\n    id: 'jobPriority',\n    label: translate('Job Priority'),\n    modelProperty: 'jobPriority',\n\n    get: function(element, node) {\n      var bo = getBusinessObject(element);\n      return {\n        jobPriority: bo.get('camunda:jobPriority')\n      };\n    },\n\n    set: function(element, values) {\n      var bo = getBusinessObject(element);\n      return cmdHelper.updateBusinessObject(element, bo, {\n        'camunda:jobPriority': values.jobPriority || undefined\n      });\n    }\n\n  });\n\n  return [ jobPriorityEntry ];\n\n};\n","'use strict';\n\nvar is = require('bpmn-js/lib/util/ModelUtil').is;\n\nvar entryFactory = require('../../../../factory/EntryFactory');\n\nvar asyncCapableHelper = require('../../../../helper/AsyncCapableHelper');\n\nvar elementHelper = require('../../../../helper/ElementHelper'),\n    eventDefinitionHelper = require('../../../../helper/EventDefinitionHelper'),\n    cmdHelper = require('../../../../helper/CmdHelper');\n\nfunction isAsyncBefore(bo) {\n  return asyncCapableHelper.isAsyncBefore(bo);\n}\n\nfunction isAsyncAfter(bo) {\n  return asyncCapableHelper.isAsyncAfter(bo);\n}\n\nfunction getFailedJobRetryTimeCycle(bo) {\n  return asyncCapableHelper.getFailedJobRetryTimeCycle(bo);\n}\n\nfunction removeFailedJobRetryTimeCycle(bo, element) {\n  return asyncCapableHelper.removeFailedJobRetryTimeCycle(bo, element);\n}\n\nfunction createExtensionElements(parent, bpmnFactory) {\n  return elementHelper.createElement('bpmn:ExtensionElements', { values: [] }, parent, bpmnFactory);\n}\n\nfunction createFailedJobRetryTimeCycle(parent, bpmnFactory, cycle) {\n  return elementHelper.createElement('camunda:FailedJobRetryTimeCycle', { body: cycle }, parent, bpmnFactory);\n}\n\nmodule.exports = function(element, bpmnFactory, options, translate) {\n\n  var getBusinessObject = options.getBusinessObject;\n\n  var idPrefix    = options.idPrefix || '',\n      labelPrefix = options.labelPrefix || '';\n\n  var retryTimeCycleEntry = entryFactory.textField({\n    id: idPrefix + 'retryTimeCycle',\n    label: labelPrefix + translate('Retry Time Cycle'),\n    modelProperty: 'cycle',\n\n    get: function(element, node) {\n      var retryTimeCycle = getFailedJobRetryTimeCycle(getBusinessObject(element));\n      var value = retryTimeCycle && retryTimeCycle.get('body');\n      return {\n        cycle: value\n      };\n    },\n\n    set: function(element, values, node) {\n      var newCycle = values.cycle;\n      var bo = getBusinessObject(element);\n\n      if (newCycle === '' || typeof newCycle === 'undefined') {\n        // remove retry time cycle element(s)\n        return removeFailedJobRetryTimeCycle(bo, element);\n      }\n\n      var retryTimeCycle = getFailedJobRetryTimeCycle(bo);\n\n      if (!retryTimeCycle) {\n        // add new retry time cycle element\n        var commands = [];\n\n        var extensionElements = bo.get('extensionElements');\n        if (!extensionElements) {\n          extensionElements = createExtensionElements(bo, bpmnFactory);\n          commands.push(cmdHelper.updateBusinessObject(element, bo, { extensionElements: extensionElements }));\n        }\n\n        retryTimeCycle = createFailedJobRetryTimeCycle(extensionElements, bpmnFactory, newCycle);\n        commands.push(cmdHelper.addAndRemoveElementsFromList(\n          element,\n          extensionElements,\n          'values',\n          'extensionElements',\n          [ retryTimeCycle ],\n          []\n        ));\n\n        return commands;\n      }\n\n      // update existing retry time cycle element\n      return cmdHelper.updateBusinessObject(element, retryTimeCycle, { body: newCycle });\n    },\n\n    hidden: function(element) {\n      var bo = getBusinessObject(element);\n\n      if (bo && (isAsyncBefore(bo) || isAsyncAfter(bo))) {\n        return false;\n      }\n\n      if (is(element, 'bpmn:Event')) {\n        return !eventDefinitionHelper.getTimerEventDefinition(element);\n      }\n\n      return true;\n    }\n\n  });\n\n  return [ retryTimeCycleEntry ];\n\n};\n","'use strict';\n\nvar is = require('bpmn-js/lib/util/ModelUtil').is,\n    getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject;\n\nvar extensionElementsEntry = require('./ExtensionElements'),\n    extensionElementsHelper = require('../../../../helper/ExtensionElementsHelper'),\n    cmdHelper = require('../../../../helper/CmdHelper'),\n    elementHelper = require('../../../../helper/ElementHelper'),\n    ImplementationTypeHelper = require('../../../../helper/ImplementationTypeHelper');\n\n\nfunction getListeners(bo, type) {\n  return bo && extensionElementsHelper.getExtensionElements(bo, type) || [];\n}\n\nvar CAMUNDA_EXECUTION_LISTENER_ELEMENT = 'camunda:ExecutionListener';\nvar CAMUNDA_TASK_LISTENER_ELEMENT = 'camunda:TaskListener';\n\nmodule.exports = function(element, bpmnFactory, options, translate) {\n\n  var LISTENER_TYPE_LABEL = {\n    class: translate('Java Class'),\n    expression: translate('Expression'),\n    delegateExpression: translate('Delegate Expression'),\n    script: translate('Script')\n  };\n\n  var bo;\n\n  var result = {\n    getSelectedListener: getSelectedListener\n  };\n\n  var entries = result.entries = [];\n\n  var isSequenceFlow = ImplementationTypeHelper.isSequenceFlow(element);\n\n  function getSelectedListener(element, node) {\n    var selection = (executionListenerEntry && executionListenerEntry.getSelected(element, node)) || { idx: -1 };\n\n    var listener = getListeners(bo, CAMUNDA_EXECUTION_LISTENER_ELEMENT)[selection.idx];\n    if (!listener && taskListenerEntry) {\n      selection = taskListenerEntry.getSelected(element, node);\n      listener = getListeners(bo, CAMUNDA_TASK_LISTENER_ELEMENT)[selection.idx];\n    }\n    return listener;\n  }\n\n  var setOptionLabelValue = function(type) {\n    return function(element, node, option, property, value, idx) {\n      var listeners = getListeners(bo, type);\n      var listener = listeners[idx];\n      var listenerType = ImplementationTypeHelper.getImplementationType(listener);\n\n      var event = (listener.get('event')) ? listener.get('event') : '<empty>';\n\n      var label = (event || '*') + ' : ' + (LISTENER_TYPE_LABEL[listenerType] || '');\n\n      option.text = label;\n    };\n  };\n\n  var newElement = function(element, type, initialEvent) {\n    return function(element, extensionElements, value) {\n      var props = {\n        event: initialEvent,\n        class: ''\n      };\n\n      var newElem = elementHelper.createElement(type, props, extensionElements, bpmnFactory);\n\n      return cmdHelper.addElementsTolist(element, extensionElements, 'values', [ newElem ]);\n    };\n  };\n\n  var removeElement = function(element, type) {\n    return function(element, extensionElements, value, idx) {\n      var listeners = getListeners(bo, type);\n      var listener = listeners[idx];\n      if (listener) {\n        return extensionElementsHelper.removeEntry(bo, element, listener);\n      }\n    };\n  };\n\n\n  ////////// Execution Listener\n\n  if (is(element, 'bpmn:FlowElement') || is(element, 'bpmn:Process') || is(element, 'bpmn:Participant')) {\n    bo = getBusinessObject(element);\n    if (is(element, 'bpmn:Participant')) {\n      element = element.processRef;\n      bo = bo.get('processRef');\n    }\n\n    if (bo) {\n\n      var executionListenerEntry = extensionElementsEntry(element, bpmnFactory, {\n        id : 'executionListeners',\n        label : translate('Execution Listener'),\n        modelProperty: 'name',\n        idGeneration: 'false',\n        reference: 'processRef',\n\n        createExtensionElement: newElement(element, CAMUNDA_EXECUTION_LISTENER_ELEMENT, (isSequenceFlow) ? 'take' : 'start'),\n        removeExtensionElement: removeElement(element, CAMUNDA_EXECUTION_LISTENER_ELEMENT),\n\n        getExtensionElements: function(element) {\n          return getListeners(bo, CAMUNDA_EXECUTION_LISTENER_ELEMENT);\n        },\n\n        onSelectionChange: function(element, node, event, scope) {\n          taskListenerEntry && taskListenerEntry.deselect(element, node);\n        },\n\n        setOptionLabelValue: setOptionLabelValue(CAMUNDA_EXECUTION_LISTENER_ELEMENT)\n\n      });\n      entries.push(executionListenerEntry);\n\n    }\n  }\n\n\n  ////////// Task Listener\n\n  if (is(element, 'bpmn:UserTask')) {\n    bo = getBusinessObject(element);\n\n    var taskListenerEntry = extensionElementsEntry(element, bpmnFactory, {\n      id : 'taskListeners',\n      label : translate('Task Listener'),\n      modelProperty: 'name',\n      idGeneration: 'false',\n\n      createExtensionElement: newElement(element, CAMUNDA_TASK_LISTENER_ELEMENT, 'create'),\n      removeExtensionElement: removeElement(element, CAMUNDA_TASK_LISTENER_ELEMENT),\n\n      getExtensionElements: function(element) {\n        return getListeners(bo, CAMUNDA_TASK_LISTENER_ELEMENT);\n      },\n\n      onSelectionChange: function(element, node, event, scope) {\n        executionListenerEntry.deselect(element, node);\n      },\n\n      setOptionLabelValue: setOptionLabelValue(CAMUNDA_TASK_LISTENER_ELEMENT)\n\n    });\n    entries.push(taskListenerEntry);\n  }\n\n  return result;\n\n};\n","'use strict';\n\nvar getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject;\n\nvar entryFactory = require('../../../../factory/EntryFactory');\n\nvar elementHelper = require('../../../../helper/ElementHelper'),\n    cmdHelper = require('../../../../helper/CmdHelper');\n\nvar domClasses = require('min-dom/lib/classes');\n\n/**\n * Get a property value of the loop characteristics.\n *\n * @param {djs.model.Base} element\n * @param {string} propertyName\n *\n * @return {any} the property value\n */\nfunction getProperty(element, propertyName) {\n  var loopCharacteristics = getLoopCharacteristics(element);\n  return loopCharacteristics && loopCharacteristics.get(propertyName);\n}\n\n/**\n * Get the body of a given expression.\n *\n * @param {ModdleElement<bpmn:FormalExpression>} expression\n *\n * @return {string} the body (value) of the expression\n */\nfunction getBody(expression) {\n  return expression && expression.get('body');\n}\n\n\n/**\n * Get the loop characteristics of an element.\n *\n * @param {djs.model.Base} element\n *\n * @return {ModdleElement<bpmn:MultiInstanceLoopCharacteristics>} the loop characteristics\n */\nfunction getLoopCharacteristics(element) {\n  var bo = getBusinessObject(element);\n  return bo.loopCharacteristics;\n}\n\n/**\n * Get the loop cardinality of the loop characteristics.\n *\n * @param {djs.model.Base} element\n *\n * @return {ModdleElement<bpmn:FormalExpression>} an expression representing the loop cardinality\n */\nfunction getLoopCardinality(element) {\n  return getProperty(element, 'loopCardinality');\n}\n\n/**\n * Get the loop cardinality value of the loop characteristics.\n *\n * @param {djs.model.Base} element\n *\n * @return {string} the loop cardinality value\n */\nfunction getLoopCardinalityValue(element) {\n  var loopCardinality = getLoopCardinality(element);\n  return getBody(loopCardinality);\n}\n\n/**\n * Get the completion condition of the loop characteristics.\n *\n * @param {djs.model.Base} element\n *\n * @return {ModdleElement<bpmn:FormalExpression>} an expression representing the completion condition\n */\nfunction getCompletionCondition(element) {\n  return getProperty(element, 'completionCondition');\n}\n\n/**\n * Get the completion condition value of the loop characteristics.\n *\n * @param {djs.model.Base} element\n *\n * @return {string} the completion condition value\n */\nfunction getCompletionConditionValue(element) {\n  var completionCondition = getCompletionCondition(element);\n  return getBody(completionCondition);\n}\n\n/**\n * Get the 'camunda:collection' attribute value of the loop characteristics.\n *\n * @param {djs.model.Base} element\n *\n * @return {string} the 'camunda:collection' value\n */\nfunction getCollection(element) {\n  return getProperty(element, 'camunda:collection');\n}\n\n/**\n * Get the 'camunda:elementVariable' attribute value of the loop characteristics.\n *\n * @param {djs.model.Base} element\n *\n * @return {string} the 'camunda:elementVariable' value\n */\nfunction getElementVariable(element) {\n  return getProperty(element, 'camunda:elementVariable');\n}\n\n\n/**\n * Creates 'bpmn:FormalExpression' element.\n *\n * @param {ModdleElement} parent\n * @param {string} body\n * @param {BpmnFactory} bpmnFactory\n *\n * @result {ModdleElement<bpmn:FormalExpression>} a formal expression\n */\nfunction createFormalExpression(parent, body, bpmnFactory) {\n  return elementHelper.createElement('bpmn:FormalExpression', { body: body }, parent, bpmnFactory);\n}\n\n/**\n * Updates a specific formal expression of the loop characteristics.\n *\n * @param {djs.model.Base} element\n * @param {string} propertyName\n * @param {string} newValue\n * @param {BpmnFactory} bpmnFactory\n */\nfunction updateFormalExpression(element, propertyName, newValue, bpmnFactory) {\n  var loopCharacteristics = getLoopCharacteristics(element);\n\n  var expressionProps = {};\n\n  if (!newValue) {\n    // remove formal expression\n    expressionProps[propertyName] = undefined;\n    return cmdHelper.updateBusinessObject(element, loopCharacteristics, expressionProps);\n  }\n\n  var existingExpression = loopCharacteristics.get(propertyName);\n\n  if (!existingExpression) {\n    // add formal expression\n    expressionProps[propertyName] = createFormalExpression(loopCharacteristics, newValue, bpmnFactory);\n    return cmdHelper.updateBusinessObject(element, loopCharacteristics, expressionProps);\n  }\n\n  // edit existing formal expression\n  return cmdHelper.updateBusinessObject(element, existingExpression, {\n    body: newValue\n  });\n}\n\n\nmodule.exports = function(element, bpmnFactory, translate) {\n\n  var entries = [];\n\n  // error message /////////////////////////////////////////////////////////////////\n\n  entries.push({\n    id: 'multiInstance-errorMessage',\n    html: '<div data-show=\"isValid\">' +\n             '<span class=\"bpp-icon-warning\"></span> ' +\n             translate('Must provide either loop cardinality or collection') +\n          '</div>',\n\n    isValid: function(element, node, notification, scope) {\n      var loopCharacteristics = getLoopCharacteristics(element);\n\n      var isValid = true;\n      if (loopCharacteristics) {\n        var loopCardinality = getLoopCardinalityValue(element);\n        var collection = getCollection(element);\n\n        isValid = !loopCardinality && !collection;\n      }\n\n      domClasses(node).toggle('bpp-hidden', !isValid);\n      domClasses(notification).toggle('bpp-error-message', isValid);\n\n      return isValid;\n    }\n  });\n\n  // loop cardinality //////////////////////////////////////////////////////////////\n\n  entries.push(entryFactory.textField({\n    id: 'multiInstance-loopCardinality',\n    label: translate('Loop Cardinality'),\n    modelProperty: 'loopCardinality',\n\n    get: function(element, node) {\n      return {\n        loopCardinality: getLoopCardinalityValue(element)\n      };\n    },\n\n    set: function(element, values) {\n      return updateFormalExpression(element, 'loopCardinality', values.loopCardinality, bpmnFactory);\n    }\n  }));\n\n\n  // collection //////////////////////////////////////////////////////////////////\n\n  entries.push(entryFactory.textField({\n    id: 'multiInstance-collection',\n    label: translate('Collection'),\n    modelProperty: 'collection',\n\n    get: function(element, node) {\n      return {\n        collection: getCollection(element)\n      };\n    },\n\n    set: function(element, values) {\n      var loopCharacteristics = getLoopCharacteristics(element);\n      return cmdHelper.updateBusinessObject(element, loopCharacteristics, {\n        'camunda:collection': values.collection || undefined\n      });\n    },\n\n    validate: function(element, values, node) {\n      var collection = getCollection(element);\n      var elementVariable = getElementVariable(element);\n\n      if (!collection && elementVariable) {\n        return { collection : 'Must provide a value' };\n      }\n    }\n  }));\n\n\n  // element variable ////////////////////////////////////////////////////////////\n\n  entries.push(entryFactory.textField({\n    id: 'multiInstance-elementVariable',\n    label: translate('Element Variable'),\n    modelProperty: 'elementVariable',\n\n    get: function(element, node) {\n      return {\n        elementVariable: getElementVariable(element)\n      };\n    },\n\n    set: function(element, values) {\n      var loopCharacteristics = getLoopCharacteristics(element);\n      return cmdHelper.updateBusinessObject(element, loopCharacteristics, {\n        'camunda:elementVariable': values.elementVariable || undefined\n      });\n    }\n  }));\n\n\n  // Completion Condition //////////////////////////////////////////////////////\n\n  entries.push(entryFactory.textField({\n    id: 'multiInstance-completionCondition',\n    label: translate('Completion Condition'),\n    modelProperty: 'completionCondition',\n\n    get: function(element) {\n      return {\n        completionCondition: getCompletionConditionValue(element)\n      };\n    },\n\n    set: function(element, values) {\n      return updateFormalExpression(element, 'completionCondition', values.completionCondition, bpmnFactory);\n    }\n  }));\n\n  return entries;\n\n};\n","'use strict';\n\nvar getBusinessObject = require('bpmn-js/lib/util/ModelUtil').getBusinessObject,\n    is = require('bpmn-js/lib/util/ModelUtil').is;\n\nvar factory = require('../../../../factory/EntryFactory');\n\nvar elementHelper = require('../../../../helper/ElementHelper'),\n    extensionElementsHelper = require('../../../../helper/ExtensionElementsHelper'),\n    cmdHelper = require('../../../../helper/CmdHelper'),\n    utils = require('../../../../Utils');\n\nvar assign = require('lodash/object/assign'),\n    forEach = require('lodash/collection/forEach'),\n    find = require('lodash/collection/find');\n\nfunction generatePropertyId() {\n  return utils.nextId('Property_');\n}\n\n/**\n * Get all camunda:property objects for a specific business object\n *\n * @param  {ModdleElement} parent\n *\n * @return {Array<ModdleElement>} a list of camunda:property objects\n */\nfunction getPropertyValues(parent) {\n  var properties = parent && getPropertiesElement(parent);\n  if (properties && properties.values) {\n    return properties.values;\n  }\n  return [];\n}\n\n/**\n * Get all camunda:Properties object for a specific business object\n *\n * @param  {ModdleElement} parent\n *\n * @return {ModdleElement} a camunda:Properties object\n */\nfunction getPropertiesElement(element) {\n  if (!isExtensionElements(element)) {\n    return element.properties;\n  } else {\n    return getPropertiesElementInsideExtensionElements(element);\n  }\n}\n\n/**\n * Get first camunda:Properties object for a specific bpmn:ExtensionElements\n * business object.\n *\n * @param {ModdleElement} extensionElements\n *\n * @return {ModdleElement} a camunda:Properties object\n */\nfunction getPropertiesElementInsideExtensionElements(extensionElements) {\n  return find(extensionElements.values, function(elem) {\n    return is(elem, 'camunda:Properties');\n  });\n}\n\n/**\n * Returns true, if the given business object is a bpmn:ExtensionElements.\n *\n * @param {ModdleElement} element\n *\n * @return {boolean} a boolean value\n */\nfunction isExtensionElements(element) {\n  return is(element, 'bpmn:ExtensionElements');\n}\n\n/**\n * Create a camunda:property entry using tableEntryFactory\n *\n * @param  {djs.model.Base} element\n * @param  {BpmnFactory} bpmnFactory\n * @param  {Object} options\n * @param  {string} options.id\n * @param  {Array<string>} options.modelProperties\n * @param  {Array<string>} options.labels\n * @param  {function} options.getParent Gets the parent business object\n * @param  {function} options.show Indicate when the entry will be shown, should return boolean\n */\nmodule.exports = function(element, bpmnFactory, options, translate) {\n\n  var getParent = options.getParent;\n\n  var modelProperties = options.modelProperties,\n      createParent    = options.createParent;\n\n  var bo = getBusinessObject(element);\n  if (is(element, 'bpmn:Participant')) {\n    bo = bo.get('processRef');\n  }\n\n  // build properties group only when the participant have a processRef\n  if (!bo) {\n    return;\n  }\n\n  assign(options, {\n    addLabel: translate('Add Property'),\n    getElements: function(element, node) {\n      var parent = getParent(element, node, bo);\n      return getPropertyValues(parent);\n    },\n    addElement: function(element, node) {\n      var commands = [],\n          parent = getParent(element, node, bo);\n\n      if (!parent && typeof createParent === 'function') {\n        var result = createParent(element, bo);\n        parent = result.parent;\n        commands.push(result.cmd);\n      }\n\n      var properties = getPropertiesElement(parent);\n      if (!properties) {\n        properties = elementHelper.createElement('camunda:Properties', {}, parent, bpmnFactory);\n\n        if (!isExtensionElements(parent)) {\n          commands.push(cmdHelper.updateBusinessObject(element, parent, { 'properties': properties }));\n        } else {\n          commands.push(cmdHelper.addAndRemoveElementsFromList(\n            element,\n            parent,\n            'values',\n            'extensionElements',\n            [ properties ],\n            []\n          ));\n        }\n      }\n\n      var propertyProps = {};\n      forEach(modelProperties, function(prop) {\n        propertyProps[prop] = undefined;\n      });\n\n      // create id if necessary\n      if (modelProperties.indexOf('id') >= 0) {\n        propertyProps.id = generatePropertyId();\n      }\n\n      var property = elementHelper.createElement('camunda:Property', propertyProps, properties, bpmnFactory);\n      commands.push(cmdHelper.addElementsTolist(element, properties, 'values', [ property ]));\n\n      return commands;\n    },\n    updateElement: function(element, value, node, idx) {\n      var parent = getParent(element, node, bo),\n          property = getPropertyValues(parent)[idx];\n\n      forEach(modelProperties, function(prop) {\n        value[prop] = value[prop] || undefined;\n      });\n\n      return cmdHelper.updateBusinessObject(element, property, value);\n    },\n    validate: function(element, value, node, idx) {\n      // validate id if necessary\n      if (modelProperties.indexOf('id') >= 0) {\n\n        var parent = getParent(element, node, bo),\n            properties = getPropertyValues(parent),\n            property = properties[idx];\n\n        if (property) {\n          // check if id is valid\n          var validationError = utils.isIdValid(property, value.id);\n\n          if (validationError) {\n            return { id: validationError };\n          }\n        }\n      }\n    },\n    removeElement: function(element, node, idx) {\n      var commands = [],\n          parent = getParent(element, node, bo),\n          properties = getPropertiesElement(parent),\n          propertyValues = getPropertyValues(parent),\n          currentProperty = propertyValues[idx];\n\n      commands.push(cmdHelper.removeElementsFromList(element, properties, 'values', null, [ currentProperty ]));\n\n      if (propertyValues.length === 1) {\n        // remove camunda:properties if the last existing property has been removed\n        if (!isExtensionElements(parent)) {\n          commands.push(cmdHelper.updateBusinessObject(element, parent, { properties: undefined }));\n        } else {\n          forEach(parent.values, function(value) {\n            if (is(value, 'camunda:Properties')) {\n              commands.push(extensionElementsHelper.removeEntry(bo, element, value));\n            }\n          });\n        }\n      }\n\n      return commands;\n    }\n  });\n\n  return factory.table(options);\n};\n","'use strict';\n\nvar is = require('bpmn-js/lib/util/ModelUtil').is;\n\nvar assign = require('lodash/object/assign');\n\nvar entryFactory = require('../../../../factory/EntryFactory'),\n    cmdHelper    = require('../../../../helper/CmdHelper');\n\nmodule.exports = function(element, bpmnFactory, options, translate) {\n\n  var getBusinessObject     = options.getBusinessObject,\n      hideResultVariable    = options.hideResultVariable,\n      id                    = options.id || 'resultVariable';\n\n\n  var resultVariableEntry = entryFactory.textField({\n    id: id,\n    label: translate('Result Variable'),\n    modelProperty: 'resultVariable',\n\n    get: function(element, node) {\n      var bo = getBusinessObject(element);\n      return { resultVariable: bo.get('camunda:resultVariable') };\n    },\n\n    set: function(element, values, node) {\n      var bo = getBusinessObject(element);\n\n      var resultVariable = values.resultVariable || undefined;\n\n      var props = {\n        'camunda:resultVariable': resultVariable\n      };\n\n      if (is(bo, 'camunda:DmnCapable') && !resultVariable) {\n        props = assign({ 'camunda:mapDecisionResult': 'resultList' }, props);\n      }\n\n      return cmdHelper.updateBusinessObject(element, bo, props);\n    },\n\n    hidden: function(element, node) {\n      if (typeof hideResultVariable === 'function') {\n        return hideResultVariable.apply(resultVariableEntry, arguments);\n      }\n    }\n\n  });\n\n  return [ resultVariableEntry ];\n\n};\n","'use strict';\n\nvar domQuery = require('min-dom/lib/query'),\n\n    utils = require('../../../../Utils');\n\n\nfunction getScriptType(node) {\n  return utils.selectedType('select[name=scriptType]', node.parentElement);\n}\n\n\nmodule.exports = function(scriptLanguagePropName, scriptValuePropName, isFormatRequired) {\n\n  return {\n    template:\n    '<div class=\"bpp-row bpp-textfield\">' +\n      '<label for=\"cam-script-format\">Script Format</label>' +\n      '<div class=\"bpp-field-wrapper\">' +\n        '<input id=\"cam-script-format\" type=\"text\" name=\"scriptFormat\" />' +\n        '<button class=\"clear\" data-action=\"script.clearScriptFormat\" data-show=\"script.canClearScriptFormat\">' +\n          '<span>X</span>' +\n        '</button>' +\n      '</div>' +\n    '</div>' +\n\n    '<div class=\"bpp-row\">' +\n      '<label for=\"cam-script-type\">Script Type</label>' +\n      '<div class=\"bpp-field-wrapper\">' +\n        '<select id=\"cam-script-type\" name=\"scriptType\" data-value>' +\n          '<option value=\"script\" selected>Inline Script</option>' +\n          '<option value=\"scriptResource\">External Resource</option>' +\n        '</select>' +\n      '</div>' +\n    '</div>' +\n\n    '<div class=\"bpp-row bpp-textfield\">' +\n      '<label for=\"cam-script-resource-val\" data-show=\"script.isScriptResource\">Resource</label>' +\n      '<div class=\"bpp-field-wrapper\" data-show=\"script.isScriptResource\">' +\n        '<input id=\"cam-script-resource-val\" type=\"text\" name=\"scriptResourceValue\" />' +\n        '<button class=\"clear\" data-action=\"script.clearScriptResource\" data-show=\"script.canClearScriptResource\">' +\n          '<span>X</span>' +\n        '</button>' +\n      '</div>' +\n    '</div>' +\n\n    '<div class=\"bpp-row\">' +\n      '<label for=\"cam-script-val\" data-show=\"script.isScript\">Script</label>' +\n      '<div class=\"bpp-field-wrapper\" data-show=\"script.isScript\">' +\n        '<textarea id=\"cam-script-val\" type=\"text\" name=\"scriptValue\"></textarea>' +\n      '</div>'+\n    '</div>',\n\n    get: function(element, bo) {\n      var values = {};\n\n      // read values from xml:\n      var boScriptResource = bo.get('camunda:resource'),\n          boScript = bo.get(scriptValuePropName),\n          boScriptFormat = bo.get(scriptLanguagePropName);\n\n      if (typeof boScriptResource !== 'undefined') {\n        values.scriptResourceValue = boScriptResource;\n        values.scriptType = 'scriptResource';\n      } else {\n        values.scriptValue = boScript;\n        values.scriptType = 'script';\n      }\n\n      values.scriptFormat = boScriptFormat;\n\n      return values;\n    },\n\n    set: function(element, values, containerElement) {\n      var scriptFormat = values.scriptFormat,\n          scriptType = values.scriptType,\n          scriptResourceValue = values.scriptResourceValue,\n          scriptValue = values.scriptValue;\n\n      // init update\n      var update = {\n        'camunda:resource': undefined\n      };\n      update[scriptValuePropName] = undefined;\n      update[scriptLanguagePropName] = undefined;\n\n      if (isFormatRequired) {\n        // always set language\n        update[scriptLanguagePropName] = scriptFormat || '';\n      } else\n        // set language only when scriptFormat has a value\n        if (scriptFormat !== '') {\n          update[scriptLanguagePropName] = scriptFormat;\n        }\n\n      // set either inline script or resource\n      if ('scriptResource' === scriptType) {\n        update['camunda:resource'] = scriptResourceValue || '';\n      } else {\n        update[scriptValuePropName] = scriptValue || '';\n      }\n\n      return update;\n    },\n\n    validate: function(element, values) {\n      var validationResult = {};\n\n      if (values.scriptType === 'script' && !values.scriptValue) {\n        validationResult.scriptValue = 'Must provide a value';\n      }\n\n      if (values.scriptType === 'scriptResource' && !values.scriptResourceValue) {\n        validationResult.scriptResourceValue = 'Must provide a value';\n      }\n\n      if (isFormatRequired && (!values.scriptFormat || values.scriptFormat.length === 0)) {\n        validationResult.scriptFormat = 'Must provide a value';\n      }\n\n      return validationResult;\n    },\n\n    clearScriptFormat: function(element, inputNode, btnNode, scopeNode) {\n      domQuery('input[name=scriptFormat]', scopeNode).value='';\n\n      return true;\n    },\n\n    canClearScriptFormat: function(element, inputNode, btnNode, scopeNode) {\n      var input = domQuery('input[name=scriptFormat]', scopeNode);\n\n      return input.value !== '';\n    },\n\n    clearScriptResource: function(element, inputNode, btnNode, scopeNode) {\n      domQuery('input[name=scriptResourceValue]', scopeNode).value='';\n\n      return true;\n    },\n\n    canClearScriptResource: function(element, inputNode, btnNode, scopeNode) {\n      var input = domQuery('input[name=scriptResourceValue]', scopeNode);\n\n      return input.value !== '';\n    },\n\n    clearScript: function(element, inputNode, btnNode, scopeNode) {\n      domQuery('textarea[name=scriptValue]', scopeNode).value='';\n\n      return true;\n    },\n\n    canClearScript: function(element, inputNode, btnNode, scopeNode) {\n      var input = domQuery('textarea[name=scriptValue]', scopeNode);\n\n      return input.value !== '';\n    },\n\n    isScriptResource: function(element, inputNode, btnNode, scopeNode) {\n      var scriptType = getScriptType(scopeNode);\n      return scriptType === 'scriptResource';\n    },\n\n    isScript: function(element, inputNode,  btnNode, scopeNode) {\n      var scriptType = getScriptType(scopeNode);\n      return scriptType === 'script';\n    }\n\n  };\n\n};\n","/**\n * Set attribute `name` to `val`, or get attr `name`.\n *\n * @param {Element} el\n * @param {String} name\n * @param {String} [val]\n * @api public\n */\n\nmodule.exports = function(el, name, val) {\n  // get\n  if (arguments.length == 2) {\n    return el.getAttribute(name);\n  }\n\n  // remove\n  if (val === null) {\n    return el.removeAttribute(name);\n  }\n\n  // set\n  el.setAttribute(name, val);\n\n  return el;\n};","module.exports = require('component-classes');","module.exports = function(el) {\n\n  var c;\n\n  while (el.childNodes.length) {\n    c = el.childNodes[0];\n    el.removeChild(c);\n  }\n\n  return el;\n};","module.exports = require('component-closest');","module.exports = require('component-delegate');","module.exports = require('domify');","module.exports = require('component-matches-selector');","module.exports = require('component-query');","module.exports = function(el) {\n  el.parentNode && el.parentNode.removeChild(el);\n};","import inherits from 'inherits';\n\nimport Ids from 'ids';\n\nimport Viewer from './Viewer';\n\nimport NavigatedViewer from './NavigatedViewer';\n\nimport KeyboardMoveModule from 'diagram-js/lib/navigation/keyboard-move';\nimport MoveCanvasModule from 'diagram-js/lib/navigation/movecanvas';\nimport TouchModule from 'diagram-js/lib/navigation/touch';\nimport ZoomScrollModule from 'diagram-js/lib/navigation/zoomscroll';\n\nimport AlignElementsModule from 'diagram-js/lib/features/align-elements';\nimport AutoPlaceModule from './features/auto-place';\nimport AutoResizeModule from './features/auto-resize';\nimport AutoScrollModule from 'diagram-js/lib/features/auto-scroll';\nimport BendpointsModule from 'diagram-js/lib/features/bendpoints';\nimport ContextPadModule from './features/context-pad';\nimport CopyPasteModule from './features/copy-paste';\nimport DistributeElementsModule from './features/distribute-elements';\nimport EditorActionsModule from './features/editor-actions';\nimport KeyboardModule from './features/keyboard';\nimport KeyboardMoveSelectionModule from 'diagram-js/lib/features/keyboard-move-selection';\nimport LabelEditingModule from './features/label-editing';\nimport ModelingModule from './features/modeling';\nimport MoveModule from 'diagram-js/lib/features/move';\nimport PaletteModule from './features/palette';\nimport ReplacePreviewModule from './features/replace-preview';\nimport ResizeModule from 'diagram-js/lib/features/resize';\nimport SnappingModule from './features/snapping';\nimport SearchModule from './features/search';\n\n\nvar initialDiagram =\n  '<?xml version=\"1.0\" encoding=\"UTF-8\"?>' +\n  '<bpmn:definitions xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" ' +\n                    'xmlns:bpmn=\"http://www.omg.org/spec/BPMN/20100524/MODEL\" ' +\n                    'xmlns:bpmndi=\"http://www.omg.org/spec/BPMN/20100524/DI\" ' +\n                    'xmlns:dc=\"http://www.omg.org/spec/DD/20100524/DC\" ' +\n                    'targetNamespace=\"http://bpmn.io/schema/bpmn\" ' +\n                    'id=\"Definitions_1\">' +\n    '<bpmn:process id=\"Process_1\" isExecutable=\"false\">' +\n      '<bpmn:startEvent id=\"StartEvent_1\"/>' +\n    '</bpmn:process>' +\n    '<bpmndi:BPMNDiagram id=\"BPMNDiagram_1\">' +\n      '<bpmndi:BPMNPlane id=\"BPMNPlane_1\" bpmnElement=\"Process_1\">' +\n        '<bpmndi:BPMNShape id=\"_BPMNShape_StartEvent_2\" bpmnElement=\"StartEvent_1\">' +\n          '<dc:Bounds height=\"36.0\" width=\"36.0\" x=\"173.0\" y=\"102.0\"/>' +\n        '</bpmndi:BPMNShape>' +\n      '</bpmndi:BPMNPlane>' +\n    '</bpmndi:BPMNDiagram>' +\n  '</bpmn:definitions>';\n\n\n/**\n * A modeler for BPMN 2.0 diagrams.\n *\n *\n * ## Extending the Modeler\n *\n * In order to extend the viewer pass extension modules to bootstrap via the\n * `additionalModules` option. An extension module is an object that exposes\n * named services.\n *\n * The following example depicts the integration of a simple\n * logging component that integrates with interaction events:\n *\n *\n * ```javascript\n *\n * // logging component\n * function InteractionLogger(eventBus) {\n *   eventBus.on('element.hover', function(event) {\n *     console.log()\n *   })\n * }\n *\n * InteractionLogger.$inject = [ 'eventBus' ]; // minification save\n *\n * // extension module\n * var extensionModule = {\n *   __init__: [ 'interactionLogger' ],\n *   interactionLogger: [ 'type', InteractionLogger ]\n * };\n *\n * // extend the viewer\n * var bpmnModeler = new Modeler({ additionalModules: [ extensionModule ] });\n * bpmnModeler.importXML(...);\n * ```\n *\n *\n * ## Customizing / Replacing Components\n *\n * You can replace individual diagram components by redefining them in override modules.\n * This works for all components, including those defined in the core.\n *\n * Pass in override modules via the `options.additionalModules` flag like this:\n *\n * ```javascript\n * function CustomContextPadProvider(contextPad) {\n *\n *   contextPad.registerProvider(this);\n *\n *   this.getContextPadEntries = function(element) {\n *     // no entries, effectively disable the context pad\n *     return {};\n *   };\n * }\n *\n * CustomContextPadProvider.$inject = [ 'contextPad' ];\n *\n * var overrideModule = {\n *   contextPadProvider: [ 'type', CustomContextPadProvider ]\n * };\n *\n * var bpmnModeler = new Modeler({ additionalModules: [ overrideModule ]});\n * ```\n *\n * @param {Object} [options] configuration options to pass to the viewer\n * @param {DOMElement} [options.container] the container to render the viewer in, defaults to body.\n * @param {String|Number} [options.width] the width of the viewer\n * @param {String|Number} [options.height] the height of the viewer\n * @param {Object} [options.moddleExtensions] extension packages to provide\n * @param {Array<didi.Module>} [options.modules] a list of modules to override the default modules\n * @param {Array<didi.Module>} [options.additionalModules] a list of modules to use with the default modules\n */\nexport default function Modeler(options) {\n  Viewer.call(this, options);\n\n  // hook ID collection into the modeler\n  this.on('import.parse.complete', function(event) {\n    if (!event.error) {\n      this._collectIds(event.definitions, event.context);\n    }\n  }, this);\n\n  this.on('diagram.destroy', function() {\n    this.get('moddle').ids.clear();\n  }, this);\n}\n\ninherits(Modeler, Viewer);\n\nModeler.Viewer = Viewer;\nModeler.NavigatedViewer = NavigatedViewer;\n\n/**\n * Create a new diagram to start modeling.\n *\n * @param {Function} [done]\n */\nModeler.prototype.createDiagram = function(done) {\n  return this.importXML(initialDiagram, done);\n};\n\n/**\n * Create a moddle instance, attaching ids to it.\n *\n * @param {Object} options\n */\nModeler.prototype._createModdle = function(options) {\n  var moddle = Viewer.prototype._createModdle.call(this, options);\n\n  // attach ids to moddle to be able to track\n  // and validated ids in the BPMN 2.0 XML document\n  // tree\n  moddle.ids = new Ids([ 32, 36, 1 ]);\n\n  return moddle;\n};\n\n/**\n * Collect ids processed during parsing of the\n * definitions object.\n *\n * @param {ModdleElement} definitions\n * @param {Context} context\n */\nModeler.prototype._collectIds = function(definitions, context) {\n\n  var moddle = definitions.$model,\n      ids = moddle.ids,\n      id;\n\n  // remove references from previous import\n  ids.clear();\n\n  for (id in context.elementsById) {\n    ids.claim(id, context.elementsById[id]);\n  }\n};\n\nModeler.prototype._interactionModules = [\n  // non-modeling components\n  KeyboardMoveModule,\n  MoveCanvasModule,\n  TouchModule,\n  ZoomScrollModule\n];\n\nModeler.prototype._modelingModules = [\n  // modeling components\n  AlignElementsModule,\n  AutoPlaceModule,\n  AutoScrollModule,\n  AutoResizeModule,\n  BendpointsModule,\n  ContextPadModule,\n  CopyPasteModule,\n  DistributeElementsModule,\n  EditorActionsModule,\n  KeyboardModule,\n  KeyboardMoveSelectionModule,\n  LabelEditingModule,\n  ModelingModule,\n  MoveModule,\n  PaletteModule,\n  ReplacePreviewModule,\n  ResizeModule,\n  SnappingModule,\n  SearchModule\n];\n\n\n// modules the modeler is composed of\n//\n// - viewer modules\n// - interaction modules\n// - modeling modules\n\nModeler.prototype._modules = [].concat(\n  Modeler.prototype._modules,\n  Modeler.prototype._interactionModules,\n  Modeler.prototype._modelingModules);\n","import inherits from 'inherits';\n\nimport Viewer from './Viewer';\n\nimport KeyboardMoveModule from 'diagram-js/lib/navigation/keyboard-move';\nimport MoveCanvasModule from 'diagram-js/lib/navigation/movecanvas';\nimport ZoomScrollModule from 'diagram-js/lib/navigation/zoomscroll';\n\n/**\n * A viewer that includes mouse navigation facilities\n *\n * @param {Object} options\n */\nexport default function NavigatedViewer(options) {\n  Viewer.call(this, options);\n}\n\ninherits(NavigatedViewer, Viewer);\n\nNavigatedViewer.prototype._navigationModules = [\n  KeyboardMoveModule,\n  MoveCanvasModule,\n  ZoomScrollModule\n];\n\nNavigatedViewer.prototype._modules = [].concat(\n  NavigatedViewer.prototype._modules,\n  NavigatedViewer.prototype._navigationModules);","/**\n * The code in the <project-logo></project-logo> area\n * must not be changed.\n *\n * @see http://bpmn.io/license for more information.\n */\nimport {\n  assign,\n  isNumber,\n  omit\n} from 'min-dash';\n\nimport {\n  domify,\n  query as domQuery,\n  remove as domRemove\n} from 'min-dom';\n\nimport {\n  innerSVG\n} from 'tiny-svg';\n\nimport Diagram from 'diagram-js';\nimport BpmnModdle from 'bpmn-moddle';\n\nimport inherits from 'inherits';\n\nimport {\n  importBpmnDiagram\n} from './import/Importer';\n\nimport CoreModule from './core';\nimport TranslateModule from 'diagram-js/lib/i18n/translate';\nimport SelectionModule from 'diagram-js/lib/features/selection';\nimport OverlaysModule from 'diagram-js/lib/features/overlays';\n\n\nfunction checkValidationError(err) {\n\n  // check if we can help the user by indicating wrong BPMN 2.0 xml\n  // (in case he or the exporting tool did not get that right)\n\n  var pattern = /unparsable content <([^>]+)> detected([\\s\\S]*)$/;\n  var match = pattern.exec(err.message);\n\n  if (match) {\n    err.message =\n      'unparsable content <' + match[1] + '> detected; ' +\n      'this may indicate an invalid BPMN 2.0 diagram file' + match[2];\n  }\n\n  return err;\n}\n\nvar DEFAULT_OPTIONS = {\n  width: '100%',\n  height: '100%',\n  position: 'relative'\n};\n\n\n/**\n * Ensure the passed argument is a proper unit (defaulting to px)\n */\nfunction ensureUnit(val) {\n  return val + (isNumber(val) ? 'px' : '');\n}\n\n/**\n * A viewer for BPMN 2.0 diagrams.\n *\n * Have a look at {@link NavigatedViewer} or {@link Modeler} for bundles that include\n * additional features.\n *\n *\n * ## Extending the Viewer\n *\n * In order to extend the viewer pass extension modules to bootstrap via the\n * `additionalModules` option. An extension module is an object that exposes\n * named services.\n *\n * The following example depicts the integration of a simple\n * logging component that integrates with interaction events:\n *\n *\n * ```javascript\n *\n * // logging component\n * function InteractionLogger(eventBus) {\n *   eventBus.on('element.hover', function(event) {\n *     console.log()\n *   })\n * }\n *\n * InteractionLogger.$inject = [ 'eventBus' ]; // minification save\n *\n * // extension module\n * var extensionModule = {\n *   __init__: [ 'interactionLogger' ],\n *   interactionLogger: [ 'type', InteractionLogger ]\n * };\n *\n * // extend the viewer\n * var bpmnViewer = new Viewer({ additionalModules: [ extensionModule ] });\n * bpmnViewer.importXML(...);\n * ```\n *\n * @param {Object} [options] configuration options to pass to the viewer\n * @param {DOMElement} [options.container] the container to render the viewer in, defaults to body.\n * @param {String|Number} [options.width] the width of the viewer\n * @param {String|Number} [options.height] the height of the viewer\n * @param {Object} [options.moddleExtensions] extension packages to provide\n * @param {Array<didi.Module>} [options.modules] a list of modules to override the default modules\n * @param {Array<didi.Module>} [options.additionalModules] a list of modules to use with the default modules\n */\nexport default function Viewer(options) {\n\n  options = assign({}, DEFAULT_OPTIONS, options);\n\n  this._moddle = this._createModdle(options);\n\n  this._container = this._createContainer(options);\n\n  /* <project-logo> */\n\n  addProjectLogo(this._container);\n\n  /* </project-logo> */\n\n  this._init(this._container, this._moddle, options);\n}\n\ninherits(Viewer, Diagram);\n\n\n/**\n * Parse and render a BPMN 2.0 diagram.\n *\n * Once finished the viewer reports back the result to the\n * provided callback function with (err, warnings).\n *\n * ## Life-Cycle Events\n *\n * During import the viewer will fire life-cycle events:\n *\n *   * import.parse.start (about to read model from xml)\n *   * import.parse.complete (model read; may have worked or not)\n *   * import.render.start (graphical import start)\n *   * import.render.complete (graphical import finished)\n *   * import.done (everything done)\n *\n * You can use these events to hook into the life-cycle.\n *\n * @param {String} xml the BPMN 2.0 xml\n * @param {Function} [done] invoked with (err, warnings=[])\n */\nViewer.prototype.importXML = function(xml, done) {\n\n  // done is optional\n  done = done || function() {};\n\n  var self = this;\n\n  // hook in pre-parse listeners +\n  // allow xml manipulation\n  xml = this._emit('import.parse.start', { xml: xml }) || xml;\n\n  this._moddle.fromXML(xml, 'bpmn:Definitions', function(err, definitions, context) {\n\n    // hook in post parse listeners +\n    // allow definitions manipulation\n    definitions = self._emit('import.parse.complete', {\n      error: err,\n      definitions: definitions,\n      context: context\n    }) || definitions;\n\n    var parseWarnings = context.warnings;\n\n    if (err) {\n      err = checkValidationError(err);\n\n      self._emit('import.done', { error: err, warnings: parseWarnings });\n\n      return done(err, parseWarnings);\n    }\n\n    self.importDefinitions(definitions, function(err, importWarnings) {\n      var allWarnings = [].concat(parseWarnings, importWarnings || []);\n\n      self._emit('import.done', { error: err, warnings: allWarnings });\n\n      done(err, allWarnings);\n    });\n  });\n};\n\n/**\n * Export the currently displayed BPMN 2.0 diagram as\n * a BPMN 2.0 XML document.\n *\n * ## Life-Cycle Events\n *\n * During XML saving the viewer will fire life-cycle events:\n *\n *   * saveXML.start (before serialization)\n *   * saveXML.serialized (after xml generation)\n *   * saveXML.done (everything done)\n *\n * You can use these events to hook into the life-cycle.\n *\n * @param {Object} [options] export options\n * @param {Boolean} [options.format=false] output formated XML\n * @param {Boolean} [options.preamble=true] output preamble\n *\n * @param {Function} done invoked with (err, xml)\n */\nViewer.prototype.saveXML = function(options, done) {\n\n  if (!done) {\n    done = options;\n    options = {};\n  }\n\n  var self = this;\n\n  var definitions = this._definitions;\n\n  if (!definitions) {\n    return done(new Error('no definitions loaded'));\n  }\n\n  // allow to fiddle around with definitions\n  definitions = this._emit('saveXML.start', {\n    definitions: definitions\n  }) || definitions;\n\n  this._moddle.toXML(definitions, options, function(err, xml) {\n\n    try {\n      xml = self._emit('saveXML.serialized', {\n        error: err,\n        xml: xml\n      }) || xml;\n\n      self._emit('saveXML.done', {\n        error: err,\n        xml: xml\n      });\n    } catch (e) {\n      console.error('error in saveXML life-cycle listener', e);\n    }\n\n    done(err, xml);\n  });\n};\n\n/**\n * Export the currently displayed BPMN 2.0 diagram as\n * an SVG image.\n *\n * ## Life-Cycle Events\n *\n * During SVG saving the viewer will fire life-cycle events:\n *\n *   * saveSVG.start (before serialization)\n *   * saveSVG.done (everything done)\n *\n * You can use these events to hook into the life-cycle.\n *\n * @param {Object} [options]\n * @param {Function} done invoked with (err, svgStr)\n */\nViewer.prototype.saveSVG = function(options, done) {\n\n  if (!done) {\n    done = options;\n    options = {};\n  }\n\n  this._emit('saveSVG.start');\n\n  var svg, err;\n\n  try {\n    var canvas = this.get('canvas');\n\n    var contentNode = canvas.getDefaultLayer(),\n        defsNode = domQuery('defs', canvas._svg);\n\n    var contents = innerSVG(contentNode),\n        defs = defsNode ? '<defs>' + innerSVG(defsNode) + '</defs>' : '';\n\n    var bbox = contentNode.getBBox();\n\n    svg =\n      '<?xml version=\"1.0\" encoding=\"utf-8\"?>\\n' +\n      '<!-- created with bpmn-js / http://bpmn.io -->\\n' +\n      '<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\" \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\\n' +\n      '<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" ' +\n           'width=\"' + bbox.width + '\" height=\"' + bbox.height + '\" ' +\n           'viewBox=\"' + bbox.x + ' ' + bbox.y + ' ' + bbox.width + ' ' + bbox.height + '\" version=\"1.1\">' +\n        defs + contents +\n      '</svg>';\n  } catch (e) {\n    err = e;\n  }\n\n  this._emit('saveSVG.done', {\n    error: err,\n    svg: svg\n  });\n\n  done(err, svg);\n};\n\n/**\n * Get a named diagram service.\n *\n * @example\n *\n * var elementRegistry = viewer.get('elementRegistry');\n * var startEventShape = elementRegistry.get('StartEvent_1');\n *\n * @param {String} name\n *\n * @return {Object} diagram service instance\n *\n * @method Viewer#get\n */\n\n/**\n * Invoke a function in the context of this viewer.\n *\n * @example\n *\n * viewer.invoke(function(elementRegistry) {\n *   var startEventShape = elementRegistry.get('StartEvent_1');\n * });\n *\n * @param {Function} fn to be invoked\n *\n * @return {Object} the functions return value\n *\n * @method Viewer#invoke\n */\n\n/**\n * Remove all drawn elements from the viewer.\n *\n * After calling this method the viewer can still\n * be reused for opening another diagram.\n *\n * @method Viewer#clear\n */\n\nViewer.prototype.importDefinitions = function(definitions, done) {\n\n  // catch synchronous exceptions during #clear()\n  try {\n    if (this._definitions) {\n      // clear existing rendered diagram\n      this.clear();\n    }\n\n    // update definitions\n    this._definitions = definitions;\n  } catch (e) {\n    return done(e);\n  }\n\n  // perform graphical import\n  return importBpmnDiagram(this, definitions, done);\n};\n\nViewer.prototype.getModules = function() {\n  return this._modules;\n};\n\n/**\n * Destroy the viewer instance and remove all its\n * remainders from the document tree.\n */\nViewer.prototype.destroy = function() {\n\n  // diagram destroy\n  Diagram.prototype.destroy.call(this);\n\n  // dom detach\n  domRemove(this._container);\n};\n\n/**\n * Register an event listener\n *\n * Remove a previously added listener via {@link #off(event, callback)}.\n *\n * @param {String} event\n * @param {Number} [priority]\n * @param {Function} callback\n * @param {Object} [that]\n */\nViewer.prototype.on = function(event, priority, callback, target) {\n  return this.get('eventBus').on(event, priority, callback, target);\n};\n\n/**\n * De-register an event listener\n *\n * @param {String} event\n * @param {Function} callback\n */\nViewer.prototype.off = function(event, callback) {\n  this.get('eventBus').off(event, callback);\n};\n\nViewer.prototype.attachTo = function(parentNode) {\n\n  if (!parentNode) {\n    throw new Error('parentNode required');\n  }\n\n  // ensure we detach from the\n  // previous, old parent\n  this.detach();\n\n  // unwrap jQuery if provided\n  if (parentNode.get && parentNode.constructor.prototype.jquery) {\n    parentNode = parentNode.get(0);\n  }\n\n  if (typeof parentNode === 'string') {\n    parentNode = domQuery(parentNode);\n  }\n\n  parentNode.appendChild(this._container);\n\n  this._emit('attach', {});\n\n  this.get('canvas').resized();\n};\n\nViewer.prototype.getDefinitions = function() {\n  return this._definitions;\n};\n\nViewer.prototype.detach = function() {\n\n  var container = this._container,\n      parentNode = container.parentNode;\n\n  if (!parentNode) {\n    return;\n  }\n\n  this._emit('detach', {});\n\n  parentNode.removeChild(container);\n};\n\nViewer.prototype._init = function(container, moddle, options) {\n\n  var baseModules = options.modules || this.getModules(),\n      additionalModules = options.additionalModules || [],\n      staticModules = [\n        {\n          bpmnjs: [ 'value', this ],\n          moddle: [ 'value', moddle ]\n        }\n      ];\n\n  var diagramModules = [].concat(staticModules, baseModules, additionalModules);\n\n  var diagramOptions = assign(omit(options, [ 'additionalModules' ]), {\n    canvas: assign({}, options.canvas, { container: container }),\n    modules: diagramModules\n  });\n\n  // invoke diagram constructor\n  Diagram.call(this, diagramOptions);\n\n  if (options && options.container) {\n    this.attachTo(options.container);\n  }\n};\n\n/**\n * Emit an event on the underlying {@link EventBus}\n *\n * @param  {String} type\n * @param  {Object} event\n *\n * @return {Object} event processing result (if any)\n */\nViewer.prototype._emit = function(type, event) {\n  return this.get('eventBus').fire(type, event);\n};\n\nViewer.prototype._createContainer = function(options) {\n\n  var container = domify('<div class=\"bjs-container\"></div>');\n\n  assign(container.style, {\n    width: ensureUnit(options.width),\n    height: ensureUnit(options.height),\n    position: options.position\n  });\n\n  return container;\n};\n\nViewer.prototype._createModdle = function(options) {\n  var moddleOptions = assign({}, this._moddleExtensions, options.moddleExtensions);\n\n  return new BpmnModdle(moddleOptions);\n};\n\n// modules the viewer is composed of\nViewer.prototype._modules = [\n  CoreModule,\n  TranslateModule,\n  SelectionModule,\n  OverlaysModule\n];\n\n// default moddle extensions the viewer is composed of\nViewer.prototype._moddleExtensions = {};\n\n/* <project-logo> */\n\nimport {\n  open as openPoweredBy,\n  BPMNIO_IMG\n} from './util/PoweredByUtil';\n\nimport {\n  event as domEvent\n} from 'min-dom';\n\n/**\n * Adds the project logo to the diagram container as\n * required by the bpmn.io license.\n *\n * @see http://bpmn.io/license\n *\n * @param {Element} container\n */\nfunction addProjectLogo(container) {\n  var img = BPMNIO_IMG;\n\n  var linkMarkup =\n    '<a href=\"http://bpmn.io\" ' +\n       'target=\"_blank\" ' +\n       'class=\"bjs-powered-by\" ' +\n       'title=\"Powered by bpmn.io\" ' +\n       'style=\"position: absolute; bottom: 15px; right: 15px; z-index: 100\">' +\n      img +\n    '</a>';\n\n  var linkElement = domify(linkMarkup);\n\n  container.appendChild(linkElement);\n\n  domEvent.bind(linkElement, 'click', function(event) {\n    openPoweredBy();\n\n    event.preventDefault();\n  });\n}\n\n/* </project-logo> */","import DrawModule from '../draw';\nimport ImportModule from '../import';\n\nexport default {\n  __depends__: [\n    DrawModule,\n    ImportModule\n  ]\n};","import {\n  every,\n  some\n} from 'min-dash';\n\nimport {\n  componentsToPath\n} from 'diagram-js/lib/util/RenderUtil';\n\n\n// element utils //////////////////////\n\n/**\n * Checks if eventDefinition of the given element matches with semantic type.\n *\n * @return {boolean} true if element is of the given semantic type\n */\nexport function isTypedEvent(event, eventDefinitionType, filter) {\n\n  function matches(definition, filter) {\n    return every(filter, function(val, key) {\n\n      // we want a == conversion here, to be able to catch\n      // undefined == false and friends\n      /* jshint -W116 */\n      return definition[key] == val;\n    });\n  }\n\n  return some(event.eventDefinitions, function(definition) {\n    return definition.$type === eventDefinitionType && matches(event, filter);\n  });\n}\n\nexport function isThrowEvent(event) {\n  return (event.$type === 'bpmn:IntermediateThrowEvent') || (event.$type === 'bpmn:EndEvent');\n}\n\nexport function isCollection(element) {\n  var dataObject = element.dataObjectRef;\n\n  return element.isCollection || (dataObject && dataObject.isCollection);\n}\n\nexport function getDi(element) {\n  return element.businessObject.di;\n}\n\nexport function getSemantic(element) {\n  return element.businessObject;\n}\n\n\n// color access //////////////////////\n\nexport function getFillColor(element, defaultColor) {\n  return getDi(element).get('bioc:fill') || defaultColor || 'white';\n}\n\nexport function getStrokeColor(element, defaultColor) {\n  return getDi(element).get('bioc:stroke') || defaultColor || 'black';\n}\n\n\n// cropping path customizations //////////////////////\n\nexport function getCirclePath(shape) {\n\n  var cx = shape.x + shape.width / 2,\n      cy = shape.y + shape.height / 2,\n      radius = shape.width / 2;\n\n  var circlePath = [\n    ['M', cx, cy],\n    ['m', 0, -radius],\n    ['a', radius, radius, 0, 1, 1, 0, 2 * radius],\n    ['a', radius, radius, 0, 1, 1, 0, -2 * radius],\n    ['z']\n  ];\n\n  return componentsToPath(circlePath);\n}\n\nexport function getRoundRectPath(shape, borderRadius) {\n\n  var x = shape.x,\n      y = shape.y,\n      width = shape.width,\n      height = shape.height;\n\n  var roundRectPath = [\n    ['M', x + borderRadius, y],\n    ['l', width - borderRadius * 2, 0],\n    ['a', borderRadius, borderRadius, 0, 0, 1, borderRadius, borderRadius],\n    ['l', 0, height - borderRadius * 2],\n    ['a', borderRadius, borderRadius, 0, 0, 1, -borderRadius, borderRadius],\n    ['l', borderRadius * 2 - width, 0],\n    ['a', borderRadius, borderRadius, 0, 0, 1, -borderRadius, -borderRadius],\n    ['l', 0, borderRadius * 2 - height],\n    ['a', borderRadius, borderRadius, 0, 0, 1, borderRadius, -borderRadius],\n    ['z']\n  ];\n\n  return componentsToPath(roundRectPath);\n}\n\nexport function getDiamondPath(shape) {\n\n  var width = shape.width,\n      height = shape.height,\n      x = shape.x,\n      y = shape.y,\n      halfWidth = width / 2,\n      halfHeight = height / 2;\n\n  var diamondPath = [\n    ['M', x + halfWidth, y],\n    ['l', halfWidth, halfHeight],\n    ['l', -halfWidth, halfHeight],\n    ['l', -halfWidth, -halfHeight],\n    ['z']\n  ];\n\n  return componentsToPath(diamondPath);\n}\n\nexport function getRectPath(shape) {\n  var x = shape.x,\n      y = shape.y,\n      width = shape.width,\n      height = shape.height;\n\n  var rectPath = [\n    ['M', x, y],\n    ['l', width, 0],\n    ['l', 0, height],\n    ['l', -width, 0],\n    ['z']\n  ];\n\n  return componentsToPath(rectPath);\n}","import inherits from 'inherits';\n\nimport {\n  isObject,\n  assign,\n  forEach\n} from 'min-dash';\n\nimport BaseRenderer from 'diagram-js/lib/draw/BaseRenderer';\n\nimport {\n  isExpanded,\n  isEventSubProcess\n} from '../util/DiUtil';\n\nimport { is } from '../util/ModelUtil';\n\nimport {\n  createLine\n} from 'diagram-js/lib/util/RenderUtil';\n\nimport {\n  isTypedEvent,\n  isThrowEvent,\n  isCollection,\n  getDi,\n  getSemantic,\n  getCirclePath,\n  getRoundRectPath,\n  getDiamondPath,\n  getRectPath,\n  getFillColor,\n  getStrokeColor\n} from './BpmnRenderUtil';\n\nimport {\n  query as domQuery\n} from 'min-dom';\n\nimport {\n  append as svgAppend,\n  attr as svgAttr,\n  create as svgCreate,\n  classes as svgClasses\n} from 'tiny-svg';\n\nimport {\n  rotate,\n  transform,\n  translate\n} from 'diagram-js/lib/util/SvgTransformUtil';\n\nimport Ids from 'ids';\n\nvar RENDERER_IDS = new Ids();\n\nvar TASK_BORDER_RADIUS = 10;\nvar INNER_OUTER_DIST = 3;\n\nvar DEFAULT_FILL_OPACITY = .95,\n    HIGH_FILL_OPACITY = .35;\n\n\nexport default function BpmnRenderer(\n    config, eventBus, styles, pathMap,\n    canvas, textRenderer, priority) {\n\n  BaseRenderer.call(this, eventBus, priority);\n\n  var defaultFillColor = config && config.defaultFillColor,\n      defaultStrokeColor = config && config.defaultStrokeColor;\n\n  var rendererId = RENDERER_IDS.next();\n\n  var markers = {};\n\n  var computeStyle = styles.computeStyle;\n\n  function addMarker(id, options) {\n    var attrs = assign({\n      fill: 'black',\n      strokeWidth: 1,\n      strokeLinecap: 'round',\n      strokeDasharray: 'none'\n    }, options.attrs);\n\n    var ref = options.ref || { x: 0, y: 0 };\n\n    var scale = options.scale || 1;\n\n    // fix for safari / chrome / firefox bug not correctly\n    // resetting stroke dash array\n    if (attrs.strokeDasharray === 'none') {\n      attrs.strokeDasharray = [10000, 1];\n    }\n\n    var marker = svgCreate('marker');\n\n    svgAttr(options.element, attrs);\n\n    svgAppend(marker, options.element);\n\n    svgAttr(marker, {\n      id: id,\n      viewBox: '0 0 20 20',\n      refX: ref.x,\n      refY: ref.y,\n      markerWidth: 20 * scale,\n      markerHeight: 20 * scale,\n      orient: 'auto'\n    });\n\n    var defs = domQuery('defs', canvas._svg);\n\n    if (!defs) {\n      defs = svgCreate('defs');\n\n      svgAppend(canvas._svg, defs);\n    }\n\n    svgAppend(defs, marker);\n\n    markers[id] = marker;\n  }\n\n  function marker(type, fill, stroke) {\n    var id = type + '-' + fill + '-' + stroke + '-' + rendererId;\n\n    if (!markers[id]) {\n      createMarker(type, fill, stroke);\n    }\n\n    return 'url(#' + id + ')';\n  }\n\n  function createMarker(type, fill, stroke) {\n    var id = type + '-' + fill + '-' + stroke + '-' + rendererId;\n\n    if (type === 'sequenceflow-end') {\n      var sequenceflowEnd = svgCreate('path');\n      svgAttr(sequenceflowEnd, { d: 'M 1 5 L 11 10 L 1 15 Z' });\n\n      addMarker(id, {\n        element: sequenceflowEnd,\n        ref: { x: 11, y: 10 },\n        scale: 0.5,\n        attrs: {\n          fill: stroke,\n          stroke: stroke\n        }\n      });\n    }\n\n    if (type === 'messageflow-start') {\n      var messageflowStart = svgCreate('circle');\n      svgAttr(messageflowStart, { cx: 6, cy: 6, r: 3.5 });\n\n      addMarker(id, {\n        element: messageflowStart,\n        attrs: {\n          fill: fill,\n          stroke: stroke\n        },\n        ref: { x: 6, y: 6 }\n      });\n    }\n\n    if (type === 'messageflow-end') {\n      var messageflowEnd = svgCreate('path');\n      svgAttr(messageflowEnd, { d: 'm 1 5 l 0 -3 l 7 3 l -7 3 z' });\n\n      addMarker(id, {\n        element: messageflowEnd,\n        attrs: {\n          fill: fill,\n          stroke: stroke,\n          strokeLinecap: 'butt'\n        },\n        ref: { x: 8.5, y: 5 }\n      });\n    }\n\n    if (type === 'association-start') {\n      var associationStart = svgCreate('path');\n      svgAttr(associationStart, { d: 'M 11 5 L 1 10 L 11 15' });\n\n      addMarker(id, {\n        element: associationStart,\n        attrs: {\n          fill: 'none',\n          stroke: stroke,\n          strokeWidth: 1.5\n        },\n        ref: { x: 1, y: 10 },\n        scale: 0.5\n      });\n    }\n\n    if (type === 'association-end') {\n      var associationEnd = svgCreate('path');\n      svgAttr(associationEnd, { d: 'M 1 5 L 11 10 L 1 15' });\n\n      addMarker(id, {\n        element: associationEnd,\n        attrs: {\n          fill: 'none',\n          stroke: stroke,\n          strokeWidth: 1.5\n        },\n        ref: { x: 12, y: 10 },\n        scale: 0.5\n      });\n    }\n\n    if (type === 'conditional-flow-marker') {\n      var conditionalflowMarker = svgCreate('path');\n      svgAttr(conditionalflowMarker, { d: 'M 0 10 L 8 6 L 16 10 L 8 14 Z' });\n\n      addMarker(id, {\n        element: conditionalflowMarker,\n        attrs: {\n          fill: fill,\n          stroke: stroke\n        },\n        ref: { x: -1, y: 10 },\n        scale: 0.5\n      });\n    }\n\n    if (type === 'conditional-default-flow-marker') {\n      var conditionaldefaultflowMarker = svgCreate('path');\n      svgAttr(conditionaldefaultflowMarker, { d: 'M 6 4 L 10 16' });\n\n      addMarker(id, {\n        element: conditionaldefaultflowMarker,\n        attrs: {\n          stroke: stroke\n        },\n        ref: { x: 0, y: 10 },\n        scale: 0.5\n      });\n    }\n  }\n\n  function drawCircle(parentGfx, width, height, offset, attrs) {\n\n    if (isObject(offset)) {\n      attrs = offset;\n      offset = 0;\n    }\n\n    offset = offset || 0;\n\n    attrs = computeStyle(attrs, {\n      stroke: 'black',\n      strokeWidth: 2,\n      fill: 'white'\n    });\n\n    if (attrs.fill === 'none') {\n      delete attrs.fillOpacity;\n    }\n\n    var cx = width / 2,\n        cy = height / 2;\n\n    var circle = svgCreate('circle');\n    svgAttr(circle, {\n      cx: cx,\n      cy: cy,\n      r: Math.round((width + height) / 4 - offset)\n    });\n    svgAttr(circle, attrs);\n\n    svgAppend(parentGfx, circle);\n\n    return circle;\n  }\n\n  function drawRect(parentGfx, width, height, r, offset, attrs) {\n\n    if (isObject(offset)) {\n      attrs = offset;\n      offset = 0;\n    }\n\n    offset = offset || 0;\n\n    attrs = computeStyle(attrs, {\n      stroke: 'black',\n      strokeWidth: 2,\n      fill: 'white'\n    });\n\n    var rect = svgCreate('rect');\n    svgAttr(rect, {\n      x: offset,\n      y: offset,\n      width: width - offset * 2,\n      height: height - offset * 2,\n      rx: r,\n      ry: r\n    });\n    svgAttr(rect, attrs);\n\n    svgAppend(parentGfx, rect);\n\n    return rect;\n  }\n\n  function drawDiamond(parentGfx, width, height, attrs) {\n\n    var x_2 = width / 2;\n    var y_2 = height / 2;\n\n    var points = [{ x: x_2, y: 0 }, { x: width, y: y_2 }, { x: x_2, y: height }, { x: 0, y: y_2 }];\n\n    var pointsString = points.map(function(point) {\n      return point.x + ',' + point.y;\n    }).join(' ');\n\n    attrs = computeStyle(attrs, {\n      stroke: 'black',\n      strokeWidth: 2,\n      fill: 'white'\n    });\n\n    var polygon = svgCreate('polygon');\n    svgAttr(polygon, {\n      points: pointsString\n    });\n    svgAttr(polygon, attrs);\n\n    svgAppend(parentGfx, polygon);\n\n    return polygon;\n  }\n\n  function drawLine(parentGfx, waypoints, attrs) {\n    attrs = computeStyle(attrs, [ 'no-fill' ], {\n      stroke: 'black',\n      strokeWidth: 2,\n      fill: 'none'\n    });\n\n    var line = createLine(waypoints, attrs);\n\n    svgAppend(parentGfx, line);\n\n    return line;\n  }\n\n  function drawPath(parentGfx, d, attrs) {\n\n    attrs = computeStyle(attrs, [ 'no-fill' ], {\n      strokeWidth: 2,\n      stroke: 'black'\n    });\n\n    var path = svgCreate('path');\n    svgAttr(path, { d: d });\n    svgAttr(path, attrs);\n\n    svgAppend(parentGfx, path);\n\n    return path;\n  }\n\n  function drawMarker(type, parentGfx, path, attrs) {\n    return drawPath(parentGfx, path, assign({ 'data-marker': type }, attrs));\n  }\n\n  function as(type) {\n    return function(parentGfx, element) {\n      return handlers[type](parentGfx, element);\n    };\n  }\n\n  function renderer(type) {\n    return handlers[type];\n  }\n\n  function renderEventContent(element, parentGfx) {\n\n    var event = getSemantic(element);\n    var isThrowing = isThrowEvent(event);\n\n    if (isTypedEvent(event, 'bpmn:MessageEventDefinition')) {\n      return renderer('bpmn:MessageEventDefinition')(parentGfx, element, isThrowing);\n    }\n\n    if (isTypedEvent(event, 'bpmn:TimerEventDefinition')) {\n      return renderer('bpmn:TimerEventDefinition')(parentGfx, element, isThrowing);\n    }\n\n    if (isTypedEvent(event, 'bpmn:ConditionalEventDefinition')) {\n      return renderer('bpmn:ConditionalEventDefinition')(parentGfx, element);\n    }\n\n    if (isTypedEvent(event, 'bpmn:SignalEventDefinition')) {\n      return renderer('bpmn:SignalEventDefinition')(parentGfx, element, isThrowing);\n    }\n\n    if (isTypedEvent(event, 'bpmn:CancelEventDefinition') &&\n      isTypedEvent(event, 'bpmn:TerminateEventDefinition', { parallelMultiple: false })) {\n      return renderer('bpmn:MultipleEventDefinition')(parentGfx, element, isThrowing);\n    }\n\n    if (isTypedEvent(event, 'bpmn:CancelEventDefinition') &&\n      isTypedEvent(event, 'bpmn:TerminateEventDefinition', { parallelMultiple: true })) {\n      return renderer('bpmn:ParallelMultipleEventDefinition')(parentGfx, element, isThrowing);\n    }\n\n    if (isTypedEvent(event, 'bpmn:EscalationEventDefinition')) {\n      return renderer('bpmn:EscalationEventDefinition')(parentGfx, element, isThrowing);\n    }\n\n    if (isTypedEvent(event, 'bpmn:LinkEventDefinition')) {\n      return renderer('bpmn:LinkEventDefinition')(parentGfx, element, isThrowing);\n    }\n\n    if (isTypedEvent(event, 'bpmn:ErrorEventDefinition')) {\n      return renderer('bpmn:ErrorEventDefinition')(parentGfx, element, isThrowing);\n    }\n\n    if (isTypedEvent(event, 'bpmn:CancelEventDefinition')) {\n      return renderer('bpmn:CancelEventDefinition')(parentGfx, element, isThrowing);\n    }\n\n    if (isTypedEvent(event, 'bpmn:CompensateEventDefinition')) {\n      return renderer('bpmn:CompensateEventDefinition')(parentGfx, element, isThrowing);\n    }\n\n    if (isTypedEvent(event, 'bpmn:TerminateEventDefinition')) {\n      return renderer('bpmn:TerminateEventDefinition')(parentGfx, element, isThrowing);\n    }\n\n    return null;\n  }\n\n  function renderLabel(parentGfx, label, options) {\n\n    options = assign({\n      size: {\n        width: 100\n      }\n    }, options);\n\n    var text = textRenderer.createText(label || '', options);\n\n    svgClasses(text).add('djs-label');\n\n    svgAppend(parentGfx, text);\n\n    return text;\n  }\n\n  function renderEmbeddedLabel(parentGfx, element, align) {\n    var semantic = getSemantic(element);\n\n    return renderLabel(parentGfx, semantic.name, {\n      box: element,\n      align: align,\n      padding: 5,\n      style: {\n        fill: getStrokeColor(element, defaultStrokeColor)\n      }\n    });\n  }\n\n  function renderExternalLabel(parentGfx, element) {\n    var semantic = getSemantic(element);\n    var box = {\n      width: 90,\n      height: 30,\n      x: element.width / 2 + element.x,\n      y: element.height / 2 + element.y\n    };\n\n    return renderLabel(parentGfx, semantic.name, {\n      box: box,\n      fitBox: true,\n      style: assign(\n        {},\n        textRenderer.getExternalStyle(),\n        {\n          fill: getStrokeColor(element, defaultStrokeColor)\n        }\n      )\n    });\n  }\n\n  function renderLaneLabel(parentGfx, text, element) {\n    var textBox = renderLabel(parentGfx, text, {\n      box: {\n        height: 30,\n        width: element.height\n      },\n      align: 'center-middle',\n      style: {\n        fill: getStrokeColor(element, defaultStrokeColor)\n      }\n    });\n\n    var top = -1 * element.height;\n\n    transform(textBox, 0, -top, 270);\n  }\n\n  function createPathFromConnection(connection) {\n    var waypoints = connection.waypoints;\n\n    var pathData = 'm  ' + waypoints[0].x + ',' + waypoints[0].y;\n    for (var i = 1; i < waypoints.length; i++) {\n      pathData += 'L' + waypoints[i].x + ',' + waypoints[i].y + ' ';\n    }\n    return pathData;\n  }\n\n  var handlers = this.handlers = {\n    'bpmn:Event': function(parentGfx, element, attrs) {\n\n      if (!('fillOpacity' in attrs)) {\n        attrs.fillOpacity = DEFAULT_FILL_OPACITY;\n      }\n\n      return drawCircle(parentGfx, element.width, element.height, attrs);\n    },\n    'bpmn:StartEvent': function(parentGfx, element) {\n      var attrs = {\n        fill: getFillColor(element, defaultFillColor),\n        stroke: getStrokeColor(element, defaultStrokeColor)\n      };\n\n      var semantic = getSemantic(element);\n\n      if (!semantic.isInterrupting) {\n        attrs = {\n          strokeDasharray: '6',\n          strokeLinecap: 'round',\n          fill: getFillColor(element, defaultFillColor),\n          stroke: getStrokeColor(element, defaultStrokeColor)\n        };\n      }\n\n      var circle = renderer('bpmn:Event')(parentGfx, element, attrs);\n\n      renderEventContent(element, parentGfx);\n\n      return circle;\n    },\n    'bpmn:MessageEventDefinition': function(parentGfx, element, isThrowing) {\n      var pathData = pathMap.getScaledPath('EVENT_MESSAGE', {\n        xScaleFactor: 0.9,\n        yScaleFactor: 0.9,\n        containerWidth: element.width,\n        containerHeight: element.height,\n        position: {\n          mx: 0.235,\n          my: 0.315\n        }\n      });\n\n      var fill = isThrowing ? getStrokeColor(element, defaultStrokeColor) : getFillColor(element, defaultFillColor);\n      var stroke = isThrowing ? getFillColor(element, defaultFillColor) : getStrokeColor(element, defaultStrokeColor);\n\n      var messagePath = drawPath(parentGfx, pathData, {\n        strokeWidth: 1,\n        fill: fill,\n        stroke: stroke\n      });\n\n      return messagePath;\n    },\n    'bpmn:TimerEventDefinition': function(parentGfx, element) {\n      var circle = drawCircle(parentGfx, element.width, element.height, 0.2 * element.height, {\n        strokeWidth: 2,\n        fill: getFillColor(element, defaultFillColor),\n        stroke: getStrokeColor(element, defaultStrokeColor)\n      });\n\n      var pathData = pathMap.getScaledPath('EVENT_TIMER_WH', {\n        xScaleFactor: 0.75,\n        yScaleFactor: 0.75,\n        containerWidth: element.width,\n        containerHeight: element.height,\n        position: {\n          mx: 0.5,\n          my: 0.5\n        }\n      });\n\n      drawPath(parentGfx, pathData, {\n        strokeWidth: 2,\n        strokeLinecap: 'square',\n        stroke: getStrokeColor(element, defaultStrokeColor)\n      });\n\n      for (var i = 0;i < 12; i++) {\n\n        var linePathData = pathMap.getScaledPath('EVENT_TIMER_LINE', {\n          xScaleFactor: 0.75,\n          yScaleFactor: 0.75,\n          containerWidth: element.width,\n          containerHeight: element.height,\n          position: {\n            mx: 0.5,\n            my: 0.5\n          }\n        });\n\n        var width = element.width / 2;\n        var height = element.height / 2;\n\n        drawPath(parentGfx, linePathData, {\n          strokeWidth: 1,\n          strokeLinecap: 'square',\n          transform: 'rotate(' + (i * 30) + ',' + height + ',' + width + ')',\n          stroke: getStrokeColor(element, defaultStrokeColor)\n        });\n      }\n\n      return circle;\n    },\n    'bpmn:EscalationEventDefinition': function(parentGfx, event, isThrowing) {\n      var pathData = pathMap.getScaledPath('EVENT_ESCALATION', {\n        xScaleFactor: 1,\n        yScaleFactor: 1,\n        containerWidth: event.width,\n        containerHeight: event.height,\n        position: {\n          mx: 0.5,\n          my: 0.2\n        }\n      });\n\n      var fill = isThrowing ? getStrokeColor(event, defaultStrokeColor) : 'none';\n\n      return drawPath(parentGfx, pathData, {\n        strokeWidth: 1,\n        fill: fill,\n        stroke: getStrokeColor(event, defaultStrokeColor)\n      });\n    },\n    'bpmn:ConditionalEventDefinition': function(parentGfx, event) {\n      var pathData = pathMap.getScaledPath('EVENT_CONDITIONAL', {\n        xScaleFactor: 1,\n        yScaleFactor: 1,\n        containerWidth: event.width,\n        containerHeight: event.height,\n        position: {\n          mx: 0.5,\n          my: 0.222\n        }\n      });\n\n      return drawPath(parentGfx, pathData, {\n        strokeWidth: 1,\n        stroke: getStrokeColor(event, defaultStrokeColor)\n      });\n    },\n    'bpmn:LinkEventDefinition': function(parentGfx, event, isThrowing) {\n      var pathData = pathMap.getScaledPath('EVENT_LINK', {\n        xScaleFactor: 1,\n        yScaleFactor: 1,\n        containerWidth: event.width,\n        containerHeight: event.height,\n        position: {\n          mx: 0.57,\n          my: 0.263\n        }\n      });\n\n      var fill = isThrowing ? getStrokeColor(event, defaultStrokeColor) : 'none';\n\n      return drawPath(parentGfx, pathData, {\n        strokeWidth: 1,\n        fill: fill,\n        stroke: getStrokeColor(event, defaultStrokeColor)\n      });\n    },\n    'bpmn:ErrorEventDefinition': function(parentGfx, event, isThrowing) {\n      var pathData = pathMap.getScaledPath('EVENT_ERROR', {\n        xScaleFactor: 1.1,\n        yScaleFactor: 1.1,\n        containerWidth: event.width,\n        containerHeight: event.height,\n        position: {\n          mx: 0.2,\n          my: 0.722\n        }\n      });\n\n      var fill = isThrowing ? getStrokeColor(event, defaultStrokeColor) : 'none';\n\n      return drawPath(parentGfx, pathData, {\n        strokeWidth: 1,\n        fill: fill,\n        stroke: getStrokeColor(event, defaultStrokeColor)\n      });\n    },\n    'bpmn:CancelEventDefinition': function(parentGfx, event, isThrowing) {\n      var pathData = pathMap.getScaledPath('EVENT_CANCEL_45', {\n        xScaleFactor: 1.0,\n        yScaleFactor: 1.0,\n        containerWidth: event.width,\n        containerHeight: event.height,\n        position: {\n          mx: 0.638,\n          my: -0.055\n        }\n      });\n\n      var fill = isThrowing ? getStrokeColor(event, defaultStrokeColor) : 'none';\n\n      var path = drawPath(parentGfx, pathData, {\n        strokeWidth: 1,\n        fill: fill,\n        stroke: getStrokeColor(event, defaultStrokeColor)\n      });\n\n      rotate(path, 45);\n\n      return path;\n    },\n    'bpmn:CompensateEventDefinition': function(parentGfx, event, isThrowing) {\n      var pathData = pathMap.getScaledPath('EVENT_COMPENSATION', {\n        xScaleFactor: 1,\n        yScaleFactor: 1,\n        containerWidth: event.width,\n        containerHeight: event.height,\n        position: {\n          mx: 0.22,\n          my: 0.5\n        }\n      });\n\n      var fill = isThrowing ? getStrokeColor(event, defaultStrokeColor) : 'none';\n\n      return drawPath(parentGfx, pathData, {\n        strokeWidth: 1,\n        fill: fill,\n        stroke: getStrokeColor(event, defaultStrokeColor)\n      });\n    },\n    'bpmn:SignalEventDefinition': function(parentGfx, event, isThrowing) {\n      var pathData = pathMap.getScaledPath('EVENT_SIGNAL', {\n        xScaleFactor: 0.9,\n        yScaleFactor: 0.9,\n        containerWidth: event.width,\n        containerHeight: event.height,\n        position: {\n          mx: 0.5,\n          my: 0.2\n        }\n      });\n\n      var fill = isThrowing ? getStrokeColor(event, defaultStrokeColor) : 'none';\n\n      return drawPath(parentGfx, pathData, {\n        strokeWidth: 1,\n        fill: fill,\n        stroke: getStrokeColor(event, defaultStrokeColor)\n      });\n    },\n    'bpmn:MultipleEventDefinition': function(parentGfx, event, isThrowing) {\n      var pathData = pathMap.getScaledPath('EVENT_MULTIPLE', {\n        xScaleFactor: 1.1,\n        yScaleFactor: 1.1,\n        containerWidth: event.width,\n        containerHeight: event.height,\n        position: {\n          mx: 0.222,\n          my: 0.36\n        }\n      });\n\n      var fill = isThrowing ? getStrokeColor(event, defaultStrokeColor) : 'none';\n\n      return drawPath(parentGfx, pathData, {\n        strokeWidth: 1,\n        fill: fill\n      });\n    },\n    'bpmn:ParallelMultipleEventDefinition': function(parentGfx, event) {\n      var pathData = pathMap.getScaledPath('EVENT_PARALLEL_MULTIPLE', {\n        xScaleFactor: 1.2,\n        yScaleFactor: 1.2,\n        containerWidth: event.width,\n        containerHeight: event.height,\n        position: {\n          mx: 0.458,\n          my: 0.194\n        }\n      });\n\n      return drawPath(parentGfx, pathData, {\n        strokeWidth: 1,\n        fill: getStrokeColor(event, defaultStrokeColor),\n        stroke: getStrokeColor(event, defaultStrokeColor)\n      });\n    },\n    'bpmn:EndEvent': function(parentGfx, element) {\n      var circle = renderer('bpmn:Event')(parentGfx, element, {\n        strokeWidth: 4,\n        fill: getFillColor(element, defaultFillColor),\n        stroke: getStrokeColor(element, defaultStrokeColor)\n      });\n\n      renderEventContent(element, parentGfx, true);\n\n      return circle;\n    },\n    'bpmn:TerminateEventDefinition': function(parentGfx, element) {\n      var circle = drawCircle(parentGfx, element.width, element.height, 8, {\n        strokeWidth: 4,\n        fill: getStrokeColor(element, defaultStrokeColor),\n        stroke: getStrokeColor(element, defaultStrokeColor)\n      });\n\n      return circle;\n    },\n    'bpmn:IntermediateEvent': function(parentGfx, element) {\n      var outer = renderer('bpmn:Event')(parentGfx, element, {\n        strokeWidth: 1,\n        fill: getFillColor(element, defaultFillColor),\n        stroke: getStrokeColor(element, defaultStrokeColor)\n      });\n\n      /* inner */\n      drawCircle(parentGfx, element.width, element.height, INNER_OUTER_DIST, {\n        strokeWidth: 1,\n        fill: getFillColor(element, 'none'),\n        stroke: getStrokeColor(element, defaultStrokeColor)\n      });\n\n      renderEventContent(element, parentGfx);\n\n      return outer;\n    },\n    'bpmn:IntermediateCatchEvent': as('bpmn:IntermediateEvent'),\n    'bpmn:IntermediateThrowEvent': as('bpmn:IntermediateEvent'),\n\n    'bpmn:Activity': function(parentGfx, element, attrs) {\n\n      attrs = attrs || {};\n\n      if (!('fillOpacity' in attrs)) {\n        attrs.fillOpacity = DEFAULT_FILL_OPACITY;\n      }\n\n      return drawRect(parentGfx, element.width, element.height, TASK_BORDER_RADIUS, attrs);\n    },\n\n    'bpmn:Task': function(parentGfx, element) {\n      var attrs = {\n        fill: getFillColor(element, defaultFillColor),\n        stroke: getStrokeColor(element, defaultStrokeColor)\n      };\n\n      var rect = renderer('bpmn:Activity')(parentGfx, element, attrs);\n\n      renderEmbeddedLabel(parentGfx, element, 'center-middle');\n      attachTaskMarkers(parentGfx, element);\n\n      return rect;\n    },\n    'bpmn:ServiceTask': function(parentGfx, element) {\n      var task = renderer('bpmn:Task')(parentGfx, element);\n\n      var pathDataBG = pathMap.getScaledPath('TASK_TYPE_SERVICE', {\n        abspos: {\n          x: 12,\n          y: 18\n        }\n      });\n\n      /* service bg */ drawPath(parentGfx, pathDataBG, {\n        strokeWidth: 1,\n        fill: getFillColor(element, defaultFillColor),\n        stroke: getStrokeColor(element, defaultStrokeColor)\n      });\n\n      var fillPathData = pathMap.getScaledPath('TASK_TYPE_SERVICE_FILL', {\n        abspos: {\n          x: 17.2,\n          y: 18\n        }\n      });\n\n      /* service fill */ drawPath(parentGfx, fillPathData, {\n        strokeWidth: 0,\n        fill: getFillColor(element, defaultFillColor)\n      });\n\n      var pathData = pathMap.getScaledPath('TASK_TYPE_SERVICE', {\n        abspos: {\n          x: 17,\n          y: 22\n        }\n      });\n\n      /* service */ drawPath(parentGfx, pathData, {\n        strokeWidth: 1,\n        fill: getFillColor(element, defaultFillColor),\n        stroke: getStrokeColor(element, defaultStrokeColor)\n      });\n\n      return task;\n    },\n    'bpmn:UserTask': function(parentGfx, element) {\n      var task = renderer('bpmn:Task')(parentGfx, element);\n\n      var x = 15;\n      var y = 12;\n\n      var pathData = pathMap.getScaledPath('TASK_TYPE_USER_1', {\n        abspos: {\n          x: x,\n          y: y\n        }\n      });\n\n      /* user path */ drawPath(parentGfx, pathData, {\n        strokeWidth: 0.5,\n        fill: getFillColor(element, defaultFillColor),\n        stroke: getStrokeColor(element, defaultStrokeColor)\n      });\n\n      var pathData2 = pathMap.getScaledPath('TASK_TYPE_USER_2', {\n        abspos: {\n          x: x,\n          y: y\n        }\n      });\n\n      /* user2 path */ drawPath(parentGfx, pathData2, {\n        strokeWidth: 0.5,\n        fill: getFillColor(element, defaultFillColor),\n        stroke: getStrokeColor(element, defaultStrokeColor)\n      });\n\n      var pathData3 = pathMap.getScaledPath('TASK_TYPE_USER_3', {\n        abspos: {\n          x: x,\n          y: y\n        }\n      });\n\n      /* user3 path */ drawPath(parentGfx, pathData3, {\n        strokeWidth: 0.5,\n        fill: getStrokeColor(element, defaultStrokeColor),\n        stroke: getStrokeColor(element, defaultStrokeColor)\n      });\n\n      return task;\n    },\n    'bpmn:ManualTask': function(parentGfx, element) {\n      var task = renderer('bpmn:Task')(parentGfx, element);\n\n      var pathData = pathMap.getScaledPath('TASK_TYPE_MANUAL', {\n        abspos: {\n          x: 17,\n          y: 15\n        }\n      });\n\n      /* manual path */ drawPath(parentGfx, pathData, {\n        strokeWidth: 0.5, // 0.25,\n        fill: getFillColor(element, defaultFillColor),\n        stroke: getStrokeColor(element, defaultStrokeColor)\n      });\n\n      return task;\n    },\n    'bpmn:SendTask': function(parentGfx, element) {\n      var task = renderer('bpmn:Task')(parentGfx, element);\n\n      var pathData = pathMap.getScaledPath('TASK_TYPE_SEND', {\n        xScaleFactor: 1,\n        yScaleFactor: 1,\n        containerWidth: 21,\n        containerHeight: 14,\n        position: {\n          mx: 0.285,\n          my: 0.357\n        }\n      });\n\n      /* send path */ drawPath(parentGfx, pathData, {\n        strokeWidth: 1,\n        fill: getStrokeColor(element, defaultStrokeColor),\n        stroke: getFillColor(element, defaultFillColor)\n      });\n\n      return task;\n    },\n    'bpmn:ReceiveTask' : function(parentGfx, element) {\n      var semantic = getSemantic(element);\n\n      var task = renderer('bpmn:Task')(parentGfx, element);\n      var pathData;\n\n      if (semantic.instantiate) {\n        drawCircle(parentGfx, 28, 28, 20 * 0.22, { strokeWidth: 1 });\n\n        pathData = pathMap.getScaledPath('TASK_TYPE_INSTANTIATING_SEND', {\n          abspos: {\n            x: 7.77,\n            y: 9.52\n          }\n        });\n      } else {\n\n        pathData = pathMap.getScaledPath('TASK_TYPE_SEND', {\n          xScaleFactor: 0.9,\n          yScaleFactor: 0.9,\n          containerWidth: 21,\n          containerHeight: 14,\n          position: {\n            mx: 0.3,\n            my: 0.4\n          }\n        });\n      }\n\n      /* receive path */ drawPath(parentGfx, pathData, {\n        strokeWidth: 1,\n        fill: getFillColor(element, defaultFillColor),\n        stroke: getStrokeColor(element, defaultStrokeColor)\n      });\n\n      return task;\n    },\n    'bpmn:ScriptTask': function(parentGfx, element) {\n      var task = renderer('bpmn:Task')(parentGfx, element);\n\n      var pathData = pathMap.getScaledPath('TASK_TYPE_SCRIPT', {\n        abspos: {\n          x: 15,\n          y: 20\n        }\n      });\n\n      /* script path */ drawPath(parentGfx, pathData, {\n        strokeWidth: 1,\n        stroke: getStrokeColor(element, defaultStrokeColor)\n      });\n\n      return task;\n    },\n    'bpmn:BusinessRuleTask': function(parentGfx, element) {\n      var task = renderer('bpmn:Task')(parentGfx, element);\n\n      var headerPathData = pathMap.getScaledPath('TASK_TYPE_BUSINESS_RULE_HEADER', {\n        abspos: {\n          x: 8,\n          y: 8\n        }\n      });\n\n      var businessHeaderPath = drawPath(parentGfx, headerPathData);\n      svgAttr(businessHeaderPath, {\n        strokeWidth: 1,\n        fill: getFillColor(element, '#aaaaaa'),\n        stroke: getStrokeColor(element, defaultStrokeColor)\n      });\n\n      var headerData = pathMap.getScaledPath('TASK_TYPE_BUSINESS_RULE_MAIN', {\n        abspos: {\n          x: 8,\n          y: 8\n        }\n      });\n\n      var businessPath = drawPath(parentGfx, headerData);\n      svgAttr(businessPath, {\n        strokeWidth: 1,\n        stroke: getStrokeColor(element, defaultStrokeColor)\n      });\n\n      return task;\n    },\n    'bpmn:SubProcess': function(parentGfx, element, attrs) {\n      attrs = assign({\n        fill: getFillColor(element, defaultFillColor),\n        stroke: getStrokeColor(element, defaultStrokeColor)\n      }, attrs);\n\n      var rect = renderer('bpmn:Activity')(parentGfx, element, attrs);\n\n      var expanded = isExpanded(element);\n\n      if (isEventSubProcess(element)) {\n        svgAttr(rect, {\n          strokeDasharray: '1,2'\n        });\n      }\n\n      renderEmbeddedLabel(parentGfx, element, expanded ? 'center-top' : 'center-middle');\n\n      if (expanded) {\n        attachTaskMarkers(parentGfx, element);\n      } else {\n        attachTaskMarkers(parentGfx, element, ['SubProcessMarker']);\n      }\n\n      return rect;\n    },\n    'bpmn:AdHocSubProcess': function(parentGfx, element) {\n      return renderer('bpmn:SubProcess')(parentGfx, element);\n    },\n    'bpmn:Transaction': function(parentGfx, element) {\n      var outer = renderer('bpmn:SubProcess')(parentGfx, element);\n\n      var innerAttrs = styles.style([ 'no-fill', 'no-events' ], {\n        stroke: getStrokeColor(element, defaultStrokeColor)\n      });\n\n      /* inner path */ drawRect(parentGfx, element.width, element.height, TASK_BORDER_RADIUS - 2, INNER_OUTER_DIST, innerAttrs);\n\n      return outer;\n    },\n    'bpmn:CallActivity': function(parentGfx, element) {\n      return renderer('bpmn:SubProcess')(parentGfx, element, {\n        strokeWidth: 5\n      });\n    },\n    'bpmn:Participant': function(parentGfx, element) {\n\n      var attrs = {\n        fillOpacity: DEFAULT_FILL_OPACITY,\n        fill: getFillColor(element, defaultFillColor),\n        stroke: getStrokeColor(element, defaultStrokeColor)\n      };\n\n      var lane = renderer('bpmn:Lane')(parentGfx, element, attrs);\n\n      var expandedPool = isExpanded(element);\n\n      if (expandedPool) {\n        drawLine(parentGfx, [\n          { x: 30, y: 0 },\n          { x: 30, y: element.height }\n        ], {\n          stroke: getStrokeColor(element, defaultStrokeColor)\n        });\n        var text = getSemantic(element).name;\n        renderLaneLabel(parentGfx, text, element);\n      } else {\n        // Collapsed pool draw text inline\n        var text2 = getSemantic(element).name;\n        renderLabel(parentGfx, text2, {\n          box: element, align: 'center-middle',\n          style: {\n            fill: getStrokeColor(element, defaultStrokeColor)\n          }\n        });\n      }\n\n      var participantMultiplicity = !!(getSemantic(element).participantMultiplicity);\n\n      if (participantMultiplicity) {\n        renderer('ParticipantMultiplicityMarker')(parentGfx, element);\n      }\n\n      return lane;\n    },\n    'bpmn:Lane': function(parentGfx, element, attrs) {\n      var rect = drawRect(parentGfx, element.width, element.height, 0, assign({\n        fill: getFillColor(element, defaultFillColor),\n        fillOpacity: HIGH_FILL_OPACITY,\n        stroke: getStrokeColor(element, defaultStrokeColor)\n      }, attrs));\n\n      var semantic = getSemantic(element);\n\n      if (semantic.$type === 'bpmn:Lane') {\n        var text = semantic.name;\n        renderLaneLabel(parentGfx, text, element);\n      }\n\n      return rect;\n    },\n    'bpmn:InclusiveGateway': function(parentGfx, element) {\n      var diamond = renderer('bpmn:Gateway')(parentGfx, element);\n\n      /* circle path */\n      drawCircle(parentGfx, element.width, element.height, element.height * 0.24, {\n        strokeWidth: 2.5,\n        fill: getFillColor(element, defaultFillColor),\n        stroke: getStrokeColor(element, defaultStrokeColor)\n      });\n\n      return diamond;\n    },\n    'bpmn:ExclusiveGateway': function(parentGfx, element) {\n      var diamond = renderer('bpmn:Gateway')(parentGfx, element);\n\n      var pathData = pathMap.getScaledPath('GATEWAY_EXCLUSIVE', {\n        xScaleFactor: 0.4,\n        yScaleFactor: 0.4,\n        containerWidth: element.width,\n        containerHeight: element.height,\n        position: {\n          mx: 0.32,\n          my: 0.3\n        }\n      });\n\n      if ((getDi(element).isMarkerVisible)) {\n        drawPath(parentGfx, pathData, {\n          strokeWidth: 1,\n          fill: getStrokeColor(element, defaultStrokeColor),\n          stroke: getStrokeColor(element, defaultStrokeColor)\n        });\n      }\n\n      return diamond;\n    },\n    'bpmn:ComplexGateway': function(parentGfx, element) {\n      var diamond = renderer('bpmn:Gateway')(parentGfx, element);\n\n      var pathData = pathMap.getScaledPath('GATEWAY_COMPLEX', {\n        xScaleFactor: 0.5,\n        yScaleFactor:0.5,\n        containerWidth: element.width,\n        containerHeight: element.height,\n        position: {\n          mx: 0.46,\n          my: 0.26\n        }\n      });\n\n      /* complex path */ drawPath(parentGfx, pathData, {\n        strokeWidth: 1,\n        fill: getStrokeColor(element, defaultStrokeColor),\n        stroke: getStrokeColor(element, defaultStrokeColor)\n      });\n\n      return diamond;\n    },\n    'bpmn:ParallelGateway': function(parentGfx, element) {\n      var diamond = renderer('bpmn:Gateway')(parentGfx, element);\n\n      var pathData = pathMap.getScaledPath('GATEWAY_PARALLEL', {\n        xScaleFactor: 0.6,\n        yScaleFactor:0.6,\n        containerWidth: element.width,\n        containerHeight: element.height,\n        position: {\n          mx: 0.46,\n          my: 0.2\n        }\n      });\n\n      /* parallel path */ drawPath(parentGfx, pathData, {\n        strokeWidth: 1,\n        fill: getStrokeColor(element, defaultStrokeColor),\n        stroke: getStrokeColor(element, defaultStrokeColor)\n      });\n\n      return diamond;\n    },\n    'bpmn:EventBasedGateway': function(parentGfx, element) {\n\n      var semantic = getSemantic(element);\n\n      var diamond = renderer('bpmn:Gateway')(parentGfx, element);\n\n      /* outer circle path */ drawCircle(parentGfx, element.width, element.height, element.height * 0.20, {\n        strokeWidth: 1,\n        fill: 'none',\n        stroke: getStrokeColor(element, defaultStrokeColor)\n      });\n\n      var type = semantic.eventGatewayType;\n      var instantiate = !!semantic.instantiate;\n\n      function drawEvent() {\n\n        var pathData = pathMap.getScaledPath('GATEWAY_EVENT_BASED', {\n          xScaleFactor: 0.18,\n          yScaleFactor: 0.18,\n          containerWidth: element.width,\n          containerHeight: element.height,\n          position: {\n            mx: 0.36,\n            my: 0.44\n          }\n        });\n\n        var attrs = {\n          strokeWidth: 2,\n          fill: getFillColor(element, 'none'),\n          stroke: getStrokeColor(element, defaultStrokeColor)\n        };\n\n        /* event path */ drawPath(parentGfx, pathData, attrs);\n      }\n\n      if (type === 'Parallel') {\n\n        var pathData = pathMap.getScaledPath('GATEWAY_PARALLEL', {\n          xScaleFactor: 0.4,\n          yScaleFactor:0.4,\n          containerWidth: element.width,\n          containerHeight: element.height,\n          position: {\n            mx: 0.474,\n            my: 0.296\n          }\n        });\n\n        var parallelPath = drawPath(parentGfx, pathData);\n        svgAttr(parallelPath, {\n          strokeWidth: 1,\n          fill: 'none'\n        });\n      } else if (type === 'Exclusive') {\n\n        if (!instantiate) {\n          var innerCircle = drawCircle(parentGfx, element.width, element.height, element.height * 0.26);\n          svgAttr(innerCircle, {\n            strokeWidth: 1,\n            fill: 'none',\n            stroke: getStrokeColor(element, defaultStrokeColor)\n          });\n        }\n\n        drawEvent();\n      }\n\n\n      return diamond;\n    },\n    'bpmn:Gateway': function(parentGfx, element) {\n      var attrs = {\n        fill: getFillColor(element, defaultFillColor),\n        fillOpacity: DEFAULT_FILL_OPACITY,\n        stroke: getStrokeColor(element, defaultStrokeColor)\n      };\n\n      return drawDiamond(parentGfx, element.width, element.height, attrs);\n    },\n    'bpmn:SequenceFlow': function(parentGfx, element) {\n      var pathData = createPathFromConnection(element);\n\n      var fill = getFillColor(element, defaultFillColor),\n          stroke = getStrokeColor(element, defaultStrokeColor);\n\n      var attrs = {\n        strokeLinejoin: 'round',\n        markerEnd: marker('sequenceflow-end', fill, stroke),\n        stroke: getStrokeColor(element, defaultStrokeColor)\n      };\n\n      var path = drawPath(parentGfx, pathData, attrs);\n\n      var sequenceFlow = getSemantic(element);\n\n      var source;\n\n      if (element.source) {\n        source = element.source.businessObject;\n\n        // conditional flow marker\n        if (sequenceFlow.conditionExpression && source.$instanceOf('bpmn:Activity')) {\n          svgAttr(path, {\n            markerStart: marker('conditional-flow-marker', fill, stroke)\n          });\n        }\n\n        // default marker\n        if (source.default && (source.$instanceOf('bpmn:Gateway') || source.$instanceOf('bpmn:Activity')) &&\n            source.default === sequenceFlow) {\n          svgAttr(path, {\n            markerStart: marker('conditional-default-flow-marker', fill, stroke)\n          });\n        }\n      }\n\n      return path;\n    },\n    'bpmn:Association': function(parentGfx, element, attrs) {\n\n      var semantic = getSemantic(element);\n\n      var fill = getFillColor(element, defaultFillColor),\n          stroke = getStrokeColor(element, defaultStrokeColor);\n\n      attrs = assign({\n        strokeDasharray: '0.5, 5',\n        strokeLinecap: 'round',\n        strokeLinejoin: 'round',\n        stroke: getStrokeColor(element, defaultStrokeColor)\n      }, attrs || {});\n\n      if (semantic.associationDirection === 'One' ||\n          semantic.associationDirection === 'Both') {\n        attrs.markerEnd = marker('association-end', fill, stroke);\n      }\n\n      if (semantic.associationDirection === 'Both') {\n        attrs.markerStart = marker('association-start', fill, stroke);\n      }\n\n      return drawLine(parentGfx, element.waypoints, attrs);\n    },\n    'bpmn:DataInputAssociation': function(parentGfx, element) {\n      var fill = getFillColor(element, defaultFillColor),\n          stroke = getStrokeColor(element, defaultStrokeColor);\n\n      return renderer('bpmn:Association')(parentGfx, element, {\n        markerEnd: marker('association-end', fill, stroke)\n      });\n    },\n    'bpmn:DataOutputAssociation': function(parentGfx, element) {\n      var fill = getFillColor(element, defaultFillColor),\n          stroke = getStrokeColor(element, defaultStrokeColor);\n\n      return renderer('bpmn:Association')(parentGfx, element, {\n        markerEnd: marker('association-end', fill, stroke)\n      });\n    },\n    'bpmn:MessageFlow': function(parentGfx, element) {\n\n      var semantic = getSemantic(element),\n          di = getDi(element);\n\n      var fill = getFillColor(element, defaultFillColor),\n          stroke = getStrokeColor(element, defaultStrokeColor);\n\n      var pathData = createPathFromConnection(element);\n\n      var attrs = {\n        markerEnd: marker('messageflow-end', fill, stroke),\n        markerStart: marker('messageflow-start', fill, stroke),\n        strokeDasharray: '10, 12',\n        strokeLinecap: 'round',\n        strokeLinejoin: 'round',\n        strokeWidth: '1.5px',\n        stroke: getStrokeColor(element, defaultStrokeColor)\n      };\n\n      var path = drawPath(parentGfx, pathData, attrs);\n\n      if (semantic.messageRef) {\n        var midPoint = path.getPointAtLength(path.getTotalLength() / 2);\n\n        var markerPathData = pathMap.getScaledPath('MESSAGE_FLOW_MARKER', {\n          abspos: {\n            x: midPoint.x,\n            y: midPoint.y\n          }\n        });\n\n        var messageAttrs = { strokeWidth: 1 };\n\n        if (di.messageVisibleKind === 'initiating') {\n          messageAttrs.fill = 'white';\n          messageAttrs.stroke = 'black';\n        } else {\n          messageAttrs.fill = '#888';\n          messageAttrs.stroke = 'white';\n        }\n\n        drawPath(parentGfx, markerPathData, messageAttrs);\n      }\n\n      return path;\n    },\n    'bpmn:DataObject': function(parentGfx, element) {\n      var pathData = pathMap.getScaledPath('DATA_OBJECT_PATH', {\n        xScaleFactor: 1,\n        yScaleFactor: 1,\n        containerWidth: element.width,\n        containerHeight: element.height,\n        position: {\n          mx: 0.474,\n          my: 0.296\n        }\n      });\n\n      var elementObject = drawPath(parentGfx, pathData, {\n        fill: getFillColor(element, defaultFillColor),\n        fillOpacity: DEFAULT_FILL_OPACITY,\n        stroke: getStrokeColor(element, defaultStrokeColor)\n      });\n\n      var semantic = getSemantic(element);\n\n      if (isCollection(semantic)) {\n        renderDataItemCollection(parentGfx, element);\n      }\n\n      return elementObject;\n    },\n    'bpmn:DataObjectReference': as('bpmn:DataObject'),\n    'bpmn:DataInput': function(parentGfx, element) {\n\n      var arrowPathData = pathMap.getRawPath('DATA_ARROW');\n\n      // page\n      var elementObject = renderer('bpmn:DataObject')(parentGfx, element);\n\n      /* input arrow path */ drawPath(parentGfx, arrowPathData, { strokeWidth: 1 });\n\n      return elementObject;\n    },\n    'bpmn:DataOutput': function(parentGfx, element) {\n      var arrowPathData = pathMap.getRawPath('DATA_ARROW');\n\n      // page\n      var elementObject = renderer('bpmn:DataObject')(parentGfx, element);\n\n      /* output arrow path */ drawPath(parentGfx, arrowPathData, {\n        strokeWidth: 1,\n        fill: 'black'\n      });\n\n      return elementObject;\n    },\n    'bpmn:DataStoreReference': function(parentGfx, element) {\n      var DATA_STORE_PATH = pathMap.getScaledPath('DATA_STORE', {\n        xScaleFactor: 1,\n        yScaleFactor: 1,\n        containerWidth: element.width,\n        containerHeight: element.height,\n        position: {\n          mx: 0,\n          my: 0.133\n        }\n      });\n\n      var elementStore = drawPath(parentGfx, DATA_STORE_PATH, {\n        strokeWidth: 2,\n        fill: getFillColor(element, defaultFillColor),\n        fillOpacity: DEFAULT_FILL_OPACITY,\n        stroke: getStrokeColor(element, defaultStrokeColor)\n      });\n\n      return elementStore;\n    },\n    'bpmn:BoundaryEvent': function(parentGfx, element) {\n\n      var semantic = getSemantic(element),\n          cancel = semantic.cancelActivity;\n\n      var attrs = {\n        strokeWidth: 1,\n        fill: getFillColor(element, defaultFillColor),\n        stroke: getStrokeColor(element, defaultStrokeColor)\n      };\n\n      if (!cancel) {\n        attrs.strokeDasharray = '6';\n        attrs.strokeLinecap = 'round';\n      }\n\n      // apply fillOpacity\n      var outerAttrs = assign({}, attrs, {\n        fillOpacity: 1\n      });\n\n      // apply no-fill\n      var innerAttrs = assign({}, attrs, {\n        fill: 'none'\n      });\n\n      var outer = renderer('bpmn:Event')(parentGfx, element, outerAttrs);\n\n      /* inner path */ drawCircle(parentGfx, element.width, element.height, INNER_OUTER_DIST, innerAttrs);\n\n      renderEventContent(element, parentGfx);\n\n      return outer;\n    },\n    'bpmn:Group': function(parentGfx, element) {\n      var semantic = getSemantic(element),\n          di = getDi(element);\n\n      var group = drawRect(parentGfx, element.width, element.height, TASK_BORDER_RADIUS, {\n        strokeWidth: 1,\n        strokeDasharray: '8,3,1,3',\n        fill: 'none',\n        pointerEvents: 'none'\n      });\n\n      var categoryValueRef = semantic.categoryValueRef || {};\n\n      if (categoryValueRef.value) {\n        var box = di.label ? di.label.bounds : element;\n\n        renderLabel(parentGfx, categoryValueRef.value, {\n          box: box,\n          style: {\n            fill: getStrokeColor(element, defaultStrokeColor)\n          }\n        });\n      }\n\n      return group;\n    },\n    'label': function(parentGfx, element) {\n      return renderExternalLabel(parentGfx, element);\n    },\n    'bpmn:TextAnnotation': function(parentGfx, element) {\n      var style = {\n        'fill': 'none',\n        'stroke': 'none'\n      };\n\n      var textElement = drawRect(parentGfx, element.width, element.height, 0, 0, style);\n\n      var textPathData = pathMap.getScaledPath('TEXT_ANNOTATION', {\n        xScaleFactor: 1,\n        yScaleFactor: 1,\n        containerWidth: element.width,\n        containerHeight: element.height,\n        position: {\n          mx: 0.0,\n          my: 0.0\n        }\n      });\n\n      drawPath(parentGfx, textPathData, {\n        stroke: getStrokeColor(element, defaultStrokeColor)\n      });\n\n      var text = getSemantic(element).text || '';\n      renderLabel(parentGfx, text, {\n        box: element,\n        align: 'left-top',\n        padding: 5,\n        style: {\n          fill: getStrokeColor(element, defaultStrokeColor)\n        }\n      });\n\n      return textElement;\n    },\n    'ParticipantMultiplicityMarker': function(parentGfx, element) {\n      var markerPath = pathMap.getScaledPath('MARKER_PARALLEL', {\n        xScaleFactor: 1,\n        yScaleFactor: 1,\n        containerWidth: element.width,\n        containerHeight: element.height,\n        position: {\n          mx: ((element.width / 2) / element.width),\n          my: (element.height - 15) / element.height\n        }\n      });\n\n      drawMarker('participant-multiplicity', parentGfx, markerPath, {\n        strokeWidth: 1,\n        fill: getFillColor(element, defaultFillColor),\n        stroke: getStrokeColor(element, defaultStrokeColor)\n      });\n    },\n    'SubProcessMarker': function(parentGfx, element) {\n      var markerRect = drawRect(parentGfx, 14, 14, 0, {\n        strokeWidth: 1,\n        fill: getFillColor(element, defaultFillColor),\n        stroke: getStrokeColor(element, defaultStrokeColor)\n      });\n\n      // Process marker is placed in the middle of the box\n      // therefore fixed values can be used here\n      translate(markerRect, element.width / 2 - 7.5, element.height - 20);\n\n      var markerPath = pathMap.getScaledPath('MARKER_SUB_PROCESS', {\n        xScaleFactor: 1.5,\n        yScaleFactor: 1.5,\n        containerWidth: element.width,\n        containerHeight: element.height,\n        position: {\n          mx: (element.width / 2 - 7.5) / element.width,\n          my: (element.height - 20) / element.height\n        }\n      });\n\n      drawMarker('sub-process', parentGfx, markerPath, {\n        fill: getFillColor(element, defaultFillColor),\n        stroke: getStrokeColor(element, defaultStrokeColor)\n      });\n    },\n    'ParallelMarker': function(parentGfx, element, position) {\n      var markerPath = pathMap.getScaledPath('MARKER_PARALLEL', {\n        xScaleFactor: 1,\n        yScaleFactor: 1,\n        containerWidth: element.width,\n        containerHeight: element.height,\n        position: {\n          mx: ((element.width / 2 + position.parallel) / element.width),\n          my: (element.height - 20) / element.height\n        }\n      });\n\n      drawMarker('parallel', parentGfx, markerPath, {\n        fill: getFillColor(element, defaultFillColor),\n        stroke: getStrokeColor(element, defaultStrokeColor)\n      });\n    },\n    'SequentialMarker': function(parentGfx, element, position) {\n      var markerPath = pathMap.getScaledPath('MARKER_SEQUENTIAL', {\n        xScaleFactor: 1,\n        yScaleFactor: 1,\n        containerWidth: element.width,\n        containerHeight: element.height,\n        position: {\n          mx: ((element.width / 2 + position.seq) / element.width),\n          my: (element.height - 19) / element.height\n        }\n      });\n\n      drawMarker('sequential', parentGfx, markerPath, {\n        fill: getFillColor(element, defaultFillColor),\n        stroke: getStrokeColor(element, defaultStrokeColor)\n      });\n    },\n    'CompensationMarker': function(parentGfx, element, position) {\n      var markerMath = pathMap.getScaledPath('MARKER_COMPENSATION', {\n        xScaleFactor: 1,\n        yScaleFactor: 1,\n        containerWidth: element.width,\n        containerHeight: element.height,\n        position: {\n          mx: ((element.width / 2 + position.compensation) / element.width),\n          my: (element.height - 13) / element.height\n        }\n      });\n\n      drawMarker('compensation', parentGfx, markerMath, {\n        strokeWidth: 1,\n        fill: getFillColor(element, defaultFillColor),\n        stroke: getStrokeColor(element, defaultStrokeColor)\n      });\n    },\n    'LoopMarker': function(parentGfx, element, position) {\n      var markerPath = pathMap.getScaledPath('MARKER_LOOP', {\n        xScaleFactor: 1,\n        yScaleFactor: 1,\n        containerWidth: element.width,\n        containerHeight: element.height,\n        position: {\n          mx: ((element.width / 2 + position.loop) / element.width),\n          my: (element.height - 7) / element.height\n        }\n      });\n\n      drawMarker('loop', parentGfx, markerPath, {\n        strokeWidth: 1,\n        fill: getFillColor(element, defaultFillColor),\n        stroke: getStrokeColor(element, defaultStrokeColor),\n        strokeLinecap: 'round',\n        strokeMiterlimit: 0.5\n      });\n    },\n    'AdhocMarker': function(parentGfx, element, position) {\n      var markerPath = pathMap.getScaledPath('MARKER_ADHOC', {\n        xScaleFactor: 1,\n        yScaleFactor: 1,\n        containerWidth: element.width,\n        containerHeight: element.height,\n        position: {\n          mx: ((element.width / 2 + position.adhoc) / element.width),\n          my: (element.height - 15) / element.height\n        }\n      });\n\n      drawMarker('adhoc', parentGfx, markerPath, {\n        strokeWidth: 1,\n        fill: getStrokeColor(element, defaultStrokeColor),\n        stroke: getStrokeColor(element, defaultStrokeColor)\n      });\n    }\n  };\n\n  function attachTaskMarkers(parentGfx, element, taskMarkers) {\n    var obj = getSemantic(element);\n\n    var subprocess = taskMarkers && taskMarkers.indexOf('SubProcessMarker') !== -1;\n    var position;\n\n    if (subprocess) {\n      position = {\n        seq: -21,\n        parallel: -22,\n        compensation: -42,\n        loop: -18,\n        adhoc: 10\n      };\n    } else {\n      position = {\n        seq: -3,\n        parallel: -6,\n        compensation: -27,\n        loop: 0,\n        adhoc: 10\n      };\n    }\n\n    forEach(taskMarkers, function(marker) {\n      renderer(marker)(parentGfx, element, position);\n    });\n\n    if (obj.isForCompensation) {\n      renderer('CompensationMarker')(parentGfx, element, position);\n    }\n\n    if (obj.$type === 'bpmn:AdHocSubProcess') {\n      renderer('AdhocMarker')(parentGfx, element, position);\n    }\n\n    var loopCharacteristics = obj.loopCharacteristics,\n        isSequential = loopCharacteristics && loopCharacteristics.isSequential;\n\n    if (loopCharacteristics) {\n\n      if (isSequential === undefined) {\n        renderer('LoopMarker')(parentGfx, element, position);\n      }\n\n      if (isSequential === false) {\n        renderer('ParallelMarker')(parentGfx, element, position);\n      }\n\n      if (isSequential === true) {\n        renderer('SequentialMarker')(parentGfx, element, position);\n      }\n    }\n  }\n\n  function renderDataItemCollection(parentGfx, element) {\n\n    var yPosition = (element.height - 16) / element.height;\n\n    var pathData = pathMap.getScaledPath('DATA_OBJECT_COLLECTION_PATH', {\n      xScaleFactor: 1,\n      yScaleFactor: 1,\n      containerWidth: element.width,\n      containerHeight: element.height,\n      position: {\n        mx: 0.451,\n        my: yPosition\n      }\n    });\n\n    /* collection path */ drawPath(parentGfx, pathData, {\n      strokeWidth: 2\n    });\n  }\n\n\n  // extension API, use at your own risk\n  this._drawPath = drawPath;\n\n}\n\n\ninherits(BpmnRenderer, BaseRenderer);\n\nBpmnRenderer.$inject = [\n  'config.bpmnRenderer',\n  'eventBus',\n  'styles',\n  'pathMap',\n  'canvas',\n  'textRenderer'\n];\n\n\nBpmnRenderer.prototype.canRender = function(element) {\n  return is(element, 'bpmn:BaseElement');\n};\n\nBpmnRenderer.prototype.drawShape = function(parentGfx, element) {\n  var type = element.type;\n  var h = this.handlers[type];\n\n  /* jshint -W040 */\n  return h(parentGfx, element);\n};\n\nBpmnRenderer.prototype.drawConnection = function(parentGfx, element) {\n  var type = element.type;\n  var h = this.handlers[type];\n\n  /* jshint -W040 */\n  return h(parentGfx, element);\n};\n\nBpmnRenderer.prototype.getShapePath = function(element) {\n\n  if (is(element, 'bpmn:Event')) {\n    return getCirclePath(element);\n  }\n\n  if (is(element, 'bpmn:Activity')) {\n    return getRoundRectPath(element, TASK_BORDER_RADIUS);\n  }\n\n  if (is(element, 'bpmn:Gateway')) {\n    return getDiamondPath(element);\n  }\n\n  return getRectPath(element);\n};\n","/**\n * Map containing SVG paths needed by BpmnRenderer.\n */\n\nexport default function PathMap() {\n\n  /**\n   * Contains a map of path elements\n   *\n   * <h1>Path definition</h1>\n   * A parameterized path is defined like this:\n   * <pre>\n   * 'GATEWAY_PARALLEL': {\n   *   d: 'm {mx},{my} {e.x0},0 0,{e.x1} {e.x1},0 0,{e.y0} -{e.x1},0 0,{e.y1} ' +\n          '-{e.x0},0 0,-{e.y1} -{e.x1},0 0,-{e.y0} {e.x1},0 z',\n   *   height: 17.5,\n   *   width:  17.5,\n   *   heightElements: [2.5, 7.5],\n   *   widthElements: [2.5, 7.5]\n   * }\n   * </pre>\n   * <p>It's important to specify a correct <b>height and width</b> for the path as the scaling\n   * is based on the ratio between the specified height and width in this object and the\n   * height and width that is set as scale target (Note x,y coordinates will be scaled with\n   * individual ratios).</p>\n   * <p>The '<b>heightElements</b>' and '<b>widthElements</b>' array must contain the values that will be scaled.\n   * The scaling is based on the computed ratios.\n   * Coordinates on the y axis should be in the <b>heightElement</b>'s array, they will be scaled using\n   * the computed ratio coefficient.\n   * In the parameterized path the scaled values can be accessed through the 'e' object in {} brackets.\n   *   <ul>\n   *    <li>The values for the y axis can be accessed in the path string using {e.y0}, {e.y1}, ....</li>\n   *    <li>The values for the x axis can be accessed in the path string using {e.x0}, {e.x1}, ....</li>\n   *   </ul>\n   *   The numbers x0, x1 respectively y0, y1, ... map to the corresponding array index.\n   * </p>\n   */\n  this.pathMap = {\n    'EVENT_MESSAGE': {\n      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}',\n      height: 36,\n      width:  36,\n      heightElements: [6, 14],\n      widthElements: [10.5, 21]\n    },\n    'EVENT_SIGNAL': {\n      d: 'M {mx},{my} l {e.x0},{e.y0} l -{e.x1},0 Z',\n      height: 36,\n      width: 36,\n      heightElements: [18],\n      widthElements: [10, 20]\n    },\n    'EVENT_ESCALATION': {\n      d: 'M {mx},{my} l {e.x0},{e.y0} l -{e.x0},-{e.y1} l -{e.x0},{e.y1} Z',\n      height: 36,\n      width: 36,\n      heightElements: [20, 7],\n      widthElements: [8]\n    },\n    'EVENT_CONDITIONAL': {\n      d: 'M {e.x0},{e.y0} l {e.x1},0 l 0,{e.y2} l -{e.x1},0 Z ' +\n         'M {e.x2},{e.y3} l {e.x0},0 ' +\n         'M {e.x2},{e.y4} l {e.x0},0 ' +\n         'M {e.x2},{e.y5} l {e.x0},0 ' +\n         'M {e.x2},{e.y6} l {e.x0},0 ' +\n         'M {e.x2},{e.y7} l {e.x0},0 ' +\n         'M {e.x2},{e.y8} l {e.x0},0 ',\n      height: 36,\n      width:  36,\n      heightElements: [8.5, 14.5, 18, 11.5, 14.5, 17.5, 20.5, 23.5, 26.5],\n      widthElements:  [10.5, 14.5, 12.5]\n    },\n    'EVENT_LINK': {\n      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',\n      height: 36,\n      width: 36,\n      heightElements: [4.4375, 6.75, 7.8125],\n      widthElements: [9.84375, 13.5]\n    },\n    'EVENT_ERROR': {\n      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',\n      height: 36,\n      width: 36,\n      heightElements: [0.023, 8.737, 8.151, 16.564, 10.591, 8.714],\n      widthElements: [0.085, 6.672, 6.97, 4.273, 5.337, 6.636]\n    },\n    'EVENT_CANCEL_45': {\n      d: 'm {mx},{my} -{e.x1},0 0,{e.x0} {e.x1},0 0,{e.y1} {e.x0},0 ' +\n        '0,-{e.y1} {e.x1},0 0,-{e.y0} -{e.x1},0 0,-{e.y1} -{e.x0},0 z',\n      height: 36,\n      width: 36,\n      heightElements: [4.75, 8.5],\n      widthElements: [4.75, 8.5]\n    },\n    'EVENT_COMPENSATION': {\n      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',\n      height: 36,\n      width: 36,\n      heightElements: [6.5, 13, 0.4, 6.1],\n      widthElements: [9, 9.3, 8.7]\n    },\n    'EVENT_TIMER_WH': {\n      d: 'M {mx},{my} l {e.x0},-{e.y0} m -{e.x0},{e.y0} l {e.x1},{e.y1} ',\n      height: 36,\n      width:  36,\n      heightElements: [10, 2],\n      widthElements: [3, 7]\n    },\n    'EVENT_TIMER_LINE': {\n      d:  'M {mx},{my} ' +\n          'm {e.x0},{e.y0} l -{e.x1},{e.y1} ',\n      height: 36,\n      width:  36,\n      heightElements: [10, 3],\n      widthElements: [0, 0]\n    },\n    'EVENT_MULTIPLE': {\n      d:'m {mx},{my} {e.x1},-{e.y0} {e.x1},{e.y0} -{e.x0},{e.y1} -{e.x2},0 z',\n      height: 36,\n      width:  36,\n      heightElements: [6.28099, 12.56199],\n      widthElements: [3.1405, 9.42149, 12.56198]\n    },\n    'EVENT_PARALLEL_MULTIPLE': {\n      d:'m {mx},{my} {e.x0},0 0,{e.y1} {e.x1},0 0,{e.y0} -{e.x1},0 0,{e.y1} ' +\n        '-{e.x0},0 0,-{e.y1} -{e.x1},0 0,-{e.y0} {e.x1},0 z',\n      height: 36,\n      width:  36,\n      heightElements: [2.56228, 7.68683],\n      widthElements: [2.56228, 7.68683]\n    },\n    'GATEWAY_EXCLUSIVE': {\n      d:'m {mx},{my} {e.x0},{e.y0} {e.x1},{e.y0} {e.x2},0 {e.x4},{e.y2} ' +\n                    '{e.x4},{e.y1} {e.x2},0 {e.x1},{e.y3} {e.x0},{e.y3} ' +\n                    '{e.x3},0 {e.x5},{e.y1} {e.x5},{e.y2} {e.x3},0 z',\n      height: 17.5,\n      width:  17.5,\n      heightElements: [8.5, 6.5312, -6.5312, -8.5],\n      widthElements:  [6.5, -6.5, 3, -3, 5, -5]\n    },\n    'GATEWAY_PARALLEL': {\n      d:'m {mx},{my} 0,{e.y1} -{e.x1},0 0,{e.y0} {e.x1},0 0,{e.y1} {e.x0},0 ' +\n        '0,-{e.y1} {e.x1},0 0,-{e.y0} -{e.x1},0 0,-{e.y1} -{e.x0},0 z',\n      height: 30,\n      width:  30,\n      heightElements: [5, 12.5],\n      widthElements: [5, 12.5]\n    },\n    'GATEWAY_EVENT_BASED': {\n      d:'m {mx},{my} {e.x0},{e.y0} {e.x0},{e.y1} {e.x1},{e.y2} {e.x2},0 z',\n      height: 11,\n      width:  11,\n      heightElements: [-6, 6, 12, -12],\n      widthElements: [9, -3, -12]\n    },\n    'GATEWAY_COMPLEX': {\n      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} ' +\n        '{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} ' +\n        '{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} ' +\n        '-{e.x0},{e.y1} 0,-{e.y0} -{e.x3},0 z',\n      height: 17.125,\n      width:  17.125,\n      heightElements: [4.875, 3.4375, 2.125, 3],\n      widthElements: [3.4375, 2.125, 4.875, 3]\n    },\n    'DATA_OBJECT_PATH': {\n      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',\n      height: 61,\n      width:  51,\n      heightElements: [10, 50, 60],\n      widthElements: [10, 40, 50, 60]\n    },\n    'DATA_OBJECT_COLLECTION_PATH': {\n      d:'m {mx}, {my} ' +\n        'm  0 15  l 0 -15 ' +\n        'm  4 15  l 0 -15 ' +\n        'm  4 15  l 0 -15 ',\n      height: 61,\n      width:  51,\n      heightElements: [12],\n      widthElements: [1, 6, 12, 15]\n    },\n    'DATA_ARROW': {\n      d:'m 5,9 9,0 0,-3 5,5 -5,5 0,-3 -9,0 z',\n      height: 61,\n      width:  51,\n      heightElements: [],\n      widthElements: []\n    },\n    'DATA_STORE': {\n      d:'m  {mx},{my} ' +\n        'l  0,{e.y2} ' +\n        'c  {e.x0},{e.y1} {e.x1},{e.y1}  {e.x2},0 ' +\n        'l  0,-{e.y2} ' +\n        'c -{e.x0},-{e.y1} -{e.x1},-{e.y1} -{e.x2},0' +\n        'c  {e.x0},{e.y1} {e.x1},{e.y1}  {e.x2},0 ' +\n        'm  -{e.x2},{e.y0}' +\n        'c  {e.x0},{e.y1} {e.x1},{e.y1} {e.x2},0' +\n        'm  -{e.x2},{e.y0}' +\n        'c  {e.x0},{e.y1} {e.x1},{e.y1}  {e.x2},0',\n      height: 61,\n      width:  61,\n      heightElements: [7, 10, 45],\n      widthElements:  [2, 58, 60]\n    },\n    'TEXT_ANNOTATION': {\n      d: 'm {mx}, {my} m 10,0 l -10,0 l 0,{e.y0} l 10,0',\n      height: 30,\n      width: 10,\n      heightElements: [30],\n      widthElements: [10]\n    },\n    'MARKER_SUB_PROCESS': {\n      d: 'm{mx},{my} m 7,2 l 0,10 m -5,-5 l 10,0',\n      height: 10,\n      width: 10,\n      heightElements: [],\n      widthElements: []\n    },\n    'MARKER_PARALLEL': {\n      d: 'm{mx},{my} m 3,2 l 0,10 m 3,-10 l 0,10 m 3,-10 l 0,10',\n      height: 10,\n      width: 10,\n      heightElements: [],\n      widthElements: []\n    },\n    'MARKER_SEQUENTIAL': {\n      d: 'm{mx},{my} m 0,3 l 10,0 m -10,3 l 10,0 m -10,3 l 10,0',\n      height: 10,\n      width: 10,\n      heightElements: [],\n      widthElements: []\n    },\n    'MARKER_COMPENSATION': {\n      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',\n      height: 10,\n      width: 21,\n      heightElements: [],\n      widthElements: []\n    },\n    'MARKER_LOOP': {\n      d: 'm {mx},{my} c 3.526979,0 6.386161,-2.829858 6.386161,-6.320661 0,-3.490806 -2.859182,-6.320661 ' +\n        '-6.386161,-6.320661 -3.526978,0 -6.38616,2.829855 -6.38616,6.320661 0,1.745402 ' +\n        '0.714797,3.325567 1.870463,4.469381 0.577834,0.571908 1.265885,1.034728 2.029916,1.35457 ' +\n        'l -0.718163,-3.909793 m 0.718163,3.909793 -3.885211,0.802902',\n      height: 13.9,\n      width: 13.7,\n      heightElements: [],\n      widthElements: []\n    },\n    'MARKER_ADHOC': {\n      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 ' +\n        '3.85579,1.15803 5.76082,1.79107 1.06385,0.34139996 2.24454,0.1438 3.18759,-0.43767 0.61743,-0.33642 ' +\n        '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 ' +\n        '-3.6918,1.66181996 -1.24459,0.0927 -2.46671,-0.2491 -3.59505,-0.74812 -1.35789,-0.55965 ' +\n        '-2.75133,-1.33436996 -4.27027,-1.18121996 -1.37741,0.14601 -2.41842,1.13685996 -3.44288,1.96782996 z',\n      height: 4,\n      width: 15,\n      heightElements: [],\n      widthElements: []\n    },\n    'TASK_TYPE_SEND': {\n      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}',\n      height: 14,\n      width:  21,\n      heightElements: [6, 14],\n      widthElements: [10.5, 21]\n    },\n    'TASK_TYPE_SCRIPT': {\n      d: 'm {mx},{my} c 9.966553,-6.27276 -8.000926,-7.91932 2.968968,-14.938 l -8.802728,0 ' +\n        'c -10.969894,7.01868 6.997585,8.66524 -2.968967,14.938 z ' +\n        'm -7,-12 l 5,0 ' +\n        'm -4.5,3 l 4.5,0 ' +\n        'm -3,3 l 5,0' +\n        'm -4,3 l 5,0',\n      height: 15,\n      width:  12.6,\n      heightElements: [6, 14],\n      widthElements: [10.5, 21]\n    },\n    'TASK_TYPE_USER_1': {\n      d: 'm {mx},{my} c 0.909,-0.845 1.594,-2.049 1.594,-3.385 0,-2.554 -1.805,-4.62199999 ' +\n        '-4.357,-4.62199999 -2.55199998,0 -4.28799998,2.06799999 -4.28799998,4.62199999 0,1.348 ' +\n        '0.974,2.562 1.89599998,3.405 -0.52899998,0.187 -5.669,2.097 -5.794,4.7560005 v 6.718 ' +\n        'h 17 v -6.718 c 0,-2.2980005 -5.5279996,-4.5950005 -6.0509996,-4.7760005 z' +\n        'm -8,6 l 0,5.5 m 11,0 l 0,-5'\n    },\n    'TASK_TYPE_USER_2': {\n      d: 'm {mx},{my} m 2.162,1.009 c 0,2.4470005 -2.158,4.4310005 -4.821,4.4310005 ' +\n        '-2.66499998,0 -4.822,-1.981 -4.822,-4.4310005 '\n    },\n    'TASK_TYPE_USER_3': {\n      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 ' +\n        '4.124,0.965 -0.098,-0.57 -0.117,-3.79099999 -4.191,-4.13599999 -3.57499998,0.001 ' +\n        '-4.20799998,3.36699999 -4.20699998,4.34799999 z'\n    },\n    'TASK_TYPE_MANUAL': {\n      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 ' +\n        '-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 ' +\n        '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 ' +\n        '-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 ' +\n        '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 ' +\n        '-10.86,-0.003 -11.0829995,-0.003 -0.022,-0.047 -0.045,-0.094 -0.069,-0.139 0.3939995,-0.319 ' +\n        '2.0409995,-1.626 2.4149995,-2.017 0.469,-0.4870005 0.519,-1.1650005 0.162,-1.6040005 -0.414,-0.511 ' +\n        '-0.973,-0.5 -1.48,-0.236 -1.4609995,0.764 -6.5999995,3.6430005 -7.7329995,4.2710005 -0.9,0.499 ' +\n        '-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 ' +\n        '-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 ' +\n        '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 ' +\n        '-5.824,-0.004 -6.04,-0.004 10e-4,-0.084 0.003,-0.586 10e-4,-0.67 z'\n    },\n    'TASK_TYPE_INSTANTIATING_SEND': {\n      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'\n    },\n    'TASK_TYPE_SERVICE': {\n      d: 'm {mx},{my} v -1.71335 c 0.352326,-0.0705 0.703932,-0.17838 1.047628,-0.32133 ' +\n        '0.344416,-0.14465 0.665822,-0.32133 0.966377,-0.52145 l 1.19431,1.18005 1.567487,-1.57688 ' +\n        '-1.195028,-1.18014 c 0.403376,-0.61394 0.683079,-1.29908 0.825447,-2.01824 l 1.622133,-0.01 ' +\n        'v -2.2196 l -1.636514,0.01 c -0.07333,-0.35153 -0.178319,-0.70024 -0.323564,-1.04372 ' +\n        '-0.145244,-0.34406 -0.321407,-0.6644 -0.522735,-0.96217 l 1.131035,-1.13631 -1.583305,-1.56293 ' +\n        '-1.129598,1.13589 c -0.614052,-0.40108 -1.302883,-0.68093 -2.022633,-0.82247 l 0.0093,-1.61852 ' +\n        '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 ' +\n        '-0.665102,0.32092 -0.9635006,0.52046 l -1.1698628,-1.15823 -1.5667691,1.5792 1.1684265,1.15669 ' +\n        'c -0.4026573,0.61283 -0.68308,1.29797 -0.8247287,2.01713 l -1.6588041,0.003 v 2.22174 ' +\n        'l 1.6724648,-0.006 c 0.073327,0.35077 0.1797598,0.70243 0.3242851,1.04472 0.1452428,0.34448 ' +\n        '0.3214064,0.6644 0.5227339,0.96066 l -1.1993431,1.19723 1.5840256,1.56011 1.1964668,-1.19348 ' +\n        'c 0.6140517,0.40346 1.3028827,0.68232 2.0233517,0.82331 l 7.19e-4,1.69892 h 2.226848 z ' +\n        'm 0.221462,-3.9957 c -1.788948,0.7502 -3.8576,-0.0928 -4.6097055,-1.87438 -0.7521065,-1.78321 ' +\n        '0.090598,-3.84627 1.8802645,-4.59604 1.78823,-0.74936 3.856881,0.0929 4.608987,1.87437 ' +\n        '0.752106,1.78165 -0.0906,3.84612 -1.879546,4.59605 z'\n    },\n    'TASK_TYPE_SERVICE_FILL': {\n      d: 'm {mx},{my} c -1.788948,0.7502 -3.8576,-0.0928 -4.6097055,-1.87438 -0.7521065,-1.78321 ' +\n        '0.090598,-3.84627 1.8802645,-4.59604 1.78823,-0.74936 3.856881,0.0929 4.608987,1.87437 ' +\n        '0.752106,1.78165 -0.0906,3.84612 -1.879546,4.59605 z'\n    },\n    'TASK_TYPE_BUSINESS_RULE_HEADER': {\n      d: 'm {mx},{my} 0,4 20,0 0,-4 z'\n    },\n    'TASK_TYPE_BUSINESS_RULE_MAIN': {\n      d: 'm {mx},{my} 0,12 20,0 0,-12 z' +\n        'm 0,8 l 20,0 ' +\n        'm -13,-4 l 0,8'\n    },\n    'MESSAGE_FLOW_MARKER': {\n      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'\n    }\n  };\n\n  this.getRawPath = function getRawPath(pathId) {\n    return this.pathMap[pathId].d;\n  };\n\n  /**\n   * Scales the path to the given height and width.\n   * <h1>Use case</h1>\n   * <p>Use case is to scale the content of elements (event, gateways) based\n   * on the element bounding box's size.\n   * </p>\n   * <h1>Why not transform</h1>\n   * <p>Scaling a path with transform() will also scale the stroke and IE does not support\n   * the option 'non-scaling-stroke' to prevent this.\n   * Also there are use cases where only some parts of a path should be\n   * scaled.</p>\n   *\n   * @param {String} pathId The ID of the path.\n   * @param {Object} param <p>\n   *   Example param object scales the path to 60% size of the container (data.width, data.height).\n   *   <pre>\n   *   {\n   *     xScaleFactor: 0.6,\n   *     yScaleFactor:0.6,\n   *     containerWidth: data.width,\n   *     containerHeight: data.height,\n   *     position: {\n   *       mx: 0.46,\n   *       my: 0.2,\n   *     }\n   *   }\n   *   </pre>\n   *   <ul>\n   *    <li>targetpathwidth = xScaleFactor * containerWidth</li>\n   *    <li>targetpathheight = yScaleFactor * containerHeight</li>\n   *    <li>Position is used to set the starting coordinate of the path. M is computed:\n    *    <ul>\n    *      <li>position.x * containerWidth</li>\n    *      <li>position.y * containerHeight</li>\n    *    </ul>\n    *    Center of the container <pre> position: {\n   *       mx: 0.5,\n   *       my: 0.5,\n   *     }</pre>\n   *     Upper left corner of the container\n   *     <pre> position: {\n   *       mx: 0.0,\n   *       my: 0.0,\n   *     }</pre>\n   *    </li>\n   *   </ul>\n   * </p>\n   *\n   */\n  this.getScaledPath = function getScaledPath(pathId, param) {\n    var rawPath = this.pathMap[pathId];\n\n    // positioning\n    // compute the start point of the path\n    var mx, my;\n\n    if (param.abspos) {\n      mx = param.abspos.x;\n      my = param.abspos.y;\n    } else {\n      mx = param.containerWidth * param.position.mx;\n      my = param.containerHeight * param.position.my;\n    }\n\n    var coordinates = {}; // map for the scaled coordinates\n    if (param.position) {\n\n      // path\n      var heightRatio = (param.containerHeight / rawPath.height) * param.yScaleFactor;\n      var widthRatio = (param.containerWidth / rawPath.width) * param.xScaleFactor;\n\n\n      // Apply height ratio\n      for (var heightIndex = 0; heightIndex < rawPath.heightElements.length; heightIndex++) {\n        coordinates['y' + heightIndex] = rawPath.heightElements[heightIndex] * heightRatio;\n      }\n\n      // Apply width ratio\n      for (var widthIndex = 0; widthIndex < rawPath.widthElements.length; widthIndex++) {\n        coordinates['x' + widthIndex] = rawPath.widthElements[widthIndex] * widthRatio;\n      }\n    }\n\n    // Apply value to raw path\n    var path = format(\n      rawPath.d, {\n        mx: mx,\n        my: my,\n        e: coordinates\n      }\n    );\n    return path;\n  };\n}\n\n// helpers //////////////////////\n\n// copied from https://github.com/adobe-webplatform/Snap.svg/blob/master/src/svg.js\nvar tokenRegex = /\\{([^}]+)\\}/g,\n    objNotationRegex = /(?:(?:^|\\.)(.+?)(?=\\[|\\.|$|\\()|\\[('|\")(.+?)\\2\\])(\\(\\))?/g; // matches .xxxxx or [\"xxxxx\"] to run over object properties\n\nfunction replacer(all, key, obj) {\n  var res = obj;\n  key.replace(objNotationRegex, function(all, name, quote, quotedName, isFunc) {\n    name = name || quotedName;\n    if (res) {\n      if (name in res) {\n        res = res[name];\n      }\n      typeof res == 'function' && isFunc && (res = res());\n    }\n  });\n  res = (res == null || res == obj ? all : res) + '';\n\n  return res;\n}\n\nfunction format(str, obj) {\n  return String(str).replace(tokenRegex, function(all, key) {\n    return replacer(all, key, obj);\n  });\n}\n","import { assign } from 'min-dash';\n\nimport TextUtil from 'diagram-js/lib/util/Text';\n\nvar DEFAULT_FONT_SIZE = 12;\nvar LINE_HEIGHT_RATIO = 1.2;\n\nvar MIN_TEXT_ANNOTATION_HEIGHT = 30;\n\n\nexport default function TextRenderer(config) {\n\n  var defaultStyle = assign({\n    fontFamily: 'Arial, sans-serif',\n    fontSize: DEFAULT_FONT_SIZE,\n    fontWeight: 'normal',\n    lineHeight: LINE_HEIGHT_RATIO\n  }, config && config.defaultStyle || {});\n\n  var fontSize = parseInt(defaultStyle.fontSize, 10) - 1;\n\n  var externalStyle = assign({}, defaultStyle, {\n    fontSize: fontSize\n  }, config && config.externalStyle || {});\n\n  var textUtil = new TextUtil({\n    style: defaultStyle\n  });\n\n  /**\n   * Get the new bounds of an externally rendered,\n   * layouted label.\n   *\n   * @param  {Bounds} bounds\n   * @param  {String} text\n   *\n   * @return {Bounds}\n   */\n  this.getExternalLabelBounds = function(bounds, text) {\n\n    var layoutedDimensions = textUtil.getDimensions(text, {\n      box: {\n        width: 90,\n        height: 30,\n        x: bounds.width / 2 + bounds.x,\n        y: bounds.height / 2 + bounds.y\n      },\n      style: externalStyle\n    });\n\n    // resize label shape to fit label text\n    return {\n      x: Math.round(bounds.x + bounds.width / 2 - layoutedDimensions.width / 2),\n      y: Math.round(bounds.y),\n      width: Math.ceil(layoutedDimensions.width),\n      height: Math.ceil(layoutedDimensions.height)\n    };\n\n  };\n\n  /**\n   * Get the new bounds of text annotation.\n   *\n   * @param  {Bounds} bounds\n   * @param  {String} text\n   *\n   * @return {Bounds}\n   */\n  this.getTextAnnotationBounds = function(bounds, text) {\n\n    var layoutedDimensions = textUtil.getDimensions(text, {\n      box: bounds,\n      style: defaultStyle,\n      align: 'left-top',\n      padding: 5\n    });\n\n    return {\n      x: bounds.x,\n      y: bounds.y,\n      width: bounds.width,\n      height: Math.max(MIN_TEXT_ANNOTATION_HEIGHT, Math.round(layoutedDimensions.height))\n    };\n  };\n\n  /**\n   * Create a layouted text element.\n   *\n   * @param {String} text\n   * @param {Object} [options]\n   *\n   * @return {SVGElement} rendered text\n   */\n  this.createText = function(text, options) {\n    return textUtil.createText(text, options || {});\n  };\n\n  /**\n   * Get default text style.\n   */\n  this.getDefaultStyle = function() {\n    return defaultStyle;\n  };\n\n  /**\n   * Get the external text style.\n   */\n  this.getExternalStyle = function() {\n    return externalStyle;\n  };\n\n}\n\nTextRenderer.$inject = [\n  'config.textRenderer'\n];","import BpmnRenderer from './BpmnRenderer';\nimport TextRenderer from './TextRenderer';\n\nimport PathMap from './PathMap';\n\nexport default {\n  __init__: [ 'bpmnRenderer' ],\n  bpmnRenderer: [ 'type', BpmnRenderer ],\n  textRenderer: [ 'type', TextRenderer ],\n  pathMap: [ 'type', PathMap ]\n};\n","import { is } from '../../util/ModelUtil';\nimport { isAny } from '../modeling/util/ModelingUtil';\n\nimport {\n  getTextAnnotationPosition,\n  getDataElementPosition,\n  getFlowNodePosition,\n  getDefaultPosition\n} from './AutoPlaceUtil';\n\n\n/**\n * A service that places elements connected to existing ones\n * to an appropriate position in an _automated_ fashion.\n *\n * @param {EventBus} eventBus\n * @param {Modeling} modeling\n */\nexport default function AutoPlace(eventBus, modeling) {\n\n  function emit(event, payload) {\n    return eventBus.fire(event, payload);\n  }\n\n\n  /**\n   * Append shape to source at appropriate position.\n   *\n   * @param {djs.model.Shape} source\n   * @param {djs.model.Shape} shape\n   *\n   * @return {djs.model.Shape} appended shape\n   */\n  this.append = function(source, shape) {\n\n    // allow others to provide the position\n    var position = emit('autoPlace', {\n      source: source,\n      shape: shape\n    });\n\n    if (!position) {\n      position = getNewShapePosition(source, shape);\n    }\n\n    var newShape = modeling.appendShape(source, shape, position, source.parent);\n\n    // notify interested parties on new shape placed\n    emit('autoPlace.end', {\n      shape: newShape\n    });\n\n    return newShape;\n  };\n\n}\n\nAutoPlace.$inject = [\n  'eventBus',\n  'modeling'\n];\n\n\n// helpers //////////////////////\n\n/**\n * Find the new position for the target element to\n * connect to source.\n *\n * @param  {djs.model.Shape} source\n * @param  {djs.model.Shape} element\n *\n * @return {Point}\n */\nfunction getNewShapePosition(source, element) {\n\n  if (is(element, 'bpmn:TextAnnotation')) {\n    return getTextAnnotationPosition(source, element);\n  }\n\n  if (isAny(element, [ 'bpmn:DataObjectReference', 'bpmn:DataStoreReference' ])) {\n    return getDataElementPosition(source, element);\n  }\n\n  if (is(element, 'bpmn:FlowNode')) {\n    return getFlowNodePosition(source, element);\n  }\n\n  return getDefaultPosition(source, element);\n}\n","/**\n * Select element after auto placement.\n *\n * @param {EventBus} eventBus\n * @param {Selection} selection\n */\nexport default function AutoPlaceSelectionBehavior(eventBus, selection) {\n\n  eventBus.on('autoPlace.end', 500, function(e) {\n    selection.select(e.shape);\n  });\n\n}\n\nAutoPlaceSelectionBehavior.$inject = [\n  'eventBus',\n  'selection'\n];","import { is } from '../../util/ModelUtil';\n\nimport {\n  getMid,\n  asTRBL,\n  getOrientation\n} from 'diagram-js/lib/layout/LayoutUtil';\n\nimport {\n  find,\n  reduce\n} from 'min-dash';\n\nvar DEFAULT_HORIZONTAL_DISTANCE = 50;\n\nvar MAX_HORIZONTAL_DISTANCE = 250;\n\n// padding to detect element placement\nvar PLACEMENT_DETECTION_PAD = 10;\n\n\n/**\n * Always try to place element right of source;\n * compute actual distance from previous nodes in flow.\n */\nexport function getFlowNodePosition(source, element) {\n\n  var sourceTrbl = asTRBL(source);\n  var sourceMid = getMid(source);\n\n  var horizontalDistance = getFlowNodeDistance(source, element);\n\n  var orientation = 'left',\n      rowSize = 80,\n      margin = 30;\n\n  if (is(source, 'bpmn:BoundaryEvent')) {\n    orientation = getOrientation(source, source.host, -25);\n\n    if (orientation.indexOf('top') !== -1) {\n      margin *= -1;\n    }\n  }\n\n  function getVerticalDistance(orient) {\n    if (orient.indexOf('top') != -1) {\n      return -1 * rowSize;\n    } else if (orient.indexOf('bottom') != -1) {\n      return rowSize;\n    } else {\n      return 0;\n    }\n  }\n\n  var position = {\n    x: sourceTrbl.right + horizontalDistance + element.width / 2,\n    y: sourceMid.y + getVerticalDistance(orientation)\n  };\n\n  var escapeDirection = {\n    y: {\n      margin: margin,\n      rowSize: rowSize\n    }\n  };\n\n  return deconflictPosition(source, element, position, escapeDirection);\n}\n\n\n/**\n * Compute best distance between source and target,\n * based on existing connections to and from source.\n *\n * @param {djs.model.Shape} source\n * @param {djs.model.Shape} element\n *\n * @return {Number} distance\n */\nexport function getFlowNodeDistance(source, element) {\n\n  var sourceTrbl = asTRBL(source);\n\n  // is connection a reference to consider?\n  function isReference(c) {\n    return is(c, 'bpmn:SequenceFlow');\n  }\n\n  function toTargetNode(weight) {\n\n    return function(shape) {\n      return {\n        shape: shape,\n        weight: weight,\n        distanceTo: function(shape) {\n          var shapeTrbl = asTRBL(shape);\n\n          return shapeTrbl.left - sourceTrbl.right;\n        }\n      };\n    };\n  }\n\n  function toSourceNode(weight) {\n    return function(shape) {\n      return {\n        shape: shape,\n        weight: weight,\n        distanceTo: function(shape) {\n          var shapeTrbl = asTRBL(shape);\n\n          return sourceTrbl.left - shapeTrbl.right;\n        }\n      };\n    };\n  }\n\n  // we create a list of nodes to take into consideration\n  // for calculating the optimal flow node distance\n  //\n  //   * weight existing target nodes higher than source nodes\n  //   * only take into account individual nodes once\n  //\n  var nodes = reduce([].concat(\n    getTargets(source, isReference).map(toTargetNode(5)),\n    getSources(source, isReference).map(toSourceNode(1))\n  ), function(nodes, node) {\n    // filter out shapes connected twice via source or target\n    nodes[node.shape.id + '__weight_' + node.weight] = node;\n\n    return nodes;\n  }, {});\n\n  // compute distances between source and incoming nodes;\n  // group at the same time by distance and expose the\n  // favourite distance as { fav: { count, value } }.\n  var distancesGrouped = reduce(nodes, function(result, node) {\n\n    var shape = node.shape,\n        weight = node.weight,\n        distanceTo = node.distanceTo;\n\n    var fav = result.fav,\n        currentDistance,\n        currentDistanceCount,\n        currentDistanceEntry;\n\n    currentDistance = distanceTo(shape);\n\n    // ignore too far away peers\n    // or non-left to right modeled nodes\n    if (currentDistance < 0 || currentDistance > MAX_HORIZONTAL_DISTANCE) {\n      return result;\n    }\n\n    currentDistanceEntry = result[String(currentDistance)] =\n      result[String(currentDistance)] || {\n        value: currentDistance,\n        count: 0\n      };\n\n    // inc diff count\n    currentDistanceCount = currentDistanceEntry.count += 1 * weight;\n\n    if (!fav || fav.count < currentDistanceCount) {\n      result.fav = currentDistanceEntry;\n    }\n\n    return result;\n  }, { });\n\n\n  if (distancesGrouped.fav) {\n    return distancesGrouped.fav.value;\n  } else {\n    return DEFAULT_HORIZONTAL_DISTANCE;\n  }\n}\n\n\n/**\n * Always try to place text annotations top right of source.\n */\nexport function getTextAnnotationPosition(source, element) {\n\n  var sourceTrbl = asTRBL(source);\n\n  var position = {\n    x: sourceTrbl.right + element.width / 2,\n    y: sourceTrbl.top - 50 - element.height / 2\n  };\n\n  var escapeDirection = {\n    y: {\n      margin: -30,\n      rowSize: 20\n    }\n  };\n\n  return deconflictPosition(source, element, position, escapeDirection);\n}\n\n\n/**\n * Always put element bottom right of source.\n */\nexport function getDataElementPosition(source, element) {\n\n  var sourceTrbl = asTRBL(source);\n\n  var position = {\n    x: sourceTrbl.right - 10 + element.width / 2,\n    y: sourceTrbl.bottom + 40 + element.width / 2\n  };\n\n  var escapeDirection = {\n    x: {\n      margin: 30,\n      rowSize: 30\n    }\n  };\n\n  return deconflictPosition(source, element, position, escapeDirection);\n}\n\n\n/**\n * Always put element right of source per default.\n */\nexport function getDefaultPosition(source, element) {\n\n  var sourceTrbl = asTRBL(source);\n\n  var sourceMid = getMid(source);\n\n  // simply put element right next to source\n  return {\n    x: sourceTrbl.right + DEFAULT_HORIZONTAL_DISTANCE + element.width / 2,\n    y: sourceMid.y\n  };\n}\n\n\n/**\n * Returns all connected elements around the given source.\n *\n * This includes:\n *\n *   - connected elements\n *   - host connected elements\n *   - attachers connected elements\n *\n * @param  {djs.model.Shape} source\n * @param  {djs.model.Shape} element\n *\n * @return {Array<djs.model.Shape>}\n */\nfunction getAutoPlaceClosure(source, element) {\n\n  var allConnected = getConnected(source);\n\n  if (source.host) {\n    allConnected = allConnected.concat(getConnected(source.host));\n  }\n\n  if (source.attachers) {\n    allConnected = allConnected.concat(source.attachers.reduce(function(shapes, attacher) {\n      return shapes.concat(getConnected(attacher));\n    }, []));\n  }\n\n  return allConnected;\n}\n\n/**\n * Return target at given position, if defined.\n *\n * This takes connected elements from host and attachers\n * into account, too.\n */\nexport function getConnectedAtPosition(source, position, element) {\n\n  var bounds = {\n    x: position.x - (element.width / 2),\n    y: position.y - (element.height / 2),\n    width: element.width,\n    height: element.height\n  };\n\n  var closure = getAutoPlaceClosure(source, element);\n\n  return find(closure, function(target) {\n\n    if (target === element) {\n      return false;\n    }\n\n    var orientation = getOrientation(target, bounds, PLACEMENT_DETECTION_PAD);\n\n    return orientation === 'intersect';\n  });\n}\n\n\n/**\n * Returns a new, position for the given element\n * based on the given element that is not occupied\n * by some element connected to source.\n *\n * Take into account the escapeDirection (where to move\n * on positining clashes) in the computation.\n *\n * @param {djs.model.Shape} source\n * @param {djs.model.Shape} element\n * @param {Point} position\n * @param {Object} escapeDelta\n *\n * @return {Point}\n */\nexport function deconflictPosition(source, element, position, escapeDelta) {\n\n  function nextPosition(existingElement) {\n\n    var newPosition = {\n      x: position.x,\n      y: position.y\n    };\n\n    [ 'x', 'y' ].forEach(function(axis) {\n\n      var axisDelta = escapeDelta[axis];\n\n      if (!axisDelta) {\n        return;\n      }\n\n      var dimension = axis === 'x' ? 'width' : 'height';\n\n      var margin = axisDelta.margin,\n          rowSize = axisDelta.rowSize;\n\n      if (margin < 0) {\n        newPosition[axis] = Math.min(\n          existingElement[axis] + margin - element[dimension] / 2,\n          position[axis] - rowSize + margin\n        );\n      } else {\n        newPosition[axis] = Math.max(\n          existingTarget[axis] + existingTarget[dimension] + margin + element[dimension] / 2,\n          position[axis] + rowSize + margin\n        );\n      }\n    });\n\n    return newPosition;\n  }\n\n  var existingTarget;\n\n  // deconflict position until free slot is found\n  while ((existingTarget = getConnectedAtPosition(source, position, element))) {\n    position = nextPosition(existingTarget);\n  }\n\n  return position;\n}\n\n\n\n// helpers //////////////////////\n\nfunction noneFilter() {\n  return true;\n}\n\nfunction getConnected(element, connectionFilter) {\n  return [].concat(\n    getTargets(element, connectionFilter),\n    getSources(element, connectionFilter)\n  );\n}\n\nfunction getSources(shape, connectionFilter) {\n\n  if (!connectionFilter) {\n    connectionFilter = noneFilter;\n  }\n\n  return shape.incoming.filter(connectionFilter).map(function(c) {\n    return c.source;\n  });\n}\n\nfunction getTargets(shape, connectionFilter) {\n\n  if (!connectionFilter) {\n    connectionFilter = noneFilter;\n  }\n\n  return shape.outgoing.filter(connectionFilter).map(function(c) {\n    return c.target;\n  });\n}","import AutoPlace from './AutoPlace';\nimport AutoPlaceSelectionBehavior from './AutoPlaceSelectionBehavior';\n\nexport default {\n  __init__: [ 'autoPlaceSelectionBehavior' ],\n  autoPlace: [ 'type', AutoPlace ],\n  autoPlaceSelectionBehavior: [ 'type', AutoPlaceSelectionBehavior ]\n};","import AutoResize from 'diagram-js/lib/features/auto-resize/AutoResize';\n\nimport inherits from 'inherits';\n\nimport { is } from '../../util/ModelUtil';\n\n\n/**\n * Sub class of the AutoResize module which implements a BPMN\n * specific resize function.\n */\nexport default function BpmnAutoResize(injector) {\n\n  injector.invoke(AutoResize, this);\n}\n\nBpmnAutoResize.$inject = [\n  'injector'\n];\n\ninherits(BpmnAutoResize, AutoResize);\n\n\n/**\n * Resize shapes and lanes\n *\n * @param  {djs.model.Shape} target\n * @param  {Object} newBounds\n */\nBpmnAutoResize.prototype.resize = function(target, newBounds) {\n\n  if (is(target, 'bpmn:Participant')) {\n    this._modeling.resizeLane(target, newBounds);\n  } else {\n    this._modeling.resizeShape(target, newBounds);\n  }\n};","import { is } from '../../util/ModelUtil';\n\nimport inherits from 'inherits';\n\nimport { forEach } from 'min-dash';\n\nimport AutoResizeProvider from 'diagram-js/lib/features/auto-resize/AutoResizeProvider';\n\n\n/**\n * This module is a provider for automatically resizing parent BPMN elements\n */\nexport default function BpmnAutoResizeProvider(eventBus, modeling) {\n  AutoResizeProvider.call(this, eventBus);\n\n  this._modeling = modeling;\n}\n\ninherits(BpmnAutoResizeProvider, AutoResizeProvider);\n\nBpmnAutoResizeProvider.$inject = [\n  'eventBus',\n  'modeling'\n];\n\n\n/**\n * Check if the given target can be expanded\n *\n * @param  {djs.model.Shape} target\n *\n * @return {boolean}\n */\nBpmnAutoResizeProvider.prototype.canResize = function(elements, target) {\n\n  if (!is(target, 'bpmn:Participant') && !is(target, 'bpmn:Lane') && !(is(target, 'bpmn:SubProcess'))) {\n    return false;\n  }\n\n  var canResize = true;\n\n  forEach(elements, function(element) {\n\n    if (is(element, 'bpmn:Lane') || element.labelTarget) {\n      canResize = false;\n      return;\n    }\n  });\n\n  return canResize;\n};\n","import BpmnAutoResize from './BpmnAutoResize';\nimport BpmnAutoResizeProvider from './BpmnAutoResizeProvider';\n\n\nexport default {\n  __init__: [\n    'bpmnAutoResize',\n    'bpmnAutoResizeProvider'\n  ],\n  bpmnAutoResize: [ 'type', BpmnAutoResize ],\n  bpmnAutoResizeProvider: [ 'type', BpmnAutoResizeProvider ]\n};\n","import {\n  assign,\n  forEach,\n  isArray\n} from 'min-dash';\n\nimport {\n  is\n} from '../../util/ModelUtil';\n\nimport {\n  isExpanded,\n  isEventSubProcess\n} from '../../util/DiUtil';\n\nimport {\n  isAny\n} from '../modeling/util/ModelingUtil';\n\nimport {\n  getChildLanes\n} from '../modeling/util/LaneUtil';\n\nimport {\n  hasPrimaryModifier\n} from 'diagram-js/lib/util/Mouse';\n\n\n/**\n * A provider for BPMN 2.0 elements context pad\n */\nexport default function ContextPadProvider(\n    config, injector, eventBus,\n    contextPad, modeling, elementFactory,\n    connect, create, popupMenu,\n    canvas, rules, translate) {\n\n  config = config || {};\n\n  contextPad.registerProvider(this);\n\n  this._contextPad = contextPad;\n\n  this._modeling = modeling;\n\n  this._elementFactory = elementFactory;\n  this._connect = connect;\n  this._create = create;\n  this._popupMenu = popupMenu;\n  this._canvas = canvas;\n  this._rules = rules;\n  this._translate = translate;\n\n  if (config.autoPlace !== false) {\n    this._autoPlace = injector.get('autoPlace', false);\n  }\n\n  eventBus.on('create.end', 250, function(event) {\n    var shape = event.context.shape;\n\n    if (!hasPrimaryModifier(event)) {\n      return;\n    }\n\n    var entries = contextPad.getEntries(shape);\n\n    if (entries.replace) {\n      entries.replace.action.click(event, shape);\n    }\n  });\n}\n\nContextPadProvider.$inject = [\n  'config.contextPad',\n  'injector',\n  'eventBus',\n  'contextPad',\n  'modeling',\n  'elementFactory',\n  'connect',\n  'create',\n  'popupMenu',\n  'canvas',\n  'rules',\n  'translate'\n];\n\n\nContextPadProvider.prototype.getContextPadEntries = function(element) {\n\n  var contextPad = this._contextPad,\n      modeling = this._modeling,\n\n      elementFactory = this._elementFactory,\n      connect = this._connect,\n      create = this._create,\n      popupMenu = this._popupMenu,\n      canvas = this._canvas,\n      rules = this._rules,\n      autoPlace = this._autoPlace,\n      translate = this._translate;\n\n  var actions = {};\n\n  if (element.type === 'label') {\n    return actions;\n  }\n\n  var businessObject = element.businessObject;\n\n  function startConnect(event, element) {\n    connect.start(event, element);\n  }\n\n  function removeElement(e) {\n    modeling.removeElements([ element ]);\n  }\n\n  function getReplaceMenuPosition(element) {\n\n    var Y_OFFSET = 5;\n\n    var diagramContainer = canvas.getContainer(),\n        pad = contextPad.getPad(element).html;\n\n    var diagramRect = diagramContainer.getBoundingClientRect(),\n        padRect = pad.getBoundingClientRect();\n\n    var top = padRect.top - diagramRect.top;\n    var left = padRect.left - diagramRect.left;\n\n    var pos = {\n      x: left,\n      y: top + padRect.height + Y_OFFSET\n    };\n\n    return pos;\n  }\n\n\n  /**\n   * Create an append action\n   *\n   * @param {String} type\n   * @param {String} className\n   * @param {String} [title]\n   * @param {Object} [options]\n   *\n   * @return {Object} descriptor\n   */\n  function appendAction(type, className, title, options) {\n\n    if (typeof title !== 'string') {\n      options = title;\n      title = translate('Append {type}', { type: type.replace(/^bpmn:/, '') });\n    }\n\n    function appendStart(event, element) {\n\n      var shape = elementFactory.createShape(assign({ type: type }, options));\n      create.start(event, shape, element);\n    }\n\n\n    var append = autoPlace ? function(event, element) {\n      var shape = elementFactory.createShape(assign({ type: type }, options));\n\n      autoPlace.append(element, shape);\n    } : appendStart;\n\n\n    return {\n      group: 'model',\n      className: className,\n      title: title,\n      action: {\n        dragstart: appendStart,\n        click: append\n      }\n    };\n  }\n\n  function splitLaneHandler(count) {\n\n    return function(event, element) {\n      // actual split\n      modeling.splitLane(element, count);\n\n      // refresh context pad after split to\n      // get rid of split icons\n      contextPad.open(element, true);\n    };\n  }\n\n\n  if (isAny(businessObject, [ 'bpmn:Lane', 'bpmn:Participant' ]) && isExpanded(businessObject)) {\n\n    var childLanes = getChildLanes(element);\n\n    assign(actions, {\n      'lane-insert-above': {\n        group: 'lane-insert-above',\n        className: 'bpmn-icon-lane-insert-above',\n        title: translate('Add Lane above'),\n        action: {\n          click: function(event, element) {\n            modeling.addLane(element, 'top');\n          }\n        }\n      }\n    });\n\n    if (childLanes.length < 2) {\n\n      if (element.height >= 120) {\n        assign(actions, {\n          'lane-divide-two': {\n            group: 'lane-divide',\n            className: 'bpmn-icon-lane-divide-two',\n            title: translate('Divide into two Lanes'),\n            action: {\n              click: splitLaneHandler(2)\n            }\n          }\n        });\n      }\n\n      if (element.height >= 180) {\n        assign(actions, {\n          'lane-divide-three': {\n            group: 'lane-divide',\n            className: 'bpmn-icon-lane-divide-three',\n            title: translate('Divide into three Lanes'),\n            action: {\n              click: splitLaneHandler(3)\n            }\n          }\n        });\n      }\n    }\n\n    assign(actions, {\n      'lane-insert-below': {\n        group: 'lane-insert-below',\n        className: 'bpmn-icon-lane-insert-below',\n        title: translate('Add Lane below'),\n        action: {\n          click: function(event, element) {\n            modeling.addLane(element, 'bottom');\n          }\n        }\n      }\n    });\n\n  }\n\n  if (is(businessObject, 'bpmn:FlowNode')) {\n\n    if (is(businessObject, 'bpmn:EventBasedGateway')) {\n\n      assign(actions, {\n        'append.receive-task': appendAction(\n          'bpmn:ReceiveTask',\n          'bpmn-icon-receive-task'\n        ),\n        'append.message-intermediate-event': appendAction(\n          'bpmn:IntermediateCatchEvent',\n          'bpmn-icon-intermediate-event-catch-message',\n          translate('Append MessageIntermediateCatchEvent'),\n          { eventDefinitionType: 'bpmn:MessageEventDefinition' }\n        ),\n        'append.timer-intermediate-event': appendAction(\n          'bpmn:IntermediateCatchEvent',\n          'bpmn-icon-intermediate-event-catch-timer',\n          translate('Append TimerIntermediateCatchEvent'),\n          { eventDefinitionType: 'bpmn:TimerEventDefinition' }\n        ),\n        'append.condtion-intermediate-event': appendAction(\n          'bpmn:IntermediateCatchEvent',\n          'bpmn-icon-intermediate-event-catch-condition',\n          translate('Append ConditionIntermediateCatchEvent'),\n          { eventDefinitionType: 'bpmn:ConditionalEventDefinition' }\n        ),\n        'append.signal-intermediate-event': appendAction(\n          'bpmn:IntermediateCatchEvent',\n          'bpmn-icon-intermediate-event-catch-signal',\n          translate('Append SignalIntermediateCatchEvent'),\n          { eventDefinitionType: 'bpmn:SignalEventDefinition' }\n        )\n      });\n    } else\n\n    if (isEventType(businessObject, 'bpmn:BoundaryEvent', 'bpmn:CompensateEventDefinition')) {\n\n      assign(actions, {\n        'append.compensation-activity':\n            appendAction(\n              'bpmn:Task',\n              'bpmn-icon-task',\n              translate('Append compensation activity'),\n              {\n                isForCompensation: true\n              }\n            )\n      });\n    } else\n\n    if (!is(businessObject, 'bpmn:EndEvent') &&\n        !businessObject.isForCompensation &&\n        !isEventType(businessObject, 'bpmn:IntermediateThrowEvent', 'bpmn:LinkEventDefinition') &&\n        !isEventSubProcess(businessObject)) {\n\n      assign(actions, {\n        'append.end-event': appendAction(\n          'bpmn:EndEvent',\n          'bpmn-icon-end-event-none'\n        ),\n        'append.gateway': appendAction(\n          'bpmn:ExclusiveGateway',\n          'bpmn-icon-gateway-none',\n          translate('Append Gateway')\n        ),\n        'append.append-task': appendAction(\n          'bpmn:Task',\n          'bpmn-icon-task'\n        ),\n        'append.intermediate-event': appendAction(\n          'bpmn:IntermediateThrowEvent',\n          'bpmn-icon-intermediate-event-none',\n          translate('Append Intermediate/Boundary Event')\n        )\n      });\n    }\n  }\n\n  if (!popupMenu.isEmpty(element, 'bpmn-replace')) {\n    // Replace menu entry\n    assign(actions, {\n      'replace': {\n        group: 'edit',\n        className: 'bpmn-icon-screw-wrench',\n        title: translate('Change type'),\n        action: {\n          click: function(event, element) {\n\n            var position = assign(getReplaceMenuPosition(element), {\n              cursor: { x: event.x, y: event.y }\n            });\n\n            popupMenu.open(element, 'bpmn-replace', position);\n          }\n        }\n      }\n    });\n  }\n\n  if (isAny(businessObject, [\n    'bpmn:FlowNode',\n    'bpmn:InteractionNode',\n    'bpmn:DataObjectReference',\n    'bpmn:DataStoreReference'\n  ])) {\n\n    assign(actions, {\n      'append.text-annotation': appendAction('bpmn:TextAnnotation', 'bpmn-icon-text-annotation'),\n\n      'connect': {\n        group: 'connect',\n        className: 'bpmn-icon-connection-multi',\n        title: translate('Connect using ' +\n                  (businessObject.isForCompensation ? '' : 'Sequence/MessageFlow or ') +\n                  'Association'),\n        action: {\n          click: startConnect,\n          dragstart: startConnect\n        }\n      }\n    });\n  }\n\n  if (isAny(businessObject, [ 'bpmn:DataObjectReference', 'bpmn:DataStoreReference' ])) {\n    assign(actions, {\n      'connect': {\n        group: 'connect',\n        className: 'bpmn-icon-connection-multi',\n        title: translate('Connect using DataInputAssociation'),\n        action: {\n          click: startConnect,\n          dragstart: startConnect\n        }\n      }\n    });\n  }\n\n  // delete element entry, only show if allowed by rules\n  var deleteAllowed = rules.allowed('elements.delete', { elements: [ element ] });\n\n  if (isArray(deleteAllowed)) {\n    // was the element returned as a deletion candidate?\n    deleteAllowed = deleteAllowed[0] === element;\n  }\n\n  if (deleteAllowed) {\n    assign(actions, {\n      'delete': {\n        group: 'edit',\n        className: 'bpmn-icon-trash',\n        title: translate('Remove'),\n        action: {\n          click: removeElement\n        }\n      }\n    });\n  }\n\n  return actions;\n};\n\nfunction isEventType(eventBo, type, definition) {\n\n  var isType = eventBo.$instanceOf(type);\n  var isDefinition = false;\n\n  var definitions = eventBo.eventDefinitions || [];\n  forEach(definitions, function(def) {\n    if (def.$type === definition) {\n      isDefinition = true;\n    }\n  });\n\n  return isType && isDefinition;\n}\n","import DirectEditingModule from 'diagram-js-direct-editing';\nimport ContextPadModule from 'diagram-js/lib/features/context-pad';\nimport SelectionModule from 'diagram-js/lib/features/selection';\nimport ConnectModule from 'diagram-js/lib/features/connect';\nimport CreateModule from 'diagram-js/lib/features/create';\nimport PopupMenuModule from '../popup-menu';\n\nimport ContextPadProvider from './ContextPadProvider';\n\nexport default {\n  __depends__: [\n    DirectEditingModule,\n    ContextPadModule,\n    SelectionModule,\n    ConnectModule,\n    CreateModule,\n    PopupMenuModule\n  ],\n  __init__: [ 'contextPadProvider' ],\n  contextPadProvider: [ 'type', ContextPadProvider ]\n};","import {\n  getBusinessObject,\n  is\n} from '../../util/ModelUtil';\n\nimport ModelCloneHelper from '../../util/model/ModelCloneHelper';\n\nimport {\n  getProperties,\n  IGNORED_PROPERTIES\n} from '../../util/model/ModelCloneUtils';\n\nimport {\n  filter,\n  forEach\n} from 'min-dash';\n\nfunction setProperties(descriptor, data, properties) {\n  forEach(properties, function(property) {\n    if (data[property] !== undefined) {\n      descriptor[property] = data[property];\n    }\n  });\n}\n\nfunction removeProperties(element, properties) {\n  forEach(properties, function(prop) {\n    if (element[prop]) {\n      delete element[prop];\n    }\n  });\n}\n\nexport default function BpmnCopyPaste(\n    bpmnFactory, eventBus, copyPaste,\n    clipboard, canvas, bpmnRules) {\n\n  var helper = new ModelCloneHelper(eventBus, bpmnFactory);\n\n  copyPaste.registerDescriptor(function(element, descriptor) {\n    var businessObject = descriptor.oldBusinessObject = getBusinessObject(element);\n\n    var colors = {};\n\n    descriptor.type = element.type;\n\n    setProperties(descriptor, businessObject.di, [ 'isExpanded' ]);\n\n    setProperties(colors, businessObject.di, [ 'fill', 'stroke' ]);\n\n    descriptor.colors = colors;\n\n    if (element.type === 'label') {\n      return descriptor;\n    }\n\n    setProperties(descriptor, businessObject, [\n      'processRef',\n      'triggeredByEvent'\n    ]);\n\n    if (businessObject.default) {\n      descriptor.default = businessObject.default.id;\n    }\n\n    return descriptor;\n  });\n\n  eventBus.on('element.paste', function(context) {\n    var descriptor = context.descriptor,\n        createdElements = context.createdElements,\n        parent = descriptor.parent,\n        rootElement = canvas.getRootElement(),\n        oldBusinessObject = descriptor.oldBusinessObject,\n        newBusinessObject,\n        source,\n        target,\n        canConnect;\n\n    newBusinessObject = bpmnFactory.create(oldBusinessObject.$type);\n\n    var properties = getProperties(oldBusinessObject.$descriptor);\n\n    properties = filter(properties, function(property) {\n      return IGNORED_PROPERTIES.indexOf(property.replace(/bpmn:/, '')) === -1;\n    });\n\n    descriptor.businessObject = helper.clone(oldBusinessObject, newBusinessObject, properties);\n\n    if (descriptor.type === 'label') {\n      return;\n    }\n\n    if (is(parent, 'bpmn:Process')) {\n      descriptor.parent = is(rootElement, 'bpmn:Collaboration') ? rootElement : parent;\n    }\n\n    if (descriptor.type === 'bpmn:DataOutputAssociation' ||\n        descriptor.type === 'bpmn:DataInputAssociation' ||\n        descriptor.type === 'bpmn:MessageFlow') {\n      descriptor.parent = rootElement;\n    }\n\n    if (is(parent, 'bpmn:Lane')) {\n      descriptor.parent = parent.parent;\n    }\n\n    // make sure that the correct type of connection is created\n    if (descriptor.waypoints) {\n      source = createdElements[descriptor.source];\n      target = createdElements[descriptor.target];\n\n      if (source && target) {\n        source = source.element;\n        target = target.element;\n      }\n\n      canConnect = bpmnRules.canConnect(source, target);\n\n      if (canConnect) {\n        descriptor.type = canConnect.type;\n      }\n    }\n\n    // remove the id or else we cannot paste multiple times\n    delete newBusinessObject.id;\n\n    // assign an ID\n    bpmnFactory._ensureId(newBusinessObject);\n\n    if (descriptor.type === 'bpmn:Participant' && descriptor.processRef) {\n      descriptor.processRef = newBusinessObject.processRef = bpmnFactory.create('bpmn:Process');\n    }\n\n    setProperties(newBusinessObject, descriptor, [\n      'isExpanded',\n      'triggeredByEvent'\n    ]);\n\n    removeProperties(descriptor, [\n      'triggeredByEvent'\n    ]);\n  });\n\n}\n\n\nBpmnCopyPaste.$inject = [\n  'bpmnFactory',\n  'eventBus',\n  'copyPaste',\n  'clipboard',\n  'canvas',\n  'bpmnRules'\n];","import CopyPasteModule from 'diagram-js/lib/features/copy-paste';\n\nimport BpmnCopyPaste from './BpmnCopyPaste';\n\nexport default {\n  __depends__: [\n    CopyPasteModule\n  ],\n  __init__: [ 'bpmnCopyPaste' ],\n  bpmnCopyPaste: [ 'type', BpmnCopyPaste ]\n};\n","import {\n  filter\n} from 'min-dash';\n\nimport {\n  isAny\n} from '../modeling/util/ModelingUtil';\n\n\n/**\n * Registers element exclude filters for elements that\n * currently do not support distribution.\n */\nexport default function BpmnDistributeElements(distributeElements) {\n\n  distributeElements.registerFilter(function(elements) {\n    return filter(elements, function(element) {\n      var cannotDistribute = isAny(element, [\n        'bpmn:Association',\n        'bpmn:BoundaryEvent',\n        'bpmn:DataInputAssociation',\n        'bpmn:DataOutputAssociation',\n        'bpmn:Lane',\n        'bpmn:MessageFlow',\n        'bpmn:Participant',\n        'bpmn:SequenceFlow',\n        'bpmn:TextAnnotation'\n      ]);\n\n      return !(element.labelTarget || cannotDistribute);\n    });\n  });\n}\n\nBpmnDistributeElements.$inject = [ 'distributeElements' ];","import DistributeElementsModule from 'diagram-js/lib/features/distribute-elements';\n\nimport BpmnDistributeElements from './BpmnDistributeElements';\n\n\nexport default {\n  __depends__: [\n    DistributeElementsModule\n  ],\n  __init__: [ 'bpmnDistributeElements' ],\n  bpmnDistributeElements: [ 'type', BpmnDistributeElements ]\n};\n","import inherits from 'inherits';\n\nimport EditorActions from 'diagram-js/lib/features/editor-actions/EditorActions';\n\nimport { filter } from 'min-dash';\n\nimport { is } from '../../util/ModelUtil';\n\nimport {\n  getBBox\n} from 'diagram-js/lib/util/Elements';\n\n\n/**\n * Registers and executes BPMN specific editor actions.\n *\n * @param {Injector} injector\n */\nexport default function BpmnEditorActions(injector) {\n  injector.invoke(EditorActions, this);\n}\n\ninherits(BpmnEditorActions, EditorActions);\n\nBpmnEditorActions.$inject = [\n  'injector'\n];\n\n/**\n * Register default actions.\n *\n * @param {Injector} injector\n */\nBpmnEditorActions.prototype._registerDefaultActions = function(injector) {\n\n  // (0) invoke super method\n\n  EditorActions.prototype._registerDefaultActions.call(this, injector);\n\n  // (1) retrieve optional components to integrate with\n\n  var canvas = injector.get('canvas', false);\n  var elementRegistry = injector.get('elementRegistry', false);\n  var selection = injector.get('selection', false);\n  var spaceTool = injector.get('spaceTool', false);\n  var lassoTool = injector.get('lassoTool', false);\n  var handTool = injector.get('handTool', false);\n  var globalConnect = injector.get('globalConnect', false);\n  var distributeElements = injector.get('distributeElements', false);\n  var alignElements = injector.get('alignElements', false);\n  var directEditing = injector.get('directEditing', false);\n  var searchPad = injector.get('searchPad', false);\n  var modeling = injector.get('modeling', false);\n\n  // (2) check components and register actions\n\n  if (canvas && elementRegistry && selection) {\n    this._registerAction('selectElements', function() {\n      // select all elements except for the invisible\n      // root element\n      var rootElement = canvas.getRootElement();\n\n      var elements = elementRegistry.filter(function(element) {\n        return element !== rootElement;\n      });\n\n      selection.select(elements);\n\n      return elements;\n    });\n  }\n\n  if (spaceTool) {\n    this._registerAction('spaceTool', function() {\n      spaceTool.toggle();\n    });\n  }\n\n  if (lassoTool) {\n    this._registerAction('lassoTool', function() {\n      lassoTool.toggle();\n    });\n  }\n\n  if (handTool) {\n    this._registerAction('handTool', function() {\n      handTool.toggle();\n    });\n  }\n\n  if (globalConnect) {\n    this._registerAction('globalConnectTool', function() {\n      globalConnect.toggle();\n    });\n  }\n\n  if (selection && distributeElements) {\n    this._registerAction('distributeElements', function(opts) {\n      var currentSelection = selection.get(),\n          type = opts.type;\n\n      if (currentSelection.length) {\n        distributeElements.trigger(currentSelection, type);\n      }\n    });\n  }\n\n  if (selection && alignElements) {\n    this._registerAction('alignElements', function(opts) {\n      var currentSelection = selection.get(),\n          aligneableElements = [],\n          type = opts.type;\n\n      if (currentSelection.length) {\n        aligneableElements = filter(currentSelection, function(element) {\n          return !is(element, 'bpmn:Lane');\n        });\n\n        alignElements.trigger(aligneableElements, type);\n      }\n    });\n  }\n\n  if (selection && modeling) {\n    this._registerAction('setColor', function(opts) {\n      var currentSelection = selection.get();\n\n      if (currentSelection.length) {\n        modeling.setColor(currentSelection, opts);\n      }\n    });\n  }\n\n  if (selection && directEditing) {\n    this._registerAction('directEditing', function() {\n      var currentSelection = selection.get();\n\n      if (currentSelection.length) {\n        directEditing.activate(currentSelection[0]);\n      }\n    });\n  }\n\n  if (searchPad) {\n    this._registerAction('find', function() {\n      searchPad.toggle();\n    });\n  }\n\n  if (canvas && modeling) {\n    this._registerAction('moveToOrigin', function() {\n      var rootElement = canvas.getRootElement(),\n          boundingBox,\n          elements;\n\n      if (is(rootElement, 'bpmn:Collaboration')) {\n        elements = elementRegistry.filter(function(element) {\n          return is(element.parent, 'bpmn:Collaboration');\n        });\n      } else {\n        elements = elementRegistry.filter(function(element) {\n          return element !== rootElement && !is(element.parent, 'bpmn:SubProcess');\n        });\n      }\n\n      boundingBox = getBBox(elements);\n\n      modeling.moveElements(\n        elements,\n        { x: -boundingBox.x, y: -boundingBox.y },\n        rootElement\n      );\n    });\n  }\n\n};","import EditorActionsModule from 'diagram-js/lib/features/editor-actions';\n\nimport BpmnEditorActions from './BpmnEditorActions';\n\nexport default {\n  __depends__: [\n    EditorActionsModule\n  ],\n  editorActions: [ 'type', BpmnEditorActions ]\n};\n","import inherits from 'inherits';\n\nimport KeyboardBindings from 'diagram-js/lib/features/keyboard/KeyboardBindings';\n\n\n/**\n * BPMN 2.0 specific keyboard bindings.\n *\n * @param {Injector} injector\n */\nexport default function BpmnKeyboardBindings(injector) {\n  injector.invoke(KeyboardBindings, this);\n}\n\ninherits(BpmnKeyboardBindings, KeyboardBindings);\n\nBpmnKeyboardBindings.$inject = [\n  'injector'\n];\n\n\n/**\n * Register available keyboard bindings.\n *\n * @param {Keyboard} keyboard\n * @param {EditorActions} editorActions\n */\nBpmnKeyboardBindings.prototype.registerBindings = function(keyboard, editorActions) {\n\n  // inherit default bindings\n  KeyboardBindings.prototype.registerBindings.call(this, keyboard, editorActions);\n\n  /**\n   * Add keyboard binding if respective editor action\n   * is registered.\n   *\n   * @param {String} action name\n   * @param {Function} fn that implements the key binding\n   */\n  function addListener(action, fn) {\n\n    if (editorActions.isRegistered(action)) {\n      keyboard.addListener(fn);\n    }\n  }\n\n  // select all elements\n  // CTRL + A\n  addListener('selectElements', function(context) {\n\n    var event = context.keyEvent;\n\n    if (keyboard.isKey(['a', 'A'], event) && keyboard.isCmd(event)) {\n      editorActions.trigger('selectElements');\n\n      return true;\n    }\n  });\n\n  // search labels\n  // CTRL + F\n  addListener('find', function(context) {\n\n    var event = context.keyEvent;\n\n    if (keyboard.isKey(['f', 'F'], event) && keyboard.isCmd(event)) {\n      editorActions.trigger('find');\n\n      return true;\n    }\n  });\n\n  // activate space tool\n  // S\n  addListener('spaceTool', function(context) {\n\n    var event = context.keyEvent;\n\n    if (keyboard.hasModifier(event)) {\n      return;\n    }\n\n    if (keyboard.isKey(['s', 'S'], event)) {\n      editorActions.trigger('spaceTool');\n\n      return true;\n    }\n  });\n\n  // activate lasso tool\n  // L\n  addListener('lassoTool', function(context) {\n\n    var event = context.keyEvent;\n\n    if (keyboard.hasModifier(event)) {\n      return;\n    }\n\n    if (keyboard.isKey(['l', 'L'], event)) {\n      editorActions.trigger('lassoTool');\n\n      return true;\n    }\n  });\n\n  // activate hand tool\n  // H\n  addListener('handTool', function(context) {\n\n    var event = context.keyEvent;\n\n    if (keyboard.hasModifier(event)) {\n      return;\n    }\n\n    if (keyboard.isKey(['h', 'H'], event)) {\n      editorActions.trigger('handTool');\n\n      return true;\n    }\n  });\n\n  // activate global connect tool\n  // C\n  addListener('globalConnectTool', function(context) {\n\n    var event = context.keyEvent;\n\n    if (keyboard.hasModifier(event)) {\n      return;\n    }\n\n    if (keyboard.isKey(['c', 'C'], event)) {\n      editorActions.trigger('globalConnectTool');\n\n      return true;\n    }\n  });\n\n  // activate direct editing\n  // E\n  addListener('directEditing', function(context) {\n\n    var event = context.keyEvent;\n\n    if (keyboard.hasModifier(event)) {\n      return;\n    }\n\n    if (keyboard.isKey(['e', 'E'], event)) {\n      editorActions.trigger('directEditing');\n\n      return true;\n    }\n  });\n\n};","import KeyboardModule from 'diagram-js/lib/features/keyboard';\n\nimport BpmnKeyboardBindings from './BpmnKeyboardBindings';\n\nexport default {\n  __depends__: [\n    KeyboardModule\n  ],\n  __init__: [ 'keyboardBindings' ],\n  keyboardBindings: [ 'type', BpmnKeyboardBindings ]\n};\n","import {\n  append as svgAppend,\n  attr as svgAttr,\n  create as svgCreate,\n  remove as svgRemove\n} from 'tiny-svg';\n\nimport {\n  getBusinessObject,\n  is\n} from '../../util/ModelUtil';\n\nimport {\n  translate\n} from 'diagram-js/lib/util/SvgTransformUtil';\n\nvar MARKER_HIDDEN = 'djs-element-hidden',\n    MARKER_LABEL_HIDDEN = 'djs-label-hidden';\n\n\nexport default function LabelEditingPreview(\n    eventBus, canvas, elementRegistry,\n    pathMap) {\n\n  var self = this;\n\n  var defaultLayer = canvas.getDefaultLayer();\n\n  var element, absoluteElementBBox, gfx;\n\n  eventBus.on('directEditing.activate', function(context) {\n    var activeProvider = context.active;\n\n    element = activeProvider.element.label || activeProvider.element;\n\n    // text annotation\n    if (is(element, 'bpmn:TextAnnotation')) {\n      absoluteElementBBox = canvas.getAbsoluteBBox(element);\n\n      gfx = svgCreate('g');\n\n      var textPathData = pathMap.getScaledPath('TEXT_ANNOTATION', {\n        xScaleFactor: 1,\n        yScaleFactor: 1,\n        containerWidth: element.width,\n        containerHeight: element.height,\n        position: {\n          mx: 0.0,\n          my: 0.0\n        }\n      });\n\n      var path = self.path = svgCreate('path');\n\n      svgAttr(path, {\n        d: textPathData,\n        strokeWidth: 2,\n        stroke: getStrokeColor(element)\n      });\n\n      svgAppend(gfx, path);\n\n      svgAppend(defaultLayer, gfx);\n\n      translate(gfx, element.x, element.y);\n    }\n\n    if (is(element, 'bpmn:TextAnnotation') ||\n        element.labelTarget) {\n      canvas.addMarker(element, MARKER_HIDDEN);\n    } else if (is(element, 'bpmn:Task') ||\n               is(element, 'bpmn:CallActivity') ||\n               is(element, 'bpmn:SubProcess') ||\n               is(element, 'bpmn:Participant')) {\n      canvas.addMarker(element, MARKER_LABEL_HIDDEN);\n    }\n  });\n\n  eventBus.on('directEditing.resize', function(context) {\n\n    // text annotation\n    if (is(element, 'bpmn:TextAnnotation')) {\n      var height = context.height,\n          dy = context.dy;\n\n      var newElementHeight = Math.max(element.height / absoluteElementBBox.height * (height + dy), 0);\n\n      var textPathData = pathMap.getScaledPath('TEXT_ANNOTATION', {\n        xScaleFactor: 1,\n        yScaleFactor: 1,\n        containerWidth: element.width,\n        containerHeight: newElementHeight,\n        position: {\n          mx: 0.0,\n          my: 0.0\n        }\n      });\n\n      svgAttr(self.path, {\n        d: textPathData\n      });\n    }\n  });\n\n  eventBus.on([ 'directEditing.complete', 'directEditing.cancel' ], function(context) {\n    var activeProvider = context.active;\n\n    if (activeProvider) {\n      canvas.removeMarker(activeProvider.element.label || activeProvider.element, MARKER_HIDDEN);\n      canvas.removeMarker(element, MARKER_LABEL_HIDDEN);\n    }\n\n    element = undefined;\n    absoluteElementBBox = undefined;\n\n    if (gfx) {\n      svgRemove(gfx);\n\n      gfx = undefined;\n    }\n  });\n}\n\nLabelEditingPreview.$inject = [\n  'eventBus',\n  'canvas',\n  'elementRegistry',\n  'pathMap'\n];\n\n\n// helpers ///////////////////\n\nfunction getStrokeColor(element, defaultColor) {\n  var bo = getBusinessObject(element);\n\n  return bo.di.get('stroke') || defaultColor || 'black';\n}","import {\n  assign\n} from 'min-dash';\n\nimport {\n  getLabel\n} from './LabelUtil';\n\nimport { is } from '../../util/ModelUtil';\nimport { isAny } from '../modeling/util/ModelingUtil';\nimport { isExpanded } from '../../util/DiUtil';\n\nimport {\n  getExternalLabelMid,\n  isLabelExternal,\n  hasExternalLabel,\n  isLabel\n} from '../../util/LabelUtil';\n\n\nexport default function LabelEditingProvider(\n    eventBus, canvas, directEditing,\n    modeling, resizeHandles, textRenderer) {\n\n  this._canvas = canvas;\n  this._modeling = modeling;\n  this._textRenderer = textRenderer;\n\n  directEditing.registerProvider(this);\n\n  // listen to dblclick on non-root elements\n  eventBus.on('element.dblclick', function(event) {\n    activateDirectEdit(event.element, true);\n  });\n\n  // complete on followup canvas operation\n  eventBus.on([\n    'element.mousedown',\n    'drag.init',\n    'canvas.viewbox.changing',\n    'autoPlace',\n    'popupMenu.open'\n  ], function(event) {\n\n    if (directEditing.isActive()) {\n      directEditing.complete();\n    }\n  });\n\n  // cancel on command stack changes\n  eventBus.on([ 'commandStack.changed' ], function(e) {\n    if (directEditing.isActive()) {\n      directEditing.cancel();\n    }\n  });\n\n\n  eventBus.on('directEditing.activate', function(event) {\n    resizeHandles.removeResizers();\n  });\n\n  eventBus.on('create.end', 500, function(event) {\n\n    var element = event.shape,\n        canExecute = event.context.canExecute,\n        isTouch = event.isTouch;\n\n    // TODO(nikku): we need to find a way to support the\n    // direct editing on mobile devices; right now this will\n    // break for desworkflowediting on mobile devices\n    // as it breaks the user interaction workflow\n\n    // TODO(nre): we should temporarily focus the edited element\n    // here and release the focused viewport after the direct edit\n    // operation is finished\n    if (isTouch) {\n      return;\n    }\n\n    if (!canExecute) {\n      return;\n    }\n\n    activateDirectEdit(element);\n  });\n\n  eventBus.on('autoPlace.end', 500, function(event) {\n    activateDirectEdit(event.shape);\n  });\n\n\n  function activateDirectEdit(element, force) {\n    if (force ||\n        isAny(element, [ 'bpmn:Task', 'bpmn:TextAnnotation' ]) ||\n        isCollapsedSubProcess(element)) {\n\n      directEditing.activate(element);\n    }\n  }\n\n}\n\nLabelEditingProvider.$inject = [\n  'eventBus',\n  'canvas',\n  'directEditing',\n  'modeling',\n  'resizeHandles',\n  'textRenderer'\n];\n\n\n/**\n * Activate direct editing for activities and text annotations.\n *\n * @param  {djs.model.Base} element\n *\n * @return {Object} an object with properties bounds (position and size), text and options\n */\nLabelEditingProvider.prototype.activate = function(element) {\n\n  // text\n  var text = getLabel(element);\n\n  if (text === undefined) {\n    return;\n  }\n\n  var context = {\n    text: text\n  };\n\n  // bounds\n  var bounds = this.getEditingBBox(element);\n\n  assign(context, bounds);\n\n  var options = {};\n\n  // tasks\n  if (\n    isAny(element, [\n      'bpmn:Task',\n      'bpmn:Participant',\n      'bpmn:Lane',\n      'bpmn:CallActivity'\n    ]) ||\n    isCollapsedSubProcess(element)\n  ) {\n    assign(options, {\n      centerVertically: true\n    });\n  }\n\n  // external labels\n  if (isLabelExternal(element)) {\n    assign(options, {\n      autoResize: true\n    });\n  }\n\n  // text annotations\n  if (is(element, 'bpmn:TextAnnotation')) {\n    assign(options, {\n      resizable: true,\n      autoResize: true\n    });\n  }\n\n  assign(context, {\n    options: options\n  });\n\n  return context;\n};\n\n\n/**\n * Get the editing bounding box based on the element's size and position\n *\n * @param  {djs.model.Base} element\n *\n * @return {Object} an object containing information about position\n *                  and size (fixed or minimum and/or maximum)\n */\nLabelEditingProvider.prototype.getEditingBBox = function(element) {\n  var canvas = this._canvas;\n\n  var target = element.label || element;\n\n  var bbox = canvas.getAbsoluteBBox(target);\n\n  var mid = {\n    x: bbox.x + bbox.width / 2,\n    y: bbox.y + bbox.height / 2\n  };\n\n  // default position\n  var bounds = { x: bbox.x, y: bbox.y };\n\n  var zoom = canvas.zoom();\n\n  var defaultStyle = this._textRenderer.getDefaultStyle(),\n      externalStyle = this._textRenderer.getExternalStyle();\n\n  // take zoom into account\n  var externalFontSize = externalStyle.fontSize * zoom,\n      externalLineHeight = externalStyle.lineHeight,\n      defaultFontSize = defaultStyle.fontSize * zoom,\n      defaultLineHeight = defaultStyle.lineHeight;\n\n  var style = {\n    fontFamily: this._textRenderer.getDefaultStyle().fontFamily,\n    fontWeight: this._textRenderer.getDefaultStyle().fontWeight\n  };\n\n  // adjust for expanded pools AND lanes\n  if (is(element, 'bpmn:Lane') || isExpandedPool(element)) {\n\n    assign(bounds, {\n      width: bbox.height,\n      height: 30 * zoom,\n      x: bbox.x - bbox.height / 2 + (15 * zoom),\n      y: mid.y - (30 * zoom) / 2\n    });\n\n    assign(style, {\n      fontSize: defaultFontSize + 'px',\n      lineHeight: defaultLineHeight,\n      paddingTop: (7 * zoom) + 'px',\n      paddingBottom: (7 * zoom) + 'px',\n      paddingLeft: (5 * zoom) + 'px',\n      paddingRight: (5 * zoom) + 'px',\n      transform: 'rotate(-90deg)'\n    });\n  }\n\n\n  // internal labels for tasks and collapsed call activities,\n  // sub processes and participants\n  if (isAny(element, [ 'bpmn:Task', 'bpmn:CallActivity']) ||\n      isCollapsedPool(element) ||\n      isCollapsedSubProcess(element)) {\n\n    assign(bounds, {\n      width: bbox.width,\n      height: bbox.height\n    });\n\n    assign(style, {\n      fontSize: defaultFontSize + 'px',\n      lineHeight: defaultLineHeight,\n      paddingTop: (7 * zoom) + 'px',\n      paddingBottom: (7 * zoom) + 'px',\n      paddingLeft: (5 * zoom) + 'px',\n      paddingRight: (5 * zoom) + 'px'\n    });\n  }\n\n\n  // internal labels for expanded sub processes\n  if (isExpandedSubProcess(element)) {\n    assign(bounds, {\n      width: bbox.width,\n      x: bbox.x\n    });\n\n    assign(style, {\n      fontSize: defaultFontSize + 'px',\n      lineHeight: defaultLineHeight,\n      paddingTop: (7 * zoom) + 'px',\n      paddingBottom: (7 * zoom) + 'px',\n      paddingLeft: (5 * zoom) + 'px',\n      paddingRight: (5 * zoom) + 'px'\n    });\n  }\n\n  var width = 90 * zoom,\n      paddingTop = 7 * zoom,\n      paddingBottom = 4 * zoom;\n\n  // external labels for events, data elements, gateways and connections\n  if (target.labelTarget) {\n    assign(bounds, {\n      width: width,\n      height: bbox.height + paddingTop + paddingBottom,\n      x: mid.x - width / 2,\n      y: bbox.y - paddingTop\n    });\n\n    assign(style, {\n      fontSize: externalFontSize + 'px',\n      lineHeight: externalLineHeight,\n      paddingTop: paddingTop + 'px',\n      paddingBottom: paddingBottom + 'px'\n    });\n  }\n\n  // external label not yet created\n  if (isLabelExternal(target)\n      && !hasExternalLabel(target)\n      && !isLabel(target)) {\n\n    var externalLabelMid = getExternalLabelMid(element);\n\n    var absoluteBBox = canvas.getAbsoluteBBox({\n      x: externalLabelMid.x,\n      y: externalLabelMid.y,\n      width: 0,\n      height: 0\n    });\n\n    var height = externalFontSize + paddingTop + paddingBottom;\n\n    assign(bounds, {\n      width: width,\n      height: height,\n      x: absoluteBBox.x - width / 2,\n      y: absoluteBBox.y - height / 2\n    });\n\n    assign(style, {\n      fontSize: externalFontSize + 'px',\n      lineHeight: externalLineHeight,\n      paddingTop: paddingTop + 'px',\n      paddingBottom: paddingBottom + 'px'\n    });\n  }\n\n  // text annotations\n  if (is(element, 'bpmn:TextAnnotation')) {\n    assign(bounds, {\n      width: bbox.width,\n      height: bbox.height,\n      minWidth: 30 * zoom,\n      minHeight: 10 * zoom\n    });\n\n    assign(style, {\n      textAlign: 'left',\n      paddingTop: (5 * zoom) + 'px',\n      paddingBottom: (7 * zoom) + 'px',\n      paddingLeft: (7 * zoom) + 'px',\n      paddingRight: (5 * zoom) + 'px',\n      fontSize: defaultFontSize + 'px',\n      lineHeight: defaultLineHeight\n    });\n  }\n\n  return { bounds: bounds, style: style };\n};\n\n\nLabelEditingProvider.prototype.update = function(\n    element, newLabel,\n    activeContextText, bounds) {\n\n  var newBounds,\n      bbox;\n\n  if (is(element, 'bpmn:TextAnnotation')) {\n\n    bbox = this._canvas.getAbsoluteBBox(element);\n\n    newBounds = {\n      x: element.x,\n      y: element.y,\n      width: element.width / bbox.width * bounds.width,\n      height: element.height / bbox.height * bounds.height\n    };\n  }\n\n  if (isEmptyText(newLabel)) {\n    newLabel = null;\n  }\n\n  this._modeling.updateLabel(element, newLabel, newBounds);\n};\n\n\n\n// helpers //////////////////////\n\nfunction isCollapsedSubProcess(element) {\n  return is(element, 'bpmn:SubProcess') && !isExpanded(element);\n}\n\nfunction isExpandedSubProcess(element) {\n  return is(element, 'bpmn:SubProcess') && isExpanded(element);\n}\n\nfunction isCollapsedPool(element) {\n  return is(element, 'bpmn:Participant') && !isExpanded(element);\n}\n\nfunction isExpandedPool(element) {\n  return is(element, 'bpmn:Participant') && isExpanded(element);\n}\n\nfunction isEmptyText(label) {\n  return !label || !label.trim();\n}","import { is } from '../../util/ModelUtil';\n\nfunction getLabelAttr(semantic) {\n  if (is(semantic, 'bpmn:FlowElement') ||\n      is(semantic, 'bpmn:Participant') ||\n      is(semantic, 'bpmn:Lane') ||\n      is(semantic, 'bpmn:SequenceFlow') ||\n      is(semantic, 'bpmn:MessageFlow')) {\n\n    return 'name';\n  }\n\n  if (is(semantic, 'bpmn:TextAnnotation')) {\n    return 'text';\n  }\n}\n\nexport function getLabel(element) {\n  var semantic = element.businessObject,\n      attr = getLabelAttr(semantic);\n\n  if (attr) {\n    return semantic[attr] || '';\n  }\n}\n\n\nexport function setLabel(element, text, isExternal) {\n  var semantic = element.businessObject,\n      attr = getLabelAttr(semantic);\n\n  if (attr) {\n    semantic[attr] = text;\n  }\n\n  return element;\n}","import {\n  setLabel,\n  getLabel\n} from '../LabelUtil';\n\nimport {\n  getExternalLabelMid,\n  isLabelExternal,\n  hasExternalLabel,\n  isLabel\n} from '../../../util/LabelUtil';\n\nimport {\n  getBusinessObject,\n  is\n} from '../../../util/ModelUtil';\n\nvar NULL_DIMENSIONS = {\n  width: 0,\n  height: 0\n};\n\n\n/**\n * A handler that updates the text of a BPMN element.\n */\nexport default function UpdateLabelHandler(modeling, textRenderer) {\n\n  /**\n   * Set the label and return the changed elements.\n   *\n   * Element parameter can be label itself or connection (i.e. sequence flow).\n   *\n   * @param {djs.model.Base} element\n   * @param {String} text\n   */\n  function setText(element, text) {\n\n    // external label if present\n    var label = element.label || element;\n\n    var labelTarget = element.labelTarget || element;\n\n    setLabel(label, text, labelTarget !== label);\n\n    return [ label, labelTarget ];\n  }\n\n  function preExecute(ctx) {\n    var element = ctx.element,\n        businessObject = element.businessObject,\n        newLabel = ctx.newLabel;\n\n    if (!isLabel(element)\n        && isLabelExternal(element)\n        && !hasExternalLabel(element)\n        && !isEmptyText(newLabel)) {\n\n      // create label\n      var paddingTop = 7;\n\n      var labelCenter = getExternalLabelMid(element);\n\n      labelCenter = {\n        x: labelCenter.x,\n        y: labelCenter.y + paddingTop\n      };\n\n      modeling.createLabel(element, labelCenter, {\n        id: businessObject.id + '_label',\n        businessObject: businessObject\n      });\n    }\n  }\n\n  function execute(ctx) {\n    ctx.oldLabel = getLabel(ctx.element);\n    return setText(ctx.element, ctx.newLabel);\n  }\n\n  function revert(ctx) {\n    return setText(ctx.element, ctx.oldLabel);\n  }\n\n  function postExecute(ctx) {\n    var element = ctx.element,\n        label = element.label || element,\n        newLabel = ctx.newLabel,\n        newBounds = ctx.newBounds,\n        hints = ctx.hints || {};\n\n    if (isLabel(label) && isEmptyText(newLabel)) {\n\n      if (hints.removeShape !== false) {\n        modeling.removeShape(label, { unsetLabel: false });\n      }\n\n      return;\n    }\n\n    // ignore internal labels for elements except text annotations\n    if (!isLabelExternal(element) && !is(element, 'bpmn:TextAnnotation')) {\n      return;\n    }\n\n    var bo = getBusinessObject(label);\n\n    var text = bo.name || bo.text;\n\n    // don't resize without text\n    if (!text) {\n      return;\n    }\n\n    // resize element based on label _or_ pre-defined bounds\n    if (typeof newBounds === 'undefined') {\n      newBounds = textRenderer.getExternalLabelBounds(label, text);\n    }\n\n    // setting newBounds to false or _null_ will\n    // disable the postExecute resize operation\n    if (newBounds) {\n      modeling.resizeShape(label, newBounds, NULL_DIMENSIONS);\n    }\n  }\n\n  // API\n\n  this.preExecute = preExecute;\n  this.execute = execute;\n  this.revert = revert;\n  this.postExecute = postExecute;\n}\n\nUpdateLabelHandler.$inject = [\n  'modeling',\n  'textRenderer'\n];\n\n\n// helpers ///////////////////////\n\nfunction isEmptyText(label) {\n  return !label || !label.trim();\n}","import ChangeSupportModule from 'diagram-js/lib/features/change-support';\nimport ResizeModule from 'diagram-js/lib/features/resize';\nimport DirectEditingModule from 'diagram-js-direct-editing';\n\nimport LabelEditingProvider from './LabelEditingProvider';\nimport LabelEditingPreview from './LabelEditingPreview';\n\n\nexport default {\n  __depends__: [\n    ChangeSupportModule,\n    ResizeModule,\n    DirectEditingModule\n  ],\n  __init__: [\n    'labelEditingProvider',\n    'labelEditingPreview'\n  ],\n  labelEditingProvider: [ 'type', LabelEditingProvider ],\n  labelEditingPreview: [ 'type', LabelEditingPreview ]\n};\n","import {\n  map,\n  assign,\n  pick\n} from 'min-dash';\n\nimport {\n  isAny\n} from './util/ModelingUtil';\n\n\nexport default function BpmnFactory(moddle) {\n  this._model = moddle;\n}\n\nBpmnFactory.$inject = [ 'moddle' ];\n\n\nBpmnFactory.prototype._needsId = function(element) {\n  return isAny(element, [\n    'bpmn:RootElement',\n    'bpmn:FlowElement',\n    'bpmn:MessageFlow',\n    'bpmn:DataAssociation',\n    'bpmn:Artifact',\n    'bpmn:Participant',\n    'bpmn:Lane',\n    'bpmn:LaneSet',\n    'bpmn:Process',\n    'bpmn:Collaboration',\n    'bpmndi:BPMNShape',\n    'bpmndi:BPMNEdge',\n    'bpmndi:BPMNDiagram',\n    'bpmndi:BPMNPlane',\n    'bpmn:Property'\n  ]);\n};\n\nBpmnFactory.prototype._ensureId = function(element) {\n\n  // generate semantic ids for elements\n  // bpmn:SequenceFlow -> SequenceFlow_ID\n  var prefix = (element.$type || '').replace(/^[^:]*:/g, '') + '_';\n\n  if (!element.id && this._needsId(element)) {\n    element.id = this._model.ids.nextPrefixed(prefix, element);\n  }\n};\n\n\nBpmnFactory.prototype.create = function(type, attrs) {\n  var element = this._model.create(type, attrs || {});\n\n  this._ensureId(element);\n\n  return element;\n};\n\n\nBpmnFactory.prototype.createDiLabel = function() {\n  return this.create('bpmndi:BPMNLabel', {\n    bounds: this.createDiBounds()\n  });\n};\n\n\nBpmnFactory.prototype.createDiShape = function(semantic, bounds, attrs) {\n\n  return this.create('bpmndi:BPMNShape', assign({\n    bpmnElement: semantic,\n    bounds: this.createDiBounds(bounds)\n  }, attrs));\n};\n\n\nBpmnFactory.prototype.createDiBounds = function(bounds) {\n  return this.create('dc:Bounds', bounds);\n};\n\n\nBpmnFactory.prototype.createDiWaypoints = function(waypoints) {\n  var self = this;\n\n  return map(waypoints, function(pos) {\n    return self.createDiWaypoint(pos);\n  });\n};\n\nBpmnFactory.prototype.createDiWaypoint = function(point) {\n  return this.create('dc:Point', pick(point, [ 'x', 'y' ]));\n};\n\n\nBpmnFactory.prototype.createDiEdge = function(semantic, waypoints, attrs) {\n  return this.create('bpmndi:BPMNEdge', assign({\n    bpmnElement: semantic\n  }, attrs));\n};\n\nBpmnFactory.prototype.createDiPlane = function(semantic) {\n  return this.create('bpmndi:BPMNPlane', {\n    bpmnElement: semantic\n  });\n};","import inherits from 'inherits';\n\nimport {\n  assign\n} from 'min-dash';\n\nimport BaseLayouter from 'diagram-js/lib/layout/BaseLayouter';\n\nimport {\n  repairConnection,\n  withoutRedundantPoints\n} from 'diagram-js/lib/layout/ManhattanLayout';\n\nimport {\n  getMid,\n  getOrientation\n} from 'diagram-js/lib/layout/LayoutUtil';\n\nimport {\n  isExpanded\n} from '../../util/DiUtil';\n\nimport { is } from '../../util/ModelUtil';\n\n\nexport default function BpmnLayouter() {}\n\ninherits(BpmnLayouter, BaseLayouter);\n\n\nBpmnLayouter.prototype.layoutConnection = function(connection, hints) {\n  hints = hints || {};\n\n  var source = connection.source,\n      target = connection.target,\n      waypoints = connection.waypoints,\n      start = hints.connectionStart,\n      end = hints.connectionEnd;\n\n  var manhattanOptions,\n      updatedWaypoints;\n\n  if (!start) {\n    start = getConnectionDocking(waypoints && waypoints[0], source);\n  }\n\n  if (!end) {\n    end = getConnectionDocking(waypoints && waypoints[waypoints.length - 1], target);\n  }\n\n  // TODO(nikku): support vertical modeling\n  // and invert preferredLayouts accordingly\n\n  if (is(connection, 'bpmn:Association') ||\n      is(connection, 'bpmn:DataAssociation')) {\n\n    if (waypoints && !isCompensationAssociation(connection)) {\n      return [].concat([ start ], waypoints.slice(1, -1), [ end ]);\n    }\n  }\n\n  // manhattan layout sequence / message flows\n  if (is(connection, 'bpmn:MessageFlow')) {\n    manhattanOptions = getMessageFlowManhattanOptions(source, target);\n\n  } else\n\n\n  // layout all connection between flow elements h:h,\n  //\n  // except for\n  //\n  // (1) outgoing of BoundaryEvents -> layout based on attach orientation and target orientation\n  // (2) incoming / outgoing of Gateway -> v:h (outgoing), h:v (incoming)\n  // (3) loops from / to the same element\n  //\n  if (is(connection, 'bpmn:SequenceFlow') ||\n      isCompensationAssociation(connection)) {\n\n    if (source === target) {\n      manhattanOptions = {\n        preferredLayouts: [ 'b:l' ]\n      };\n    } else\n\n    if (is(source, 'bpmn:BoundaryEvent')) {\n\n      manhattanOptions = {\n        preferredLayouts: getBoundaryEventPreferredLayouts(source, target)\n      };\n\n    } else\n\n    if (is(source, 'bpmn:Gateway')) {\n\n      manhattanOptions = {\n        preferredLayouts: [ 'v:h' ]\n      };\n    } else\n\n    if (is(target, 'bpmn:Gateway')) {\n\n      manhattanOptions = {\n        preferredLayouts: [ 'h:v' ]\n      };\n    }\n\n    else {\n      manhattanOptions = {\n        preferredLayouts: [ 'h:h' ]\n      };\n    }\n\n  }\n\n  if (manhattanOptions) {\n\n    manhattanOptions = assign(manhattanOptions, hints);\n\n    updatedWaypoints =\n      withoutRedundantPoints(\n        repairConnection(\n          source, target,\n          start, end,\n          waypoints,\n          manhattanOptions\n        )\n      );\n  }\n\n  return updatedWaypoints || [ start, end ];\n};\n\n\nfunction getAttachOrientation(attachedElement) {\n\n  var hostElement = attachedElement.host,\n      padding = -10;\n\n  return getOrientation(getMid(attachedElement), hostElement, padding);\n}\n\n\nfunction getMessageFlowManhattanOptions(source, target) {\n  return {\n    preferredLayouts: [ 'straight', 'v:v' ],\n    preserveDocking: getMessageFlowPreserveDocking(source, target)\n  };\n}\n\n\nfunction getMessageFlowPreserveDocking(source, target) {\n\n  // (1) docking element connected to participant has precedence\n\n  if (is(target, 'bpmn:Participant')) {\n    return 'source';\n  }\n\n  if (is(source, 'bpmn:Participant')) {\n    return 'target';\n  }\n\n  // (2) docking element connected to expanded sub-process has precedence\n\n  if (isExpandedSubProcess(target)) {\n    return 'source';\n  }\n\n  if (isExpandedSubProcess(source)) {\n    return 'target';\n  }\n\n  // (3) docking event has precedence\n\n  if (is(target, 'bpmn:Event')) {\n    return 'target';\n  }\n\n  if (is(source, 'bpmn:Event')) {\n    return 'source';\n  }\n\n  return null;\n}\n\n\nfunction getConnectionDocking(point, shape) {\n  return point ? (point.original || point) : getMid(shape);\n}\n\nfunction isCompensationAssociation(connection) {\n\n  var source = connection.source,\n      target = connection.target;\n\n  return is(target, 'bpmn:Activity') &&\n         is(source, 'bpmn:BoundaryEvent') &&\n         target.businessObject.isForCompensation;\n}\n\n\nfunction isExpandedSubProcess(element) {\n  return is(element, 'bpmn:SubProcess') && isExpanded(element);\n}\n\nfunction isSame(a, b) {\n  return a === b;\n}\n\nfunction isAnyOrientation(orientation, orientations) {\n  return orientations.indexOf(orientation) !== -1;\n}\n\nvar oppositeOrientationMapping = {\n  'top': 'bottom',\n  'top-right': 'bottom-left',\n  'top-left': 'bottom-right',\n  'right': 'left',\n  'bottom': 'top',\n  'bottom-right': 'top-left',\n  'bottom-left': 'top-right',\n  'left': 'right'\n};\n\nvar orientationDirectionMapping = {\n  top: 't',\n  right: 'r',\n  bottom: 'b',\n  left: 'l'\n};\n\nfunction getHorizontalOrientation(orientation) {\n  var matches = /right|left/.exec(orientation);\n\n  return matches && matches[0];\n}\n\nfunction getVerticalOrientation(orientation) {\n  var matches = /top|bottom/.exec(orientation);\n\n  return matches && matches[0];\n}\n\nfunction isOppositeOrientation(a, b) {\n  return oppositeOrientationMapping[a] === b;\n}\n\nfunction isOppositeHorizontalOrientation(a, b) {\n  var horizontalOrientation = getHorizontalOrientation(a);\n\n  var oppositeHorizontalOrientation = oppositeOrientationMapping[horizontalOrientation];\n\n  return b.indexOf(oppositeHorizontalOrientation) !== -1;\n}\n\nfunction isOppositeVerticalOrientation(a, b) {\n  var verticalOrientation = getVerticalOrientation(a);\n\n  var oppositeVerticalOrientation = oppositeOrientationMapping[verticalOrientation];\n\n  return b.indexOf(oppositeVerticalOrientation) !== -1;\n}\n\nfunction isHorizontalOrientation(orientation) {\n  return orientation === 'right' || orientation === 'left';\n}\n\nfunction getBoundaryEventPreferredLayouts(source, target) {\n  var sourceMid = getMid(source),\n      targetMid = getMid(target),\n      attachOrientation = getAttachOrientation(source),\n      sourceLayout,\n      targetlayout;\n\n  var isLoop = isSame(source.host, target);\n\n  var attachedToSide = isAnyOrientation(attachOrientation, [ 'top', 'right', 'bottom', 'left' ]);\n\n  var isHorizontalAttachOrientation = isHorizontalOrientation(attachOrientation);\n\n  var targetOrientation = getOrientation(targetMid, sourceMid, {\n    x: source.width / 2 + target.width / 2,\n    y: source.height / 2 + target.height / 2\n  });\n\n  // source layout\n\n  // attached to either top, right, bottom or left side\n  if (attachedToSide) {\n\n    sourceLayout = orientationDirectionMapping[\n      isHorizontalAttachOrientation ?\n        getHorizontalOrientation(attachOrientation) :\n        getVerticalOrientation(attachOrientation)\n    ];\n\n  } else\n\n  // attached to either top-right, top-left, bottom-right or bottom-left corner\n  {\n\n    // loop, same vertical or opposite horizontal orientation\n    if (isLoop ||\n      isSame(getVerticalOrientation(attachOrientation), getVerticalOrientation(targetOrientation)) ||\n      isOppositeOrientation(getHorizontalOrientation(attachOrientation), getHorizontalOrientation(targetOrientation))\n    ) {\n      sourceLayout = orientationDirectionMapping[getVerticalOrientation(attachOrientation)];\n    } else {\n      sourceLayout = orientationDirectionMapping[getHorizontalOrientation(attachOrientation)];\n    }\n\n  }\n\n  // target layout\n\n  // attached to either top, right, bottom or left side\n  if (attachedToSide) {\n\n    // loop or opposite horizontal/vertical orientation\n    if (\n      isLoop ||\n      (isHorizontalAttachOrientation ?\n        isOppositeHorizontalOrientation(attachOrientation, targetOrientation) :\n        isOppositeVerticalOrientation(attachOrientation, targetOrientation))\n    ) {\n      targetlayout = isHorizontalAttachOrientation ? 'h' : 'v';\n    } else {\n      targetlayout = isHorizontalAttachOrientation ? 'v' : 'h';\n    }\n\n  } else\n\n  // attached to either top-right, top-left, bottom-right or bottom-left corner\n  {\n\n    // orientation is 'right', 'left'\n    // or same vertical orientation but also 'right' or 'left'\n    if (\n      isHorizontalOrientation(targetOrientation) ||\n      (isSame(getVerticalOrientation(attachOrientation), getVerticalOrientation(targetOrientation)) &&\n        getHorizontalOrientation(targetOrientation))\n    ) {\n      targetlayout = 'h';\n    } else {\n      targetlayout = 'v';\n    }\n\n  }\n\n  return [ sourceLayout + ':' + targetlayout ];\n}","import {\n  assign,\n  forEach\n} from 'min-dash';\n\nimport inherits from 'inherits';\n\nimport {\n  remove as collectionRemove,\n  add as collectionAdd\n} from 'diagram-js/lib/util/Collections';\n\nimport {\n  Label\n} from 'diagram-js/lib/model';\n\nimport {\n  getBusinessObject,\n  is\n} from '../../util/ModelUtil';\n\nimport CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';\n\n/**\n * A handler responsible for updating the underlying BPMN 2.0 XML + DI\n * once changes on the diagram happen\n */\nexport default function BpmnUpdater(\n    eventBus, bpmnFactory, connectionDocking,\n    translate) {\n\n  CommandInterceptor.call(this, eventBus);\n\n  this._bpmnFactory = bpmnFactory;\n  this._translate = translate;\n\n  var self = this;\n\n\n\n  // connection cropping //////////////////////\n\n  // crop connection ends during create/update\n  function cropConnection(e) {\n    var context = e.context,\n        connection;\n\n    if (!context.cropped) {\n      connection = context.connection;\n      connection.waypoints = connectionDocking.getCroppedWaypoints(connection);\n      context.cropped = true;\n    }\n  }\n\n  this.executed([\n    'connection.layout',\n    'connection.create',\n    'connection.reconnectEnd',\n    'connection.reconnectStart'\n  ], cropConnection);\n\n  this.reverted([ 'connection.layout' ], function(e) {\n    delete e.context.cropped;\n  });\n\n\n\n  // BPMN + DI update //////////////////////\n\n\n  // update parent\n  function updateParent(e) {\n    var context = e.context;\n\n    self.updateParent(context.shape || context.connection, context.oldParent);\n  }\n\n  function reverseUpdateParent(e) {\n    var context = e.context;\n\n    var element = context.shape || context.connection,\n        // oldParent is the (old) new parent, because we are undoing\n        oldParent = context.parent || context.newParent;\n\n    self.updateParent(element, oldParent);\n  }\n\n  this.executed([\n    'shape.move',\n    'shape.create',\n    'shape.delete',\n    'connection.create',\n    'connection.move',\n    'connection.delete'\n  ], ifBpmn(updateParent));\n\n  this.reverted([\n    'shape.move',\n    'shape.create',\n    'shape.delete',\n    'connection.create',\n    'connection.move',\n    'connection.delete'\n  ], ifBpmn(reverseUpdateParent));\n\n  /*\n   * ## Updating Parent\n   *\n   * When morphing a Process into a Collaboration or vice-versa,\n   * make sure that both the *semantic* and *di* parent of each element\n   * is updated.\n   *\n   */\n  function updateRoot(event) {\n    var context = event.context,\n        oldRoot = context.oldRoot,\n        children = oldRoot.children;\n\n    forEach(children, function(child) {\n      if (is(child, 'bpmn:BaseElement')) {\n        self.updateParent(child);\n      }\n    });\n  }\n\n  this.executed([ 'canvas.updateRoot' ], updateRoot);\n  this.reverted([ 'canvas.updateRoot' ], updateRoot);\n\n\n  // update bounds\n  function updateBounds(e) {\n    var shape = e.context.shape;\n\n    if (!is(shape, 'bpmn:BaseElement')) {\n      return;\n    }\n\n    self.updateBounds(shape);\n  }\n\n  this.executed([ 'shape.move', 'shape.create', 'shape.resize' ], ifBpmn(function(event) {\n\n    // exclude labels because they're handled separately during shape.changed\n    if (event.context.shape.type === 'label') {\n      return;\n    }\n\n    updateBounds(event);\n  }));\n\n  this.reverted([ 'shape.move', 'shape.create', 'shape.resize' ], ifBpmn(function(event) {\n\n    // exclude labels because they're handled separately during shape.changed\n    if (event.context.shape.type === 'label') {\n      return;\n    }\n\n    updateBounds(event);\n  }));\n\n  // Handle labels separately. This is necessary, because the label bounds have to be updated\n  // every time its shape changes, not only on move, create and resize.\n  eventBus.on('shape.changed', function(event) {\n    if (event.element.type === 'label') {\n      updateBounds({ context: { shape: event.element } });\n    }\n  });\n\n  // attach / detach connection\n  function updateConnection(e) {\n    self.updateConnection(e.context);\n  }\n\n  this.executed([\n    'connection.create',\n    'connection.move',\n    'connection.delete',\n    'connection.reconnectEnd',\n    'connection.reconnectStart'\n  ], ifBpmn(updateConnection));\n\n  this.reverted([\n    'connection.create',\n    'connection.move',\n    'connection.delete',\n    'connection.reconnectEnd',\n    'connection.reconnectStart'\n  ], ifBpmn(updateConnection));\n\n\n  // update waypoints\n  function updateConnectionWaypoints(e) {\n    self.updateConnectionWaypoints(e.context.connection);\n  }\n\n  this.executed([\n    'connection.layout',\n    'connection.move',\n    'connection.updateWaypoints',\n    'connection.reconnectEnd',\n    'connection.reconnectStart'\n  ], ifBpmn(updateConnectionWaypoints));\n\n  this.reverted([\n    'connection.layout',\n    'connection.move',\n    'connection.updateWaypoints',\n    'connection.reconnectEnd',\n    'connection.reconnectStart'\n  ], ifBpmn(updateConnectionWaypoints));\n\n\n  // update Default & Conditional flows\n  this.executed([\n    'connection.reconnectEnd',\n    'connection.reconnectStart'\n  ], ifBpmn(function(e) {\n    var context = e.context,\n        connection = context.connection,\n        businessObject = getBusinessObject(connection),\n        oldSource = getBusinessObject(context.oldSource),\n        oldTarget = getBusinessObject(context.oldTarget),\n        newSource = getBusinessObject(connection.source),\n        newTarget = getBusinessObject(connection.target);\n\n    if (oldSource === newSource || oldTarget === newTarget) {\n      return;\n    }\n\n    // on reconnectStart -> default flow\n    if (oldSource && oldSource.default === businessObject) {\n      context.default = oldSource.default;\n      oldSource.default = undefined;\n    }\n\n    // on reconnectEnd -> default flow\n    if ((businessObject.sourceRef && businessObject.sourceRef.default) &&\n        !(is(newTarget, 'bpmn:Activity') ||\n          is(newTarget, 'bpmn:EndEvent') ||\n          is(newTarget, 'bpmn:Gateway') ||\n          is(newTarget, 'bpmn:IntermediateThrowEvent'))) {\n      context.default = businessObject.sourceRef.default;\n      businessObject.sourceRef.default = undefined;\n    }\n\n    // on reconnectStart -> conditional flow\n    if (oldSource && (businessObject.conditionExpression) &&\n      !(is(newSource, 'bpmn:Activity') ||\n        is(newSource, 'bpmn:Gateway'))) {\n      context.conditionExpression = businessObject.conditionExpression;\n      businessObject.conditionExpression = undefined;\n    }\n\n    // on reconnectEnd -> conditional flow\n    if (oldTarget && (businessObject.conditionExpression) &&\n        !(is(newTarget, 'bpmn:Activity') ||\n          is(newTarget, 'bpmn:EndEvent') ||\n          is(newTarget, 'bpmn:Gateway') ||\n          is(newTarget, 'bpmn:IntermediateThrowEvent'))) {\n      context.conditionExpression = businessObject.conditionExpression;\n      businessObject.conditionExpression = undefined;\n    }\n  }));\n\n  this.reverted([\n    'connection.reconnectEnd',\n    'connection.reconnectStart'\n  ], ifBpmn(function(e) {\n    var context = e.context,\n        connection = context.connection,\n        businessObject = getBusinessObject(connection),\n        newSource = getBusinessObject(connection.source);\n\n    // default flow\n    if (context.default) {\n      if (is(newSource, 'bpmn:ExclusiveGateway') || is(newSource, 'bpmn:InclusiveGateway') ||\n          is(newSource, 'bpmn:Activity')) {\n        newSource.default = context.default;\n      }\n    }\n\n    // conditional flow\n    if (context.conditionExpression && is(newSource, 'bpmn:Activity')) {\n      businessObject.conditionExpression = context.conditionExpression;\n    }\n  }));\n\n  // update attachments\n  function updateAttachment(e) {\n    self.updateAttachment(e.context);\n  }\n\n  this.executed([ 'element.updateAttachment' ], ifBpmn(updateAttachment));\n  this.reverted([ 'element.updateAttachment' ], ifBpmn(updateAttachment));\n}\n\ninherits(BpmnUpdater, CommandInterceptor);\n\nBpmnUpdater.$inject = [\n  'eventBus',\n  'bpmnFactory',\n  'connectionDocking',\n  'translate'\n];\n\n\n// implementation //////////////////////\n\nBpmnUpdater.prototype.updateAttachment = function(context) {\n\n  var shape = context.shape,\n      businessObject = shape.businessObject,\n      host = shape.host;\n\n  businessObject.attachedToRef = host && host.businessObject;\n};\n\nBpmnUpdater.prototype.updateParent = function(element, oldParent) {\n  // do not update BPMN 2.0 label parent\n  if (element instanceof Label) {\n    return;\n  }\n\n  // data stores in collaborations are handled seperately by DataStoreBehavior\n  if (is(element, 'bpmn:DataStoreReference') &&\n      element.parent &&\n      is(element.parent, 'bpmn:Collaboration')) {\n    return;\n  }\n\n  var parentShape = element.parent;\n\n  var businessObject = element.businessObject,\n      parentBusinessObject = parentShape && parentShape.businessObject,\n      parentDi = parentBusinessObject && parentBusinessObject.di;\n\n  if (is(element, 'bpmn:FlowNode')) {\n    this.updateFlowNodeRefs(businessObject, parentBusinessObject, oldParent && oldParent.businessObject);\n  }\n\n  if (is(element, 'bpmn:DataOutputAssociation')) {\n    if (element.source) {\n      parentBusinessObject = element.source.businessObject;\n    } else {\n      parentBusinessObject = null;\n    }\n  }\n\n  if (is(element, 'bpmn:DataInputAssociation')) {\n    if (element.target) {\n      parentBusinessObject = element.target.businessObject;\n    } else {\n      parentBusinessObject = null;\n    }\n  }\n\n  this.updateSemanticParent(businessObject, parentBusinessObject);\n\n  if (is(element, 'bpmn:DataObjectReference') && businessObject.dataObjectRef) {\n    this.updateSemanticParent(businessObject.dataObjectRef, parentBusinessObject);\n  }\n\n  this.updateDiParent(businessObject.di, parentDi);\n};\n\n\nBpmnUpdater.prototype.updateBounds = function(shape) {\n\n  var di = shape.businessObject.di;\n\n  var target = (shape instanceof Label) ? this._getLabel(di) : di;\n\n  var bounds = target.bounds;\n\n  if (!bounds) {\n    bounds = this._bpmnFactory.createDiBounds();\n    target.set('bounds', bounds);\n  }\n\n  assign(bounds, {\n    x: shape.x,\n    y: shape.y,\n    width: shape.width,\n    height: shape.height\n  });\n};\n\nBpmnUpdater.prototype.updateFlowNodeRefs = function(businessObject, newContainment, oldContainment) {\n\n  if (oldContainment === newContainment) {\n    return;\n  }\n\n  var oldRefs, newRefs;\n\n  if (is (oldContainment, 'bpmn:Lane')) {\n    oldRefs = oldContainment.get('flowNodeRef');\n    collectionRemove(oldRefs, businessObject);\n  }\n\n  if (is(newContainment, 'bpmn:Lane')) {\n    newRefs = newContainment.get('flowNodeRef');\n    collectionAdd(newRefs, businessObject);\n  }\n};\n\n\n// update existing sourceElement and targetElement di information\nBpmnUpdater.prototype.updateDiConnection = function(di, newSource, newTarget) {\n\n  if (di.sourceElement && di.sourceElement.bpmnElement !== newSource) {\n    di.sourceElement = newSource && newSource.di;\n  }\n\n  if (di.targetElement && di.targetElement.bpmnElement !== newTarget) {\n    di.targetElement = newTarget && newTarget.di;\n  }\n\n};\n\n\nBpmnUpdater.prototype.updateDiParent = function(di, parentDi) {\n\n  if (parentDi && !is(parentDi, 'bpmndi:BPMNPlane')) {\n    parentDi = parentDi.$parent;\n  }\n\n  if (di.$parent === parentDi) {\n    return;\n  }\n\n  var planeElements = (parentDi || di.$parent).get('planeElement');\n\n  if (parentDi) {\n    planeElements.push(di);\n    di.$parent = parentDi;\n  } else {\n    collectionRemove(planeElements, di);\n    di.$parent = null;\n  }\n};\n\nfunction getDefinitions(element) {\n  while (element && !is(element, 'bpmn:Definitions')) {\n    element = element.$parent;\n  }\n\n  return element;\n}\n\nBpmnUpdater.prototype.getLaneSet = function(container) {\n\n  var laneSet, laneSets;\n\n  // bpmn:Lane\n  if (is(container, 'bpmn:Lane')) {\n    laneSet = container.childLaneSet;\n\n    if (!laneSet) {\n      laneSet = this._bpmnFactory.create('bpmn:LaneSet');\n      container.childLaneSet = laneSet;\n      laneSet.$parent = container;\n    }\n\n    return laneSet;\n  }\n\n  // bpmn:Participant\n  if (is(container, 'bpmn:Participant')) {\n    container = container.processRef;\n  }\n\n  // bpmn:FlowElementsContainer\n  laneSets = container.get('laneSets');\n  laneSet = laneSets[0];\n\n  if (!laneSet) {\n    laneSet = this._bpmnFactory.create('bpmn:LaneSet');\n    laneSet.$parent = container;\n    laneSets.push(laneSet);\n  }\n\n  return laneSet;\n};\n\nBpmnUpdater.prototype.updateSemanticParent = function(businessObject, newParent, visualParent) {\n\n  var containment,\n      translate = this._translate;\n\n  if (businessObject.$parent === newParent) {\n    return;\n  }\n\n  if (is(businessObject, 'bpmn:Lane')) {\n\n    if (newParent) {\n      newParent = this.getLaneSet(newParent);\n    }\n\n    containment = 'lanes';\n  } else\n\n  if (is(businessObject, 'bpmn:FlowElement')) {\n\n    if (newParent) {\n\n      if (is(newParent, 'bpmn:Participant')) {\n        newParent = newParent.processRef;\n      } else\n\n      if (is(newParent, 'bpmn:Lane')) {\n        do {\n          // unwrap Lane -> LaneSet -> (Lane | FlowElementsContainer)\n          newParent = newParent.$parent.$parent;\n        } while (is(newParent, 'bpmn:Lane'));\n\n      }\n    }\n\n    containment = 'flowElements';\n\n  } else\n\n  if (is(businessObject, 'bpmn:Artifact')) {\n\n    while (newParent &&\n           !is(newParent, 'bpmn:Process') &&\n           !is(newParent, 'bpmn:SubProcess') &&\n           !is(newParent, 'bpmn:Collaboration')) {\n\n      if (is(newParent, 'bpmn:Participant')) {\n        newParent = newParent.processRef;\n        break;\n      } else {\n        newParent = newParent.$parent;\n      }\n    }\n\n    containment = 'artifacts';\n  } else\n\n  if (is(businessObject, 'bpmn:MessageFlow')) {\n    containment = 'messageFlows';\n\n  } else\n\n  if (is(businessObject, 'bpmn:Participant')) {\n    containment = 'participants';\n\n    // make sure the participants process is properly attached / detached\n    // from the XML document\n\n    var process = businessObject.processRef,\n        definitions;\n\n    if (process) {\n      definitions = getDefinitions(businessObject.$parent || newParent);\n\n      if (businessObject.$parent) {\n        collectionRemove(definitions.get('rootElements'), process);\n        process.$parent = null;\n      }\n\n      if (newParent) {\n        collectionAdd(definitions.get('rootElements'), process);\n        process.$parent = definitions;\n      }\n    }\n  } else\n\n  if (is(businessObject, 'bpmn:DataOutputAssociation')) {\n    containment = 'dataOutputAssociations';\n  } else\n\n  if (is(businessObject, 'bpmn:DataInputAssociation')) {\n    containment = 'dataInputAssociations';\n  }\n\n  if (!containment) {\n    throw new Error(translate(\n      'no parent for {element} in {parent}',\n      {\n        element: businessObject.id,\n        parent: newParent.id\n      }\n    ));\n  }\n\n  var children;\n\n  if (businessObject.$parent) {\n    // remove from old parent\n    children = businessObject.$parent.get(containment);\n    collectionRemove(children, businessObject);\n  }\n\n  if (!newParent) {\n    businessObject.$parent = null;\n  } else {\n    // add to new parent\n    children = newParent.get(containment);\n    children.push(businessObject);\n    businessObject.$parent = newParent;\n  }\n\n  if (visualParent) {\n    var diChildren = visualParent.get(containment);\n\n    collectionRemove(children, businessObject);\n\n    if (newParent) {\n\n      if (!diChildren) {\n        diChildren = [];\n        newParent.set(containment, diChildren);\n      }\n\n      diChildren.push(businessObject);\n    }\n  }\n};\n\n\nBpmnUpdater.prototype.updateConnectionWaypoints = function(connection) {\n  connection.businessObject.di.set('waypoint', this._bpmnFactory.createDiWaypoints(connection.waypoints));\n};\n\n\nBpmnUpdater.prototype.updateConnection = function(context) {\n\n  var connection = context.connection,\n      businessObject = getBusinessObject(connection),\n      newSource = getBusinessObject(connection.source),\n      newTarget = getBusinessObject(connection.target),\n      visualParent;\n\n  if (!is(businessObject, 'bpmn:DataAssociation')) {\n\n    var inverseSet = is(businessObject, 'bpmn:SequenceFlow');\n\n    if (businessObject.sourceRef !== newSource) {\n      if (inverseSet) {\n        collectionRemove(businessObject.sourceRef && businessObject.sourceRef.get('outgoing'), businessObject);\n\n        if (newSource && newSource.get('outgoing')) {\n          newSource.get('outgoing').push(businessObject);\n        }\n      }\n\n      businessObject.sourceRef = newSource;\n    }\n\n    if (businessObject.targetRef !== newTarget) {\n      if (inverseSet) {\n        collectionRemove(businessObject.targetRef && businessObject.targetRef.get('incoming'), businessObject);\n\n        if (newTarget && newTarget.get('incoming')) {\n          newTarget.get('incoming').push(businessObject);\n        }\n      }\n\n      businessObject.targetRef = newTarget;\n    }\n  } else\n\n  if (is(businessObject, 'bpmn:DataInputAssociation')) {\n    // handle obnoxious isMsome sourceRef\n    businessObject.get('sourceRef')[0] = newSource;\n\n    visualParent = context.parent || context.newParent || newTarget;\n\n    this.updateSemanticParent(businessObject, newTarget, parent.businessObject);\n  } else\n\n  if (is(businessObject, 'bpmn:DataOutputAssociation')) {\n    visualParent = context.parent || context.newParent || newSource;\n\n    this.updateSemanticParent(businessObject, newSource, visualParent);\n\n    // targetRef = new target\n    businessObject.targetRef = newTarget;\n  }\n\n  this.updateConnectionWaypoints(connection);\n\n  this.updateDiConnection(businessObject.di, newSource, newTarget);\n};\n\n\n// helpers //////////////////////\n\nBpmnUpdater.prototype._getLabel = function(di) {\n  if (!di.label) {\n    di.label = this._bpmnFactory.createDiLabel();\n  }\n\n  return di.label;\n};\n\n\n/**\n * Make sure the event listener is only called\n * if the touched element is a BPMN element.\n *\n * @param  {Function} fn\n * @return {Function} guarded function\n */\nfunction ifBpmn(fn) {\n\n  return function(event) {\n\n    var context = event.context,\n        element = context.shape || context.connection;\n\n    if (is(element, 'bpmn:BaseElement')) {\n      fn(event);\n    }\n  };\n}\n","import {\n  assign,\n  forEach\n} from 'min-dash';\n\nimport inherits from 'inherits';\n\nimport { is } from '../../util/ModelUtil';\n\nimport {\n  isExpanded\n} from '../../util/DiUtil';\n\nimport BaseElementFactory from 'diagram-js/lib/core/ElementFactory';\n\nimport {\n  DEFAULT_LABEL_SIZE\n} from '../../util/LabelUtil';\n\n\n/**\n * A bpmn-aware factory for diagram-js shapes\n */\nexport default function ElementFactory(bpmnFactory, moddle, translate) {\n  BaseElementFactory.call(this);\n\n  this._bpmnFactory = bpmnFactory;\n  this._moddle = moddle;\n  this._translate = translate;\n}\n\ninherits(ElementFactory, BaseElementFactory);\n\nElementFactory.$inject = [\n  'bpmnFactory',\n  'moddle',\n  'translate'\n];\n\nElementFactory.prototype.baseCreate = BaseElementFactory.prototype.create;\n\nElementFactory.prototype.create = function(elementType, attrs) {\n  // no special magic for labels,\n  // we assume their businessObjects have already been created\n  // and wired via attrs\n  if (elementType === 'label') {\n    return this.baseCreate(elementType, assign({ type: 'label' }, DEFAULT_LABEL_SIZE, attrs));\n  }\n\n  return this.createBpmnElement(elementType, attrs);\n};\n\nElementFactory.prototype.createBpmnElement = function(elementType, attrs) {\n  var size,\n      translate = this._translate;\n\n  attrs = attrs || {};\n\n  var businessObject = attrs.businessObject;\n\n  if (!businessObject) {\n    if (!attrs.type) {\n      throw new Error(translate('no shape type specified'));\n    }\n\n    businessObject = this._bpmnFactory.create(attrs.type);\n  }\n\n  if (!businessObject.di) {\n    if (elementType === 'root') {\n      businessObject.di = this._bpmnFactory.createDiPlane(businessObject, [], {\n        id: businessObject.id + '_di'\n      });\n    } else\n    if (elementType === 'connection') {\n      businessObject.di = this._bpmnFactory.createDiEdge(businessObject, [], {\n        id: businessObject.id + '_di'\n      });\n    } else {\n      businessObject.di = this._bpmnFactory.createDiShape(businessObject, {}, {\n        id: businessObject.id + '_di'\n      });\n    }\n  }\n\n  if (attrs.colors) {\n    assign(businessObject.di, attrs.colors);\n\n    delete attrs.colors;\n  }\n\n  applyAttributes(businessObject, attrs, [\n    'processRef',\n    'isInterrupting',\n    'associationDirection',\n    'isForCompensation'\n  ]);\n\n  if (attrs.isExpanded) {\n    applyAttribute(businessObject.di, attrs, 'isExpanded');\n  }\n\n  if (is(businessObject, 'bpmn:ExclusiveGateway')) {\n    businessObject.di.isMarkerVisible = true;\n  }\n\n  var eventDefinitions,\n      newEventDefinition;\n\n  if (attrs.eventDefinitionType) {\n    eventDefinitions = businessObject.get('eventDefinitions') || [];\n    newEventDefinition = this._moddle.create(attrs.eventDefinitionType);\n\n    if (attrs.eventDefinitionType === 'bpmn:ConditionalEventDefinition') {\n      newEventDefinition.condition = this._moddle.create('bpmn:FormalExpression');\n    }\n\n    eventDefinitions.push(newEventDefinition);\n\n    newEventDefinition.$parent = businessObject;\n    businessObject.eventDefinitions = eventDefinitions;\n\n    delete attrs.eventDefinitionType;\n  }\n\n  size = this._getDefaultSize(businessObject);\n\n  attrs = assign({\n    businessObject: businessObject,\n    id: businessObject.id\n  }, size, attrs);\n\n  return this.baseCreate(elementType, attrs);\n};\n\n\nElementFactory.prototype._getDefaultSize = function(semantic) {\n\n  if (is(semantic, 'bpmn:SubProcess')) {\n\n    if (isExpanded(semantic)) {\n      return { width: 350, height: 200 };\n    } else {\n      return { width: 100, height: 80 };\n    }\n  }\n\n  if (is(semantic, 'bpmn:Task')) {\n    return { width: 100, height: 80 };\n  }\n\n  if (is(semantic, 'bpmn:Gateway')) {\n    return { width: 50, height: 50 };\n  }\n\n  if (is(semantic, 'bpmn:Event')) {\n    return { width: 36, height: 36 };\n  }\n\n  if (is(semantic, 'bpmn:Participant')) {\n    if (!isExpanded(semantic)) {\n      return { width: 400, height: 100 };\n    } else {\n      return { width: 600, height: 250 };\n    }\n  }\n\n  if (is(semantic, 'bpmn:Lane')) {\n    return { width: 400, height: 100 };\n  }\n\n  if (is(semantic, 'bpmn:DataObjectReference')) {\n    return { width: 36, height: 50 };\n  }\n\n  if (is(semantic, 'bpmn:DataStoreReference')) {\n    return { width: 50, height: 50 };\n  }\n\n  if (is(semantic, 'bpmn:TextAnnotation')) {\n    return { width: 100, height: 30 };\n  }\n\n  return { width: 100, height: 80 };\n};\n\n\nElementFactory.prototype.createParticipantShape = function(collapsed) {\n\n  var attrs = { type: 'bpmn:Participant' };\n\n  if (!collapsed) {\n    attrs.processRef = this._bpmnFactory.create('bpmn:Process');\n  }\n\n  return this.createShape(attrs);\n};\n\n\n// helpers //////////////////////\n\n/**\n * Apply attributes from a map to the given element,\n * remove attribute from the map on application.\n *\n * @param {Base} element\n * @param {Object} attrs (in/out map of attributes)\n * @param {Array<String>} attributeNames name of attributes to apply\n */\nfunction applyAttributes(element, attrs, attributeNames) {\n\n  forEach(attributeNames, function(property) {\n    if (attrs[property] !== undefined) {\n      applyAttribute(element, attrs, property);\n    }\n  });\n}\n\n/**\n * Apply named property to element and drain it from the attrs\n * collection.\n *\n * @param {Base} element\n * @param {Object} attrs (in/out map of attributes)\n * @param {String} attributeName to apply\n */\nfunction applyAttribute(element, attrs, attributeName) {\n  element[attributeName] = attrs[attributeName];\n\n  delete attrs[attributeName];\n}","import inherits from 'inherits';\n\nimport BaseModeling from 'diagram-js/lib/features/modeling/Modeling';\n\nimport UpdatePropertiesHandler from './cmd/UpdatePropertiesHandler';\nimport UpdateCanvasRootHandler from './cmd/UpdateCanvasRootHandler';\nimport AddLaneHandler from './cmd/AddLaneHandler';\nimport SplitLaneHandler from './cmd/SplitLaneHandler';\nimport ResizeLaneHandler from './cmd/ResizeLaneHandler';\nimport UpdateFlowNodeRefsHandler from './cmd/UpdateFlowNodeRefsHandler';\nimport IdClaimHandler from './cmd/IdClaimHandler';\nimport SetColorHandler from './cmd/SetColorHandler';\n\nimport UpdateLabelHandler from '../label-editing/cmd/UpdateLabelHandler';\n\n\n/**\n * BPMN 2.0 modeling features activator\n *\n * @param {EventBus} eventBus\n * @param {ElementFactory} elementFactory\n * @param {CommandStack} commandStack\n * @param {BpmnRules} bpmnRules\n */\nexport default function Modeling(\n    eventBus, elementFactory, commandStack,\n    bpmnRules) {\n\n  BaseModeling.call(this, eventBus, elementFactory, commandStack);\n\n  this._bpmnRules = bpmnRules;\n}\n\ninherits(Modeling, BaseModeling);\n\nModeling.$inject = [\n  'eventBus',\n  'elementFactory',\n  'commandStack',\n  'bpmnRules'\n];\n\n\nModeling.prototype.getHandlers = function() {\n  var handlers = BaseModeling.prototype.getHandlers.call(this);\n\n  handlers['element.updateProperties'] = UpdatePropertiesHandler;\n  handlers['canvas.updateRoot'] = UpdateCanvasRootHandler;\n  handlers['lane.add'] = AddLaneHandler;\n  handlers['lane.resize'] = ResizeLaneHandler;\n  handlers['lane.split'] = SplitLaneHandler;\n  handlers['lane.updateRefs'] = UpdateFlowNodeRefsHandler;\n  handlers['id.updateClaim'] = IdClaimHandler;\n  handlers['element.setColor'] = SetColorHandler;\n  handlers['element.updateLabel'] = UpdateLabelHandler;\n\n  return handlers;\n};\n\n\nModeling.prototype.updateLabel = function(element, newLabel, newBounds, hints) {\n  this._commandStack.execute('element.updateLabel', {\n    element: element,\n    newLabel: newLabel,\n    newBounds: newBounds,\n    hints: hints || {}\n  });\n};\n\n\nModeling.prototype.connect = function(source, target, attrs, hints) {\n\n  var bpmnRules = this._bpmnRules;\n\n  if (!attrs) {\n    attrs = bpmnRules.canConnect(source, target);\n  }\n\n  if (!attrs) {\n    return;\n  }\n\n  return this.createConnection(source, target, attrs, source.parent, hints);\n};\n\n\nModeling.prototype.updateProperties = function(element, properties) {\n  this._commandStack.execute('element.updateProperties', {\n    element: element,\n    properties: properties\n  });\n};\n\nModeling.prototype.resizeLane = function(laneShape, newBounds, balanced) {\n  this._commandStack.execute('lane.resize', {\n    shape: laneShape,\n    newBounds: newBounds,\n    balanced: balanced\n  });\n};\n\nModeling.prototype.addLane = function(targetLaneShape, location) {\n  var context = {\n    shape: targetLaneShape,\n    location: location\n  };\n\n  this._commandStack.execute('lane.add', context);\n\n  return context.newLane;\n};\n\nModeling.prototype.splitLane = function(targetLane, count) {\n  this._commandStack.execute('lane.split', {\n    shape: targetLane,\n    count: count\n  });\n};\n\n/**\n * Transform the current diagram into a collaboration.\n *\n * @return {djs.model.Root} the new root element\n */\nModeling.prototype.makeCollaboration = function() {\n\n  var collaborationElement = this._create('root', {\n    type: 'bpmn:Collaboration'\n  });\n\n  var context = {\n    newRoot: collaborationElement\n  };\n\n  this._commandStack.execute('canvas.updateRoot', context);\n\n  return collaborationElement;\n};\n\nModeling.prototype.updateLaneRefs = function(flowNodeShapes, laneShapes) {\n\n  this._commandStack.execute('lane.updateRefs', {\n    flowNodeShapes: flowNodeShapes,\n    laneShapes: laneShapes\n  });\n};\n\n/**\n * Transform the current diagram into a process.\n *\n * @return {djs.model.Root} the new root element\n */\nModeling.prototype.makeProcess = function() {\n\n  var processElement = this._create('root', {\n    type: 'bpmn:Process'\n  });\n\n  var context = {\n    newRoot: processElement\n  };\n\n  this._commandStack.execute('canvas.updateRoot', context);\n};\n\n\nModeling.prototype.claimId = function(id, moddleElement) {\n  this._commandStack.execute('id.updateClaim', {\n    id: id,\n    element: moddleElement,\n    claiming: true\n  });\n};\n\n\nModeling.prototype.unclaimId = function(id, moddleElement) {\n  this._commandStack.execute('id.updateClaim', {\n    id: id,\n    element: moddleElement\n  });\n};\n\nModeling.prototype.setColor = function(elements, colors) {\n  if (!elements.length) {\n    elements = [ elements ];\n  }\n\n  this._commandStack.execute('element.setColor', {\n    elements: elements,\n    colors: colors\n  });\n};\n","import inherits from 'inherits';\n\nimport {\n  getOrientation,\n  getMid,\n  asTRBL\n} from 'diagram-js/lib/layout/LayoutUtil';\n\nimport {\n  substract\n} from 'diagram-js/lib/util/Math';\n\nimport {\n  hasExternalLabel\n} from '../../../util/LabelUtil';\n\nimport CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';\n\n\n/**\n * A component that makes sure that external labels are added\n * together with respective elements and properly updated (DI wise)\n * during move.\n *\n * @param {EventBus} eventBus\n * @param {Modeling} modeling\n */\nexport default function AdaptiveLabelPositioningBehavior(eventBus, modeling) {\n\n  CommandInterceptor.call(this, eventBus);\n\n  this.postExecuted([\n    'connection.create',\n    'connection.layout',\n    'connection.reconnectEnd',\n    'connection.reconnectStart',\n    'connection.updateWaypoints'\n  ], function(event) {\n\n    var context = event.context,\n        connection = context.connection;\n\n    var source = connection.source,\n        target = connection.target;\n\n    checkLabelAdjustment(source);\n    checkLabelAdjustment(target);\n  });\n\n\n  this.postExecuted([\n    'label.create'\n  ], function(event) {\n    checkLabelAdjustment(event.context.shape.labelTarget);\n  });\n\n\n  function checkLabelAdjustment(element) {\n\n    // skip non-existing labels\n    if (!hasExternalLabel(element)) {\n      return;\n    }\n\n    var optimalPosition = getOptimalPosition(element);\n\n    // no optimal position found\n    if (!optimalPosition) {\n      return;\n    }\n\n    adjustLabelPosition(element, optimalPosition);\n  }\n\n  var ELEMENT_LABEL_DISTANCE = 10;\n\n  function adjustLabelPosition(element, orientation) {\n\n    var elementMid = getMid(element),\n        label = element.label,\n        labelMid = getMid(label);\n\n    var elementTrbl = asTRBL(element);\n\n    var newLabelMid;\n\n    switch (orientation) {\n    case 'top':\n      newLabelMid = {\n        x: elementMid.x,\n        y: elementTrbl.top - ELEMENT_LABEL_DISTANCE - label.height / 2\n      };\n\n      break;\n\n    case 'left':\n\n      newLabelMid = {\n        x: elementTrbl.left - ELEMENT_LABEL_DISTANCE - label.width / 2,\n        y: elementMid.y\n      };\n\n      break;\n\n    case 'bottom':\n\n      newLabelMid = {\n        x: elementMid.x,\n        y: elementTrbl.bottom + ELEMENT_LABEL_DISTANCE + label.height / 2\n      };\n\n      break;\n\n    case 'right':\n\n      newLabelMid = {\n        x: elementTrbl.right + ELEMENT_LABEL_DISTANCE + label.width / 2,\n        y: elementMid.y\n      };\n\n      break;\n    }\n\n\n    var delta = substract(newLabelMid, labelMid);\n\n    modeling.moveShape(label, delta);\n  }\n\n}\n\ninherits(AdaptiveLabelPositioningBehavior, CommandInterceptor);\n\nAdaptiveLabelPositioningBehavior.$inject = [\n  'eventBus',\n  'modeling'\n];\n\n\n/**\n * Return the optimal label position around an element\n * or _undefined_, if none was found.\n *\n * @param  {Shape} element\n *\n * @return {String} positioning identifier\n */\nfunction getOptimalPosition(element) {\n\n  var labelMid = getMid(element.label);\n\n  var elementMid = getMid(element);\n\n  var labelOrientation = getApproximateOrientation(elementMid, labelMid);\n\n  if (!isAligned(labelOrientation)) {\n    return;\n  }\n\n  var takenAlignments = [].concat(\n    element.incoming.map(function(c) {\n      return c.waypoints[c.waypoints.length - 2 ];\n    }),\n    element.outgoing.map(function(c) {\n      return c.waypoints[1];\n    })\n  ).map(function(point) {\n    return getApproximateOrientation(elementMid, point);\n  });\n\n  var freeAlignments = ALIGNMENTS.filter(function(alignment) {\n\n    return takenAlignments.indexOf(alignment) === -1;\n  });\n\n  // NOTHING TO DO; label already aligned a.O.K.\n  if (freeAlignments.indexOf(labelOrientation) !== -1) {\n    return;\n  }\n\n  return freeAlignments[0];\n}\n\nvar ALIGNMENTS = [\n  'top',\n  'bottom',\n  'left',\n  'right'\n];\n\nfunction getApproximateOrientation(p0, p1) {\n  return getOrientation(p1, p0, 5);\n}\n\nfunction isAligned(orientation) {\n  return ALIGNMENTS.indexOf(orientation) !== -1;\n}\n","import inherits from 'inherits';\n\nimport { is } from '../../../util/ModelUtil';\n\nimport CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';\n\n\nexport default function AppendBehavior(eventBus, elementFactory, bpmnRules) {\n\n  CommandInterceptor.call(this, eventBus);\n\n  // assign correct shape position unless already set\n\n  this.preExecute('shape.append', function(context) {\n\n    var source = context.source,\n        shape = context.shape;\n\n    if (!context.position) {\n\n      if (is(shape, 'bpmn:TextAnnotation')) {\n        context.position = {\n          x: source.x + source.width / 2 + 75,\n          y: source.y - (50) - shape.height / 2\n        };\n      } else {\n        context.position = {\n          x: source.x + source.width + 80 + shape.width / 2,\n          y: source.y + source.height / 2\n        };\n      }\n    }\n  }, true);\n}\n\ninherits(AppendBehavior, CommandInterceptor);\n\nAppendBehavior.$inject = [\n  'eventBus',\n  'elementFactory',\n  'bpmnRules'\n];","import inherits from 'inherits';\n\nimport CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';\n\nimport { is } from '../../../util/ModelUtil';\n\nimport {\n  filter,\n  forEach\n} from 'min-dash';\n\n\n/**\n * BPMN specific boundary event behavior\n */\nexport default function BoundaryEventBehavior(eventBus, modeling) {\n\n  CommandInterceptor.call(this, eventBus);\n\n  function getBoundaryEvents(element) {\n    return filter(element.attachers, function(attacher) {\n      return is(attacher, 'bpmn:BoundaryEvent');\n    });\n  }\n\n  // remove after connecting to event-based gateway\n  this.postExecute('connection.create', function(event) {\n    var source = event.context.source,\n        target = event.context.target,\n        boundaryEvents = getBoundaryEvents(target);\n\n    if (\n      is(source, 'bpmn:EventBasedGateway') &&\n      is(target, 'bpmn:ReceiveTask') &&\n      boundaryEvents.length > 0\n    ) {\n      modeling.removeElements(boundaryEvents);\n    }\n\n  });\n\n  // remove after replacing connected gateway with event-based gateway\n  this.postExecute('connection.reconnectStart', function(event) {\n    var oldSource = event.context.oldSource,\n        newSource = event.context.newSource;\n\n    if (is(oldSource, 'bpmn:Gateway') &&\n        is(newSource, 'bpmn:EventBasedGateway')) {\n      forEach(newSource.outgoing, function(connection) {\n        var target = connection.target,\n            attachedboundaryEvents = getBoundaryEvents(target);\n\n        if (is(target, 'bpmn:ReceiveTask') &&\n            attachedboundaryEvents.length > 0) {\n          modeling.removeElements(attachedboundaryEvents);\n        }\n      });\n    }\n  });\n}\n\nBoundaryEventBehavior.$inject = [\n  'eventBus',\n  'modeling'\n];\n\ninherits(BoundaryEventBehavior, CommandInterceptor);\n","import inherits from 'inherits';\n\nimport {\n  forEach\n} from 'min-dash';\n\nimport { is } from '../../../util/ModelUtil';\n\nimport CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';\n\n\nexport default function CopyPasteBehavior(eventBus, modeling, canvas) {\n\n  CommandInterceptor.call(this, eventBus);\n\n  this.preExecute('elements.paste', 1500, function(context) {\n    var topParent = context.topParent;\n\n    // always grab the latest root\n    if (!topParent.parent) {\n      context.topParent = canvas.getRootElement();\n    }\n\n    if (is(topParent, 'bpmn:Lane')) {\n      do {\n        // unwrap Lane -> LaneSet -> (Lane | FlowElementsContainer)\n        topParent = context.topParent = topParent.parent;\n\n      } while (is(topParent, 'bpmn:Lane') || !is(topParent, 'bpmn:Participant'));\n    }\n  }, true);\n\n  this.postExecute('elements.paste', function(context) {\n\n    var tree = context.tree,\n        createdElements = tree.createdElements;\n\n    forEach(createdElements, function(data) {\n      var element = data.element,\n          businessObject = element.businessObject,\n          descriptor = data.descriptor,\n          defaultFlow;\n\n      if ((is(businessObject, 'bpmn:ExclusiveGateway') || is(businessObject, 'bpmn:InclusiveGateway') ||\n           is(businessObject, 'bpmn:Activity')) && descriptor.default) {\n\n        defaultFlow = createdElements[descriptor.default];\n\n        // if the default flow wasn't created, means that it wasn't copied\n        if (defaultFlow) {\n          defaultFlow = defaultFlow.element;\n        } else {\n          defaultFlow = undefined;\n        }\n\n        delete element.default;\n\n        modeling.updateProperties(element, { default: defaultFlow });\n      }\n    });\n  }, true);\n}\n\n\nCopyPasteBehavior.$inject = [\n  'eventBus',\n  'modeling',\n  'canvas'\n];\n\ninherits(CopyPasteBehavior, CommandInterceptor);","import inherits from 'inherits';\n\nimport CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';\n\nimport { is } from '../../../util/ModelUtil';\n\n\n/**\n * BPMN specific create boundary event behavior\n */\nexport default function CreateBoundaryEventBehavior(\n    eventBus, modeling, elementFactory,\n    bpmnFactory) {\n\n  CommandInterceptor.call(this, eventBus);\n\n  /**\n   * replace intermediate event with boundary event when\n   * attaching it to a shape\n   */\n\n  this.preExecute('shape.create', function(context) {\n    var shape = context.shape,\n        host = context.host,\n        businessObject,\n        boundaryEvent;\n\n    var attrs = {\n      cancelActivity: true\n    };\n\n    if (host && is(shape, 'bpmn:IntermediateThrowEvent')) {\n      attrs.attachedToRef = host.businessObject;\n\n      businessObject = bpmnFactory.create('bpmn:BoundaryEvent', attrs);\n\n      boundaryEvent = {\n        type: 'bpmn:BoundaryEvent',\n        businessObject: businessObject\n      };\n\n      context.shape = elementFactory.createShape(boundaryEvent);\n    }\n  }, true);\n}\n\nCreateBoundaryEventBehavior.$inject = [\n  'eventBus',\n  'modeling',\n  'elementFactory',\n  'bpmnFactory'\n];\n\ninherits(CreateBoundaryEventBehavior, CommandInterceptor);\n","import inherits from 'inherits';\n\nimport CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';\n\nimport { is } from '../../../util/ModelUtil';\n\n\n/**\n * BPMN specific create data object behavior\n */\nexport default function CreateDataObjectBehavior(eventBus, bpmnFactory, moddle) {\n\n  CommandInterceptor.call(this, eventBus);\n\n  this.preExecute('shape.create', function(event) {\n\n    var context = event.context,\n        shape = context.shape;\n\n    if (is(shape, 'bpmn:DataObjectReference') && shape.type !== 'label') {\n\n      // create a DataObject every time a DataObjectReference is created\n      var dataObject = bpmnFactory.create('bpmn:DataObject');\n\n      // set the reference to the DataObject\n      shape.businessObject.dataObjectRef = dataObject;\n    }\n  });\n\n}\n\nCreateDataObjectBehavior.$inject = [\n  'eventBus',\n  'bpmnFactory',\n  'moddle'\n];\n\ninherits(CreateDataObjectBehavior, CommandInterceptor);","import inherits from 'inherits';\n\nimport CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';\n\nimport { is } from '../../../util/ModelUtil';\n\n\n/**\n * BPMN specific create participant behavior\n */\nexport default function CreateParticipantBehavior(\n    eventBus, modeling, elementFactory,\n    bpmnFactory, canvas) {\n\n  CommandInterceptor.call(this, eventBus);\n\n  /**\n   * morph process into collaboration before adding\n   * participant onto collaboration\n   */\n\n  this.preExecute('shape.create', function(context) {\n\n    var parent = context.parent,\n        shape = context.shape,\n        position = context.position;\n\n    var rootElement = canvas.getRootElement();\n\n    if (\n      is(parent, 'bpmn:Process') &&\n      is(shape, 'bpmn:Participant') &&\n      !is(rootElement, 'bpmn:Collaboration')\n    ) {\n\n      // this is going to detach the process root\n      // and set the returned collaboration element\n      // as the new root element\n      var collaborationElement = modeling.makeCollaboration();\n\n      // monkey patch the create context\n      // so that the participant is being dropped\n      // onto the new collaboration root instead\n      context.position = position;\n      context.parent = collaborationElement;\n\n      context.processRoot = parent;\n    }\n  }, true);\n\n\n  this.execute('shape.create', function(context) {\n\n    var processRoot = context.processRoot,\n        shape = context.shape;\n\n    if (processRoot) {\n      context.oldProcessRef = shape.businessObject.processRef;\n\n      // assign the participant processRef\n      shape.businessObject.processRef = processRoot.businessObject;\n    }\n  }, true);\n\n\n  this.revert('shape.create', function(context) {\n    var processRoot = context.processRoot,\n        shape = context.shape;\n\n    if (processRoot) {\n      // assign the participant processRef\n      shape.businessObject.processRef = context.oldProcessRef;\n    }\n  }, true);\n\n\n  this.postExecute('shape.create', function(context) {\n\n    var processRoot = context.processRoot,\n        shape = context.shape;\n\n    if (processRoot) {\n      // process root is already detached at this point\n      var processChildren = processRoot.children.slice();\n      modeling.moveElements(processChildren, { x: 0, y: 0 }, shape);\n    }\n\n  }, true);\n\n}\n\nCreateParticipantBehavior.$inject = [\n  'eventBus',\n  'modeling',\n  'elementFactory',\n  'bpmnFactory',\n  'canvas'\n];\n\ninherits(CreateParticipantBehavior, CommandInterceptor);","import inherits from 'inherits';\n\nimport CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';\n\nimport {\n  add as collectionAdd,\n  remove as collectionRemove\n} from 'diagram-js/lib/util/Collections';\n\nimport {\n  find\n} from 'min-dash';\n\nimport {\n  is\n} from '../../../util/ModelUtil';\n\nvar TARGET_REF_PLACEHOLDER_NAME = '__targetRef_placeholder';\n\n\n/**\n * This behavior makes sure we always set a fake\n * DataInputAssociation#targetRef as demanded by the BPMN 2.0\n * XSD schema.\n *\n * The reference is set to a bpmn:Property{ name: '__targetRef_placeholder' }\n * which is created on the fly and cleaned up afterwards if not needed\n * anymore.\n *\n * @param {EventBus} eventBus\n * @param {BpmnFactory} bpmnFactory\n */\nexport default function DataInputAssociationBehavior(eventBus, bpmnFactory) {\n\n  CommandInterceptor.call(this, eventBus);\n\n\n  this.executed([\n    'connection.create',\n    'connection.delete',\n    'connection.move',\n    'connection.reconnectEnd'\n  ], ifDataInputAssociation(fixTargetRef));\n\n  this.reverted([\n    'connection.create',\n    'connection.delete',\n    'connection.move',\n    'connection.reconnectEnd'\n  ], ifDataInputAssociation(fixTargetRef));\n\n\n  function usesTargetRef(element, targetRef, removedConnection) {\n\n    var inputAssociations = element.get('dataInputAssociations');\n\n    return find(inputAssociations, function(association) {\n      return association !== removedConnection &&\n             association.targetRef === targetRef;\n    });\n  }\n\n  function getTargetRef(element, create) {\n\n    var properties = element.get('properties');\n\n    var targetRefProp = find(properties, function(p) {\n      return p.name === TARGET_REF_PLACEHOLDER_NAME;\n    });\n\n    if (!targetRefProp && create) {\n      targetRefProp = bpmnFactory.create('bpmn:Property', {\n        name: TARGET_REF_PLACEHOLDER_NAME\n      });\n\n      collectionAdd(properties, targetRefProp);\n    }\n\n    return targetRefProp;\n  }\n\n  function cleanupTargetRef(element, connection) {\n\n    var targetRefProp = getTargetRef(element);\n\n    if (!targetRefProp) {\n      return;\n    }\n\n    if (!usesTargetRef(element, targetRefProp, connection)) {\n      collectionRemove(element.get('properties'), targetRefProp);\n    }\n  }\n\n  /**\n   * Make sure targetRef is set to a valid property or\n   * `null` if the connection is detached.\n   *\n   * @param {Event} event\n   */\n  function fixTargetRef(event) {\n\n    var context = event.context,\n        connection = context.connection,\n        connectionBo = connection.businessObject,\n        target = connection.target,\n        targetBo = target && target.businessObject,\n        newTarget = context.newTarget,\n        newTargetBo = newTarget && newTarget.businessObject,\n        oldTarget = context.oldTarget || context.target,\n        oldTargetBo = oldTarget && oldTarget.businessObject;\n\n    var dataAssociation = connection.businessObject,\n        targetRefProp;\n\n    if (oldTargetBo && oldTargetBo !== targetBo) {\n      cleanupTargetRef(oldTargetBo, connectionBo);\n    }\n\n    if (newTargetBo && newTargetBo !== targetBo) {\n      cleanupTargetRef(newTargetBo, connectionBo);\n    }\n\n    if (targetBo) {\n      targetRefProp = getTargetRef(targetBo, true);\n      dataAssociation.targetRef = targetRefProp;\n    } else {\n      dataAssociation.targetRef = null;\n    }\n  }\n}\n\nDataInputAssociationBehavior.$inject = [\n  'eventBus',\n  'bpmnFactory'\n];\n\ninherits(DataInputAssociationBehavior, CommandInterceptor);\n\n\n/**\n * Only call the given function when the event\n * touches a bpmn:DataInputAssociation.\n *\n * @param {Function} fn\n * @return {Function}\n */\nfunction ifDataInputAssociation(fn) {\n\n  return function(event) {\n    var context = event.context,\n        connection = context.connection;\n\n    if (is(connection, 'bpmn:DataInputAssociation')) {\n      return fn(event);\n    }\n  };\n}","import inherits from 'inherits';\r\n\r\nimport CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';\r\n\r\nimport { is } from '../../../util/ModelUtil';\r\n\r\nimport { isAny } from '../util/ModelingUtil';\r\n\r\nimport UpdateSemanticParentHandler from '../cmd/UpdateSemanticParentHandler';\r\n\r\n\r\n/**\r\n * BPMN specific data store behavior\r\n */\r\nexport default function DataStoreBehavior(\r\n    canvas, commandStack, elementRegistry,\r\n    eventBus) {\r\n\r\n  CommandInterceptor.call(this, eventBus);\r\n\r\n  commandStack.registerHandler('dataStore.updateContainment', UpdateSemanticParentHandler);\r\n\r\n  function getFirstParticipant() {\r\n    return elementRegistry.filter(function(element) {\r\n      return is(element, 'bpmn:Participant');\r\n    })[0];\r\n  }\r\n\r\n  function getDataStores(element) {\r\n    return element.children.filter(function(child) {\r\n      return is(child, 'bpmn:DataStoreReference') && !child.labelTarget;\r\n    });\r\n  }\r\n\r\n  function updateDataStoreParent(dataStore, newDataStoreParent) {\r\n    var dataStoreBo = dataStore.businessObject || dataStore;\r\n\r\n    newDataStoreParent = newDataStoreParent || getFirstParticipant();\r\n\r\n    if (newDataStoreParent) {\r\n      var newDataStoreParentBo = newDataStoreParent.businessObject || newDataStoreParent;\r\n\r\n      commandStack.execute('dataStore.updateContainment', {\r\n        dataStoreBo: dataStoreBo,\r\n        newSemanticParent: newDataStoreParentBo.processRef || newDataStoreParentBo,\r\n        newDiParent: newDataStoreParentBo.di\r\n      });\r\n    }\r\n  }\r\n\r\n\r\n  // disable auto-resize for data stores\r\n  this.preExecute('shape.create', function(event) {\r\n\r\n    var context = event.context,\r\n        shape = context.shape;\r\n\r\n    if (is(shape, 'bpmn:DataStoreReference') &&\r\n        shape.type !== 'label') {\r\n\r\n      if (!context.hints) {\r\n        context.hints = {};\r\n      }\r\n\r\n      // prevent auto resizing\r\n      context.hints.autoResize = false;\r\n    }\r\n  });\r\n\r\n\r\n  // disable auto-resize for data stores\r\n  this.preExecute('elements.move', function(event) {\r\n    var context = event.context,\r\n        shapes = context.shapes;\r\n\r\n    var dataStoreReferences = shapes.filter(function(shape) {\r\n      return is(shape, 'bpmn:DataStoreReference');\r\n    });\r\n\r\n    if (dataStoreReferences.length) {\r\n      if (!context.hints) {\r\n        context.hints = {};\r\n      }\r\n\r\n      // prevent auto resizing for data store references\r\n      context.hints.autoResize = shapes.filter(function(shape) {\r\n        return !is(shape, 'bpmn:DataStoreReference');\r\n      });\r\n    }\r\n  });\r\n\r\n\r\n  // update parent on data store created\r\n  this.postExecute('shape.create', function(event) {\r\n    var context = event.context,\r\n        shape = context.shape,\r\n        parent = shape.parent;\r\n\r\n\r\n    if (is(shape, 'bpmn:DataStoreReference') &&\r\n        shape.type !== 'label' &&\r\n        is(parent, 'bpmn:Collaboration')) {\r\n\r\n      updateDataStoreParent(shape);\r\n    }\r\n  });\r\n\r\n\r\n  // update parent on data store moved\r\n  this.postExecute('shape.move', function(event) {\r\n    var context = event.context,\r\n        shape = context.shape,\r\n        oldParent = context.oldParent,\r\n        parent = shape.parent;\r\n\r\n    if (is(oldParent, 'bpmn:Collaboration')) {\r\n\r\n      // do nothing if not necessary\r\n      return;\r\n    }\r\n\r\n    if (is(shape, 'bpmn:DataStoreReference') &&\r\n        shape.type !== 'label' &&\r\n        is(parent, 'bpmn:Collaboration')) {\r\n\r\n      var participant = is(oldParent, 'bpmn:Participant') ?\r\n        oldParent :\r\n        getAncestor(oldParent, 'bpmn:Participant');\r\n\r\n      updateDataStoreParent(shape, participant);\r\n    }\r\n  });\r\n\r\n\r\n  // update data store parents on participant or subprocess deleted\r\n  this.postExecute('shape.delete', function(event) {\r\n    var context = event.context,\r\n        shape = context.shape,\r\n        rootElement = canvas.getRootElement();\r\n\r\n    if (isAny(shape, [ 'bpmn:Participant', 'bpmn:SubProcess' ])\r\n        && is(rootElement, 'bpmn:Collaboration')) {\r\n      getDataStores(rootElement)\r\n        .filter(function(dataStore) {\r\n          return isDescendant(dataStore, shape);\r\n        })\r\n        .forEach(function(dataStore) {\r\n          updateDataStoreParent(dataStore);\r\n        });\r\n    }\r\n  });\r\n\r\n  // update data store parents on collaboration -> process\r\n  this.postExecute('canvas.updateRoot', function(event) {\r\n    var context = event.context,\r\n        oldRoot = context.oldRoot,\r\n        newRoot = context.newRoot;\r\n\r\n    var dataStores = getDataStores(oldRoot);\r\n\r\n    dataStores.forEach(function(dataStore) {\r\n\r\n      if (is(newRoot, 'bpmn:Process')) {\r\n        updateDataStoreParent(dataStore, newRoot);\r\n      }\r\n\r\n    });\r\n  });\r\n}\r\n\r\nDataStoreBehavior.$inject = [\r\n  'canvas',\r\n  'commandStack',\r\n  'elementRegistry',\r\n  'eventBus',\r\n];\r\n\r\ninherits(DataStoreBehavior, CommandInterceptor);\r\n\r\n\r\n// helpers //////////\r\n\r\nfunction isDescendant(descendant, ancestor) {\r\n  var descendantBo = descendant.businessObject || descendant,\r\n      ancestorBo = ancestor.businessObject || ancestor;\r\n\r\n  while (descendantBo.$parent) {\r\n    if (descendantBo.$parent === ancestorBo.processRef || ancestorBo) {\r\n      return true;\r\n    }\r\n\r\n    descendantBo = descendantBo.$parent;\r\n  }\r\n\r\n  return false;\r\n}\r\n\r\nfunction getAncestor(element, type) {\r\n\r\n  while (element.parent) {\r\n    if (is(element.parent, type)) {\r\n      return element.parent;\r\n    }\r\n\r\n    element = element.parent;\r\n  }\r\n}","import inherits from 'inherits';\n\nimport CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';\n\nimport { is } from '../../../util/ModelUtil';\n\nimport {\n  getChildLanes\n} from '../util/LaneUtil';\n\nimport {\n  eachElement\n} from 'diagram-js/lib/util/Elements';\n\n\nvar LOW_PRIORITY = 500;\n\n\n/**\n * BPMN specific delete lane behavior\n */\nexport default function DeleteLaneBehavior(eventBus, modeling, spaceTool) {\n\n  CommandInterceptor.call(this, eventBus);\n\n\n  function compensateLaneDelete(shape, oldParent) {\n\n    var siblings = getChildLanes(oldParent);\n\n    var topAffected = [];\n    var bottomAffected = [];\n\n    eachElement(siblings, function(element) {\n\n      if (element.y > shape.y) {\n        bottomAffected.push(element);\n      } else {\n        topAffected.push(element);\n      }\n\n      return element.children;\n    });\n\n    if (!siblings.length) {\n      return;\n    }\n\n    var offset;\n\n    if (bottomAffected.length && topAffected.length) {\n      offset = shape.height / 2;\n    } else {\n      offset = shape.height;\n    }\n\n    var topAdjustments,\n        bottomAdjustments;\n\n    if (topAffected.length) {\n      topAdjustments = spaceTool.calculateAdjustments(\n        topAffected, 'y', offset, shape.y - 10);\n\n      spaceTool.makeSpace(\n        topAdjustments.movingShapes,\n        topAdjustments.resizingShapes,\n        { x: 0, y: offset }, 's');\n    }\n\n    if (bottomAffected.length) {\n      bottomAdjustments = spaceTool.calculateAdjustments(\n        bottomAffected, 'y', -offset, shape.y + shape.height + 10);\n\n      spaceTool.makeSpace(\n        bottomAdjustments.movingShapes,\n        bottomAdjustments.resizingShapes,\n        { x: 0, y: -offset }, 'n');\n    }\n  }\n\n\n  /**\n   * Adjust sizes of other lanes after lane deletion\n   */\n  this.postExecuted('shape.delete', LOW_PRIORITY, function(event) {\n\n    var context = event.context,\n        hints = context.hints,\n        shape = context.shape,\n        oldParent = context.oldParent;\n\n    // only compensate lane deletes\n    if (!is(shape, 'bpmn:Lane')) {\n      return;\n    }\n\n    // compensate root deletes only\n    if (hints && hints.nested) {\n      return;\n    }\n\n    compensateLaneDelete(shape, oldParent);\n  });\n}\n\nDeleteLaneBehavior.$inject = [\n  'eventBus',\n  'modeling',\n  'spaceTool'\n];\n\ninherits(DeleteLaneBehavior, CommandInterceptor);","import inherits from 'inherits';\n\nimport {\n  assign,\n  find,\n  filter\n} from 'min-dash';\n\nimport CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';\n\nimport {\n  getApproxIntersection\n} from 'diagram-js/lib/util/LineIntersection';\n\n\nexport default function DropOnFlowBehavior(eventBus, bpmnRules, modeling) {\n\n  CommandInterceptor.call(this, eventBus);\n\n  /**\n   * Reconnect start / end of a connection after\n   * dropping an element on a flow.\n   */\n\n  function insertShape(shape, targetFlow, position) {\n    var waypoints = targetFlow.waypoints,\n        waypointsBefore,\n        waypointsAfter,\n        dockingPoint,\n        source,\n        target,\n        incomingConnection,\n        outgoingConnection,\n        oldOutgoing = shape.outgoing.slice(),\n        oldIncoming = shape.incoming.slice();\n\n    var intersection = getApproxIntersection(waypoints, position);\n\n    if (intersection) {\n      waypointsBefore = waypoints.slice(0, intersection.index);\n      waypointsAfter = waypoints.slice(intersection.index + (intersection.bendpoint ? 1 : 0));\n\n      // due to inaccuracy intersection might have been found\n      if (!waypointsBefore.length || !waypointsAfter.length) {\n        return;\n      }\n\n      dockingPoint = intersection.bendpoint ? waypoints[intersection.index] : position;\n\n      // if last waypointBefore is inside shape's bounds, ignore docking point\n      if (!isPointInsideBBox(shape, waypointsBefore[waypointsBefore.length-1])) {\n        waypointsBefore.push(copy(dockingPoint));\n      }\n\n      // if first waypointAfter is inside shape's bounds, ignore docking point\n      if (!isPointInsideBBox(shape, waypointsAfter[0])) {\n        waypointsAfter.unshift(copy(dockingPoint));\n      }\n    }\n\n    source = targetFlow.source;\n    target = targetFlow.target;\n\n    if (bpmnRules.canConnect(source, shape, targetFlow)) {\n      // reconnect source -> inserted shape\n      modeling.reconnectEnd(targetFlow, shape, waypointsBefore || position);\n\n      incomingConnection = targetFlow;\n    }\n\n    if (bpmnRules.canConnect(shape, target, targetFlow)) {\n\n      if (!incomingConnection) {\n        // reconnect inserted shape -> end\n        modeling.reconnectStart(targetFlow, shape, waypointsAfter || position);\n\n        outgoingConnection = targetFlow;\n      } else {\n        outgoingConnection = modeling.connect(\n          shape, target, { type: targetFlow.type, waypoints: waypointsAfter }\n        );\n      }\n    }\n\n    var duplicateConnections = [].concat(\n\n      incomingConnection && filter(oldIncoming, function(connection) {\n        return connection.source === incomingConnection.source;\n      }) || [],\n\n      outgoingConnection && filter(oldOutgoing, function(connection) {\n        return connection.source === outgoingConnection.source;\n      }) || []\n    );\n\n    if (duplicateConnections.length) {\n      modeling.removeElements(duplicateConnections);\n    }\n  }\n\n  this.preExecute('elements.move', function(context) {\n\n    var newParent = context.newParent,\n        shapes = context.shapes,\n        delta = context.delta,\n        shape = shapes[0];\n\n    if (!shape || !newParent) {\n      return;\n    }\n\n    // if the new parent is a connection,\n    // change it to the new parent's parent\n    if (newParent && newParent.waypoints) {\n      context.newParent = newParent = newParent.parent;\n    }\n\n    var shapeMid = getMid(shape);\n    var newShapeMid = {\n      x: shapeMid.x + delta.x,\n      y: shapeMid.y + delta.y\n    };\n\n    // find a connection which intersects with the\n    // element's mid point\n    var connection = find(newParent.children, function(element) {\n      var canInsert = bpmnRules.canInsert(shapes, element);\n\n      return canInsert && getApproxIntersection(element.waypoints, newShapeMid);\n    });\n\n    if (connection) {\n      context.targetFlow = connection;\n      context.position = newShapeMid;\n    }\n\n  }, true);\n\n  this.postExecuted('elements.move', function(context) {\n\n    var shapes = context.shapes,\n        targetFlow = context.targetFlow,\n        position = context.position;\n\n    if (targetFlow) {\n      insertShape(shapes[0], targetFlow, position);\n    }\n\n  }, true);\n\n  this.preExecute('shape.create', function(context) {\n\n    var parent = context.parent,\n        shape = context.shape;\n\n    if (bpmnRules.canInsert(shape, parent)) {\n      context.targetFlow = parent;\n      context.parent = parent.parent;\n    }\n  }, true);\n\n  this.postExecuted('shape.create', function(context) {\n\n    var shape = context.shape,\n        targetFlow = context.targetFlow,\n        position = context.position;\n\n    if (targetFlow) {\n      insertShape(shape, targetFlow, position);\n    }\n  }, true);\n}\n\ninherits(DropOnFlowBehavior, CommandInterceptor);\n\nDropOnFlowBehavior.$inject = [\n  'eventBus',\n  'bpmnRules',\n  'modeling'\n];\n\n\n// helpers /////////////////////\n\nfunction isPointInsideBBox(bbox, point) {\n  var x = point.x,\n      y = point.y;\n\n  return x >= bbox.x &&\n    x <= bbox.x + bbox.width &&\n    y >= bbox.y &&\n    y <= bbox.y + bbox.height;\n}\n\nfunction copy(obj) {\n  return assign({}, obj);\n}\n\nfunction getMid(bounds) {\n\n  return {\n    x: Math.round(bounds.x + bounds.width / 2),\n    y: Math.round(bounds.y + bounds.height / 2)\n  };\n}\n\n","import {\n  getMid\n} from 'diagram-js/lib/layout/LayoutUtil';\n\nimport lineIntersect from './util/LineIntersect';\n\n\n/**\n * Fix broken dockings after DI imports.\n *\n * @param {EventBus} eventBus\n */\nexport default function ImportDockingFix(eventBus) {\n\n  function adjustDocking(startPoint, nextPoint, elementMid) {\n\n    var elementTop = {\n      x: elementMid.x,\n      y: elementMid.y - 50\n    };\n\n    var elementLeft = {\n      x: elementMid.x - 50,\n      y: elementMid.y\n    };\n\n    var verticalIntersect = lineIntersect(startPoint, nextPoint, elementMid, elementTop),\n        horizontalIntersect = lineIntersect(startPoint, nextPoint, elementMid, elementLeft);\n\n    // original is horizontal or vertical center cross intersection\n    var centerIntersect;\n\n    if (verticalIntersect && horizontalIntersect) {\n      if (getDistance(verticalIntersect, elementMid) > getDistance(horizontalIntersect, elementMid)) {\n        centerIntersect = horizontalIntersect;\n      } else {\n        centerIntersect = verticalIntersect;\n      }\n    } else {\n      centerIntersect = verticalIntersect || horizontalIntersect;\n    }\n\n    startPoint.original = centerIntersect;\n  }\n\n  function fixDockings(connection) {\n    var waypoints = connection.waypoints;\n\n    adjustDocking(\n      waypoints[0],\n      waypoints[1],\n      getMid(connection.source)\n    );\n\n    adjustDocking(\n      waypoints[waypoints.length - 1],\n      waypoints[waypoints.length - 2],\n      getMid(connection.target)\n    );\n  }\n\n  eventBus.on('bpmnElement.added', function(e) {\n\n    var element = e.element;\n\n    if (element.waypoints) {\n      fixDockings(element);\n    }\n  });\n}\n\nImportDockingFix.$inject = [\n  'eventBus'\n];\n\n\n// helpers //////////////////////\n\nfunction getDistance(p1, p2) {\n  return Math.sqrt(Math.pow(p1.x - p2.x, 2) + Math.pow(p1.y - p2.y, 2));\n}","import {\n  assign\n} from 'min-dash';\n\nimport inherits from 'inherits';\n\nimport {\n  is,\n  getBusinessObject\n} from '../../../util/ModelUtil';\n\nimport {\n  isLabelExternal,\n  getExternalLabelMid,\n} from '../../../util/LabelUtil';\n\nimport {\n  getLabelAdjustment\n} from './util/LabelLayoutUtil';\n\nimport CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';\n\nvar DEFAULT_LABEL_DIMENSIONS = {\n  width: 90,\n  height: 20\n};\n\nvar NAME_PROPERTY = 'name';\nvar TEXT_PROPERTY = 'text';\n\n/**\n * A component that makes sure that external labels are added\n * together with respective elements and properly updated (DI wise)\n * during move.\n *\n * @param {EventBus} eventBus\n * @param {Modeling} modeling\n * @param {BpmnFactory} bpmnFactory\n * @param {TextRenderer} textRenderer\n */\nexport default function LabelBehavior(\n    eventBus, modeling, bpmnFactory,\n    textRenderer) {\n\n  CommandInterceptor.call(this, eventBus);\n\n  // update label if name property was updated\n  this.postExecute('element.updateProperties', function(e) {\n    var context = e.context,\n        element = context.element,\n        properties = context.properties;\n\n    if (NAME_PROPERTY in properties) {\n      modeling.updateLabel(element, properties[NAME_PROPERTY]);\n    }\n\n    if (TEXT_PROPERTY in properties\n        && is(element, 'bpmn:TextAnnotation')) {\n\n      var newBounds = textRenderer.getTextAnnotationBounds(\n        {\n          x: element.x,\n          y: element.y,\n          width: element.width,\n          height: element.height\n        },\n        properties[TEXT_PROPERTY] || ''\n      );\n\n      modeling.updateLabel(element, properties.text, newBounds);\n    }\n  });\n\n  // create label shape after shape/connection was created\n  this.postExecute([ 'shape.create', 'connection.create' ], function(e) {\n    var context = e.context;\n\n    var element = context.shape || context.connection,\n        businessObject = element.businessObject;\n\n    if (!isLabelExternal(element)) {\n      return;\n    }\n\n    // only create label if name\n    if (!businessObject.name) {\n      return;\n    }\n\n    var labelCenter = getExternalLabelMid(element);\n\n    // we don't care about x and y\n    var labelDimensions = textRenderer.getExternalLabelBounds(\n      DEFAULT_LABEL_DIMENSIONS,\n      businessObject.name || ''\n    );\n\n    modeling.createLabel(element, labelCenter, {\n      id: businessObject.id + '_label',\n      businessObject: businessObject,\n      width: labelDimensions.width,\n      height: labelDimensions.height\n    });\n  });\n\n  // update label after label shape was deleted\n  this.postExecute('shape.delete', function(event) {\n    var context = event.context,\n        labelTarget = context.labelTarget,\n        hints = context.hints || {};\n\n    // check if label\n    if (labelTarget && hints.unsetLabel !== false) {\n      modeling.updateLabel(labelTarget, null, null, { removeShape: false });\n    }\n  });\n\n  // update di information on label creation\n  this.postExecute([ 'label.create' ], function(event) {\n\n    var context = event.context,\n        element = context.shape,\n        businessObject,\n        di;\n\n    // we want to trigger on real labels only\n    if (!element.labelTarget) {\n      return;\n    }\n\n    // we want to trigger on BPMN elements only\n    if (!is(element.labelTarget || element, 'bpmn:BaseElement')) {\n      return;\n    }\n\n    businessObject = element.businessObject,\n    di = businessObject.di;\n\n\n    if (!di.label) {\n      di.label = bpmnFactory.create('bpmndi:BPMNLabel', {\n        bounds: bpmnFactory.create('dc:Bounds')\n      });\n    }\n\n    assign(di.label.bounds, {\n      x: element.x,\n      y: element.y,\n      width: element.width,\n      height: element.height\n    });\n  });\n\n  function getVisibleLabelAdjustment(event) {\n\n    var command = event.command,\n        context = event.context,\n        connection = context.connection,\n        label = connection.label,\n        hints = assign({}, context.hints),\n        newWaypoints = context.newWaypoints || connection.waypoints,\n        oldWaypoints = context.oldWaypoints;\n\n\n    if (typeof hints.startChanged === 'undefined') {\n      hints.startChanged = (command === 'connection.reconnectStart');\n    }\n\n    if (typeof hints.endChanged === 'undefined') {\n      hints.endChanged = (command === 'connection.reconnectEnd');\n    }\n\n    return getLabelAdjustment(label, newWaypoints, oldWaypoints, hints);\n  }\n\n  this.postExecute([\n    'connection.layout',\n    'connection.reconnectEnd',\n    'connection.reconnectStart',\n    'connection.updateWaypoints'\n  ], function(event) {\n\n    var label = event.context.connection.label,\n        labelAdjustment;\n\n    if (!label) {\n      return;\n    }\n\n    labelAdjustment = getVisibleLabelAdjustment(event);\n\n    modeling.moveShape(label, labelAdjustment);\n  });\n\n\n  // keep label position on shape replace\n  this.postExecute([ 'shape.replace' ], function(event) {\n    var context = event.context,\n        newShape = context.newShape,\n        oldShape = context.oldShape;\n\n    var businessObject = getBusinessObject(newShape);\n\n    if (businessObject\n      && isLabelExternal(businessObject)\n      && oldShape.label\n      && newShape.label) {\n      newShape.label.x = oldShape.label.x;\n      newShape.label.y = oldShape.label.y;\n    }\n  });\n\n}\n\ninherits(LabelBehavior, CommandInterceptor);\n\nLabelBehavior.$inject = [\n  'eventBus',\n  'modeling',\n  'bpmnFactory',\n  'textRenderer'\n];","import { is } from '../../../util/ModelUtil';\n\nvar COLLAB_ERR_MSG = 'flow elements must be children of pools/participants',\n    PROCESS_ERR_MSG = 'participants cannot be pasted onto a non-empty process diagram';\n\n\nexport default function ModelingFeedback(eventBus, tooltips, translate) {\n\n  function showError(position, message, timeout) {\n    tooltips.add({\n      position: {\n        x: position.x + 5,\n        y: position.y + 5\n      },\n      type: 'error',\n      timeout: timeout || 2000,\n      html: '<div>' + message + '</div>'\n    });\n  }\n\n  eventBus.on([ 'shape.move.rejected', 'create.rejected' ], function(event) {\n    var context = event.context,\n        shape = context.shape,\n        target = context.target;\n\n    if (is(target, 'bpmn:Collaboration') && is(shape, 'bpmn:FlowNode')) {\n      showError(event, translate(COLLAB_ERR_MSG));\n    }\n  });\n\n  eventBus.on([ 'elements.paste.rejected' ], function(event) {\n    var context = event.context,\n        position = context.position,\n        target = context.target;\n\n    if (is(target, 'bpmn:Collaboration')) {\n      showError(position, translate(COLLAB_ERR_MSG));\n    }\n\n    if (is(target, 'bpmn:Process')) {\n      showError(position, translate(PROCESS_ERR_MSG), 3000);\n    }\n  });\n}\n\nModelingFeedback.$inject = [\n  'eventBus',\n  'tooltips',\n  'translate'\n];\n","import inherits from 'inherits';\n\nimport { is } from '../../../util/ModelUtil';\n\nimport CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';\n\nimport lineIntersect from './util/LineIntersect';\n\n\nexport default function RemoveElementBehavior(eventBus, bpmnRules, modeling) {\n\n  CommandInterceptor.call(this, eventBus);\n\n  /**\n   * Combine sequence flows when deleting an element\n   * if there is one incoming and one outgoing\n   * sequence flow\n   */\n  this.preExecute('shape.delete', function(e) {\n\n    var shape = e.context.shape;\n\n    // only handle [a] -> [shape] -> [b] patterns\n    if (shape.incoming.length !== 1 || shape.outgoing.length !== 1) {\n      return;\n    }\n\n    var inConnection = shape.incoming[0],\n        outConnection = shape.outgoing[0];\n\n    // only handle sequence flows\n    if (!is(inConnection, 'bpmn:SequenceFlow') || !is(outConnection, 'bpmn:SequenceFlow')) {\n      return;\n    }\n\n    if (bpmnRules.canConnect(inConnection.source, outConnection.target, inConnection)) {\n\n      // compute new, combined waypoints\n      var newWaypoints = getNewWaypoints(inConnection.waypoints, outConnection.waypoints);\n\n      modeling.reconnectEnd(inConnection, outConnection.target, newWaypoints);\n    }\n  });\n\n}\n\ninherits(RemoveElementBehavior, CommandInterceptor);\n\nRemoveElementBehavior.$inject = [\n  'eventBus',\n  'bpmnRules',\n  'modeling'\n];\n\n\n// helpers //////////////////////\n\nfunction getDocking(point) {\n  return point.original || point;\n}\n\n\nfunction getNewWaypoints(inWaypoints, outWaypoints) {\n\n  var intersection = lineIntersect(\n    getDocking(inWaypoints[inWaypoints.length - 2]),\n    getDocking(inWaypoints[inWaypoints.length - 1]),\n    getDocking(outWaypoints[1]),\n    getDocking(outWaypoints[0]));\n\n  if (intersection) {\n    return [].concat(\n      inWaypoints.slice(0, inWaypoints.length - 1),\n      [ intersection ],\n      outWaypoints.slice(1));\n  } else {\n    return [\n      getDocking(inWaypoints[0]),\n      getDocking(outWaypoints[outWaypoints.length - 1])\n    ];\n  }\n}","import inherits from 'inherits';\n\nimport CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';\n\nimport { is } from '../../../util/ModelUtil';\n\n\n/**\n * BPMN specific remove behavior\n */\nexport default function RemoveParticipantBehavior(eventBus, modeling) {\n\n  CommandInterceptor.call(this, eventBus);\n\n\n  /**\n   * morph collaboration diagram into process diagram\n   * after the last participant has been removed\n   */\n\n  this.preExecute('shape.delete', function(context) {\n\n    var shape = context.shape,\n        parent = shape.parent;\n\n    // activate the behavior if the shape to be removed\n    // is a participant\n    if (is(shape, 'bpmn:Participant')) {\n      context.collaborationRoot = parent;\n    }\n  }, true);\n\n  this.postExecute('shape.delete', function(context) {\n\n    var collaborationRoot = context.collaborationRoot;\n\n    if (collaborationRoot && !collaborationRoot.businessObject.participants.length) {\n      // replace empty collaboration with process diagram\n      modeling.makeProcess();\n    }\n  }, true);\n\n}\n\nRemoveParticipantBehavior.$inject = [ 'eventBus', 'modeling' ];\n\ninherits(RemoveParticipantBehavior, CommandInterceptor);","import {\n  forEach,\n  find,\n  matchPattern\n} from 'min-dash';\n\nimport inherits from 'inherits';\n\nimport CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';\n\nimport { is } from '../../../util/ModelUtil';\n\n\nexport default function ReplaceConnectionBehavior(eventBus, modeling, bpmnRules) {\n\n  CommandInterceptor.call(this, eventBus);\n\n  function fixConnection(connection) {\n\n    var source = connection.source,\n        target = connection.target,\n        parent = connection.parent;\n\n    // do not do anything if connection\n    // is already deleted (may happen due to other\n    // behaviors plugged-in before)\n    if (!parent) {\n      return;\n    }\n\n    var replacementType,\n        remove;\n\n    /**\n     * Check if incoming or outgoing connections\n     * can stay or could be substituted with an\n     * appropriate replacement.\n     *\n     * This holds true for SequenceFlow <> MessageFlow.\n     */\n\n    if (is(connection, 'bpmn:SequenceFlow')) {\n      if (!bpmnRules.canConnectSequenceFlow(source, target)) {\n        remove = true;\n      }\n\n      if (bpmnRules.canConnectMessageFlow(source, target)) {\n        replacementType = 'bpmn:MessageFlow';\n      }\n    }\n\n    // transform message flows into sequence flows, if possible\n\n    if (is(connection, 'bpmn:MessageFlow')) {\n\n      if (!bpmnRules.canConnectMessageFlow(source, target)) {\n        remove = true;\n      }\n\n      if (bpmnRules.canConnectSequenceFlow(source, target)) {\n        replacementType = 'bpmn:SequenceFlow';\n      }\n    }\n\n    if (is(connection, 'bpmn:Association') && !bpmnRules.canConnectAssociation(source, target)) {\n      remove = true;\n    }\n\n\n    // remove invalid connection,\n    // unless it has been removed already\n    if (remove) {\n      modeling.removeConnection(connection);\n    }\n\n    // replace SequenceFlow <> MessageFlow\n\n    if (replacementType) {\n      modeling.connect(source, target, {\n        type: replacementType,\n        waypoints: connection.waypoints.slice()\n      });\n    }\n  }\n\n  this.postExecuted('elements.move', function(context) {\n\n    var closure = context.closure,\n        allConnections = closure.allConnections;\n\n    forEach(allConnections, fixConnection);\n  }, true);\n\n  this.postExecuted([\n    'connection.reconnectStart',\n    'connection.reconnectEnd'\n  ], function(event) {\n\n    var connection = event.context.connection;\n\n    fixConnection(connection);\n  });\n\n  this.postExecuted('element.updateProperties', function(event) {\n    var context = event.context,\n        properties = context.properties,\n        element = context.element,\n        businessObject = element.businessObject,\n        connection;\n\n    // remove condition expression when morphing to default flow\n    if (properties.default) {\n      connection = find(\n        element.outgoing,\n        matchPattern({ id: element.businessObject.default.id })\n      );\n\n      if (connection) {\n        modeling.updateProperties(connection, { conditionExpression: undefined });\n      }\n    }\n\n    // remove default property from source when morphing to conditional flow\n    if (properties.conditionExpression && businessObject.sourceRef.default === businessObject) {\n      modeling.updateProperties(element.source, { default: undefined });\n    }\n  });\n}\n\ninherits(ReplaceConnectionBehavior, CommandInterceptor);\n\nReplaceConnectionBehavior.$inject = [\n  'eventBus',\n  'modeling',\n  'bpmnRules'\n];\n","import inherits from 'inherits';\n\nimport CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';\n\nimport {\n  forEach\n} from 'min-dash';\n\nimport {\n  isEventSubProcess\n} from '../../../util/DiUtil';\n\nimport { is } from '../../../util/ModelUtil';\n\n\n/**\n * Defines the behaviour of what happens to the elements inside a container\n * that morphs into another BPMN element\n */\nexport default function ReplaceElementBehaviour(\n    eventBus, bpmnReplace, bpmnRules,\n    elementRegistry, selection, modeling) {\n\n  CommandInterceptor.call(this, eventBus);\n\n  this._bpmnReplace = bpmnReplace;\n  this._elementRegistry = elementRegistry;\n  this._selection = selection;\n  this._modeling = modeling;\n\n  this.postExecuted([ 'elements.move' ], 500, function(event) {\n\n    var context = event.context,\n        target = context.newParent,\n        newHost = context.newHost,\n        elements = [];\n\n    forEach(context.closure.topLevel, function(topLevelElements) {\n      if (isEventSubProcess(topLevelElements)) {\n        elements = elements.concat(topLevelElements.children);\n      } else {\n        elements = elements.concat(topLevelElements);\n      }\n    });\n\n    // Change target to host when the moving element is a `bpmn:BoundaryEvent`\n    if (elements.length === 1 && newHost) {\n      target = newHost;\n    }\n\n    var canReplace = bpmnRules.canReplace(elements, target);\n\n    if (canReplace) {\n      this.replaceElements(elements, canReplace.replacements, newHost);\n    }\n  }, this);\n\n  // update attachments if the host is replaced\n  this.postExecute([ 'shape.replace' ], 1500, function(e) {\n\n    var context = e.context,\n        oldShape = context.oldShape,\n        newShape = context.newShape,\n        attachers = oldShape.attachers,\n        canReplace;\n\n    if (attachers && attachers.length) {\n      canReplace = bpmnRules.canReplace(attachers, newShape);\n\n      this.replaceElements(attachers, canReplace.replacements);\n    }\n\n  }, this);\n\n  this.postExecuted([ 'shape.replace' ], 1500, function(e) {\n    var context = e.context,\n        oldShape = context.oldShape,\n        newShape = context.newShape;\n\n    modeling.unclaimId(oldShape.businessObject.id, oldShape.businessObject);\n    modeling.updateProperties(newShape, { id: oldShape.id });\n  });\n}\n\ninherits(ReplaceElementBehaviour, CommandInterceptor);\n\n\nReplaceElementBehaviour.prototype.replaceElements = function(elements, newElements, newHost) {\n  var elementRegistry = this._elementRegistry,\n      bpmnReplace = this._bpmnReplace,\n      selection = this._selection,\n      modeling = this._modeling;\n\n  forEach(newElements, function(replacement) {\n\n    var newElement = {\n      type: replacement.newElementType\n    };\n\n    var oldElement = elementRegistry.get(replacement.oldElementId);\n\n    if (newHost && is(oldElement, 'bpmn:BoundaryEvent')) {\n      modeling.updateAttachment(oldElement, null);\n    }\n\n    var idx = elements.indexOf(oldElement);\n\n    elements[idx] = bpmnReplace.replaceElement(oldElement, newElement, { select: false });\n\n    if (newHost && is(elements[idx], 'bpmn:BoundaryEvent')) {\n      modeling.updateAttachment(elements[idx], newHost);\n    }\n  });\n\n  if (newElements) {\n    selection.select(elements);\n  }\n};\n\nReplaceElementBehaviour.$inject = [\n  'eventBus',\n  'bpmnReplace',\n  'bpmnRules',\n  'elementRegistry',\n  'selection',\n  'modeling'\n];\n","import { is } from '../../../util/ModelUtil';\n\nimport {\n  roundBounds\n} from 'diagram-js/lib/layout/LayoutUtil';\n\nimport {\n  hasPrimaryModifier\n} from 'diagram-js/lib/util/Mouse';\n\nvar SLIGHTLY_HIGHER_PRIORITY = 1001;\n\n\n/**\n * Invoke {@link Modeling#resizeLane} instead of\n * {@link Modeling#resizeShape} when resizing a Lane\n * or Participant shape.\n */\nexport default function ResizeLaneBehavior(eventBus, modeling) {\n\n  eventBus.on('resize.start', SLIGHTLY_HIGHER_PRIORITY + 500, function(event) {\n    var context = event.context,\n        shape = context.shape;\n\n    if (is(shape, 'bpmn:Lane') || is(shape, 'bpmn:Participant')) {\n\n      // should we resize the opposite lane(s) in\n      // order to compensate for the resize operation?\n      context.balanced = !hasPrimaryModifier(event);\n    }\n  });\n\n  /**\n   * Intercept resize end and call resize lane function instead.\n   */\n  eventBus.on('resize.end', SLIGHTLY_HIGHER_PRIORITY, function(event) {\n    var context = event.context,\n        shape = context.shape,\n        canExecute = context.canExecute,\n        newBounds = context.newBounds;\n\n    if (is(shape, 'bpmn:Lane') || is(shape, 'bpmn:Participant')) {\n\n      if (canExecute) {\n        // ensure we have actual pixel values for new bounds\n        // (important when zoom level was > 1 during move)\n        newBounds = roundBounds(newBounds);\n\n        // perform the actual resize\n        modeling.resizeLane(shape, newBounds, context.balanced);\n      }\n\n      // stop propagation\n      return false;\n    }\n  });\n}\n\nResizeLaneBehavior.$inject = [\n  'eventBus',\n  'modeling'\n];\n","import inherits from 'inherits';\n\nimport CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';\n\nimport {\n  getBusinessObject,\n  is\n} from '../../../util/ModelUtil';\n\nimport {\n  computeChildrenBBox\n} from 'diagram-js/lib/features/resize/ResizeUtil';\n\n\nvar LOW_PRIORITY = 500;\n\n\nexport default function ToggleElementCollapseBehaviour(\n    eventBus, elementFactory, modeling,\n    resize) {\n\n  CommandInterceptor.call(this, eventBus);\n\n\n  function hideEmptyLables(children) {\n    if (children.length) {\n      children.forEach(function(child) {\n        if (child.type === 'label' && !child.businessObject.name) {\n          child.hidden = true;\n        }\n      });\n    }\n  }\n\n  function expandedBounds(shape, defaultSize) {\n    var children = shape.children,\n        newBounds = defaultSize,\n        visibleElements,\n        visibleBBox;\n\n    visibleElements = filterVisible(children).concat([ shape ]);\n\n    visibleBBox = computeChildrenBBox(visibleElements);\n\n    if (visibleBBox) {\n      // center to visibleBBox with max(defaultSize, childrenBounds)\n      newBounds.width = Math.max(visibleBBox.width, newBounds.width);\n      newBounds.height = Math.max(visibleBBox.height, newBounds.height);\n\n      newBounds.x = visibleBBox.x + (visibleBBox.width - newBounds.width) / 2;\n      newBounds.y = visibleBBox.y + (visibleBBox.height - newBounds.height) / 2;\n    } else {\n      // center to collapsed shape with defaultSize\n      newBounds.x = shape.x + (shape.width - newBounds.width) / 2;\n      newBounds.y = shape.y + (shape.height - newBounds.height) / 2;\n    }\n\n    return newBounds;\n  }\n\n  function collapsedBounds(shape, defaultSize) {\n\n    return {\n      x: shape.x + (shape.width - defaultSize.width) / 2,\n      y: shape.y + (shape.height - defaultSize.height) / 2,\n      width: defaultSize.width,\n      height: defaultSize.height\n    };\n  }\n\n  this.executed([ 'shape.toggleCollapse' ], LOW_PRIORITY, function(e) {\n\n    var context = e.context,\n        shape = context.shape;\n\n    if (!is(shape, 'bpmn:SubProcess')) {\n      return;\n    }\n\n    if (!shape.collapsed) {\n      // all children got made visible through djs, hide empty labels\n      hideEmptyLables(shape.children);\n\n      // remove collapsed marker\n      getBusinessObject(shape).di.isExpanded = true;\n    } else {\n      // place collapsed marker\n      getBusinessObject(shape).di.isExpanded = false;\n    }\n  });\n\n  this.reverted([ 'shape.toggleCollapse' ], LOW_PRIORITY, function(e) {\n\n    var context = e.context;\n    var shape = context.shape;\n\n\n    // revert removing/placing collapsed marker\n    if (!shape.collapsed) {\n      getBusinessObject(shape).di.isExpanded = true;\n\n    } else {\n      getBusinessObject(shape).di.isExpanded = false;\n    }\n  });\n\n  this.postExecuted([ 'shape.toggleCollapse' ], LOW_PRIORITY, function(e) {\n    var shape = e.context.shape,\n        defaultSize = elementFactory._getDefaultSize(shape),\n        newBounds;\n\n    if (shape.collapsed) {\n\n      // resize to default size of collapsed shapes\n      newBounds = collapsedBounds(shape, defaultSize);\n    } else {\n\n      // resize to bounds of max(visible children, defaultSize)\n      newBounds = expandedBounds(shape, defaultSize);\n    }\n\n    modeling.resizeShape(shape, newBounds);\n  });\n\n}\n\n\ninherits(ToggleElementCollapseBehaviour, CommandInterceptor);\n\nToggleElementCollapseBehaviour.$inject = [\n  'eventBus',\n  'elementFactory',\n  'modeling'\n];\n\n\n// helpers //////////////////////\n\nfunction filterVisible(elements) {\n  return elements.filter(function(e) {\n    return !e.hidden;\n  });\n}","import {\n  forEach\n} from 'min-dash';\n\nimport inherits from 'inherits';\n\nimport CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';\n\n\n/**\n * Unclaims model IDs on element deletion.\n *\n * @param {EventBus} eventBus\n * @param {Modeling} modeling\n */\nexport default function UnclaimIdBehavior(eventBus, modeling) {\n\n  CommandInterceptor.call(this, eventBus);\n\n  this.preExecute('elements.delete', function(event) {\n    var context = event.context,\n        elements = context.elements;\n\n    forEach(elements, function(element) {\n      modeling.unclaimId(element.businessObject.id, element.businessObject);\n    });\n\n  });\n}\n\ninherits(UnclaimIdBehavior, CommandInterceptor);\n\nUnclaimIdBehavior.$inject = [ 'eventBus', 'modeling' ];","import inherits from 'inherits';\n\nimport CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';\n\nimport {\n  getBusinessObject,\n  is\n} from '../../../util/ModelUtil';\n\n\n/**\n * A behavior that unsets the Default property of\n * sequence flow source on element delete, if the\n * removed element is the Gateway or Task's default flow.\n *\n * @param {EventBus} eventBus\n * @param {Modeling} modeling\n */\nexport default function DeleteSequenceFlowBehavior(eventBus, modeling) {\n\n  CommandInterceptor.call(this, eventBus);\n\n\n  this.preExecute('connection.delete', function(event) {\n    var context = event.context,\n        connection = context.connection,\n        source = connection.source;\n\n    if (isDefaultFlow(connection, source)) {\n      modeling.updateProperties(source, {\n        'default': null\n      });\n    }\n  });\n}\n\ninherits(DeleteSequenceFlowBehavior, CommandInterceptor);\n\nDeleteSequenceFlowBehavior.$inject = [\n  'eventBus',\n  'modeling'\n];\n\n\n// helpers //////////////////////\n\nfunction isDefaultFlow(connection, source) {\n\n  if (!is(connection, 'bpmn:SequenceFlow')) {\n    return false;\n  }\n\n  var sourceBo = getBusinessObject(source),\n      sequenceFlow = getBusinessObject(connection);\n\n  return sourceBo.get('default') === sequenceFlow;\n}","import inherits from 'inherits';\n\nimport CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';\n\nimport {\n  is\n} from '../../../util/ModelUtil';\n\nvar LOW_PRIORITY = 500,\n    HIGH_PRIORITY = 5000;\n\n\n/**\n * BPMN specific delete lane behavior\n */\nexport default function UpdateFlowNodeRefsBehavior(eventBus, modeling, translate) {\n\n  CommandInterceptor.call(this, eventBus);\n\n  /**\n   * Ok, this is it:\n   *\n   * We have to update the Lane#flowNodeRefs _and_\n   * FlowNode#lanes with every FlowNode move/resize and\n   * Lane move/resize.\n   *\n   * We want to group that stuff to recompute containments\n   * as efficient as possible.\n   *\n   * Yea!\n   */\n\n  // the update context\n  var context;\n\n\n  function initContext() {\n    context = context || new UpdateContext();\n    context.enter();\n\n    return context;\n  }\n\n  function getContext() {\n    if (!context) {\n      throw new Error(translate('out of bounds release'));\n    }\n\n    return context;\n  }\n\n  function releaseContext() {\n\n    if (!context) {\n      throw new Error(translate('out of bounds release'));\n    }\n\n    var triggerUpdate = context.leave();\n\n    if (triggerUpdate) {\n      modeling.updateLaneRefs(context.flowNodes, context.lanes);\n\n      context = null;\n    }\n\n    return triggerUpdate;\n  }\n\n\n  var laneRefUpdateEvents = [\n    'spaceTool',\n    'lane.add',\n    'lane.resize',\n    'lane.split',\n    'elements.move',\n    'elements.delete',\n    'shape.create',\n    'shape.delete',\n    'shape.move',\n    'shape.resize'\n  ];\n\n\n  // listen to a lot of stuff to group lane updates\n\n  this.preExecute(laneRefUpdateEvents, HIGH_PRIORITY, function(event) {\n    initContext();\n  });\n\n  this.postExecuted(laneRefUpdateEvents, LOW_PRIORITY, function(event) {\n    releaseContext();\n  });\n\n\n  // Mark flow nodes + lanes that need an update\n\n  this.preExecute([\n    'shape.create',\n    'shape.move',\n    'shape.delete',\n    'shape.resize'\n  ], function(event) {\n\n    var context = event.context,\n        shape = context.shape;\n\n    var updateContext = getContext();\n\n    // no need to update labels\n    if (shape.labelTarget) {\n      return;\n    }\n\n    if (is(shape, 'bpmn:Lane')) {\n      updateContext.addLane(shape);\n    }\n\n    if (is(shape, 'bpmn:FlowNode')) {\n      updateContext.addFlowNode(shape);\n    }\n  });\n}\n\nUpdateFlowNodeRefsBehavior.$inject = [\n  'eventBus',\n  'modeling' ,\n  'translate'\n];\n\ninherits(UpdateFlowNodeRefsBehavior, CommandInterceptor);\n\n\nfunction UpdateContext() {\n\n  this.flowNodes = [];\n  this.lanes = [];\n\n  this.counter = 0;\n\n  this.addLane = function(lane) {\n    this.lanes.push(lane);\n  };\n\n  this.addFlowNode = function(flowNode) {\n    this.flowNodes.push(flowNode);\n  };\n\n  this.enter = function() {\n    this.counter++;\n  };\n\n  this.leave = function() {\n    this.counter--;\n\n    return !this.counter;\n  };\n}","import AdaptiveLabelPositioningBehavior from './AdaptiveLabelPositioningBehavior';\nimport AppendBehavior from './AppendBehavior';\nimport BoundaryEventBehavior from './BoundaryEventBehavior';\nimport CopyPasteBehavior from './CopyPasteBehavior';\nimport CreateBoundaryEventBehavior from './CreateBoundaryEventBehavior';\nimport CreateDataObjectBehavior from './CreateDataObjectBehavior';\nimport CreateParticipantBehavior from './CreateParticipantBehavior';\nimport DataInputAssociationBehavior from './DataInputAssociationBehavior';\nimport DataStoreBehavior from './DataStoreBehavior';\nimport DeleteLaneBehavior from './DeleteLaneBehavior';\nimport DropOnFlowBehavior from './DropOnFlowBehavior';\nimport ImportDockingFix from './ImportDockingFix';\nimport LabelBehavior from './LabelBehavior';\nimport ModelingFeedback from './ModelingFeedback';\nimport ReplaceConnectionBehavior from './ReplaceConnectionBehavior';\nimport RemoveParticipantBehavior from './RemoveParticipantBehavior';\nimport ReplaceElementBehaviour from './ReplaceElementBehaviour';\nimport ResizeLaneBehavior from './ResizeLaneBehavior';\nimport RemoveElementBehavior from './RemoveElementBehavior';\nimport ToggleElementCollapseBehaviour from './ToggleElementCollapseBehaviour';\nimport UnclaimIdBehavior from './UnclaimIdBehavior';\nimport UpdateFlowNodeRefsBehavior from './UpdateFlowNodeRefsBehavior';\nimport UnsetDefaultFlowBehavior from './UnsetDefaultFlowBehavior';\n\nexport default {\n  __init__: [\n    'adaptiveLabelPositioningBehavior',\n    'appendBehavior',\n    'boundaryEventBehavior',\n    'copyPasteBehavior',\n    'createBoundaryEventBehavior',\n    'createDataObjectBehavior',\n    'dataStoreBehavior',\n    'createParticipantBehavior',\n    'dataInputAssociationBehavior',\n    'deleteLaneBehavior',\n    'dropOnFlowBehavior',\n    'importDockingFix',\n    'labelBehavior',\n    'modelingFeedback',\n    'removeElementBehavior',\n    'removeParticipantBehavior',\n    'replaceConnectionBehavior',\n    'replaceElementBehaviour',\n    'resizeLaneBehavior',\n    'toggleElementCollapseBehaviour',\n    'unclaimIdBehavior',\n    'unsetDefaultFlowBehavior',\n    'updateFlowNodeRefsBehavior'\n  ],\n  adaptiveLabelPositioningBehavior: [ 'type', AdaptiveLabelPositioningBehavior ],\n  appendBehavior: [ 'type', AppendBehavior ],\n  boundaryEventBehavior: [ 'type', BoundaryEventBehavior ],\n  copyPasteBehavior: [ 'type', CopyPasteBehavior ],\n  createBoundaryEventBehavior: [ 'type', CreateBoundaryEventBehavior ],\n  createDataObjectBehavior: [ 'type', CreateDataObjectBehavior ],\n  createParticipantBehavior: [ 'type', CreateParticipantBehavior ],\n  dataInputAssociationBehavior: [ 'type', DataInputAssociationBehavior ],\n  dataStoreBehavior: [ 'type', DataStoreBehavior ],\n  deleteLaneBehavior: [ 'type', DeleteLaneBehavior ],\n  dropOnFlowBehavior: [ 'type', DropOnFlowBehavior ],\n  importDockingFix: [ 'type', ImportDockingFix ],\n  labelBehavior: [ 'type', LabelBehavior ],\n  modelingFeedback: [ 'type', ModelingFeedback ],\n  replaceConnectionBehavior: [ 'type', ReplaceConnectionBehavior ],\n  removeParticipantBehavior: [ 'type', RemoveParticipantBehavior ],\n  replaceElementBehaviour: [ 'type', ReplaceElementBehaviour ],\n  resizeLaneBehavior: [ 'type', ResizeLaneBehavior ],\n  removeElementBehavior: [ 'type', RemoveElementBehavior ],\n  toggleElementCollapseBehaviour : [ 'type', ToggleElementCollapseBehaviour ],\n  unclaimIdBehavior: [ 'type', UnclaimIdBehavior ],\n  updateFlowNodeRefsBehavior: [ 'type', UpdateFlowNodeRefsBehavior ],\n  unsetDefaultFlowBehavior: [ 'type', UnsetDefaultFlowBehavior ]\n};\n","/**\n * Returns the length of a vector\n *\n * @param {Vector}\n * @return {Float}\n */\nexport function vectorLength(v) {\n  return Math.sqrt(Math.pow(v.x, 2) + Math.pow(v.y, 2));\n}\n\n\n/**\n * Calculates the angle between a line a the yAxis\n *\n * @param {Array}\n * @return {Float}\n */\nexport function getAngle(line) {\n  // return value is between 0, 180 and -180, -0\n  // @janstuemmel: maybe replace return a/b with b/a\n  return Math.atan((line[1].y - line[0].y) / (line[1].x - line[0].x));\n}\n\n\n/**\n * Rotates a vector by a given angle\n *\n * @param {Vector}\n * @param {Float} Angle in radians\n * @return {Vector}\n */\nexport function rotateVector(vector, angle) {\n  return (!angle) ? vector : {\n    x: Math.cos(angle) * vector.x - Math.sin(angle) * vector.y,\n    y: Math.sin(angle) * vector.x + Math.cos(angle) * vector.y\n  };\n}\n\n\n/**\n * Solves a 2D equation system\n * a + r*b = c, where a,b,c are 2D vectors\n *\n * @param {Vector}\n * @param {Vector}\n * @param {Vector}\n * @return {Float}\n */\nfunction solveLambaSystem(a, b, c) {\n\n  // the 2d system\n  var system = [\n    { n: a[0] - c[0], lambda: b[0] },\n    { n: a[1] - c[1], lambda: b[1] }\n  ];\n\n  // solve\n  var n = system[0].n * b[0] + system[1].n * b[1],\n      l = system[0].lambda * b[0] + system[1].lambda * b[1];\n\n  return -n/l;\n}\n\n\n/**\n * Position of perpendicular foot\n *\n * @param {Point}\n * @param [ {Point}, {Point} ] line defined throug two points\n * @return {Point} the perpendicular foot position\n */\nexport function perpendicularFoot(point, line) {\n\n  var a = line[0], b = line[1];\n\n  // relative position of b from a\n  var bd = { x: b.x - a.x, y: b.y - a.y };\n\n  // solve equation system to the parametrized vectors param real value\n  var r = solveLambaSystem([ a.x, a.y ], [ bd.x, bd.y ], [ point.x, point.y ]);\n\n  return { x: a.x + r*bd.x, y: a.y + r*bd.y };\n}\n\n\n/**\n * Calculates the distance between a point and a line\n *\n * @param {Point}\n * @param [ {Point}, {Point} ] line defined throug two points\n * @return {Float} distance\n */\nexport function getDistancePointLine(point, line) {\n\n  var pfPoint = perpendicularFoot(point, line);\n\n  // distance vector\n  var connectionVector = {\n    x: pfPoint.x - point.x,\n    y: pfPoint.y - point.y\n  };\n\n  return vectorLength(connectionVector);\n}\n\n\n/**\n * Calculates the distance between two points\n *\n * @param {Point}\n * @param {Point}\n * @return {Float} distance\n */\nexport function getDistancePointPoint(point1, point2) {\n\n  return vectorLength({\n    x: point1.x - point2.x,\n    y: point1.y - point2.y\n  });\n}","import {\n  getDistancePointPoint,\n  rotateVector,\n  getAngle\n} from './GeometricUtil';\n\nimport {\n  getAttachment\n} from './LineAttachmentUtil';\n\nimport {\n  roundPoint\n} from 'diagram-js/lib/layout/LayoutUtil';\n\n\nexport function findNewLabelLineStartIndex(oldWaypoints, newWaypoints, attachment, hints) {\n\n  var index = attachment.segmentIndex;\n\n  var offset = newWaypoints.length - oldWaypoints.length;\n\n  // segmentMove happend\n  if (hints.segmentMove) {\n\n    var oldSegmentStartIndex = hints.segmentMove.segmentStartIndex,\n        newSegmentStartIndex = hints.segmentMove.newSegmentStartIndex;\n\n    // if label was on moved segment return new segment index\n    if (index === oldSegmentStartIndex) {\n      return newSegmentStartIndex;\n    }\n\n    // label is after new segment index\n    if (index >= newSegmentStartIndex) {\n      return (index+offset < newSegmentStartIndex) ? newSegmentStartIndex : index+offset;\n    }\n\n    // if label is before new segment index\n    return index;\n  }\n\n  // bendpointMove happend\n  if (hints.bendpointMove) {\n\n    var insert = hints.bendpointMove.insert,\n        bendpointIndex = hints.bendpointMove.bendpointIndex,\n        newIndex;\n\n    // waypoints length didnt change\n    if (offset === 0) {\n      return index;\n    }\n\n    // label behind new/removed bendpoint\n    if (index >= bendpointIndex) {\n      newIndex = insert ? index + 1 : index - 1;\n    }\n\n    // label before new/removed bendpoint\n    if (index < bendpointIndex) {\n\n      newIndex = index;\n\n      // decide label should take right or left segment\n      if (insert && attachment.type !== 'bendpoint' && bendpointIndex-1 === index) {\n\n        var rel = relativePositionMidWaypoint(newWaypoints, bendpointIndex);\n\n        if (rel < attachment.relativeLocation) {\n          newIndex++;\n        }\n      }\n    }\n\n    return newIndex;\n  }\n\n  // start/end changed\n  if (offset === 0) {\n    return index;\n  }\n\n  if (hints.connectionStart) {\n    return (index === 0) ? 0 : null;\n  }\n\n  if (hints.connectionEnd) {\n    return (index === oldWaypoints.length - 2) ? newWaypoints.length - 2 : null;\n  }\n\n  // if nothing fits, return null\n  return null;\n}\n\n\n/**\n * Calculate the required adjustment (move delta) for the given label\n * after the connection waypoints got updated.\n *\n * @param {djs.model.Label} label\n * @param {Array<Point>} newWaypoints\n * @param {Array<Point>} oldWaypoints\n * @param {Object} hints\n *\n * @return {Point} delta\n */\nexport function getLabelAdjustment(label, newWaypoints, oldWaypoints, hints) {\n\n  var x = 0,\n      y = 0;\n\n  var labelPosition = getLabelMid(label);\n\n  // get closest attachment\n  var attachment = getAttachment(labelPosition, oldWaypoints),\n      oldLabelLineIndex = attachment.segmentIndex,\n      newLabelLineIndex = findNewLabelLineStartIndex(oldWaypoints, newWaypoints, attachment, hints);\n\n  if (newLabelLineIndex === null) {\n    return { x: x, y: y };\n  }\n\n  // should never happen\n  // TODO(@janstuemmel): throw an error here when connectionSegmentMove is refactored\n  if (newLabelLineIndex < 0 ||\n      newLabelLineIndex > newWaypoints.length - 2) {\n    return { x: x, y: y };\n  }\n\n  var oldLabelLine = getLine(oldWaypoints, oldLabelLineIndex),\n      newLabelLine = getLine(newWaypoints, newLabelLineIndex),\n      oldFoot = attachment.position;\n\n  var relativeFootPosition = getRelativeFootPosition(oldLabelLine, oldFoot),\n      angleDelta = getAngleDelta(oldLabelLine, newLabelLine);\n\n  // special rule if label on bendpoint\n  if (attachment.type === 'bendpoint') {\n\n    var offset = newWaypoints.length - oldWaypoints.length,\n        oldBendpointIndex = attachment.bendpointIndex,\n        oldBendpoint = oldWaypoints[oldBendpointIndex];\n\n    // bendpoint position hasnt changed, return same position\n    if (newWaypoints.indexOf(oldBendpoint) !== -1) {\n      return { x: x, y: y };\n    }\n\n    // new bendpoint and old bendpoint have same index, then just return the offset\n    if (offset === 0) {\n      var newBendpoint = newWaypoints[oldBendpointIndex];\n\n      return {\n        x: newBendpoint.x - attachment.position.x,\n        y: newBendpoint.y - attachment.position.y\n      };\n    }\n\n    // if bendpoints get removed\n    if (offset < 0 && oldBendpointIndex !== 0 && oldBendpointIndex < oldWaypoints.length - 1) {\n      relativeFootPosition = relativePositionMidWaypoint(oldWaypoints, oldBendpointIndex);\n    }\n  }\n\n  var newFoot = {\n    x: (newLabelLine[1].x - newLabelLine[0].x) * relativeFootPosition + newLabelLine[0].x,\n    y: (newLabelLine[1].y - newLabelLine[0].y) * relativeFootPosition + newLabelLine[0].y\n  };\n\n  // the rotated vector to label\n  var newLabelVector = rotateVector({\n    x: labelPosition.x - oldFoot.x,\n    y: labelPosition.y - oldFoot.y\n  }, angleDelta);\n\n  // the new relative position\n  x = newFoot.x + newLabelVector.x - labelPosition.x;\n  y = newFoot.y + newLabelVector.y - labelPosition.y;\n\n  return roundPoint({\n    x: x,\n    y: y\n  });\n}\n\n\n// HELPERS //////////////////////\n\nfunction relativePositionMidWaypoint(waypoints, idx) {\n\n  var distanceSegment1 = getDistancePointPoint(waypoints[idx-1], waypoints[idx]),\n      distanceSegment2 = getDistancePointPoint(waypoints[idx], waypoints[idx+1]);\n\n  var relativePosition = distanceSegment1 / (distanceSegment1 + distanceSegment2);\n\n  return relativePosition;\n}\n\nfunction getLabelMid(label) {\n  return {\n    x: label.x + label.width / 2,\n    y: label.y + label.height / 2\n  };\n}\n\nfunction getAngleDelta(l1, l2) {\n  var a1 = getAngle(l1),\n      a2 = getAngle(l2);\n  return a2 - a1;\n}\n\nfunction getLine(waypoints, idx) {\n  return [ waypoints[idx], waypoints[idx+1] ];\n}\n\nfunction getRelativeFootPosition(line, foot) {\n\n  var length = getDistancePointPoint(line[0], line[1]),\n      lengthToFoot = getDistancePointPoint(line[0], foot);\n\n  return length === 0 ? 0 : lengthToFoot / length;\n}\n","var sqrt = Math.sqrt,\n    min = Math.min,\n    max = Math.max,\n    abs = Math.abs;\n\n/**\n * Calculate the square (power to two) of a number.\n *\n * @param {Number} n\n *\n * @return {Number}\n */\nfunction sq(n) {\n  return Math.pow(n, 2);\n}\n\n/**\n * Get distance between two points.\n *\n * @param {Point} p1\n * @param {Point} p2\n *\n * @return {Number}\n */\nfunction getDistance(p1, p2) {\n  return sqrt(sq(p1.x - p2.x) + sq(p1.y - p2.y));\n}\n\n/**\n * Return the attachment of the given point on the specified line.\n *\n * The attachment is either a bendpoint (attached to the given point)\n * or segment (attached to a location on a line segment) attachment:\n *\n * ```javascript\n * var pointAttachment = {\n *   type: 'bendpoint',\n *   bendpointIndex: 3,\n *   position: { x: 10, y: 10 } // the attach point on the line\n * };\n *\n * var segmentAttachment = {\n *   type: 'segment',\n *   segmentIndex: 2,\n *   relativeLocation: 0.31, // attach point location between 0 (at start) and 1 (at end)\n *   position: { x: 10, y: 10 } // the attach point on the line\n * };\n * ```\n *\n * @param {Point} point\n * @param {Array<Point>} line\n *\n * @return {Object} attachment\n */\nexport function getAttachment(point, line) {\n\n  var idx = 0,\n      segmentStart,\n      segmentEnd,\n      segmentStartDistance,\n      segmentEndDistance,\n      attachmentPosition,\n      minDistance,\n      intersections,\n      attachment,\n      attachmentDistance,\n      closestAttachmentDistance,\n      closestAttachment;\n\n  for (idx = 0; idx < line.length - 1; idx++) {\n\n    segmentStart = line[idx];\n    segmentEnd = line[idx + 1];\n\n    if (pointsEqual(segmentStart, segmentEnd)) {\n      intersections = [ segmentStart ];\n    } else {\n      segmentStartDistance = getDistance(point, segmentStart);\n      segmentEndDistance = getDistance(point, segmentEnd);\n\n      minDistance = min(segmentStartDistance, segmentEndDistance);\n\n      intersections = getCircleSegmentIntersections(segmentStart, segmentEnd, point, minDistance);\n    }\n\n    if (intersections.length < 1) {\n      throw new Error('expected between [1, 2] circle -> line intersections');\n    }\n\n    // one intersection -> bendpoint attachment\n    if (intersections.length === 1) {\n      attachment = {\n        type: 'bendpoint',\n        position: intersections[0],\n        segmentIndex: idx,\n        bendpointIndex: pointsEqual(segmentStart, intersections[0]) ? idx : idx + 1\n      };\n    }\n\n    // two intersections -> segment attachment\n    if (intersections.length === 2) {\n\n      attachmentPosition = mid(intersections[0], intersections[1]);\n\n      attachment = {\n        type: 'segment',\n        position: attachmentPosition,\n        segmentIndex: idx,\n        relativeLocation: getDistance(segmentStart, attachmentPosition) / getDistance(segmentStart, segmentEnd)\n      };\n    }\n\n    attachmentDistance = getDistance(attachment.position, point);\n\n    if (!closestAttachment || closestAttachmentDistance > attachmentDistance) {\n      closestAttachment = attachment;\n      closestAttachmentDistance = attachmentDistance;\n    }\n  }\n\n  return closestAttachment;\n}\n\n/**\n * Gets the intersection between a circle and a line segment.\n *\n * @param {Point} s1 segment start\n * @param {Point} s2 segment end\n * @param {Point} cc circle center\n * @param {Number} cr circle radius\n *\n * @return {Array<Point>} intersections\n */\nfunction getCircleSegmentIntersections(s1, s2, cc, cr) {\n\n  var baX = s2.x - s1.x;\n  var baY = s2.y - s1.y;\n  var caX = cc.x - s1.x;\n  var caY = cc.y - s1.y;\n\n  var a = baX * baX + baY * baY;\n  var bBy2 = baX * caX + baY * caY;\n  var c = caX * caX + caY * caY - cr * cr;\n\n  var pBy2 = bBy2 / a;\n  var q = c / a;\n\n  var disc = pBy2 * pBy2 - q;\n\n  // check against negative value to work around\n  // negative, very close to zero results (-4e-15)\n  // being produced in some environments\n  if (disc < 0 && disc > -0.000001) {\n    disc = 0;\n  }\n\n  if (disc < 0) {\n    return [];\n  }\n\n  // if disc == 0 ... dealt with later\n  var tmpSqrt = sqrt(disc);\n  var abScalingFactor1 = -pBy2 + tmpSqrt;\n  var abScalingFactor2 = -pBy2 - tmpSqrt;\n\n  var i1 = {\n    x: s1.x - baX * abScalingFactor1,\n    y: s1.y - baY * abScalingFactor1\n  };\n\n  if (disc === 0) { // abScalingFactor1 == abScalingFactor2\n    return [ i1 ];\n  }\n\n  var i2 = {\n    x: s1.x - baX * abScalingFactor2,\n    y: s1.y - baY * abScalingFactor2\n  };\n\n  // return only points on line segment\n  return [ i1, i2 ].filter(function(p) {\n    return isPointInSegment(p, s1, s2);\n  });\n}\n\n\nfunction isPointInSegment(p, segmentStart, segmentEnd) {\n  return (\n    fenced(p.x, segmentStart.x, segmentEnd.x) &&\n    fenced(p.y, segmentStart.y, segmentEnd.y)\n  );\n}\n\nfunction fenced(n, rangeStart, rangeEnd) {\n\n  // use matching threshold to work around\n  // precisison errors in intersection computation\n\n  return (\n    n >= min(rangeStart, rangeEnd) - EQUAL_THRESHOLD &&\n    n <= max(rangeStart, rangeEnd) + EQUAL_THRESHOLD\n  );\n}\n\n/**\n * Calculate mid of two points.\n *\n * @param {Point} p1\n * @param {Point} p2\n *\n * @return {Point}\n */\nfunction mid(p1, p2) {\n\n  return {\n    x: (p1.x + p2.x) / 2,\n    y: (p1.y + p2.y) / 2\n  };\n}\n\nvar EQUAL_THRESHOLD = 0.1;\n\nfunction pointsEqual(p1, p2) {\n\n  return (\n    abs(p1.x - p2.x) <= EQUAL_THRESHOLD &&\n    abs(p1.y - p2.y) <= EQUAL_THRESHOLD\n  );\n}\n","/**\n * Returns the intersection between two line segments a and b.\n *\n * @param {Point} l1s\n * @param {Point} l1e\n * @param {Point} l2s\n * @param {Point} l2e\n *\n * @return {Point}\n */\nexport default function lineIntersect(l1s, l1e, l2s, l2e) {\n  // if the lines intersect, the result contains the x and y of the\n  // intersection (treating the lines as infinite) and booleans for\n  // whether line segment 1 or line segment 2 contain the point\n  var denominator, a, b, c, numerator;\n\n  denominator = ((l2e.y - l2s.y) * (l1e.x - l1s.x)) - ((l2e.x - l2s.x) * (l1e.y - l1s.y));\n\n  if (denominator == 0) {\n    return null;\n  }\n\n  a = l1s.y - l2s.y;\n  b = l1s.x - l2s.x;\n  numerator = ((l2e.x - l2s.x) * a) - ((l2e.y - l2s.y) * b);\n\n  c = numerator / denominator;\n\n  // if we cast these lines infinitely in\n  // both directions, they intersect here\n  return {\n    x: Math.round(l1s.x + (c * (l1e.x - l1s.x))),\n    y: Math.round(l1s.y + (c * (l1e.y - l1s.y)))\n  };\n}","import {\n  filter\n} from 'min-dash';\n\nimport {\n  eachElement\n} from 'diagram-js/lib/util/Elements';\n\nimport {\n  getLanesRoot,\n  getChildLanes,\n  LANE_INDENTATION\n} from '../util/LaneUtil';\n\n\n/**\n * A handler that allows us to add a new lane\n * above or below an existing one.\n *\n * @param {Modeling} modeling\n */\nexport default function AddLaneHandler(modeling, spaceTool) {\n  this._modeling = modeling;\n  this._spaceTool = spaceTool;\n}\n\nAddLaneHandler.$inject = [\n  'modeling',\n  'spaceTool'\n];\n\n\nAddLaneHandler.prototype.preExecute = function(context) {\n\n  var spaceTool = this._spaceTool,\n      modeling = this._modeling;\n\n  var shape = context.shape,\n      location = context.location;\n\n  var lanesRoot = getLanesRoot(shape);\n\n  var isRoot = lanesRoot === shape,\n      laneParent = isRoot ? shape : shape.parent;\n\n  var existingChildLanes = getChildLanes(laneParent);\n\n  // (0) add a lane if we currently got none and are adding to root\n  if (!existingChildLanes.length) {\n    modeling.createShape({ type: 'bpmn:Lane' }, {\n      x: shape.x + LANE_INDENTATION,\n      y: shape.y,\n      width: shape.width - LANE_INDENTATION,\n      height: shape.height\n    }, laneParent);\n  }\n\n  // (1) collect affected elements to create necessary space\n  var allAffected = [];\n\n  eachElement(lanesRoot, function(element) {\n    allAffected.push(element);\n\n    if (element === shape) {\n      return [];\n    }\n\n    return filter(element.children, function(c) {\n      return c !== shape;\n    });\n  });\n\n  var offset = location === 'top' ? -120 : 120,\n      lanePosition = location === 'top' ? shape.y : shape.y + shape.height,\n      spacePos = lanePosition + (location === 'top' ? 10 : -10),\n      direction = location === 'top' ? 'n' : 's';\n\n  var adjustments = spaceTool.calculateAdjustments(allAffected, 'y', offset, spacePos);\n\n  spaceTool.makeSpace(adjustments.movingShapes, adjustments.resizingShapes, { x: 0, y: offset }, direction);\n\n  // (2) create new lane at open space\n  context.newLane = modeling.createShape({ type: 'bpmn:Lane' }, {\n    x: shape.x + (isRoot ? LANE_INDENTATION : 0),\n    y: lanePosition - (location === 'top' ? 120 : 0),\n    width: shape.width - (isRoot ? LANE_INDENTATION : 0),\n    height: 120\n  }, laneParent);\n};\n","export default function IdClaimHandler(moddle) {\n  this._moddle = moddle;\n}\n\nIdClaimHandler.$inject = [ 'moddle' ];\n\n\nIdClaimHandler.prototype.execute = function(context) {\n  var ids = this._moddle.ids,\n      id = context.id,\n      element = context.element,\n      claiming = context.claiming;\n\n  if (claiming) {\n    ids.claim(id, element);\n  } else {\n    ids.unclaim(id);\n  }\n};\n\n/**\n * Command revert implementation.\n */\nIdClaimHandler.prototype.revert = function(context) {\n  var ids = this._moddle.ids,\n      id = context.id,\n      element = context.element,\n      claiming = context.claiming;\n\n  if (claiming) {\n    ids.unclaim(id);\n  } else {\n    ids.claim(id, element);\n  }\n};\n\n","import { is } from '../../../util/ModelUtil';\n\nimport {\n  getLanesRoot,\n  computeLanesResize\n} from '../util/LaneUtil';\n\nimport {\n  eachElement\n} from 'diagram-js/lib/util/Elements';\n\nimport {\n  asTRBL\n} from 'diagram-js/lib/layout/LayoutUtil';\n\nimport {\n  substractTRBL\n} from 'diagram-js/lib/features/resize/ResizeUtil';\n\n\n/**\n * A handler that resizes a lane.\n *\n * @param {Modeling} modeling\n */\nexport default function ResizeLaneHandler(modeling, spaceTool) {\n  this._modeling = modeling;\n  this._spaceTool = spaceTool;\n}\n\nResizeLaneHandler.$inject = [\n  'modeling',\n  'spaceTool'\n];\n\n\nResizeLaneHandler.prototype.preExecute = function(context) {\n\n  var shape = context.shape,\n      newBounds = context.newBounds,\n      balanced = context.balanced;\n\n  if (balanced !== false) {\n    this.resizeBalanced(shape, newBounds);\n  } else {\n    this.resizeSpace(shape, newBounds);\n  }\n};\n\n\n/**\n * Resize balanced, adjusting next / previous lane sizes.\n *\n * @param {djs.model.Shape} shape\n * @param {Bounds} newBounds\n */\nResizeLaneHandler.prototype.resizeBalanced = function(shape, newBounds) {\n\n  var modeling = this._modeling;\n\n  var resizeNeeded = computeLanesResize(shape, newBounds);\n\n  // resize the lane\n  modeling.resizeShape(shape, newBounds);\n\n  // resize other lanes as needed\n  resizeNeeded.forEach(function(r) {\n    modeling.resizeShape(r.shape, r.newBounds);\n  });\n};\n\n\n/**\n * Resize, making actual space and moving below / above elements.\n *\n * @param {djs.model.Shape} shape\n * @param {Bounds} newBounds\n */\nResizeLaneHandler.prototype.resizeSpace = function(shape, newBounds) {\n  var spaceTool = this._spaceTool;\n\n  var shapeTrbl = asTRBL(shape),\n      newTrbl = asTRBL(newBounds);\n\n  var trblDiff = substractTRBL(newTrbl, shapeTrbl);\n\n  var lanesRoot = getLanesRoot(shape);\n\n  var allAffected = [],\n      allLanes = [];\n\n  eachElement(lanesRoot, function(element) {\n    allAffected.push(element);\n\n    if (is(element, 'bpmn:Lane') || is(element, 'bpmn:Participant')) {\n      allLanes.push(element);\n    }\n\n    return element.children;\n  });\n\n  var change,\n      spacePos,\n      direction,\n      offset,\n      adjustments;\n\n  if (trblDiff.bottom || trblDiff.top) {\n\n    change = trblDiff.bottom || trblDiff.top;\n    spacePos = shape.y + (trblDiff.bottom ? shape.height : 0) + (trblDiff.bottom ? -10 : 10);\n    direction = trblDiff.bottom ? 's' : 'n';\n\n    offset = trblDiff.top > 0 || trblDiff.bottom < 0 ? -change : change;\n\n    adjustments = spaceTool.calculateAdjustments(allAffected, 'y', offset, spacePos);\n\n    spaceTool.makeSpace(adjustments.movingShapes, adjustments.resizingShapes, { x: 0, y: change }, direction);\n  }\n\n\n  if (trblDiff.left || trblDiff.right) {\n\n    change = trblDiff.right || trblDiff.left;\n    spacePos = shape.x + (trblDiff.right ? shape.width : 0) + (trblDiff.right ? -10 : 100);\n    direction = trblDiff.right ? 'e' : 'w';\n\n    offset = trblDiff.left > 0 || trblDiff.right < 0 ? -change : change;\n\n    adjustments = spaceTool.calculateAdjustments(allLanes, 'x', offset, spacePos);\n\n    spaceTool.makeSpace(adjustments.movingShapes, adjustments.resizingShapes, { x: change, y: 0 }, direction);\n  }\n};","import {\r\n  assign,\r\n  forEach\r\n} from 'min-dash';\r\n\r\n\r\nvar DEFAULT_COLORS = {\r\n  fill: undefined,\r\n  stroke: undefined\r\n};\r\n\r\n\r\nexport default function SetColorHandler(commandStack) {\r\n  this._commandStack = commandStack;\r\n}\r\n\r\nSetColorHandler.$inject = [\r\n  'commandStack'\r\n];\r\n\r\n\r\nSetColorHandler.prototype.postExecute = function(context) {\r\n  var elements = context.elements,\r\n      colors = context.colors || DEFAULT_COLORS;\r\n\r\n  var self = this;\r\n\r\n  var di = {};\r\n\r\n  if ('fill' in colors) {\r\n    assign(di, { fill: colors.fill });\r\n  }\r\n\r\n  if ('stroke' in colors) {\r\n    assign(di, { stroke: colors.stroke });\r\n  }\r\n\r\n  forEach(elements, function(element) {\r\n\r\n    self._commandStack.execute('element.updateProperties', {\r\n      element: element,\r\n      properties: {\r\n        di: di\r\n      }\r\n    });\r\n  });\r\n\r\n};","import {\n  getChildLanes,\n  LANE_INDENTATION\n} from '../util/LaneUtil';\n\n\n/**\n * A handler that splits a lane into a number of sub-lanes,\n * creating new sub lanes, if neccessary.\n *\n * @param {Modeling} modeling\n */\nexport default function SplitLaneHandler(modeling, translate) {\n  this._modeling = modeling;\n  this._translate = translate;\n}\n\nSplitLaneHandler.$inject = [\n  'modeling',\n  'translate'\n];\n\n\nSplitLaneHandler.prototype.preExecute = function(context) {\n\n  var modeling = this._modeling,\n      translate = this._translate;\n\n  var shape = context.shape,\n      newLanesCount = context.count;\n\n  var childLanes = getChildLanes(shape),\n      existingLanesCount = childLanes.length;\n\n  if (existingLanesCount > newLanesCount) {\n    throw new Error(translate('more than {count} child lanes', { count: newLanesCount }));\n  }\n\n  var newLanesHeight = Math.round(shape.height / newLanesCount);\n\n  // Iterate from top to bottom in child lane order,\n  // resizing existing lanes and creating new ones\n  // so that they split the parent proportionally.\n  //\n  // Due to rounding related errors, the bottom lane\n  // needs to take up all the remaining space.\n  var laneY,\n      laneHeight,\n      laneBounds,\n      newLaneAttrs,\n      idx;\n\n  for (idx = 0; idx < newLanesCount; idx++) {\n\n    laneY = shape.y + idx * newLanesHeight;\n\n    // if bottom lane\n    if (idx === newLanesCount - 1) {\n      laneHeight = shape.height - (newLanesHeight * idx);\n    } else {\n      laneHeight = newLanesHeight;\n    }\n\n    laneBounds = {\n      x: shape.x + LANE_INDENTATION,\n      y: laneY,\n      width: shape.width - LANE_INDENTATION,\n      height: laneHeight\n    };\n\n    if (idx < existingLanesCount) {\n      // resize existing lane\n      modeling.resizeShape(childLanes[idx], laneBounds);\n    } else {\n      // create a new lane at position\n      newLaneAttrs = {\n        type: 'bpmn:Lane'\n      };\n\n      modeling.createShape(newLaneAttrs, laneBounds, shape);\n    }\n  }\n};\n","import {\n  add as collectionAdd,\n  remove as collectionRemove\n} from 'diagram-js/lib/util/Collections';\n\n\nexport default function UpdateCanvasRootHandler(canvas, modeling) {\n  this._canvas = canvas;\n  this._modeling = modeling;\n}\n\nUpdateCanvasRootHandler.$inject = [\n  'canvas',\n  'modeling'\n];\n\n\nUpdateCanvasRootHandler.prototype.execute = function(context) {\n\n  var canvas = this._canvas;\n\n  var newRoot = context.newRoot,\n      newRootBusinessObject = newRoot.businessObject,\n      oldRoot = canvas.getRootElement(),\n      oldRootBusinessObject = oldRoot.businessObject,\n      bpmnDefinitions = oldRootBusinessObject.$parent,\n      diPlane = oldRootBusinessObject.di;\n\n  // (1) replace process old <> new root\n  canvas.setRootElement(newRoot, true);\n\n  // (2) update root elements\n  collectionAdd(bpmnDefinitions.rootElements, newRootBusinessObject);\n  newRootBusinessObject.$parent = bpmnDefinitions;\n\n  collectionRemove(bpmnDefinitions.rootElements, oldRootBusinessObject);\n  oldRootBusinessObject.$parent = null;\n\n  // (3) wire di\n  oldRootBusinessObject.di = null;\n\n  diPlane.bpmnElement = newRootBusinessObject;\n  newRootBusinessObject.di = diPlane;\n\n  context.oldRoot = oldRoot;\n\n  // TODO(nikku): return changed elements?\n  // return [ newRoot, oldRoot ];\n};\n\n\nUpdateCanvasRootHandler.prototype.revert = function(context) {\n\n  var canvas = this._canvas;\n\n  var newRoot = context.newRoot,\n      newRootBusinessObject = newRoot.businessObject,\n      oldRoot = context.oldRoot,\n      oldRootBusinessObject = oldRoot.businessObject,\n      bpmnDefinitions = newRootBusinessObject.$parent,\n      diPlane = newRootBusinessObject.di;\n\n  // (1) replace process old <> new root\n  canvas.setRootElement(oldRoot, true);\n\n  // (2) update root elements\n  collectionRemove(bpmnDefinitions.rootElements, newRootBusinessObject);\n  newRootBusinessObject.$parent = null;\n\n  collectionAdd(bpmnDefinitions.rootElements, oldRootBusinessObject);\n  oldRootBusinessObject.$parent = bpmnDefinitions;\n\n  // (3) wire di\n  newRootBusinessObject.di = null;\n\n  diPlane.bpmnElement = oldRootBusinessObject;\n  oldRootBusinessObject.di = diPlane;\n\n  // TODO(nikku): return changed elements?\n  // return [ newRoot, oldRoot ];\n};","import {\n  collectLanes,\n  getLanesRoot\n} from '../util/LaneUtil';\n\nimport {\n  is\n} from '../../../util/ModelUtil';\n\nimport {\n  add as collectionAdd,\n  remove as collectionRemove\n} from 'diagram-js/lib/util/Collections';\n\nimport {\n  asTRBL\n} from 'diagram-js/lib/layout/LayoutUtil';\n\nvar FLOW_NODE_REFS_ATTR = 'flowNodeRef',\n    LANES_ATTR = 'lanes';\n\n\n/**\n * A handler that updates lane refs on changed elements\n */\nexport default function UpdateFlowNodeRefsHandler(elementRegistry) {\n  this._elementRegistry = elementRegistry;\n}\n\nUpdateFlowNodeRefsHandler.$inject = [\n  'elementRegistry'\n];\n\n\nUpdateFlowNodeRefsHandler.prototype.computeUpdates = function(flowNodeShapes, laneShapes) {\n\n  var handledNodes = {};\n\n  var updates = [];\n\n  var participantCache = {};\n\n  var allFlowNodeShapes = [];\n\n  function isInLaneShape(element, laneShape) {\n\n    var laneTrbl = asTRBL(laneShape);\n\n    var elementMid = {\n      x: element.x + element.width / 2,\n      y: element.y + element.height / 2\n    };\n\n    return elementMid.x > laneTrbl.left &&\n           elementMid.x < laneTrbl.right &&\n           elementMid.y > laneTrbl.top &&\n           elementMid.y < laneTrbl.bottom;\n  }\n\n  function addFlowNodeShape(flowNodeShape) {\n    if (!handledNodes[flowNodeShape.id]) {\n      allFlowNodeShapes.push(flowNodeShape);\n      handledNodes[flowNodeShape.id] = flowNodeShape;\n    }\n  }\n\n  function getAllLaneShapes(flowNodeShape) {\n\n    var root = getLanesRoot(flowNodeShape);\n\n    if (!participantCache[root.id]) {\n      participantCache[root.id] = collectLanes(root);\n    }\n\n    return participantCache[root.id];\n  }\n\n  function getNewLanes(flowNodeShape) {\n    if (!flowNodeShape.parent) {\n      return [];\n    }\n\n    var allLaneShapes = getAllLaneShapes(flowNodeShape);\n\n    return allLaneShapes.filter(function(l) {\n      return isInLaneShape(flowNodeShape, l);\n    }).map(function(shape) {\n      return shape.businessObject;\n    });\n  }\n\n  laneShapes.forEach(function(laneShape) {\n    var root = getLanesRoot(laneShape);\n\n    if (!root || handledNodes[root.id]) {\n      return;\n    }\n\n    var children = root.children.filter(function(c) {\n      return is(c, 'bpmn:FlowNode');\n    });\n\n    children.forEach(addFlowNodeShape);\n\n    handledNodes[root.id] = root;\n  });\n\n  flowNodeShapes.forEach(addFlowNodeShape);\n\n\n  allFlowNodeShapes.forEach(function(flowNodeShape) {\n\n    var flowNode = flowNodeShape.businessObject;\n\n    var lanes = flowNode.get(LANES_ATTR),\n        remove = lanes.slice(),\n        add = getNewLanes(flowNodeShape);\n\n    updates.push({ flowNode: flowNode, remove: remove, add: add });\n  });\n\n  laneShapes.forEach(function(laneShape) {\n\n    var lane = laneShape.businessObject;\n\n    // lane got removed XX-)\n    if (!laneShape.parent) {\n      lane.get(FLOW_NODE_REFS_ATTR).forEach(function(flowNode) {\n        updates.push({ flowNode: flowNode, remove: [ lane ], add: [] });\n      });\n    }\n  });\n\n  return updates;\n};\n\nUpdateFlowNodeRefsHandler.prototype.execute = function(context) {\n\n  var updates = context.updates;\n\n  if (!updates) {\n    updates = context.updates = this.computeUpdates(context.flowNodeShapes, context.laneShapes);\n  }\n\n\n  updates.forEach(function(update) {\n\n    var flowNode = update.flowNode,\n        lanes = flowNode.get(LANES_ATTR);\n\n    // unwire old\n    update.remove.forEach(function(oldLane) {\n      collectionRemove(lanes, oldLane);\n      collectionRemove(oldLane.get(FLOW_NODE_REFS_ATTR), flowNode);\n    });\n\n    // wire new\n    update.add.forEach(function(newLane) {\n      collectionAdd(lanes, newLane);\n      collectionAdd(newLane.get(FLOW_NODE_REFS_ATTR), flowNode);\n    });\n  });\n\n  // TODO(nikku): return changed elements\n  // return [ ... ];\n};\n\n\nUpdateFlowNodeRefsHandler.prototype.revert = function(context) {\n\n  var updates = context.updates;\n\n  updates.forEach(function(update) {\n\n    var flowNode = update.flowNode,\n        lanes = flowNode.get(LANES_ATTR);\n\n    // unwire new\n    update.add.forEach(function(newLane) {\n      collectionRemove(lanes, newLane);\n      collectionRemove(newLane.get(FLOW_NODE_REFS_ATTR), flowNode);\n    });\n\n    // wire old\n    update.remove.forEach(function(oldLane) {\n      collectionAdd(lanes, oldLane);\n      collectionAdd(oldLane.get(FLOW_NODE_REFS_ATTR), flowNode);\n    });\n  });\n\n  // TODO(nikku): return changed elements\n  // return [ ... ];\n};","import {\n  reduce,\n  keys,\n  forEach,\n  assign\n} from 'min-dash';\n\nimport {\n  getBusinessObject\n} from '../../../util/ModelUtil';\n\nvar DEFAULT_FLOW = 'default',\n    ID = 'id',\n    DI = 'di';\n\nvar NULL_DIMENSIONS = {\n  width: 0,\n  height: 0\n};\n\n/**\n * A handler that implements a BPMN 2.0 property update.\n *\n * This should be used to set simple properties on elements with\n * an underlying BPMN business object.\n *\n * Use respective diagram-js provided handlers if you would\n * like to perform automated modeling.\n */\nexport default function UpdatePropertiesHandler(\n    elementRegistry, moddle, translate,\n    modeling, textRenderer) {\n\n  this._elementRegistry = elementRegistry;\n  this._moddle = moddle;\n  this._translate = translate;\n  this._modeling = modeling;\n  this._textRenderer = textRenderer;\n}\n\nUpdatePropertiesHandler.$inject = [\n  'elementRegistry',\n  'moddle',\n  'translate',\n  'modeling',\n  'textRenderer'\n];\n\n\n// api //////////////////////\n\n/**\n * Updates a BPMN element with a list of new properties\n *\n * @param {Object} context\n * @param {djs.model.Base} context.element the element to update\n * @param {Object} context.properties a list of properties to set on the element's\n *                                    businessObject (the BPMN model element)\n *\n * @return {Array<djs.model.Base>} the updated element\n */\nUpdatePropertiesHandler.prototype.execute = function(context) {\n\n  var element = context.element,\n      changed = [ element ],\n      translate = this._translate;\n\n  if (!element) {\n    throw new Error(translate('element required'));\n  }\n\n  var elementRegistry = this._elementRegistry,\n      ids = this._moddle.ids;\n\n  var businessObject = element.businessObject,\n      properties = unwrapBusinessObjects(context.properties),\n      oldProperties = context.oldProperties || getProperties(businessObject, properties);\n\n  if (isIdChange(properties, businessObject)) {\n    ids.unclaim(businessObject[ID]);\n\n    elementRegistry.updateId(element, properties[ID]);\n\n    ids.claim(properties[ID], businessObject);\n  }\n\n  // correctly indicate visual changes on default flow updates\n  if (DEFAULT_FLOW in properties) {\n\n    if (properties[DEFAULT_FLOW]) {\n      changed.push(elementRegistry.get(properties[DEFAULT_FLOW].id));\n    }\n\n    if (businessObject[DEFAULT_FLOW]) {\n      changed.push(elementRegistry.get(businessObject[DEFAULT_FLOW].id));\n    }\n  }\n\n  // update properties\n  setProperties(businessObject, properties);\n\n  // store old values\n  context.oldProperties = oldProperties;\n  context.changed = changed;\n\n  // indicate changed on objects affected by the update\n  return changed;\n};\n\n\nUpdatePropertiesHandler.prototype.postExecute = function(context) {\n  var element = context.element,\n      label = element.label;\n\n  var text = label && getBusinessObject(label).name;\n\n  if (!text) {\n    return;\n  }\n\n  // get layouted text bounds and resize external\n  // external label accordingly\n  var newLabelBounds = this._textRenderer.getExternalLabelBounds(label, text);\n\n  this._modeling.resizeShape(label, newLabelBounds, NULL_DIMENSIONS);\n};\n\n/**\n * Reverts the update on a BPMN elements properties.\n *\n * @param  {Object} context\n *\n * @return {djs.model.Base} the updated element\n */\nUpdatePropertiesHandler.prototype.revert = function(context) {\n\n  var element = context.element,\n      properties = context.properties,\n      oldProperties = context.oldProperties,\n      businessObject = element.businessObject,\n      elementRegistry = this._elementRegistry,\n      ids = this._moddle.ids;\n\n  // update properties\n  setProperties(businessObject, oldProperties);\n\n  if (isIdChange(properties, businessObject)) {\n    ids.unclaim(properties[ID]);\n\n    elementRegistry.updateId(element, oldProperties[ID]);\n\n    ids.claim(oldProperties[ID], businessObject);\n  }\n\n  return context.changed;\n};\n\n\nfunction isIdChange(properties, businessObject) {\n  return ID in properties && properties[ID] !== businessObject[ID];\n}\n\n\nfunction getProperties(businessObject, properties) {\n  var propertyNames = keys(properties);\n\n  return reduce(propertyNames, function(result, key) {\n\n    // handle DI seperately\n    if (key !== DI) {\n      result[key] = businessObject.get(key);\n    } else {\n      result[key] = getDiProperties(businessObject.di, keys(properties.di));\n    }\n\n    return result;\n  }, {});\n}\n\n\nfunction getDiProperties(di, propertyNames) {\n  return reduce(propertyNames, function(result, key) {\n    result[key] = di.get(key);\n\n    return result;\n  }, {});\n}\n\n\nfunction setProperties(businessObject, properties) {\n  forEach(properties, function(value, key) {\n\n    if (key !== DI) {\n      businessObject.set(key, value);\n    } else {\n      // only update, if businessObject.di exists\n      if (businessObject.di) {\n        setDiProperties(businessObject.di, value);\n      }\n    }\n  });\n}\n\n\nfunction setDiProperties(di, properties) {\n  forEach(properties, function(value, key) {\n    di.set(key, value);\n  });\n}\n\n\nvar referencePropertyNames = [ 'default' ];\n\n/**\n * Make sure we unwrap the actual business object\n * behind diagram element that may have been\n * passed as arguments.\n *\n * @param  {Object} properties\n *\n * @return {Object} unwrappedProps\n */\nfunction unwrapBusinessObjects(properties) {\n\n  var unwrappedProps = assign({}, properties);\n\n  referencePropertyNames.forEach(function(name) {\n    if (name in properties) {\n      unwrappedProps[name] = getBusinessObject(unwrappedProps[name]);\n    }\n  });\n\n  return unwrappedProps;\n}","export default function UpdateSemanticParentHandler(bpmnUpdater) {\r\n  this._bpmnUpdater = bpmnUpdater;\r\n}\r\n\r\nUpdateSemanticParentHandler.$inject = [ 'bpmnUpdater' ];\r\n\r\n\r\nUpdateSemanticParentHandler.prototype.execute = function(context) {\r\n  var dataStoreBo = context.dataStoreBo,\r\n      newSemanticParent = context.newSemanticParent,\r\n      newDiParent = context.newDiParent;\r\n\r\n  context.oldSemanticParent = dataStoreBo.$parent;\r\n  context.oldDiParent = dataStoreBo.di.$parent;\r\n\r\n  // update semantic parent\r\n  this._bpmnUpdater.updateSemanticParent(dataStoreBo, newSemanticParent);\r\n\r\n  // update DI parent\r\n  this._bpmnUpdater.updateDiParent(dataStoreBo.di, newDiParent);\r\n};\r\n\r\nUpdateSemanticParentHandler.prototype.revert = function(context) {\r\n  var dataStoreBo = context.dataStoreBo,\r\n      oldSemanticParent = context.oldSemanticParent,\r\n      oldDiParent = context.oldDiParent;\r\n\r\n  // update semantic parent\r\n  this._bpmnUpdater.updateSemanticParent(dataStoreBo, oldSemanticParent);\r\n\r\n  // update DI parent\r\n  this._bpmnUpdater.updateDiParent(dataStoreBo.di, oldDiParent);\r\n};\r\n\r\n","import BehaviorModule from './behavior';\nimport RulesModule from '../rules';\nimport OrderingModule from '../ordering';\nimport ReplaceModule from '../replace';\n\nimport CommandModule from 'diagram-js/lib/command';\nimport TooltipsModule from 'diagram-js/lib/features/tooltips';\nimport LabelSupportModule from 'diagram-js/lib/features/label-support';\nimport AttachSupportModule from 'diagram-js/lib/features/attach-support';\nimport SelectionModule from 'diagram-js/lib/features/selection';\nimport ChangeSupportModule from 'diagram-js/lib/features/change-support';\nimport SpaceToolModule from 'diagram-js/lib/features/space-tool';\n\nimport BpmnFactory from './BpmnFactory';\nimport BpmnUpdater from './BpmnUpdater';\nimport ElementFactory from './ElementFactory';\nimport Modeling from './Modeling';\nimport BpmnLayouter from './BpmnLayouter';\nimport CroppingConnectionDocking from 'diagram-js/lib/layout/CroppingConnectionDocking';\n\n\nexport default {\n  __init__: [\n    'modeling',\n    'bpmnUpdater'\n  ],\n  __depends__: [\n    BehaviorModule,\n    RulesModule,\n    OrderingModule,\n    ReplaceModule,\n    CommandModule,\n    TooltipsModule,\n    LabelSupportModule,\n    AttachSupportModule,\n    SelectionModule,\n    ChangeSupportModule,\n    SpaceToolModule\n  ],\n  bpmnFactory: [ 'type', BpmnFactory ],\n  bpmnUpdater: [ 'type', BpmnUpdater ],\n  elementFactory: [ 'type', ElementFactory ],\n  modeling: [ 'type', Modeling ],\n  layouter: [ 'type', BpmnLayouter ],\n  connectionDocking: [ 'type', CroppingConnectionDocking ]\n};","import { is } from '../../../util/ModelUtil';\n\nimport {\n  getParent\n} from './ModelingUtil';\n\nimport {\n  asTRBL\n} from 'diagram-js/lib/layout/LayoutUtil';\n\nimport {\n  substractTRBL,\n  resizeTRBL\n} from 'diagram-js/lib/features/resize/ResizeUtil';\n\nvar abs = Math.abs;\n\n\nfunction getTRBLResize(oldBounds, newBounds) {\n  return substractTRBL(asTRBL(newBounds), asTRBL(oldBounds));\n}\n\n\nvar LANE_PARENTS = [\n  'bpmn:Participant',\n  'bpmn:Process',\n  'bpmn:SubProcess'\n];\n\nexport var LANE_INDENTATION = 30;\n\n\n/**\n * Collect all lane shapes in the given paren\n *\n * @param  {djs.model.Shape} shape\n * @param  {Array<djs.model.Base>} [collectedShapes]\n *\n * @return {Array<djs.model.Base>}\n */\nexport function collectLanes(shape, collectedShapes) {\n\n  collectedShapes = collectedShapes || [];\n\n  shape.children.filter(function(s) {\n    if (is(s, 'bpmn:Lane')) {\n      collectLanes(s, collectedShapes);\n\n      collectedShapes.push(s);\n    }\n  });\n\n  return collectedShapes;\n}\n\n\n/**\n * Return the lane children of the given element.\n *\n * @param {djs.model.Shape} shape\n *\n * @return {Array<djs.model.Shape>}\n */\nexport function getChildLanes(shape) {\n  return shape.children.filter(function(c) {\n    return is(c, 'bpmn:Lane');\n  });\n}\n\n\n/**\n * Return the root element containing the given lane shape\n *\n * @param {djs.model.Shape} shape\n *\n * @return {djs.model.Shape}\n */\nexport function getLanesRoot(shape) {\n  return getParent(shape, LANE_PARENTS) || shape;\n}\n\n\n/**\n * Compute the required resize operations for lanes\n * adjacent to the given shape, assuming it will be\n * resized to the given new bounds.\n *\n * @param {djs.model.Shape} shape\n * @param {Bounds} newBounds\n *\n * @return {Array<Object>}\n */\nexport function computeLanesResize(shape, newBounds) {\n\n  var rootElement = getLanesRoot(shape);\n\n  var initialShapes = is(rootElement, 'bpmn:Process') ? [] : [ rootElement ];\n\n  var allLanes = collectLanes(rootElement, initialShapes),\n      shapeTrbl = asTRBL(shape),\n      shapeNewTrbl = asTRBL(newBounds),\n      trblResize = getTRBLResize(shape, newBounds),\n      resizeNeeded = [];\n\n  allLanes.forEach(function(other) {\n\n    if (other === shape) {\n      return;\n    }\n\n    var topResize = 0,\n        rightResize = trblResize.right,\n        bottomResize = 0,\n        leftResize = trblResize.left;\n\n    var otherTrbl = asTRBL(other);\n\n    if (trblResize.top) {\n      if (abs(otherTrbl.bottom - shapeTrbl.top) < 10) {\n        bottomResize = shapeNewTrbl.top - otherTrbl.bottom;\n      }\n\n      if (abs(otherTrbl.top - shapeTrbl.top) < 5) {\n        topResize = shapeNewTrbl.top - otherTrbl.top;\n      }\n    }\n\n    if (trblResize.bottom) {\n      if (abs(otherTrbl.top - shapeTrbl.bottom) < 10) {\n        topResize = shapeNewTrbl.bottom - otherTrbl.top;\n      }\n\n      if (abs(otherTrbl.bottom - shapeTrbl.bottom) < 5) {\n        bottomResize = shapeNewTrbl.bottom - otherTrbl.bottom;\n      }\n    }\n\n    if (topResize || rightResize || bottomResize || leftResize) {\n\n      resizeNeeded.push({\n        shape: other,\n        newBounds: resizeTRBL(other, {\n          top: topResize,\n          right: rightResize,\n          bottom: bottomResize,\n          left: leftResize\n        })\n      });\n    }\n\n  });\n\n  return resizeNeeded;\n}","import {\n  some\n} from 'min-dash';\n\nimport { is } from '../../../util/ModelUtil';\n\n\n/**\n * Return true if element has any of the given types.\n *\n * @param {djs.model.Base} element\n * @param {Array<String>} types\n *\n * @return {Boolean}\n */\nexport function isAny(element, types) {\n  return some(types, function(t) {\n    return is(element, t);\n  });\n}\n\n\n/**\n * Return the parent of the element with any of the given types.\n *\n * @param {djs.model.Base} element\n * @param {String|Array<String>} anyType\n *\n * @return {djs.model.Base}\n */\nexport function getParent(element, anyType) {\n\n  if (typeof anyType === 'string') {\n    anyType = [ anyType ];\n  }\n\n  while ((element = element.parent)) {\n    if (isAny(element, anyType)) {\n      return element;\n    }\n  }\n\n  return null;\n}","import inherits from 'inherits';\n\nimport OrderingProvider from 'diagram-js/lib/features/ordering/OrderingProvider';\n\nimport {\n  isAny\n} from '../modeling/util/ModelingUtil';\n\nimport {\n  findIndex,\n  find\n} from 'min-dash';\n\n\n/**\n * a simple ordering provider that makes sure:\n *\n * (0) labels are rendered always on top\n * (1) elements are ordered by a {level} property\n */\nexport default function BpmnOrderingProvider(eventBus, canvas, translate) {\n\n  OrderingProvider.call(this, eventBus);\n\n  var orders = [\n    { type: 'bpmn:SubProcess', order: { level: 6 } },\n    {\n      type: 'bpmn:SequenceFlow',\n      order: {\n        level: 3,\n        containers: [\n          'bpmn:Participant',\n          'bpmn:FlowElementsContainer'\n        ]\n      }\n    },\n    // handle DataAssociation(s) like message flows and render them always on top\n    {\n      type: 'bpmn:DataAssociation',\n      order: {\n        level: 9,\n        containers: [\n          'bpmn:Collaboration',\n          'bpmn:Process'\n        ]\n      }\n    },\n    {\n      type: 'bpmn:MessageFlow', order: {\n        level: 9,\n        containers: [ 'bpmn:Collaboration' ]\n      }\n    },\n    {\n      type: 'bpmn:Association',\n      order: {\n        level: 6,\n        containers: [\n          'bpmn:Participant',\n          'bpmn:FlowElementsContainer',\n          'bpmn:Collaboration'\n        ]\n      }\n    },\n    { type: 'bpmn:BoundaryEvent', order: { level: 8 } },\n    { type: 'bpmn:FlowElement', order: { level: 5 } },\n    { type: 'bpmn:Participant', order: { level: -2 } },\n    { type: 'bpmn:Lane', order: { level: -1 } }\n  ];\n\n  function computeOrder(element) {\n    if (element.labelTarget) {\n      return { level: 10 };\n    }\n\n    var entry = find(orders, function(o) {\n      return isAny(element, [ o.type ]);\n    });\n\n    return entry && entry.order || { level: 1 };\n  }\n\n  function getOrder(element) {\n\n    var order = element.order;\n\n    if (!order) {\n      element.order = order = computeOrder(element);\n    }\n\n    return order;\n  }\n\n  function findActualParent(element, newParent, containers) {\n\n    var actualParent = newParent;\n\n    while (actualParent) {\n\n      if (isAny(actualParent, containers)) {\n        break;\n      }\n\n      actualParent = actualParent.parent;\n    }\n\n    if (!actualParent) {\n      throw new Error(translate('no parent for {element} in {parent}', {\n        element: element.id,\n        parent: newParent.id\n      }));\n    }\n\n    return actualParent;\n  }\n\n  this.getOrdering = function(element, newParent) {\n\n    // render labels always on top\n    if (element.labelTarget) {\n      return {\n        parent: canvas.getRootElement(),\n        index: -1\n      };\n    }\n\n    var elementOrder = getOrder(element);\n\n\n    if (elementOrder.containers) {\n      newParent = findActualParent(element, newParent, elementOrder.containers);\n    }\n\n\n    var currentIndex = newParent.children.indexOf(element);\n\n    var insertIndex = findIndex(newParent.children, function(child) {\n\n      // do not compare with labels, they are created\n      // in the wrong order (right after elements) during import and\n      // mess up the positioning.\n      if (!element.labelTarget && child.labelTarget) {\n        return false;\n      }\n\n      return elementOrder.level < getOrder(child).level;\n    });\n\n\n    // if the element is already in the child list at\n    // a smaller index, we need to adjust the inser index.\n    // this takes into account that the element is being removed\n    // before being re-inserted\n    if (insertIndex !== -1) {\n      if (currentIndex !== -1 && currentIndex < insertIndex) {\n        insertIndex -= 1;\n      }\n    }\n\n    return {\n      index: insertIndex,\n      parent: newParent\n    };\n  };\n}\n\nBpmnOrderingProvider.$inject = [ 'eventBus', 'canvas', 'translate' ];\n\ninherits(BpmnOrderingProvider, OrderingProvider);","import translate from 'diagram-js/lib/i18n/translate';\n\nimport BpmnOrderingProvider from './BpmnOrderingProvider';\n\nexport default {\n  __depends__: [\n    translate\n  ],\n  __init__: [ 'bpmnOrderingProvider' ],\n  bpmnOrderingProvider: [ 'type', BpmnOrderingProvider ]\n};","import {\n  assign\n} from 'min-dash';\n\n\n/**\n * A palette provider for BPMN 2.0 elements.\n */\nexport default function PaletteProvider(\n    palette, create, elementFactory,\n    spaceTool, lassoTool, handTool,\n    globalConnect, translate) {\n\n  this._palette = palette;\n  this._create = create;\n  this._elementFactory = elementFactory;\n  this._spaceTool = spaceTool;\n  this._lassoTool = lassoTool;\n  this._handTool = handTool;\n  this._globalConnect = globalConnect;\n  this._translate = translate;\n\n  palette.registerProvider(this);\n}\n\nPaletteProvider.$inject = [\n  'palette',\n  'create',\n  'elementFactory',\n  'spaceTool',\n  'lassoTool',\n  'handTool',\n  'globalConnect',\n  'translate'\n];\n\n\nPaletteProvider.prototype.getPaletteEntries = function(element) {\n\n  var actions = {},\n      create = this._create,\n      elementFactory = this._elementFactory,\n      spaceTool = this._spaceTool,\n      lassoTool = this._lassoTool,\n      handTool = this._handTool,\n      globalConnect = this._globalConnect,\n      translate = this._translate;\n\n  function createAction(type, group, className, title, options) {\n\n    function createListener(event) {\n      var shape = elementFactory.createShape(assign({ type: type }, options));\n\n      if (options) {\n        shape.businessObject.di.isExpanded = options.isExpanded;\n      }\n\n      create.start(event, shape);\n    }\n\n    var shortType = type.replace(/^bpmn:/, '');\n\n    return {\n      group: group,\n      className: className,\n      title: title || translate('Create {type}', { type: shortType }),\n      action: {\n        dragstart: createListener,\n        click: createListener\n      }\n    };\n  }\n\n  function createParticipant(event, collapsed) {\n    create.start(event, elementFactory.createParticipantShape(collapsed));\n  }\n\n  assign(actions, {\n    'hand-tool': {\n      group: 'tools',\n      className: 'bpmn-icon-hand-tool',\n      title: translate('Activate the hand tool'),\n      action: {\n        click: function(event) {\n          handTool.activateHand(event);\n        }\n      }\n    },\n    'lasso-tool': {\n      group: 'tools',\n      className: 'bpmn-icon-lasso-tool',\n      title: translate('Activate the lasso tool'),\n      action: {\n        click: function(event) {\n          lassoTool.activateSelection(event);\n        }\n      }\n    },\n    'space-tool': {\n      group: 'tools',\n      className: 'bpmn-icon-space-tool',\n      title: translate('Activate the create/remove space tool'),\n      action: {\n        click: function(event) {\n          spaceTool.activateSelection(event);\n        }\n      }\n    },\n    'global-connect-tool': {\n      group: 'tools',\n      className: 'bpmn-icon-connection-multi',\n      title: translate('Activate the global connect tool'),\n      action: {\n        click: function(event) {\n          globalConnect.toggle(event);\n        }\n      }\n    },\n    'tool-separator': {\n      group: 'tools',\n      separator: true\n    },\n    'create.start-event': createAction(\n      'bpmn:StartEvent', 'event', 'bpmn-icon-start-event-none'\n    ),\n    'create.intermediate-event': createAction(\n      'bpmn:IntermediateThrowEvent', 'event', 'bpmn-icon-intermediate-event-none',\n      translate('Create Intermediate/Boundary Event')\n    ),\n    'create.end-event': createAction(\n      'bpmn:EndEvent', 'event', 'bpmn-icon-end-event-none'\n    ),\n    'create.exclusive-gateway': createAction(\n      'bpmn:ExclusiveGateway', 'gateway', 'bpmn-icon-gateway-none',\n      translate('Create Gateway')\n    ),\n    'create.task': createAction(\n      'bpmn:Task', 'activity', 'bpmn-icon-task'\n    ),\n    'create.data-object': createAction(\n      'bpmn:DataObjectReference', 'data-object', 'bpmn-icon-data-object'\n    ),\n    'create.data-store': createAction(\n      'bpmn:DataStoreReference', 'data-store', 'bpmn-icon-data-store'\n    ),\n    'create.subprocess-expanded': createAction(\n      'bpmn:SubProcess', 'activity', 'bpmn-icon-subprocess-expanded',\n      translate('Create expanded SubProcess'),\n      { isExpanded: true }\n    ),\n    'create.participant-expanded': {\n      group: 'collaboration',\n      className: 'bpmn-icon-participant',\n      title: translate('Create Pool/Participant'),\n      action: {\n        dragstart: createParticipant,\n        click: createParticipant\n      }\n    }\n  });\n\n  return actions;\n};\n","import PaletteModule from 'diagram-js/lib/features/palette';\nimport CreateModule from 'diagram-js/lib/features/create';\nimport SpaceToolModule from 'diagram-js/lib/features/space-tool';\nimport LassoToolModule from 'diagram-js/lib/features/lasso-tool';\nimport HandToolModule from 'diagram-js/lib/features/hand-tool';\nimport GlobalConnectModule from 'diagram-js/lib/features/global-connect';\nimport translate from 'diagram-js/lib/i18n/translate';\n\nimport PaletteProvider from './PaletteProvider';\n\nexport default {\n  __depends__: [\n    PaletteModule,\n    CreateModule,\n    SpaceToolModule,\n    LassoToolModule,\n    HandToolModule,\n    GlobalConnectModule,\n    translate\n  ],\n  __init__: [ 'paletteProvider' ],\n  paletteProvider: [ 'type', PaletteProvider ]\n};\n","import {\n  getBusinessObject,\n  is\n} from '../../util/ModelUtil';\n\nimport {\n  isEventSubProcess,\n  isExpanded\n} from '../../util/DiUtil';\n\nimport {\n  isDifferentType\n} from './util/TypeUtil';\n\nimport {\n  forEach,\n  filter\n} from 'min-dash';\n\nimport * as replaceOptions from '../replace/ReplaceOptions';\n\n\n/**\n * This module is an element agnostic replace menu provider for the popup menu.\n */\nexport default function ReplaceMenuProvider(\n    popupMenu, modeling, moddle,\n    bpmnReplace, rules, translate) {\n\n  this._popupMenu = popupMenu;\n  this._modeling = modeling;\n  this._moddle = moddle;\n  this._bpmnReplace = bpmnReplace;\n  this._rules = rules;\n  this._translate = translate;\n\n  this.register();\n}\n\nReplaceMenuProvider.$inject = [\n  'popupMenu',\n  'modeling',\n  'moddle',\n  'bpmnReplace',\n  'rules',\n  'translate'\n];\n\n\n/**\n * Register replace menu provider in the popup menu\n */\nReplaceMenuProvider.prototype.register = function() {\n  this._popupMenu.registerProvider('bpmn-replace', this);\n};\n\n\n/**\n * Get all entries from replaceOptions for the given element and apply filters\n * on them. Get for example only elements, which are different from the current one.\n *\n * @param {djs.model.Base} element\n *\n * @return {Array<Object>} a list of menu entry items\n */\nReplaceMenuProvider.prototype.getEntries = function(element) {\n\n  var businessObject = element.businessObject;\n\n  var rules = this._rules;\n\n  var entries;\n\n  if (!rules.allowed('shape.replace', { element: element })) {\n    return [];\n  }\n\n  var differentType = isDifferentType(element);\n\n  // start events outside event sub processes\n  if (is(businessObject, 'bpmn:StartEvent') && !isEventSubProcess(businessObject.$parent)) {\n\n    entries = filter(replaceOptions.START_EVENT, differentType);\n\n    return this._createEntries(element, entries);\n  }\n\n  // expanded/collapsed pools\n  if (is(businessObject, 'bpmn:Participant')) {\n\n    entries = filter(replaceOptions.PARTICIPANT, function(entry) {\n      return isExpanded(businessObject) !== entry.target.isExpanded;\n    });\n\n    return this._createEntries(element, entries);\n  }\n\n  // start events inside event sub processes\n  if (is(businessObject, 'bpmn:StartEvent') && isEventSubProcess(businessObject.$parent)) {\n\n    entries = filter(replaceOptions.EVENT_SUB_PROCESS_START_EVENT, function(entry) {\n\n      var target = entry.target;\n\n      var isInterrupting = target.isInterrupting !== false;\n\n      var isInterruptingEqual = getBusinessObject(element).isInterrupting === isInterrupting;\n\n      // filters elements which types and event definition are equal but have have different interrupting types\n      return differentType(entry) || !differentType(entry) && !isInterruptingEqual;\n\n    });\n\n    return this._createEntries(element, entries);\n  }\n\n  // end events\n  if (is(businessObject, 'bpmn:EndEvent')) {\n\n    entries = filter(replaceOptions.END_EVENT, function(entry) {\n      var target = entry.target;\n\n      // hide cancel end events outside transactions\n      if (target.eventDefinitionType == 'bpmn:CancelEventDefinition' && !is(businessObject.$parent, 'bpmn:Transaction')) {\n        return false;\n      }\n\n      return differentType(entry);\n    });\n\n    return this._createEntries(element, entries);\n  }\n\n  // boundary events\n  if (is(businessObject, 'bpmn:BoundaryEvent')) {\n\n    entries = filter(replaceOptions.BOUNDARY_EVENT, function(entry) {\n\n      var target = entry.target;\n\n      if (target.eventDefinition == 'bpmn:CancelEventDefinition' &&\n         !is(businessObject.attachedToRef, 'bpmn:Transaction')) {\n        return false;\n      }\n      var cancelActivity = target.cancelActivity !== false;\n\n      var isCancelActivityEqual = businessObject.cancelActivity == cancelActivity;\n\n      return differentType(entry) || !differentType(entry) && !isCancelActivityEqual;\n    });\n\n    return this._createEntries(element, entries);\n  }\n\n  // intermediate events\n  if (is(businessObject, 'bpmn:IntermediateCatchEvent') ||\n      is(businessObject, 'bpmn:IntermediateThrowEvent')) {\n\n    entries = filter(replaceOptions.INTERMEDIATE_EVENT, differentType);\n\n    return this._createEntries(element, entries);\n  }\n\n  // gateways\n  if (is(businessObject, 'bpmn:Gateway')) {\n\n    entries = filter(replaceOptions.GATEWAY, differentType);\n\n    return this._createEntries(element, entries);\n  }\n\n  // transactions\n  if (is(businessObject, 'bpmn:Transaction')) {\n\n    entries = filter(replaceOptions.TRANSACTION, differentType);\n\n    return this._createEntries(element, entries);\n  }\n\n  // expanded event sub processes\n  if (isEventSubProcess(businessObject) && isExpanded(businessObject)) {\n\n    entries = filter(replaceOptions.EVENT_SUB_PROCESS, differentType);\n\n    return this._createEntries(element, entries);\n  }\n\n  // expanded sub processes\n  if (is(businessObject, 'bpmn:SubProcess') && isExpanded(businessObject)) {\n\n    entries = filter(replaceOptions.SUBPROCESS_EXPANDED, differentType);\n\n    return this._createEntries(element, entries);\n  }\n\n  // collapsed ad hoc sub processes\n  if (is(businessObject, 'bpmn:AdHocSubProcess') && !isExpanded(businessObject)) {\n\n    entries = filter(replaceOptions.TASK, function(entry) {\n\n      var target = entry.target;\n\n      var isTargetSubProcess = target.type === 'bpmn:SubProcess';\n\n      var isTargetExpanded = target.isExpanded === true;\n\n      return isDifferentType(element, target) && (!isTargetSubProcess || isTargetExpanded);\n    });\n\n    return this._createEntries(element, entries);\n  }\n\n  // sequence flows\n  if (is(businessObject, 'bpmn:SequenceFlow')) {\n    return this._createSequenceFlowEntries(element, replaceOptions.SEQUENCE_FLOW);\n  }\n\n  // flow nodes\n  if (is(businessObject, 'bpmn:FlowNode')) {\n    entries = filter(replaceOptions.TASK, differentType);\n\n    // collapsed SubProcess can not be replaced with itself\n    if (is(businessObject, 'bpmn:SubProcess') && !isExpanded(businessObject)) {\n      entries = filter(entries, function(entry) {\n        return entry.label !== 'Sub Process (collapsed)';\n      });\n    }\n\n    return this._createEntries(element, entries);\n  }\n\n  return [];\n};\n\n\n/**\n * Get a list of header items for the given element. This includes buttons\n * for multi instance markers and for the ad hoc marker.\n *\n * @param {djs.model.Base} element\n *\n * @return {Array<Object>} a list of menu entry items\n */\nReplaceMenuProvider.prototype.getHeaderEntries = function(element) {\n\n  var headerEntries = [];\n\n  if (is(element, 'bpmn:Activity') && !isEventSubProcess(element)) {\n    headerEntries = headerEntries.concat(this._getLoopEntries(element));\n  }\n\n  if (is(element, 'bpmn:SubProcess') &&\n      !is(element, 'bpmn:Transaction') &&\n      !isEventSubProcess(element)) {\n    headerEntries.push(this._getAdHocEntry(element));\n  }\n\n  return headerEntries;\n};\n\n\n/**\n * Creates an array of menu entry objects for a given element and filters the replaceOptions\n * according to a filter function.\n *\n * @param  {djs.model.Base} element\n * @param  {Object} replaceOptions\n *\n * @return {Array<Object>} a list of menu items\n */\nReplaceMenuProvider.prototype._createEntries = function(element, replaceOptions) {\n  var menuEntries = [];\n\n  var self = this;\n\n  forEach(replaceOptions, function(definition) {\n    var entry = self._createMenuEntry(definition, element);\n\n    menuEntries.push(entry);\n  });\n\n  return menuEntries;\n};\n\n/**\n * Creates an array of menu entry objects for a given sequence flow.\n *\n * @param  {djs.model.Base} element\n * @param  {Object} replaceOptions\n\n * @return {Array<Object>} a list of menu items\n */\nReplaceMenuProvider.prototype._createSequenceFlowEntries = function(element, replaceOptions) {\n\n  var businessObject = getBusinessObject(element);\n\n  var menuEntries = [];\n\n  var modeling = this._modeling,\n      moddle = this._moddle;\n\n  var self = this;\n\n  forEach(replaceOptions, function(entry) {\n\n    switch (entry.actionName) {\n    case 'replace-with-default-flow':\n      if (businessObject.sourceRef.default !== businessObject &&\n            (is(businessObject.sourceRef, 'bpmn:ExclusiveGateway') ||\n             is(businessObject.sourceRef, 'bpmn:InclusiveGateway') ||\n             is(businessObject.sourceRef, 'bpmn:ComplexGateway') ||\n             is(businessObject.sourceRef, 'bpmn:Activity'))) {\n\n        menuEntries.push(self._createMenuEntry(entry, element, function() {\n          modeling.updateProperties(element.source, { default: businessObject });\n        }));\n      }\n      break;\n    case 'replace-with-conditional-flow':\n      if (!businessObject.conditionExpression && is(businessObject.sourceRef, 'bpmn:Activity')) {\n\n        menuEntries.push(self._createMenuEntry(entry, element, function() {\n          var conditionExpression = moddle.create('bpmn:FormalExpression', { body: '' });\n\n          modeling.updateProperties(element, { conditionExpression: conditionExpression });\n        }));\n      }\n      break;\n    default:\n      // default flows\n      if (is(businessObject.sourceRef, 'bpmn:Activity') && businessObject.conditionExpression) {\n        return menuEntries.push(self._createMenuEntry(entry, element, function() {\n          modeling.updateProperties(element, { conditionExpression: undefined });\n        }));\n      }\n      // conditional flows\n      if ((is(businessObject.sourceRef, 'bpmn:ExclusiveGateway') ||\n           is(businessObject.sourceRef, 'bpmn:InclusiveGateway') ||\n           is(businessObject.sourceRef, 'bpmn:ComplexGateway') ||\n           is(businessObject.sourceRef, 'bpmn:Activity')) &&\n           businessObject.sourceRef.default === businessObject) {\n\n        return menuEntries.push(self._createMenuEntry(entry, element, function() {\n          modeling.updateProperties(element.source, { default: undefined });\n        }));\n      }\n    }\n  });\n\n  return menuEntries;\n};\n\n\n/**\n * Creates and returns a single menu entry item.\n *\n * @param  {Object} definition a single replace options definition object\n * @param  {djs.model.Base} element\n * @param  {Function} [action] an action callback function which gets called when\n *                             the menu entry is being triggered.\n *\n * @return {Object} menu entry item\n */\nReplaceMenuProvider.prototype._createMenuEntry = function(definition, element, action) {\n  var translate = this._translate;\n  var replaceElement = this._bpmnReplace.replaceElement;\n\n  var replaceAction = function() {\n    return replaceElement(element, definition.target);\n  };\n\n  action = action || replaceAction;\n\n  var menuEntry = {\n    label: translate(definition.label),\n    className: definition.className,\n    id: definition.actionName,\n    action: action\n  };\n\n  return menuEntry;\n};\n\n/**\n * Get a list of menu items containing buttons for multi instance markers\n *\n * @param  {djs.model.Base} element\n *\n * @return {Array<Object>} a list of menu items\n */\nReplaceMenuProvider.prototype._getLoopEntries = function(element) {\n\n  var self = this;\n  var translate = this._translate;\n\n  function toggleLoopEntry(event, entry) {\n    var loopCharacteristics;\n\n    if (entry.active) {\n      loopCharacteristics = undefined;\n    } else {\n      loopCharacteristics = self._moddle.create(entry.options.loopCharacteristics);\n\n      if (entry.options.isSequential) {\n        loopCharacteristics.isSequential = entry.options.isSequential;\n      }\n    }\n    self._modeling.updateProperties(element, { loopCharacteristics: loopCharacteristics });\n  }\n\n  var businessObject = getBusinessObject(element),\n      loopCharacteristics = businessObject.loopCharacteristics;\n\n  var isSequential,\n      isLoop,\n      isParallel;\n\n  if (loopCharacteristics) {\n    isSequential = loopCharacteristics.isSequential;\n    isLoop = loopCharacteristics.isSequential === undefined;\n    isParallel = loopCharacteristics.isSequential !== undefined && !loopCharacteristics.isSequential;\n  }\n\n\n  var loopEntries = [\n    {\n      id: 'toggle-parallel-mi',\n      className: 'bpmn-icon-parallel-mi-marker',\n      title: translate('Parallel Multi Instance'),\n      active: isParallel,\n      action: toggleLoopEntry,\n      options: {\n        loopCharacteristics: 'bpmn:MultiInstanceLoopCharacteristics',\n        isSequential: false\n      }\n    },\n    {\n      id: 'toggle-sequential-mi',\n      className: 'bpmn-icon-sequential-mi-marker',\n      title: translate('Sequential Multi Instance'),\n      active: isSequential,\n      action: toggleLoopEntry,\n      options: {\n        loopCharacteristics: 'bpmn:MultiInstanceLoopCharacteristics',\n        isSequential: true\n      }\n    },\n    {\n      id: 'toggle-loop',\n      className: 'bpmn-icon-loop-marker',\n      title: translate('Loop'),\n      active: isLoop,\n      action: toggleLoopEntry,\n      options: {\n        loopCharacteristics: 'bpmn:StandardLoopCharacteristics'\n      }\n    }\n  ];\n  return loopEntries;\n};\n\n\n/**\n * Get the menu items containing a button for the ad hoc marker\n *\n * @param  {djs.model.Base} element\n *\n * @return {Object} a menu item\n */\nReplaceMenuProvider.prototype._getAdHocEntry = function(element) {\n  var translate = this._translate;\n  var businessObject = getBusinessObject(element);\n\n  var isAdHoc = is(businessObject, 'bpmn:AdHocSubProcess');\n\n  var replaceElement = this._bpmnReplace.replaceElement;\n\n  var adHocEntry = {\n    id: 'toggle-adhoc',\n    className: 'bpmn-icon-ad-hoc-marker',\n    title: translate('Ad-hoc'),\n    active: isAdHoc,\n    action: function(event, entry) {\n      if (isAdHoc) {\n        return replaceElement(element, { type: 'bpmn:SubProcess' });\n      } else {\n        return replaceElement(element, { type: 'bpmn:AdHocSubProcess' });\n      }\n    }\n  };\n\n  return adHocEntry;\n};\n","import PopupMenuModule from 'diagram-js/lib/features/popup-menu';\nimport ReplaceModule from '../replace';\n\nimport ReplaceMenuProvider from './ReplaceMenuProvider';\n\n\nexport default {\n  __depends__: [\n    PopupMenuModule,\n    ReplaceModule\n  ],\n  __init__: [ 'replaceMenuProvider' ],\n  replaceMenuProvider: [ 'type', ReplaceMenuProvider ]\n};","import {\n  getBusinessObject\n} from '../../../util/ModelUtil';\n\nimport {\n  isExpanded\n} from '../../../util/DiUtil';\n\n\n/**\n * Returns true, if an element is from a different type\n * than a target definition. Takes into account the type,\n * event definition type and triggeredByEvent property.\n *\n * @param {djs.model.Base} element\n *\n * @return {Boolean}\n */\nexport function isDifferentType(element) {\n\n  return function(entry) {\n    var target = entry.target;\n\n    var businessObject = getBusinessObject(element),\n        eventDefinition = businessObject.eventDefinitions && businessObject.eventDefinitions[0];\n\n    var isTypeEqual = businessObject.$type === target.type;\n\n    var isEventDefinitionEqual = (\n      (eventDefinition && eventDefinition.$type) === target.eventDefinitionType\n    );\n\n    var isTriggeredByEventEqual = (\n      businessObject.triggeredByEvent === target.triggeredByEvent\n    );\n\n    var isExpandedEqual = (\n      target.isExpanded === undefined ||\n      target.isExpanded === isExpanded(businessObject)\n    );\n\n    return !isTypeEqual || !isEventDefinitionEqual || !isTriggeredByEventEqual || !isExpandedEqual;\n  };\n}","import CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';\n\nimport inherits from 'inherits';\n\nimport cssEscape from 'css.escape';\n\nimport {\n  assign,\n  forEach\n} from 'min-dash';\n\nimport {\n  query as domQuery\n} from 'min-dom';\n\nimport {\n  attr as svgAttr\n} from 'tiny-svg';\n\nvar LOW_PRIORITY = 250;\n\n\nexport default function BpmnReplacePreview(\n    eventBus, elementRegistry, elementFactory,\n    canvas, previewSupport) {\n\n  CommandInterceptor.call(this, eventBus);\n\n  /**\n   * Replace the visuals of all elements in the context which can be replaced\n   *\n   * @param  {Object} context\n   */\n  function replaceVisual(context) {\n\n    var replacements = context.canExecute.replacements;\n\n    forEach(replacements, function(replacement) {\n\n      var id = replacement.oldElementId;\n\n      var newElement = {\n        type: replacement.newElementType\n      };\n\n      // if the visual of the element is already replaced\n      if (context.visualReplacements[id]) {\n        return;\n      }\n\n      var element = elementRegistry.get(id);\n\n      assign(newElement, { x: element.x, y: element.y });\n\n      // create a temporary shape\n      var tempShape = elementFactory.createShape(newElement);\n\n      canvas.addShape(tempShape, element.parent);\n\n      // select the original SVG element related to the element and hide it\n      var gfx = domQuery('[data-element-id=\"' + cssEscape(element.id) + '\"]', context.dragGroup);\n\n      if (gfx) {\n        svgAttr(gfx, { display: 'none' });\n      }\n\n      // clone the gfx of the temporary shape and add it to the drag group\n      var dragger = previewSupport.addDragger(tempShape, context.dragGroup);\n\n      context.visualReplacements[id] = dragger;\n\n      canvas.removeShape(tempShape);\n    });\n  }\n\n  /**\n   * Restore the original visuals of the previously replaced elements\n   *\n   * @param  {Object} context\n   */\n  function restoreVisual(context) {\n\n    var visualReplacements = context.visualReplacements;\n\n    forEach(visualReplacements, function(dragger, id) {\n\n      var originalGfx = domQuery('[data-element-id=\"' + cssEscape(id) + '\"]', context.dragGroup);\n\n      if (originalGfx) {\n        svgAttr(originalGfx, { display: 'inline' });\n      }\n\n      dragger.remove();\n\n      if (visualReplacements[id]) {\n        delete visualReplacements[id];\n      }\n    });\n  }\n\n  eventBus.on('shape.move.move', LOW_PRIORITY, function(event) {\n\n    var context = event.context,\n        canExecute = context.canExecute;\n\n    if (!context.visualReplacements) {\n      context.visualReplacements = {};\n    }\n\n    if (canExecute.replacements) {\n      replaceVisual(context);\n    } else {\n      restoreVisual(context);\n    }\n  });\n}\n\nBpmnReplacePreview.$inject = [\n  'eventBus',\n  'elementRegistry',\n  'elementFactory',\n  'canvas',\n  'previewSupport'\n];\n\ninherits(BpmnReplacePreview, CommandInterceptor);","import PreviewSupportModule from 'diagram-js/lib/features/preview-support';\n\nimport BpmnReplacePreview from './BpmnReplacePreview';\n\nexport default {\n  __depends__: [\n    PreviewSupportModule\n  ],\n  __init__: [ 'bpmnReplacePreview' ],\n  bpmnReplacePreview: [ 'type', BpmnReplacePreview ]\n};\n","import {\n  pick,\n  assign,\n  filter,\n  has\n} from 'min-dash';\n\nimport {\n  is,\n  getBusinessObject\n} from '../../util/ModelUtil';\n\nimport {\n  isAny\n} from '../modeling/util/ModelingUtil';\n\nimport {\n  isExpanded,\n  isEventSubProcess\n} from '../../util/DiUtil';\n\nimport {\n  getProperties,\n  IGNORED_PROPERTIES\n} from '../../util/model/ModelCloneUtils';\n\nimport ModelCloneHelper from '../../util/model/ModelCloneHelper';\n\nvar CUSTOM_PROPERTIES = [\n  'cancelActivity',\n  'instantiate',\n  'eventGatewayType',\n  'triggeredByEvent',\n  'isInterrupting'\n];\n\n\nfunction toggeling(element, target) {\n\n  var oldCollapsed = (\n    element && has(element, 'collapsed') ? element.collapsed : !isExpanded(element)\n  );\n\n  var targetCollapsed;\n\n  if (target && (has(target, 'collapsed') || has(target, 'isExpanded'))) {\n    // property is explicitly set so use it\n    targetCollapsed = (\n      has(target, 'collapsed') ? target.collapsed : !target.isExpanded\n    );\n  } else {\n    // keep old state\n    targetCollapsed = oldCollapsed;\n  }\n\n  if (oldCollapsed !== targetCollapsed) {\n    element.collapsed = oldCollapsed;\n    return true;\n  }\n\n  return false;\n}\n\n\n\n/**\n * This module takes care of replacing BPMN elements\n */\nexport default function BpmnReplace(\n    bpmnFactory, replace, selection,\n    modeling, eventBus) {\n\n  var helper = new ModelCloneHelper(eventBus, bpmnFactory);\n\n  /**\n   * Prepares a new business object for the replacement element\n   * and triggers the replace operation.\n   *\n   * @param  {djs.model.Base} element\n   * @param  {Object} target\n   * @param  {Object} [hints]\n   *\n   * @return {djs.model.Base} the newly created element\n   */\n  function replaceElement(element, target, hints) {\n\n    hints = hints || {};\n\n    var type = target.type,\n        oldBusinessObject = element.businessObject;\n\n    if (isSubProcess(oldBusinessObject)) {\n      if (type === 'bpmn:SubProcess') {\n        if (toggeling(element, target)) {\n          // expanding or collapsing process\n          modeling.toggleCollapse(element);\n\n          return element;\n        }\n      }\n    }\n\n    var newBusinessObject = bpmnFactory.create(type);\n\n    var newElement = {\n      type: type,\n      businessObject: newBusinessObject\n    };\n\n    var elementProps = getProperties(oldBusinessObject.$descriptor),\n        newElementProps = getProperties(newBusinessObject.$descriptor, true),\n        copyProps = intersection(elementProps, newElementProps);\n\n    // initialize special properties defined in target definition\n    assign(newBusinessObject, pick(target, CUSTOM_PROPERTIES));\n\n    var properties = filter(copyProps, function(property) {\n      var propName = property.replace(/bpmn:/, '');\n\n      // copying event definitions, unless we replace\n      if (propName === 'eventDefinitions') {\n        return hasEventDefinition(element, target.eventDefinitionType);\n      }\n\n      // retain loop characteristics if the target element\n      // is not an event sub process\n      if (propName === 'loopCharacteristics') {\n        return !isEventSubProcess(newBusinessObject);\n      }\n\n      // so the applied properties from 'target' don't get lost\n      if (property in newBusinessObject) {\n        return false;\n      }\n\n      if (propName === 'processRef' && target.isExpanded === false) {\n        return false;\n      }\n\n      if (propName === 'triggeredByEvent') {\n        return false;\n      }\n\n      return IGNORED_PROPERTIES.indexOf(propName) === -1;\n    });\n\n    newBusinessObject = helper.clone(oldBusinessObject, newBusinessObject, properties);\n\n    // initialize custom BPMN extensions\n    if (target.eventDefinitionType) {\n\n      // only initialize with new eventDefinition\n      // if we did not set an event definition yet,\n      // i.e. because we cloned it\n      if (!hasEventDefinition(newBusinessObject, target.eventDefinitionType)) {\n        newElement.eventDefinitionType = target.eventDefinitionType;\n      }\n    }\n\n    if (is(oldBusinessObject, 'bpmn:Activity')) {\n\n      if (isSubProcess(oldBusinessObject)) {\n        // no toggeling, so keep old state\n        newElement.isExpanded = isExpanded(oldBusinessObject);\n      }\n      // else if property is explicitly set, use it\n      else if (target && has(target, 'isExpanded')) {\n        newElement.isExpanded = target.isExpanded;\n      }\n\n      // TODO: need also to respect min/max Size\n      // copy size, from an expanded subprocess to an expanded alternative subprocess\n      // except bpmn:Task, because Task is always expanded\n      if ((isExpanded(oldBusinessObject) && !is(oldBusinessObject, 'bpmn:Task')) && newElement.isExpanded) {\n        newElement.width = element.width;\n        newElement.height = element.height;\n      }\n    }\n\n    // remove children if not expanding sub process\n    if (isSubProcess(oldBusinessObject) && !isSubProcess(newBusinessObject)) {\n      hints.moveChildren = false;\n    }\n\n    // transform collapsed/expanded pools\n    if (is(oldBusinessObject, 'bpmn:Participant')) {\n\n      // create expanded pool\n      if (target.isExpanded === true) {\n        newBusinessObject.processRef = bpmnFactory.create('bpmn:Process');\n      } else {\n        // remove children when transforming to collapsed pool\n        hints.moveChildren = false;\n      }\n\n      // apply same size\n      newElement.width = element.width;\n      newElement.height = element.height;\n    }\n\n    newBusinessObject.name = oldBusinessObject.name;\n\n    // retain default flow's reference between inclusive <-> exclusive gateways and activities\n    if (\n      isAny(oldBusinessObject, [\n        'bpmn:ExclusiveGateway',\n        'bpmn:InclusiveGateway',\n        'bpmn:Activity'\n      ]) &&\n      isAny(newBusinessObject, [\n        'bpmn:ExclusiveGateway',\n        'bpmn:InclusiveGateway',\n        'bpmn:Activity'\n      ])\n    ) {\n      newBusinessObject.default = oldBusinessObject.default;\n    }\n\n    if ('fill' in oldBusinessObject.di || 'stroke' in oldBusinessObject.di) {\n      assign(newElement, { colors: pick(oldBusinessObject.di, [ 'fill', 'stroke' ]) });\n    }\n\n    newElement = replace.replaceElement(element, newElement, hints);\n\n    if (hints.select !== false) {\n      selection.select(newElement);\n    }\n\n    return newElement;\n  }\n\n  this.replaceElement = replaceElement;\n}\n\nBpmnReplace.$inject = [\n  'bpmnFactory',\n  'replace',\n  'selection',\n  'modeling',\n  'eventBus'\n];\n\n\nfunction isSubProcess(bo) {\n  return is(bo, 'bpmn:SubProcess');\n}\n\nfunction hasEventDefinition(element, type) {\n\n  var bo = getBusinessObject(element);\n\n  return type && bo.get('eventDefinitions').some(function(definition) {\n    return is(definition, type);\n  });\n}\n\n/**\n * Compute intersection between two arrays.\n */\nfunction intersection(a1, a2) {\n  return a1.filter(function(el) {\n    return a2.indexOf(el) !== -1;\n  });\n}","export var START_EVENT = [\n  {\n    label: 'Start Event',\n    actionName: 'replace-with-none-start',\n    className: 'bpmn-icon-start-event-none',\n    target: {\n      type: 'bpmn:StartEvent'\n    }\n  },\n  {\n    label: 'Intermediate Throw Event',\n    actionName: 'replace-with-none-intermediate-throwing',\n    className: 'bpmn-icon-intermediate-event-none',\n    target: {\n      type: 'bpmn:IntermediateThrowEvent'\n    }\n  },\n  {\n    label: 'End Event',\n    actionName: 'replace-with-none-end',\n    className: 'bpmn-icon-end-event-none',\n    target: {\n      type: 'bpmn:EndEvent'\n    }\n  },\n  {\n    label: 'Message Start Event',\n    actionName: 'replace-with-message-start',\n    className: 'bpmn-icon-start-event-message',\n    target: {\n      type: 'bpmn:StartEvent',\n      eventDefinitionType: 'bpmn:MessageEventDefinition'\n    }\n  },\n  {\n    label: 'Timer Start Event',\n    actionName: 'replace-with-timer-start',\n    className: 'bpmn-icon-start-event-timer',\n    target: {\n      type: 'bpmn:StartEvent',\n      eventDefinitionType: 'bpmn:TimerEventDefinition'\n    }\n  },\n  {\n    label: 'Conditional Start Event',\n    actionName: 'replace-with-conditional-start',\n    className: 'bpmn-icon-start-event-condition',\n    target: {\n      type: 'bpmn:StartEvent',\n      eventDefinitionType: 'bpmn:ConditionalEventDefinition'\n    }\n  },\n  {\n    label: 'Signal Start Event',\n    actionName: 'replace-with-signal-start',\n    className: 'bpmn-icon-start-event-signal',\n    target: {\n      type: 'bpmn:StartEvent',\n      eventDefinitionType: 'bpmn:SignalEventDefinition'\n    }\n  }\n];\n\nexport var INTERMEDIATE_EVENT = [\n  {\n    label: 'Start Event',\n    actionName: 'replace-with-none-start',\n    className: 'bpmn-icon-start-event-none',\n    target: {\n      type: 'bpmn:StartEvent'\n    }\n  },\n  {\n    label: 'Intermediate Throw Event',\n    actionName: 'replace-with-none-intermediate-throw',\n    className: 'bpmn-icon-intermediate-event-none',\n    target: {\n      type: 'bpmn:IntermediateThrowEvent'\n    }\n  },\n  {\n    label: 'End Event',\n    actionName: 'replace-with-none-end',\n    className: 'bpmn-icon-end-event-none',\n    target: {\n      type: 'bpmn:EndEvent'\n    }\n  },\n  {\n    label: 'Message Intermediate Catch Event',\n    actionName: 'replace-with-message-intermediate-catch',\n    className: 'bpmn-icon-intermediate-event-catch-message',\n    target: {\n      type: 'bpmn:IntermediateCatchEvent',\n      eventDefinitionType: 'bpmn:MessageEventDefinition'\n    }\n  },\n  {\n    label: 'Message Intermediate Throw Event',\n    actionName: 'replace-with-message-intermediate-throw',\n    className: 'bpmn-icon-intermediate-event-throw-message',\n    target: {\n      type: 'bpmn:IntermediateThrowEvent',\n      eventDefinitionType: 'bpmn:MessageEventDefinition'\n    }\n  },\n  {\n    label: 'Timer Intermediate Catch Event',\n    actionName: 'replace-with-timer-intermediate-catch',\n    className: 'bpmn-icon-intermediate-event-catch-timer',\n    target: {\n      type: 'bpmn:IntermediateCatchEvent',\n      eventDefinitionType: 'bpmn:TimerEventDefinition'\n    }\n  },\n  {\n    label: 'Escalation Intermediate Throw Event',\n    actionName: 'replace-with-escalation-intermediate-throw',\n    className: 'bpmn-icon-intermediate-event-throw-escalation',\n    target: {\n      type: 'bpmn:IntermediateThrowEvent',\n      eventDefinitionType: 'bpmn:EscalationEventDefinition'\n    }\n  },\n  {\n    label: 'Conditional Intermediate Catch Event',\n    actionName: 'replace-with-conditional-intermediate-catch',\n    className: 'bpmn-icon-intermediate-event-catch-condition',\n    target: {\n      type: 'bpmn:IntermediateCatchEvent',\n      eventDefinitionType: 'bpmn:ConditionalEventDefinition'\n    }\n  },\n  {\n    label: 'Link Intermediate Catch Event',\n    actionName: 'replace-with-link-intermediate-catch',\n    className: 'bpmn-icon-intermediate-event-catch-link',\n    target: {\n      type: 'bpmn:IntermediateCatchEvent',\n      eventDefinitionType: 'bpmn:LinkEventDefinition'\n    }\n  },\n  {\n    label: 'Link Intermediate Throw Event',\n    actionName: 'replace-with-link-intermediate-throw',\n    className: 'bpmn-icon-intermediate-event-throw-link',\n    target: {\n      type: 'bpmn:IntermediateThrowEvent',\n      eventDefinitionType: 'bpmn:LinkEventDefinition'\n    }\n  },\n  {\n    label: 'Compensation Intermediate Throw Event',\n    actionName: 'replace-with-compensation-intermediate-throw',\n    className: 'bpmn-icon-intermediate-event-throw-compensation',\n    target: {\n      type: 'bpmn:IntermediateThrowEvent',\n      eventDefinitionType: 'bpmn:CompensateEventDefinition'\n    }\n  },\n  {\n    label: 'Signal Intermediate Catch Event',\n    actionName: 'replace-with-signal-intermediate-catch',\n    className: 'bpmn-icon-intermediate-event-catch-signal',\n    target: {\n      type: 'bpmn:IntermediateCatchEvent',\n      eventDefinitionType: 'bpmn:SignalEventDefinition'\n    }\n  },\n  {\n    label: 'Signal Intermediate Throw Event',\n    actionName: 'replace-with-signal-intermediate-throw',\n    className: 'bpmn-icon-intermediate-event-throw-signal',\n    target: {\n      type: 'bpmn:IntermediateThrowEvent',\n      eventDefinitionType: 'bpmn:SignalEventDefinition'\n    }\n  }\n];\n\nexport var END_EVENT = [\n  {\n    label: 'Start Event',\n    actionName: 'replace-with-none-start',\n    className: 'bpmn-icon-start-event-none',\n    target: {\n      type: 'bpmn:StartEvent'\n    }\n  },\n  {\n    label: 'Intermediate Throw Event',\n    actionName: 'replace-with-none-intermediate-throw',\n    className: 'bpmn-icon-intermediate-event-none',\n    target: {\n      type: 'bpmn:IntermediateThrowEvent'\n    }\n  },\n  {\n    label: 'End Event',\n    actionName: 'replace-with-none-end',\n    className: 'bpmn-icon-end-event-none',\n    target: {\n      type: 'bpmn:EndEvent'\n    }\n  },\n  {\n    label: 'Message End Event',\n    actionName: 'replace-with-message-end',\n    className: 'bpmn-icon-end-event-message',\n    target: {\n      type: 'bpmn:EndEvent',\n      eventDefinitionType: 'bpmn:MessageEventDefinition'\n    }\n  },\n  {\n    label: 'Escalation End Event',\n    actionName: 'replace-with-escalation-end',\n    className: 'bpmn-icon-end-event-escalation',\n    target: {\n      type: 'bpmn:EndEvent',\n      eventDefinitionType: 'bpmn:EscalationEventDefinition'\n    }\n  },\n  {\n    label: 'Error End Event',\n    actionName: 'replace-with-error-end',\n    className: 'bpmn-icon-end-event-error',\n    target: {\n      type: 'bpmn:EndEvent',\n      eventDefinitionType: 'bpmn:ErrorEventDefinition'\n    }\n  },\n  {\n    label: 'Cancel End Event',\n    actionName: 'replace-with-cancel-end',\n    className: 'bpmn-icon-end-event-cancel',\n    target: {\n      type: 'bpmn:EndEvent',\n      eventDefinitionType: 'bpmn:CancelEventDefinition'\n    }\n  },\n  {\n    label: 'Compensation End Event',\n    actionName: 'replace-with-compensation-end',\n    className: 'bpmn-icon-end-event-compensation',\n    target: {\n      type: 'bpmn:EndEvent',\n      eventDefinitionType: 'bpmn:CompensateEventDefinition'\n    }\n  },\n  {\n    label: 'Signal End Event',\n    actionName: 'replace-with-signal-end',\n    className: 'bpmn-icon-end-event-signal',\n    target: {\n      type: 'bpmn:EndEvent',\n      eventDefinitionType: 'bpmn:SignalEventDefinition'\n    }\n  },\n  {\n    label: 'Terminate End Event',\n    actionName: 'replace-with-terminate-end',\n    className: 'bpmn-icon-end-event-terminate',\n    target: {\n      type: 'bpmn:EndEvent',\n      eventDefinitionType: 'bpmn:TerminateEventDefinition'\n    }\n  }\n];\n\nexport var GATEWAY = [\n  {\n    label: 'Exclusive Gateway',\n    actionName: 'replace-with-exclusive-gateway',\n    className: 'bpmn-icon-gateway-xor',\n    target: {\n      type: 'bpmn:ExclusiveGateway'\n    }\n  },\n  {\n    label: 'Parallel Gateway',\n    actionName: 'replace-with-parallel-gateway',\n    className: 'bpmn-icon-gateway-parallel',\n    target: {\n      type: 'bpmn:ParallelGateway'\n    }\n  },\n  {\n    label: 'Inclusive Gateway',\n    actionName: 'replace-with-inclusive-gateway',\n    className: 'bpmn-icon-gateway-or',\n    target: {\n      type: 'bpmn:InclusiveGateway'\n    }\n  },\n  {\n    label: 'Complex Gateway',\n    actionName: 'replace-with-complex-gateway',\n    className: 'bpmn-icon-gateway-complex',\n    target: {\n      type: 'bpmn:ComplexGateway'\n    }\n  },\n  {\n    label: 'Event based Gateway',\n    actionName: 'replace-with-event-based-gateway',\n    className: 'bpmn-icon-gateway-eventbased',\n    target: {\n      type: 'bpmn:EventBasedGateway',\n      instantiate: false,\n      eventGatewayType: 'Exclusive'\n    }\n  }\n  // Gateways deactivated until https://github.com/bpmn-io/bpmn-js/issues/194\n  // {\n  //   label: 'Event based instantiating Gateway',\n  //   actionName: 'replace-with-exclusive-event-based-gateway',\n  //   className: 'bpmn-icon-exclusive-event-based',\n  //   target: {\n  //     type: 'bpmn:EventBasedGateway'\n  //   },\n  //   options: {\n  //     businessObject: { instantiate: true, eventGatewayType: 'Exclusive' }\n  //   }\n  // },\n  // {\n  //   label: 'Parallel Event based instantiating Gateway',\n  //   actionName: 'replace-with-parallel-event-based-instantiate-gateway',\n  //   className: 'bpmn-icon-parallel-event-based-instantiate-gateway',\n  //   target: {\n  //     type: 'bpmn:EventBasedGateway'\n  //   },\n  //   options: {\n  //     businessObject: { instantiate: true, eventGatewayType: 'Parallel' }\n  //   }\n  // }\n];\n\nexport var SUBPROCESS_EXPANDED = [\n  {\n    label: 'Transaction',\n    actionName: 'replace-with-transaction',\n    className: 'bpmn-icon-transaction',\n    target: {\n      type: 'bpmn:Transaction',\n      isExpanded: true\n    }\n  },\n  {\n    label: 'Event Sub Process',\n    actionName: 'replace-with-event-subprocess',\n    className: 'bpmn-icon-event-subprocess-expanded',\n    target: {\n      type: 'bpmn:SubProcess',\n      triggeredByEvent: true,\n      isExpanded: true\n    }\n  },\n  {\n    label: 'Sub Process (collapsed)',\n    actionName: 'replace-with-collapsed-subprocess',\n    className: 'bpmn-icon-subprocess-collapsed',\n    target: {\n      type: 'bpmn:SubProcess',\n      isExpanded: false\n    }\n  }\n];\n\nexport var TRANSACTION = [\n  {\n    label: 'Sub Process',\n    actionName: 'replace-with-subprocess',\n    className: 'bpmn-icon-subprocess-expanded',\n    target: {\n      type: 'bpmn:SubProcess',\n      isExpanded: true\n    }\n  },\n  {\n    label: 'Event Sub Process',\n    actionName: 'replace-with-event-subprocess',\n    className: 'bpmn-icon-event-subprocess-expanded',\n    target: {\n      type: 'bpmn:SubProcess',\n      triggeredByEvent: true,\n      isExpanded: true\n    }\n  }\n];\n\nexport var EVENT_SUB_PROCESS = [\n  {\n    label: 'Sub Process',\n    actionName: 'replace-with-subprocess',\n    className: 'bpmn-icon-subprocess-expanded',\n    target: {\n      type: 'bpmn:SubProcess',\n      isExpanded: true\n    }\n  },\n  {\n    label: 'Transaction',\n    actionName: 'replace-with-transaction',\n    className: 'bpmn-icon-transaction',\n    target: {\n      type: 'bpmn:Transaction',\n      isExpanded: true\n    }\n  }\n];\n\nexport var TASK = [\n  {\n    label: 'Task',\n    actionName: 'replace-with-task',\n    className: 'bpmn-icon-task',\n    target: {\n      type: 'bpmn:Task'\n    }\n  },\n  {\n    label: 'Send Task',\n    actionName: 'replace-with-send-task',\n    className: 'bpmn-icon-send',\n    target: {\n      type: 'bpmn:SendTask'\n    }\n  },\n  {\n    label: 'Receive Task',\n    actionName: 'replace-with-receive-task',\n    className: 'bpmn-icon-receive',\n    target: {\n      type: 'bpmn:ReceiveTask'\n    }\n  },\n  {\n    label: 'User Task',\n    actionName: 'replace-with-user-task',\n    className: 'bpmn-icon-user',\n    target: {\n      type: 'bpmn:UserTask'\n    }\n  },\n  {\n    label: 'Manual Task',\n    actionName: 'replace-with-manual-task',\n    className: 'bpmn-icon-manual',\n    target: {\n      type: 'bpmn:ManualTask'\n    }\n  },\n  {\n    label: 'Business Rule Task',\n    actionName: 'replace-with-rule-task',\n    className: 'bpmn-icon-business-rule',\n    target: {\n      type: 'bpmn:BusinessRuleTask'\n    }\n  },\n  {\n    label: 'Service Task',\n    actionName: 'replace-with-service-task',\n    className: 'bpmn-icon-service',\n    target: {\n      type: 'bpmn:ServiceTask'\n    }\n  },\n  {\n    label: 'Script Task',\n    actionName: 'replace-with-script-task',\n    className: 'bpmn-icon-script',\n    target: {\n      type: 'bpmn:ScriptTask'\n    }\n  },\n  {\n    label: 'Call Activity',\n    actionName: 'replace-with-call-activity',\n    className: 'bpmn-icon-call-activity',\n    target: {\n      type: 'bpmn:CallActivity'\n    }\n  },\n  {\n    label: 'Sub Process (collapsed)',\n    actionName: 'replace-with-collapsed-subprocess',\n    className: 'bpmn-icon-subprocess-collapsed',\n    target: {\n      type: 'bpmn:SubProcess',\n      isExpanded: false\n    }\n  },\n  {\n    label: 'Sub Process (expanded)',\n    actionName: 'replace-with-expanded-subprocess',\n    className: 'bpmn-icon-subprocess-expanded',\n    target: {\n      type: 'bpmn:SubProcess',\n      isExpanded: true\n    }\n  }\n];\n\nexport var BOUNDARY_EVENT = [\n  {\n    label: 'Message Boundary Event',\n    actionName: 'replace-with-message-boundary',\n    className: 'bpmn-icon-intermediate-event-catch-message',\n    target: {\n      type: 'bpmn:BoundaryEvent',\n      eventDefinitionType: 'bpmn:MessageEventDefinition'\n    }\n  },\n  {\n    label: 'Timer Boundary Event',\n    actionName: 'replace-with-timer-boundary',\n    className: 'bpmn-icon-intermediate-event-catch-timer',\n    target: {\n      type: 'bpmn:BoundaryEvent',\n      eventDefinitionType: 'bpmn:TimerEventDefinition'\n    }\n  },\n  {\n    label: 'Escalation Boundary Event',\n    actionName: 'replace-with-escalation-boundary',\n    className: 'bpmn-icon-intermediate-event-catch-escalation',\n    target: {\n      type: 'bpmn:BoundaryEvent',\n      eventDefinitionType: 'bpmn:EscalationEventDefinition'\n    }\n  },\n  {\n    label: 'Conditional Boundary Event',\n    actionName: 'replace-with-conditional-boundary',\n    className: 'bpmn-icon-intermediate-event-catch-condition',\n    target: {\n      type: 'bpmn:BoundaryEvent',\n      eventDefinitionType: 'bpmn:ConditionalEventDefinition'\n    }\n  },\n  {\n    label: 'Error Boundary Event',\n    actionName: 'replace-with-error-boundary',\n    className: 'bpmn-icon-intermediate-event-catch-error',\n    target: {\n      type: 'bpmn:BoundaryEvent',\n      eventDefinitionType: 'bpmn:ErrorEventDefinition'\n    }\n  },\n  {\n    label: 'Cancel Boundary Event',\n    actionName: 'replace-with-cancel-boundary',\n    className: 'bpmn-icon-intermediate-event-catch-cancel',\n    target: {\n      type: 'bpmn:BoundaryEvent',\n      eventDefinitionType: 'bpmn:CancelEventDefinition'\n    }\n  },\n  {\n    label: 'Signal Boundary Event',\n    actionName: 'replace-with-signal-boundary',\n    className: 'bpmn-icon-intermediate-event-catch-signal',\n    target: {\n      type: 'bpmn:BoundaryEvent',\n      eventDefinitionType: 'bpmn:SignalEventDefinition'\n    }\n  },\n  {\n    label: 'Compensation Boundary Event',\n    actionName: 'replace-with-compensation-boundary',\n    className: 'bpmn-icon-intermediate-event-catch-compensation',\n    target: {\n      type: 'bpmn:BoundaryEvent',\n      eventDefinitionType: 'bpmn:CompensateEventDefinition'\n    }\n  },\n  {\n    label: 'Message Boundary Event (non-interrupting)',\n    actionName: 'replace-with-non-interrupting-message-boundary',\n    className: 'bpmn-icon-intermediate-event-catch-non-interrupting-message',\n    target: {\n      type: 'bpmn:BoundaryEvent',\n      eventDefinitionType: 'bpmn:MessageEventDefinition',\n      cancelActivity: false\n    }\n  },\n  {\n    label: 'Timer Boundary Event (non-interrupting)',\n    actionName: 'replace-with-non-interrupting-timer-boundary',\n    className: 'bpmn-icon-intermediate-event-catch-non-interrupting-timer',\n    target: {\n      type: 'bpmn:BoundaryEvent',\n      eventDefinitionType: 'bpmn:TimerEventDefinition',\n      cancelActivity: false\n    }\n  },\n  {\n    label: 'Escalation Boundary Event (non-interrupting)',\n    actionName: 'replace-with-non-interrupting-escalation-boundary',\n    className: 'bpmn-icon-intermediate-event-catch-non-interrupting-escalation',\n    target: {\n      type: 'bpmn:BoundaryEvent',\n      eventDefinitionType: 'bpmn:EscalationEventDefinition',\n      cancelActivity: false\n    }\n  },\n  {\n    label: 'Conditional Boundary Event (non-interrupting)',\n    actionName: 'replace-with-non-interrupting-conditional-boundary',\n    className: 'bpmn-icon-intermediate-event-catch-non-interrupting-condition',\n    target: {\n      type: 'bpmn:BoundaryEvent',\n      eventDefinitionType: 'bpmn:ConditionalEventDefinition',\n      cancelActivity: false\n    }\n  },\n  {\n    label: 'Signal Boundary Event (non-interrupting)',\n    actionName: 'replace-with-non-interrupting-signal-boundary',\n    className: 'bpmn-icon-intermediate-event-catch-non-interrupting-signal',\n    target: {\n      type: 'bpmn:BoundaryEvent',\n      eventDefinitionType: 'bpmn:SignalEventDefinition',\n      cancelActivity: false\n    }\n  }\n];\n\nexport var EVENT_SUB_PROCESS_START_EVENT = [\n  {\n    label: 'Message Start Event',\n    actionName: 'replace-with-message-start',\n    className: 'bpmn-icon-start-event-message',\n    target: {\n      type: 'bpmn:StartEvent',\n      eventDefinitionType: 'bpmn:MessageEventDefinition'\n    }\n  },\n  {\n    label: 'Timer Start Event',\n    actionName: 'replace-with-timer-start',\n    className: 'bpmn-icon-start-event-timer',\n    target: {\n      type: 'bpmn:StartEvent',\n      eventDefinitionType: 'bpmn:TimerEventDefinition'\n    }\n  },\n  {\n    label: 'Conditional Start Event',\n    actionName: 'replace-with-conditional-start',\n    className: 'bpmn-icon-start-event-condition',\n    target: {\n      type: 'bpmn:StartEvent',\n      eventDefinitionType: 'bpmn:ConditionalEventDefinition'\n    }\n  },\n  {\n    label: 'Signal Start Event',\n    actionName: 'replace-with-signal-start',\n    className: 'bpmn-icon-start-event-signal',\n    target: {\n      type: 'bpmn:StartEvent',\n      eventDefinitionType: 'bpmn:SignalEventDefinition'\n    }\n  },\n  {\n    label: 'Error Start Event',\n    actionName: 'replace-with-error-start',\n    className: 'bpmn-icon-start-event-error',\n    target: {\n      type: 'bpmn:StartEvent',\n      eventDefinitionType: 'bpmn:ErrorEventDefinition'\n    }\n  },\n  {\n    label: 'Escalation Start Event',\n    actionName: 'replace-with-escalation-start',\n    className: 'bpmn-icon-start-event-escalation',\n    target: {\n      type: 'bpmn:StartEvent',\n      eventDefinitionType: 'bpmn:EscalationEventDefinition'\n    }\n  },\n  {\n    label: 'Compensation Start Event',\n    actionName: 'replace-with-compensation-start',\n    className: 'bpmn-icon-start-event-compensation',\n    target: {\n      type: 'bpmn:StartEvent',\n      eventDefinitionType: 'bpmn:CompensateEventDefinition'\n    }\n  },\n  {\n    label: 'Message Start Event (non-interrupting)',\n    actionName: 'replace-with-non-interrupting-message-start',\n    className: 'bpmn-icon-start-event-non-interrupting-message',\n    target: {\n      type: 'bpmn:StartEvent',\n      eventDefinitionType: 'bpmn:MessageEventDefinition',\n      isInterrupting: false\n    }\n  },\n  {\n    label: 'Timer Start Event (non-interrupting)',\n    actionName: 'replace-with-non-interrupting-timer-start',\n    className: 'bpmn-icon-start-event-non-interrupting-timer',\n    target: {\n      type: 'bpmn:StartEvent',\n      eventDefinitionType: 'bpmn:TimerEventDefinition',\n      isInterrupting: false\n    }\n  },\n  {\n    label: 'Conditional Start Event (non-interrupting)',\n    actionName: 'replace-with-non-interrupting-conditional-start',\n    className: 'bpmn-icon-start-event-non-interrupting-condition',\n    target: {\n      type: 'bpmn:StartEvent',\n      eventDefinitionType: 'bpmn:ConditionalEventDefinition',\n      isInterrupting: false\n    }\n  },\n  {\n    label: 'Signal Start Event (non-interrupting)',\n    actionName: 'replace-with-non-interrupting-signal-start',\n    className: 'bpmn-icon-start-event-non-interrupting-signal',\n    target: {\n      type: 'bpmn:StartEvent',\n      eventDefinitionType: 'bpmn:SignalEventDefinition',\n      isInterrupting: false\n    }\n  },\n  {\n    label: 'Escalation Start Event (non-interrupting)',\n    actionName: 'replace-with-non-interrupting-escalation-start',\n    className: 'bpmn-icon-start-event-non-interrupting-escalation',\n    target: {\n      type: 'bpmn:StartEvent',\n      eventDefinitionType: 'bpmn:EscalationEventDefinition',\n      isInterrupting: false\n    }\n  }\n];\n\nexport var SEQUENCE_FLOW = [\n  {\n    label: 'Sequence Flow',\n    actionName: 'replace-with-sequence-flow',\n    className: 'bpmn-icon-connection'\n  },\n  {\n    label: 'Default Flow',\n    actionName: 'replace-with-default-flow',\n    className: 'bpmn-icon-default-flow'\n  },\n  {\n    label: 'Conditional Flow',\n    actionName: 'replace-with-conditional-flow',\n    className: 'bpmn-icon-conditional-flow'\n  }\n];\n\nexport var PARTICIPANT = [\n  {\n    label: 'Expanded Pool',\n    actionName: 'replace-with-expanded-pool',\n    className: 'bpmn-icon-participant',\n    target: {\n      type: 'bpmn:Participant',\n      isExpanded: true\n    }\n  },\n  {\n    label: 'Collapsed Pool',\n    actionName: 'replace-with-collapsed-pool',\n    // TODO(@janstuemmel): maybe design new icon\n    className: 'bpmn-icon-lane',\n    target: {\n      type: 'bpmn:Participant',\n      isExpanded: false\n    }\n  }\n];\n","import SelectionModule from 'diagram-js/lib/features/selection';\nimport ReplaceModule from 'diagram-js/lib/features/replace';\n\nimport BpmnReplace from './BpmnReplace';\n\nexport default {\n  __depends__: [\n    SelectionModule,\n    ReplaceModule\n  ],\n  bpmnReplace: [ 'type', BpmnReplace ]\n};\n","import {\n  find,\n  some,\n  every,\n  forEach\n} from 'min-dash';\n\nimport inherits from 'inherits';\n\nimport {\n  is,\n  getBusinessObject\n} from '../../util/ModelUtil';\n\nimport {\n  isAny\n} from '../modeling/util/ModelingUtil';\n\nimport {\n  isLabel\n} from '../../util/LabelUtil';\n\nimport {\n  isExpanded,\n  isEventSubProcess,\n  isInterrupting,\n  hasErrorEventDefinition,\n  hasEscalationEventDefinition,\n  hasCompensateEventDefinition\n} from '../../util/DiUtil';\n\nimport RuleProvider from 'diagram-js/lib/features/rules/RuleProvider';\n\nimport {\n  getBoundaryAttachment as isBoundaryAttachment\n} from '../snapping/BpmnSnappingUtil';\n\n\n/**\n * BPMN specific modeling rule\n */\nexport default function BpmnRules(eventBus) {\n  RuleProvider.call(this, eventBus);\n}\n\ninherits(BpmnRules, RuleProvider);\n\nBpmnRules.$inject = [ 'eventBus' ];\n\nBpmnRules.prototype.init = function() {\n\n  this.addRule('connection.start', function(context) {\n    var source = context.source;\n\n    return canStartConnection(source);\n  });\n\n  this.addRule('connection.create', function(context) {\n    var source = context.source,\n        target = context.target,\n        hints = context.hints || {},\n        targetParent = hints.targetParent,\n        targetAttach = hints.targetAttach;\n\n    // don't allow incoming connections on\n    // newly created boundary events\n    // to boundary events\n    if (targetAttach) {\n      return false;\n    }\n\n    // temporarily set target parent for scoping\n    // checks to work\n    if (targetParent) {\n      target.parent = targetParent;\n    }\n\n    try {\n      return canConnect(source, target);\n    } finally {\n      // unset temporary target parent\n      if (targetParent) {\n        target.parent = null;\n      }\n    }\n  });\n\n  this.addRule('connection.reconnectStart', function(context) {\n\n    var connection = context.connection,\n        source = context.hover || context.source,\n        target = connection.target;\n\n    return canConnect(source, target, connection);\n  });\n\n  this.addRule('connection.reconnectEnd', function(context) {\n\n    var connection = context.connection,\n        source = connection.source,\n        target = context.hover || context.target;\n\n    return canConnect(source, target, connection);\n  });\n\n  this.addRule('connection.updateWaypoints', function(context) {\n    // OK! but visually ignore\n    return null;\n  });\n\n  this.addRule('shape.resize', function(context) {\n\n    var shape = context.shape,\n        newBounds = context.newBounds;\n\n    return canResize(shape, newBounds);\n  });\n\n  this.addRule('elements.move', function(context) {\n\n    var target = context.target,\n        shapes = context.shapes,\n        position = context.position;\n\n    return canAttach(shapes, target, null, position) ||\n           canReplace(shapes, target, position) ||\n           canMove(shapes, target, position) ||\n           canInsert(shapes, target, position);\n  });\n\n  this.addRule('shape.create', function(context) {\n    return canCreate(\n      context.shape,\n      context.target,\n      context.source,\n      context.position\n    );\n  });\n\n  this.addRule('shape.attach', function(context) {\n\n    return canAttach(\n      context.shape,\n      context.target,\n      null,\n      context.position\n    );\n  });\n\n  this.addRule('element.copy', function(context) {\n    var collection = context.collection,\n        element = context.element;\n\n    return canCopy(collection, element);\n  });\n\n  this.addRule('element.paste', function(context) {\n    var parent = context.parent,\n        element = context.element,\n        position = context.position,\n        source = context.source,\n        target = context.target;\n\n    if (source || target) {\n      return canConnect(source, target);\n    }\n\n    return canAttach([ element ], parent, null, position) || canCreate(element, parent, null, position);\n  });\n\n  this.addRule('elements.paste', function(context) {\n    var tree = context.tree,\n        target = context.target;\n\n    return canPaste(tree, target);\n  });\n};\n\nBpmnRules.prototype.canConnectMessageFlow = canConnectMessageFlow;\n\nBpmnRules.prototype.canConnectSequenceFlow = canConnectSequenceFlow;\n\nBpmnRules.prototype.canConnectDataAssociation = canConnectDataAssociation;\n\nBpmnRules.prototype.canConnectAssociation = canConnectAssociation;\n\nBpmnRules.prototype.canMove = canMove;\n\nBpmnRules.prototype.canAttach = canAttach;\n\nBpmnRules.prototype.canReplace = canReplace;\n\nBpmnRules.prototype.canDrop = canDrop;\n\nBpmnRules.prototype.canInsert = canInsert;\n\nBpmnRules.prototype.canCreate = canCreate;\n\nBpmnRules.prototype.canConnect = canConnect;\n\nBpmnRules.prototype.canResize = canResize;\n\nBpmnRules.prototype.canCopy = canCopy;\n\n/**\n * Utility functions for rule checking\n */\n\n/**\n * Checks if given element can be used for starting connection.\n *\n * @param  {Element} source\n * @return {Boolean}\n */\nfunction canStartConnection(element) {\n  if (nonExistingOrLabel(element)) {\n    return null;\n  }\n\n  return isAny(element, [\n    'bpmn:FlowNode',\n    'bpmn:InteractionNode',\n    'bpmn:DataObjectReference',\n    'bpmn:DataStoreReference'\n  ]);\n}\n\nfunction nonExistingOrLabel(element) {\n  return !element || isLabel(element);\n}\n\nfunction isSame(a, b) {\n  return a === b;\n}\n\nfunction getOrganizationalParent(element) {\n\n  do {\n    if (is(element, 'bpmn:Process')) {\n      return getBusinessObject(element);\n    }\n\n    if (is(element, 'bpmn:Participant')) {\n      return (\n        getBusinessObject(element).processRef ||\n        getBusinessObject(element)\n      );\n    }\n  } while ((element = element.parent));\n\n}\n\nfunction isTextAnnotation(element) {\n  return is(element, 'bpmn:TextAnnotation');\n}\n\nfunction isCompensationBoundary(element) {\n  return is(element, 'bpmn:BoundaryEvent') &&\n         hasEventDefinition(element, 'bpmn:CompensateEventDefinition');\n}\n\nfunction isForCompensation(e) {\n  return getBusinessObject(e).isForCompensation;\n}\n\nfunction isSameOrganization(a, b) {\n  var parentA = getOrganizationalParent(a),\n      parentB = getOrganizationalParent(b);\n\n  return parentA === parentB;\n}\n\nfunction isMessageFlowSource(element) {\n  return (\n    is(element, 'bpmn:InteractionNode') && (\n      !is(element, 'bpmn:Event') || (\n        is(element, 'bpmn:ThrowEvent') &&\n        hasEventDefinitionOrNone(element, 'bpmn:MessageEventDefinition')\n      )\n    )\n  );\n}\n\nfunction isMessageFlowTarget(element) {\n  return (\n    is(element, 'bpmn:InteractionNode') &&\n    !isForCompensation(element) && (\n      !is(element, 'bpmn:Event') || (\n        is(element, 'bpmn:CatchEvent') &&\n        hasEventDefinitionOrNone(element, 'bpmn:MessageEventDefinition')\n      )\n    )\n  );\n}\n\nfunction getScopeParent(element) {\n\n  var parent = element;\n\n  while ((parent = parent.parent)) {\n\n    if (is(parent, 'bpmn:FlowElementsContainer')) {\n      return getBusinessObject(parent);\n    }\n\n    if (is(parent, 'bpmn:Participant')) {\n      return getBusinessObject(parent).processRef;\n    }\n  }\n\n  return null;\n}\n\nfunction isSameScope(a, b) {\n  var scopeParentA = getScopeParent(a),\n      scopeParentB = getScopeParent(b);\n\n  return scopeParentA && (scopeParentA === scopeParentB);\n}\n\nfunction hasEventDefinition(element, eventDefinition) {\n  var bo = getBusinessObject(element);\n\n  return !!find(bo.eventDefinitions || [], function(definition) {\n    return is(definition, eventDefinition);\n  });\n}\n\nfunction hasEventDefinitionOrNone(element, eventDefinition) {\n  var bo = getBusinessObject(element);\n\n  return (bo.eventDefinitions || []).every(function(definition) {\n    return is(definition, eventDefinition);\n  });\n}\n\nfunction isSequenceFlowSource(element) {\n  return (\n    is(element, 'bpmn:FlowNode') &&\n    !is(element, 'bpmn:EndEvent') &&\n    !isEventSubProcess(element) &&\n    !(is(element, 'bpmn:IntermediateThrowEvent') &&\n      hasEventDefinition(element, 'bpmn:LinkEventDefinition')\n    ) &&\n    !isCompensationBoundary(element) &&\n    !isForCompensation(element)\n  );\n}\n\nfunction isSequenceFlowTarget(element) {\n  return (\n    is(element, 'bpmn:FlowNode') &&\n    !is(element, 'bpmn:StartEvent') &&\n    !is(element, 'bpmn:BoundaryEvent') &&\n    !isEventSubProcess(element) &&\n    !(is(element, 'bpmn:IntermediateCatchEvent') &&\n      hasEventDefinition(element, 'bpmn:LinkEventDefinition')\n    ) &&\n    !isForCompensation(element)\n  );\n}\n\nfunction isEventBasedTarget(element) {\n  return (\n    is(element, 'bpmn:ReceiveTask') || (\n      is(element, 'bpmn:IntermediateCatchEvent') && (\n        hasEventDefinition(element, 'bpmn:MessageEventDefinition') ||\n        hasEventDefinition(element, 'bpmn:TimerEventDefinition') ||\n        hasEventDefinition(element, 'bpmn:ConditionalEventDefinition') ||\n        hasEventDefinition(element, 'bpmn:SignalEventDefinition')\n      )\n    )\n  );\n}\n\nfunction isConnection(element) {\n  return element.waypoints;\n}\n\nfunction getParents(element) {\n\n  var parents = [];\n\n  while (element) {\n    element = element.parent;\n\n    if (element) {\n      parents.push(element);\n    }\n  }\n\n  return parents;\n}\n\nfunction isParent(possibleParent, element) {\n  var allParents = getParents(element);\n  return allParents.indexOf(possibleParent) !== -1;\n}\n\nfunction canConnect(source, target, connection) {\n\n  if (nonExistingOrLabel(source) || nonExistingOrLabel(target)) {\n    return null;\n  }\n\n  if (!is(connection, 'bpmn:DataAssociation')) {\n\n    if (canConnectMessageFlow(source, target)) {\n      return { type: 'bpmn:MessageFlow' };\n    }\n\n    if (canConnectSequenceFlow(source, target)) {\n      return { type: 'bpmn:SequenceFlow' };\n    }\n  }\n\n  var connectDataAssociation = canConnectDataAssociation(source, target);\n\n  if (connectDataAssociation) {\n    return connectDataAssociation;\n  }\n\n  if (isCompensationBoundary(source) && isForCompensation(target)) {\n    return {\n      type: 'bpmn:Association',\n      associationDirection: 'One'\n    };\n  }\n\n  if (canConnectAssociation(source, target)) {\n\n    return {\n      type: 'bpmn:Association'\n    };\n  }\n\n  return false;\n}\n\n/**\n * Can an element be dropped into the target element\n *\n * @return {Boolean}\n */\nfunction canDrop(element, target, position) {\n\n  // can move labels everywhere\n  if (isLabel(element)) {\n    return true;\n  }\n\n  // disallow to create elements on collapsed pools\n  if (is(target, 'bpmn:Participant') && !isExpanded(target)) {\n    return false;\n  }\n\n  // allow to create new participants on\n  // on existing collaboration and process diagrams\n  if (is(element, 'bpmn:Participant')) {\n    return is(target, 'bpmn:Process') || is(target, 'bpmn:Collaboration');\n  }\n\n  // allow creating lanes on participants and other lanes only\n  if (is(element, 'bpmn:Lane')) {\n    return is(target, 'bpmn:Participant') || is(target, 'bpmn:Lane');\n  }\n\n  if (is(element, 'bpmn:BoundaryEvent')) {\n    return false;\n  }\n\n  // drop flow elements onto flow element containers\n  // and participants\n  if (is(element, 'bpmn:FlowElement') && !is(element, 'bpmn:DataStoreReference')) {\n    if (is(target, 'bpmn:FlowElementsContainer')) {\n      return isExpanded(target);\n    }\n\n    return isAny(target, [ 'bpmn:Participant', 'bpmn:Lane' ]);\n  }\n\n  // account for the fact that data associations are always\n  // rendered and moved to top (Process or Collaboration level)\n  //\n  // artifacts may be placed wherever, too\n  if (isAny(element, [ 'bpmn:Artifact', 'bpmn:DataAssociation', 'bpmn:DataStoreReference' ])) {\n    return isAny(target, [\n      'bpmn:Collaboration',\n      'bpmn:Lane',\n      'bpmn:Participant',\n      'bpmn:Process',\n      'bpmn:SubProcess' ]);\n  }\n\n  if (is(element, 'bpmn:MessageFlow')) {\n    return is(target, 'bpmn:Collaboration')\n      || element.source.parent == target\n      || element.target.parent == target;\n  }\n\n  return false;\n}\n\nfunction canPaste(tree, target) {\n  var topLevel = tree[0],\n      participants;\n\n  if (is(target, 'bpmn:Collaboration')) {\n    return every(topLevel, function(e) {\n      return e.type === 'bpmn:Participant';\n    });\n  }\n\n  if (is(target, 'bpmn:Process')) {\n    participants = some(topLevel, function(e) {\n      return e.type === 'bpmn:Participant';\n    });\n\n    return !(participants && target.children.length > 0);\n  }\n\n  // disallow to create elements on collapsed pools\n  if (is(target, 'bpmn:Participant') && !isExpanded(target)) {\n    return false;\n  }\n\n  if (is(target, 'bpmn:FlowElementsContainer')) {\n    return isExpanded(target);\n  }\n\n  return isAny(target, [\n    'bpmn:Collaboration',\n    'bpmn:Lane',\n    'bpmn:Participant',\n    'bpmn:Process',\n    'bpmn:SubProcess' ]);\n}\n\nfunction isBoundaryEvent(element) {\n  return !isLabel(element) && is(element, 'bpmn:BoundaryEvent');\n}\n\nfunction isLane(element) {\n  return is(element, 'bpmn:Lane');\n}\n\n/**\n * We treat IntermediateThrowEvents as boundary events during create,\n * this must be reflected in the rules.\n */\nfunction isBoundaryCandidate(element) {\n  return isBoundaryEvent(element) ||\n        (is(element, 'bpmn:IntermediateThrowEvent') && !element.parent);\n}\n\nfunction isReceiveTaskAfterEventBasedGateway(element) {\n  return (\n    is(element, 'bpmn:ReceiveTask') &&\n    find(element.incoming, function(incoming) {\n      return is(incoming.source, 'bpmn:EventBasedGateway');\n    })\n  );\n}\n\n\nfunction canAttach(elements, target, source, position) {\n\n  if (!Array.isArray(elements)) {\n    elements = [ elements ];\n  }\n\n  // disallow appending as boundary event\n  if (source) {\n    return false;\n  }\n\n  // only (re-)attach one element at a time\n  if (elements.length !== 1) {\n    return false;\n  }\n\n  var element = elements[0];\n\n  // do not attach labels\n  if (isLabel(element)) {\n    return false;\n  }\n\n  // only handle boundary events\n  if (!isBoundaryCandidate(element)) {\n    return false;\n  }\n\n  // allow default move operation\n  if (!target) {\n    return true;\n  }\n\n  // disallow drop on event sub processes\n  if (isEventSubProcess(target)) {\n    return false;\n  }\n\n  // only allow drop on non compensation activities\n  if (!is(target, 'bpmn:Activity') || isForCompensation(target)) {\n    return false;\n  }\n\n  // only attach to subprocess border\n  if (position && !isBoundaryAttachment(position, target)) {\n    return false;\n  }\n\n  // do not attach on receive tasks after event based gateways\n  if (isReceiveTaskAfterEventBasedGateway(target)) {\n    return false;\n  }\n\n  return 'attach';\n}\n\n\n/**\n * Defines how to replace elements for a given target.\n *\n * Returns an array containing all elements which will be replaced.\n *\n * @example\n *\n *  [{ id: 'IntermediateEvent_2',\n *     type: 'bpmn:StartEvent'\n *   },\n *   { id: 'IntermediateEvent_5',\n *     type: 'bpmn:EndEvent'\n *   }]\n *\n * @param  {Array} elements\n * @param  {Object} target\n *\n * @return {Object} an object containing all elements which have to be replaced\n */\nfunction canReplace(elements, target, position) {\n\n  if (!target) {\n    return false;\n  }\n\n  var canExecute = {\n    replacements: []\n  };\n\n  forEach(elements, function(element) {\n\n    if (!isEventSubProcess(target)) {\n\n      if (is(element, 'bpmn:StartEvent') &&\n          element.type !== 'label' &&\n          canDrop(element, target)) {\n\n        // replace a non-interrupting start event by a blank interrupting start event\n        // when the target is not an event sub process\n        if (!isInterrupting(element)) {\n          canExecute.replacements.push({\n            oldElementId: element.id,\n            newElementType: 'bpmn:StartEvent'\n          });\n        }\n\n        // replace an error/escalation/compansate start event by a blank interrupting start event\n        // when the target is not an event sub process\n        if (hasErrorEventDefinition(element) ||\n            hasEscalationEventDefinition(element) ||\n            hasCompensateEventDefinition(element)) {\n          canExecute.replacements.push({\n            oldElementId: element.id,\n            newElementType: 'bpmn:StartEvent'\n          });\n        }\n      }\n    }\n\n    if (!is(target, 'bpmn:Transaction')) {\n      if (hasEventDefinition(element, 'bpmn:CancelEventDefinition') &&\n          element.type !== 'label') {\n\n        if (is(element, 'bpmn:EndEvent') && canDrop(element, target)) {\n          canExecute.replacements.push({\n            oldElementId: element.id,\n            newElementType: 'bpmn:EndEvent'\n          });\n        }\n\n        if (is(element, 'bpmn:BoundaryEvent') && canAttach(element, target, null, position)) {\n          canExecute.replacements.push({\n            oldElementId: element.id,\n            newElementType: 'bpmn:BoundaryEvent'\n          });\n        }\n      }\n    }\n  });\n\n  return canExecute.replacements.length ? canExecute : false;\n}\n\nfunction canMove(elements, target) {\n\n  // do not move selection containing boundary events\n  if (some(elements, isBoundaryEvent)) {\n    return false;\n  }\n\n  // do not move selection containing lanes\n  if (some(elements, isLane)) {\n    return false;\n  }\n\n  // allow default move check to start move operation\n  if (!target) {\n    return true;\n  }\n\n  return elements.every(function(element) {\n    return canDrop(element, target);\n  });\n}\n\nfunction canCreate(shape, target, source, position) {\n\n  if (!target) {\n    return false;\n  }\n\n  if (isLabel(target)) {\n    return null;\n  }\n\n  if (isSame(source, target)) {\n    return false;\n  }\n\n  // ensure we do not drop the element\n  // into source\n  if (source && isParent(source, target)) {\n    return false;\n  }\n\n  return canDrop(shape, target, position) || canInsert(shape, target, position);\n}\n\nfunction canResize(shape, newBounds) {\n  if (is(shape, 'bpmn:SubProcess')) {\n    return (\n      isExpanded(shape) && (\n        !newBounds || (newBounds.width >= 100 && newBounds.height >= 80)\n      )\n    );\n  }\n\n  if (is(shape, 'bpmn:Lane')) {\n    return !newBounds || (newBounds.width >= 130 && newBounds.height >= 60);\n  }\n\n  if (is(shape, 'bpmn:Participant')) {\n    return !newBounds || (newBounds.width >= 250 && newBounds.height >= 50);\n  }\n\n  if (isTextAnnotation(shape)) {\n    return true;\n  }\n\n  return false;\n}\n\n/**\n * Check, whether one side of the relationship\n * is a text annotation.\n */\nfunction isOneTextAnnotation(source, target) {\n\n  var sourceTextAnnotation = isTextAnnotation(source),\n      targetTextAnnotation = isTextAnnotation(target);\n\n  return (\n    (sourceTextAnnotation || targetTextAnnotation) &&\n    (sourceTextAnnotation !== targetTextAnnotation)\n  );\n}\n\n\nfunction canConnectAssociation(source, target) {\n\n  // do not connect connections\n  if (isConnection(source) || isConnection(target)) {\n    return false;\n  }\n\n  // compensation boundary events are exception\n  if (isCompensationBoundary(source) && isForCompensation(target)) {\n    return true;\n  }\n\n  // don't connect parent <-> child\n  if (isParent(target, source) || isParent(source, target)) {\n    return false;\n  }\n\n  // allow connection of associations between <!TextAnnotation> and <TextAnnotation>\n  return isOneTextAnnotation(source, target);\n}\n\nfunction canConnectMessageFlow(source, target) {\n\n  return isMessageFlowSource(source) &&\n         isMessageFlowTarget(target) &&\n        !isSameOrganization(source, target);\n}\n\nfunction canConnectSequenceFlow(source, target) {\n\n  return isSequenceFlowSource(source) &&\n         isSequenceFlowTarget(target) &&\n         isSameScope(source, target) &&\n         !(is(source, 'bpmn:EventBasedGateway') && !isEventBasedTarget(target));\n}\n\n\nfunction canConnectDataAssociation(source, target) {\n\n  if (isAny(source, [ 'bpmn:DataObjectReference', 'bpmn:DataStoreReference' ]) &&\n      isAny(target, [ 'bpmn:Activity', 'bpmn:ThrowEvent' ])) {\n    return { type: 'bpmn:DataInputAssociation' };\n  }\n\n  if (isAny(target, [ 'bpmn:DataObjectReference', 'bpmn:DataStoreReference' ]) &&\n      isAny(source, [ 'bpmn:Activity', 'bpmn:CatchEvent' ])) {\n    return { type: 'bpmn:DataOutputAssociation' };\n  }\n\n  return false;\n}\n\nfunction canInsert(shape, flow, position) {\n\n  if (!flow) {\n    return false;\n  }\n\n  if (Array.isArray(shape)) {\n    if (shape.length !== 1) {\n      return false;\n    }\n\n    shape = shape[0];\n  }\n\n  if (flow.source === shape ||\n      flow.target === shape) {\n    return false;\n  }\n\n  // return true if we can drop on the\n  // underlying flow parent\n  //\n  // at this point we are not really able to talk\n  // about connection rules (yet)\n\n  return (\n    isAny(flow, [ 'bpmn:SequenceFlow', 'bpmn:MessageFlow' ]) &&\n    !isLabel(flow) &&\n    is(shape, 'bpmn:FlowNode') &&\n    !is(shape, 'bpmn:BoundaryEvent') &&\n    canDrop(shape, flow.parent, position));\n}\n\nfunction contains(collection, element) {\n  return (collection && element) && collection.indexOf(element) !== -1;\n}\n\nfunction canCopy(collection, element) {\n  if (is(element, 'bpmn:Lane') && !contains(collection, element.parent)) {\n    return false;\n  }\n\n  if (is(element, 'bpmn:BoundaryEvent') && !contains(collection, element.host)) {\n    return false;\n  }\n\n  return true;\n}\n","import RulesModule from 'diagram-js/lib/features/rules';\n\nimport BpmnRules from './BpmnRules';\n\nexport default {\n  __depends__: [\n    RulesModule\n  ],\n  __init__: [ 'bpmnRules' ],\n  bpmnRules: [ 'type', BpmnRules ]\n};\n","import {\n  map,\n  filter,\n  sortBy\n} from 'min-dash';\n\nimport {\n  getLabel\n} from '../label-editing/LabelUtil';\n\n\n/**\n * Provides ability to search through BPMN elements\n */\nexport default function BpmnSearchProvider(elementRegistry, searchPad, canvas) {\n\n  this._elementRegistry = elementRegistry;\n  this._canvas = canvas;\n\n  searchPad.registerProvider(this);\n}\n\nBpmnSearchProvider.$inject = [\n  'elementRegistry',\n  'searchPad',\n  'canvas'\n];\n\n\n/**\n * Finds all elements that match given pattern\n *\n * <Result> :\n *  {\n *    primaryTokens: <Array<Token>>,\n *    secondaryTokens: <Array<Token>>,\n *    element: <Element>\n *  }\n *\n * <Token> :\n *  {\n *    normal|matched: <String>\n *  }\n *\n * @param  {String} pattern\n * @return {Array<Result>}\n */\nBpmnSearchProvider.prototype.find = function(pattern) {\n  var rootElement = this._canvas.getRootElement();\n\n  var elements = this._elementRegistry.filter(function(element) {\n    if (element.labelTarget) {\n      return false;\n    }\n    return true;\n  });\n\n  // do not include root element\n  elements = filter(elements, function(element) {\n    return element !== rootElement;\n  });\n\n  elements = map(elements, function(element) {\n    return {\n      primaryTokens: matchAndSplit(getLabel(element), pattern),\n      secondaryTokens: matchAndSplit(element.id, pattern),\n      element: element\n    };\n  });\n\n  // exclude non-matched elements\n  elements = filter(elements, function(element) {\n    return hasMatched(element.primaryTokens) || hasMatched(element.secondaryTokens);\n  });\n\n  elements = sortBy(elements, function(element) {\n    return getLabel(element.element) + element.element.id;\n  });\n\n  return elements;\n};\n\n\nfunction hasMatched(tokens) {\n  var matched = filter(tokens, function(t) {\n    return !!t.matched;\n  });\n\n  return matched.length > 0;\n}\n\n\nfunction matchAndSplit(text, pattern) {\n  var tokens = [],\n      originalText = text;\n\n  if (!text) {\n    return tokens;\n  }\n\n  text = text.toLowerCase();\n  pattern = pattern.toLowerCase();\n\n  var i = text.indexOf(pattern);\n\n  if (i > -1) {\n    if (i !== 0) {\n      tokens.push({\n        normal: originalText.substr(0, i)\n      });\n    }\n\n    tokens.push({\n      matched: originalText.substr(i, pattern.length)\n    });\n\n    if (pattern.length + i < text.length) {\n      tokens.push({\n        normal: originalText.substr(pattern.length + i, text.length)\n      });\n    }\n  } else {\n    tokens.push({\n      normal: originalText\n    });\n  }\n\n  return tokens;\n}","import SearchPadModule from 'diagram-js/lib/features/search-pad';\n\nimport BpmnSearchProvider from './BpmnSearchProvider';\n\n\nexport default {\n  __depends__: [\n    SearchPadModule\n  ],\n  __init__: [ 'bpmnSearch'],\n  bpmnSearch: [ 'type', BpmnSearchProvider ]\n};\n","import inherits from 'inherits';\n\nimport {\n  forEach\n} from 'min-dash';\n\nimport {\n  getBBox as getBoundingBox\n} from 'diagram-js/lib/util/Elements';\n\nimport { is } from '../../util/ModelUtil';\n\nimport { isAny } from '../modeling/util/ModelingUtil';\n\nimport {\n  isExpanded\n} from '../../util/DiUtil';\n\nimport Snapping from 'diagram-js/lib/features/snapping/Snapping';\n\nimport {\n  mid,\n  topLeft,\n  bottomRight,\n  isSnapped,\n  setSnapped\n} from 'diagram-js/lib/features/snapping/SnapUtil';\n\nimport {\n  asTRBL\n} from 'diagram-js/lib/layout/LayoutUtil';\n\n\nimport {\n  getBoundaryAttachment,\n  getParticipantSizeConstraints\n} from './BpmnSnappingUtil';\n\nimport {\n  getLanesRoot\n} from '../modeling/util/LaneUtil';\n\nvar round = Math.round;\n\nvar HIGH_PRIORITY = 1500;\n\n\n/**\n * BPMN specific snapping functionality\n *\n *  * snap on process elements if a pool is created inside a\n *    process diagram\n *\n * @param {EventBus} eventBus\n * @param {Canvas} canvas\n */\nexport default function BpmnSnapping(eventBus, canvas, bpmnRules, elementRegistry) {\n\n  // instantiate super\n  Snapping.call(this, eventBus, canvas);\n\n\n  /**\n   * Drop participant on process <> process elements snapping\n   */\n  eventBus.on('create.start', function(event) {\n\n    var context = event.context,\n        shape = context.shape,\n        rootElement = canvas.getRootElement();\n\n    // snap participant around existing elements (if any)\n    if (is(shape, 'bpmn:Participant') && is(rootElement, 'bpmn:Process')) {\n      initParticipantSnapping(context, shape, rootElement.children);\n    }\n  });\n\n  eventBus.on([ 'create.move', 'create.end' ], HIGH_PRIORITY, function(event) {\n\n    var context = event.context,\n        shape = context.shape,\n        participantSnapBox = context.participantSnapBox;\n\n    if (!isSnapped(event) && participantSnapBox) {\n      snapParticipant(participantSnapBox, shape, event);\n    }\n  });\n\n  eventBus.on('shape.move.start', function(event) {\n\n    var context = event.context,\n        shape = context.shape,\n        rootElement = canvas.getRootElement();\n\n    // snap participant around existing elements (if any)\n    if (is(shape, 'bpmn:Participant') && is(rootElement, 'bpmn:Process')) {\n      initParticipantSnapping(context, shape, rootElement.children);\n    }\n  });\n\n\n  function canAttach(shape, target, position) {\n    return bpmnRules.canAttach([ shape ], target, null, position) === 'attach';\n  }\n\n  function canConnect(source, target) {\n    return bpmnRules.canConnect(source, target);\n  }\n\n  /**\n   * Snap boundary events to elements border\n   */\n  eventBus.on([\n    'create.move',\n    'create.end',\n    'shape.move.move',\n    'shape.move.end'\n  ], HIGH_PRIORITY, function(event) {\n\n    var context = event.context,\n        target = context.target,\n        shape = context.shape;\n\n    if (target && !isSnapped(event) && canAttach(shape, target, event)) {\n      snapBoundaryEvent(event, shape, target);\n    }\n  });\n\n  /**\n   * Adjust parent for flowElements to the target participant\n   * when droping onto lanes.\n   */\n  eventBus.on([\n    'shape.move.hover',\n    'shape.move.move',\n    'shape.move.end',\n    'create.hover',\n    'create.move',\n    'create.end'\n  ], HIGH_PRIORITY, function(event) {\n    var context = event.context,\n        shape = context.shape,\n        hover = event.hover;\n\n    if (is(hover, 'bpmn:Lane') && !isAny(shape, [ 'bpmn:Lane', 'bpmn:Participant' ])) {\n      event.hover = getLanesRoot(hover);\n      event.hoverGfx = elementRegistry.getGraphics(event.hover);\n    }\n  });\n\n  /**\n   * Snap sequence flows.\n   */\n  eventBus.on([\n    'connect.move',\n    'connect.hover',\n    'connect.end'\n  ], HIGH_PRIORITY, function(event) {\n    var context = event.context,\n        source = context.source,\n        target = context.target;\n\n    var connection = canConnect(source, target) || {};\n\n    if (!context.initialSourcePosition) {\n      context.initialSourcePosition = context.sourcePosition;\n    }\n\n    if (\n      target && (\n        connection.type === 'bpmn:Association' ||\n        connection.type === 'bpmn:DataOutputAssociation' ||\n        connection.type === 'bpmn:DataInputAssociation' ||\n        connection.type === 'bpmn:SequenceFlow'\n      )\n    ) {\n      // snap source\n      context.sourcePosition = mid(source);\n\n      // snap target\n      snapToPosition(event, mid(target));\n    } else\n\n    if (connection.type === 'bpmn:MessageFlow') {\n\n      if (is(source, 'bpmn:Event')) {\n        // snap source\n        context.sourcePosition = mid(source);\n      }\n\n      if (is(target, 'bpmn:Event')) {\n        // snap target\n        snapToPosition(event, mid(target));\n      }\n    }\n\n    else {\n      // otherwise reset source snap\n      context.sourcePosition = context.initialSourcePosition;\n    }\n\n  });\n\n\n  eventBus.on('resize.start', HIGH_PRIORITY, function(event) {\n    var context = event.context,\n        shape = context.shape;\n\n    if (is(shape, 'bpmn:SubProcess') && isExpanded(shape)) {\n      context.minDimensions = { width: 140, height: 120 };\n    }\n\n    if (is(shape, 'bpmn:Participant')) {\n      context.minDimensions = { width: 300, height: 150 };\n    }\n\n    if (is(shape, 'bpmn:Lane') || is(shape, 'bpmn:Participant')) {\n      context.resizeConstraints = getParticipantSizeConstraints(\n        shape,\n        context.direction,\n        context.balanced\n      );\n    }\n\n    if (is(shape, 'bpmn:TextAnnotation')) {\n      context.minDimensions = { width: 50, height: 30 };\n    }\n  });\n\n}\n\ninherits(BpmnSnapping, Snapping);\n\nBpmnSnapping.$inject = [\n  'eventBus',\n  'canvas',\n  'bpmnRules',\n  'elementRegistry'\n];\n\n\nBpmnSnapping.prototype.initSnap = function(event) {\n\n  var context = event.context,\n      shape = event.shape,\n      shapeMid,\n      shapeBounds,\n      shapeTopLeft,\n      shapeBottomRight,\n      snapContext;\n\n\n  snapContext = Snapping.prototype.initSnap.call(this, event);\n\n  if (is(shape, 'bpmn:Participant')) {\n    // assign higher priority for outer snaps on participants\n    snapContext.setSnapLocations([ 'top-left', 'bottom-right', 'mid' ]);\n  }\n\n\n  if (shape) {\n\n    shapeMid = mid(shape, event);\n\n    shapeBounds = {\n      width: shape.width,\n      height: shape.height,\n      x: isNaN(shape.x) ? round(shapeMid.x - shape.width / 2) : shape.x,\n      y: isNaN(shape.y) ? round(shapeMid.y - shape.height / 2) : shape.y\n    };\n\n    shapeTopLeft = topLeft(shapeBounds);\n    shapeBottomRight = bottomRight(shapeBounds);\n\n    snapContext.setSnapOrigin('top-left', {\n      x: shapeTopLeft.x - event.x,\n      y: shapeTopLeft.y - event.y\n    });\n\n    snapContext.setSnapOrigin('bottom-right', {\n      x: shapeBottomRight.x - event.x,\n      y: shapeBottomRight.y - event.y\n    });\n\n    forEach(shape.outgoing, function(c) {\n      var docking = c.waypoints[0];\n\n      docking = docking.original || docking;\n\n      snapContext.setSnapOrigin(c.id + '-docking', {\n        x: docking.x - event.x,\n        y: docking.y - event.y\n      });\n    });\n\n    forEach(shape.incoming, function(c) {\n      var docking = c.waypoints[c.waypoints.length - 1];\n\n      docking = docking.original || docking;\n\n      snapContext.setSnapOrigin(c.id + '-docking', {\n        x: docking.x - event.x,\n        y: docking.y - event.y\n      });\n    });\n\n  }\n\n  var source = context.source;\n\n  if (source) {\n    snapContext.addDefaultSnap('mid', mid(source));\n  }\n};\n\n\nBpmnSnapping.prototype.addTargetSnaps = function(snapPoints, shape, target) {\n\n  // use target parent as snap target\n  if (is(shape, 'bpmn:BoundaryEvent') && shape.type !== 'label') {\n    target = target.parent;\n  }\n\n  // add sequence flow parents as snap targets\n  if (is(target, 'bpmn:SequenceFlow')) {\n    this.addTargetSnaps(snapPoints, shape, target.parent);\n  }\n\n  var siblings = this.getSiblings(shape, target) || [];\n\n  forEach(siblings, function(sibling) {\n\n    // do not snap to lanes\n    if (is(sibling, 'bpmn:Lane')) {\n      return;\n    }\n\n    if (sibling.waypoints) {\n\n      forEach(sibling.waypoints.slice(1, -1), function(waypoint, i) {\n        var nextWaypoint = sibling.waypoints[i + 2],\n            previousWaypoint = sibling.waypoints[i];\n\n        if (!nextWaypoint || !previousWaypoint) {\n          throw new Error('waypoints must exist');\n        }\n\n        if (nextWaypoint.x === waypoint.x ||\n            nextWaypoint.y === waypoint.y ||\n            previousWaypoint.x === waypoint.x ||\n            previousWaypoint.y === waypoint.y) {\n          snapPoints.add('mid', waypoint);\n        }\n      });\n\n      return;\n    }\n\n    snapPoints.add('mid', mid(sibling));\n\n    if (is(sibling, 'bpmn:Participant')) {\n      snapPoints.add('top-left', topLeft(sibling));\n      snapPoints.add('bottom-right', bottomRight(sibling));\n    }\n  });\n\n\n  forEach(shape.incoming, function(c) {\n\n    if (siblings.indexOf(c.source) === -1) {\n      snapPoints.add('mid', mid(c.source));\n    }\n\n    var docking = c.waypoints[0];\n    snapPoints.add(c.id + '-docking', docking.original || docking);\n  });\n\n\n  forEach(shape.outgoing, function(c) {\n\n    if (siblings.indexOf(c.target) === -1) {\n      snapPoints.add('mid', mid(c.target));\n    }\n\n    var docking = c.waypoints[c.waypoints.length - 1];\n    snapPoints.add(c.id + '-docking', docking.original || docking);\n  });\n};\n\n\n// participant snapping //////////////////////\n\nfunction initParticipantSnapping(context, shape, elements) {\n\n  if (!elements.length) {\n    return;\n  }\n\n  var snapBox = getBoundingBox(elements.filter(function(e) {\n    return !e.labelTarget && !e.waypoints;\n  }));\n\n  snapBox.x -= 50;\n  snapBox.y -= 20;\n  snapBox.width += 70;\n  snapBox.height += 40;\n\n  // adjust shape height to include bounding box\n  shape.width = Math.max(shape.width, snapBox.width);\n  shape.height = Math.max(shape.height, snapBox.height);\n\n  context.participantSnapBox = snapBox;\n}\n\nfunction snapParticipant(snapBox, shape, event, offset) {\n  offset = offset || 0;\n\n  var shapeHalfWidth = shape.width / 2 - offset,\n      shapeHalfHeight = shape.height / 2;\n\n  var currentTopLeft = {\n    x: event.x - shapeHalfWidth - offset,\n    y: event.y - shapeHalfHeight\n  };\n\n  var currentBottomRight = {\n    x: event.x + shapeHalfWidth + offset,\n    y: event.y + shapeHalfHeight\n  };\n\n  var snapTopLeft = snapBox,\n      snapBottomRight = bottomRight(snapBox);\n\n  if (currentTopLeft.x >= snapTopLeft.x) {\n    setSnapped(event, 'x', snapTopLeft.x + offset + shapeHalfWidth);\n  } else\n  if (currentBottomRight.x <= snapBottomRight.x) {\n    setSnapped(event, 'x', snapBottomRight.x - offset - shapeHalfWidth);\n  }\n\n  if (currentTopLeft.y >= snapTopLeft.y) {\n    setSnapped(event, 'y', snapTopLeft.y + shapeHalfHeight);\n  } else\n  if (currentBottomRight.y <= snapBottomRight.y) {\n    setSnapped(event, 'y', snapBottomRight.y - shapeHalfHeight);\n  }\n}\n\n\n// boundary event snapping //////////////////////\n\nfunction snapBoundaryEvent(event, shape, target) {\n  var targetTRBL = asTRBL(target);\n\n  var direction = getBoundaryAttachment(event, target);\n\n  if (/top/.test(direction)) {\n    setSnapped(event, 'y', targetTRBL.top);\n  } else\n  if (/bottom/.test(direction)) {\n    setSnapped(event, 'y', targetTRBL.bottom);\n  }\n\n  if (/left/.test(direction)) {\n    setSnapped(event, 'x', targetTRBL.left);\n  } else\n  if (/right/.test(direction)) {\n    setSnapped(event, 'x', targetTRBL.right);\n  }\n}\n\n\nfunction snapToPosition(event, position) {\n  setSnapped(event, 'x', position.x);\n  setSnapped(event, 'y', position.y);\n}","import {\n  getOrientation\n} from 'diagram-js/lib/layout/LayoutUtil';\n\n\nexport function getBoundaryAttachment(position, targetBounds) {\n\n  var orientation = getOrientation(position, targetBounds, -15);\n\n  if (orientation !== 'intersect') {\n    return orientation;\n  } else {\n    return null;\n  }\n}\n\n\n// participant snapping box implementation //////////////////////\n\nimport { is } from '../../util/ModelUtil';\n\nimport {\n  asTRBL\n} from 'diagram-js/lib/layout/LayoutUtil';\n\nimport {\n  collectLanes,\n  getLanesRoot\n} from '../modeling/util/LaneUtil';\n\nvar abs = Math.abs,\n    min = Math.min,\n    max = Math.max;\n\n\nfunction addToTrbl(trbl, attr, value, choice) {\n\n  var current = trbl[attr];\n\n  // make sure to set the value if it does not exist\n  // or apply the correct value by comparing against\n  // choice(value, currentValue)\n  trbl[attr] = current === undefined ? value : choice(value, current);\n}\n\nfunction addMin(trbl, attr, value) {\n  return addToTrbl(trbl, attr, value, min);\n}\n\nfunction addMax(trbl, attr, value) {\n  return addToTrbl(trbl, attr, value, max);\n}\n\n\nvar LANE_MIN_HEIGHT = 60,\n    LANE_MIN_WIDTH = 300,\n    LANE_RIGHT_PADDING = 20,\n    LANE_LEFT_PADDING = 50,\n    LANE_TOP_PADDING = 20,\n    LANE_BOTTOM_PADDING = 20;\n\n\nexport function getParticipantSizeConstraints(laneShape, resizeDirection, balanced) {\n\n  var lanesRoot = getLanesRoot(laneShape);\n\n  var isFirst = true,\n      isLast = true;\n\n  // max top/bottom size for lanes\n\n  var allLanes = collectLanes(lanesRoot, [ lanesRoot ]);\n\n  var laneTrbl = asTRBL(laneShape);\n\n  var maxTrbl = {},\n      minTrbl = {};\n\n  if (/e/.test(resizeDirection)) {\n    minTrbl.right = laneTrbl.left + LANE_MIN_WIDTH;\n  } else\n  if (/w/.test(resizeDirection)) {\n    minTrbl.left = laneTrbl.right - LANE_MIN_WIDTH;\n  }\n\n  allLanes.forEach(function(other) {\n\n    var otherTrbl = asTRBL(other);\n\n    if (/n/.test(resizeDirection)) {\n\n      if (otherTrbl.top < (laneTrbl.top - 10)) {\n        isFirst = false;\n      }\n\n      // max top size (based on next element)\n      if (balanced && abs(laneTrbl.top - otherTrbl.bottom) < 10) {\n        addMax(maxTrbl, 'top', otherTrbl.top + LANE_MIN_HEIGHT);\n      }\n\n      // min top size (based on self or nested element)\n      if (abs(laneTrbl.top - otherTrbl.top) < 5) {\n        addMin(minTrbl, 'top', otherTrbl.bottom - LANE_MIN_HEIGHT);\n      }\n    }\n\n    if (/s/.test(resizeDirection)) {\n\n      if (otherTrbl.bottom > (laneTrbl.bottom + 10)) {\n        isLast = false;\n      }\n\n      // max bottom size (based on previous element)\n      if (balanced && abs(laneTrbl.bottom - otherTrbl.top) < 10) {\n        addMin(maxTrbl, 'bottom', otherTrbl.bottom - LANE_MIN_HEIGHT);\n      }\n\n      // min bottom size (based on self or nested element)\n      if (abs(laneTrbl.bottom - otherTrbl.bottom) < 5) {\n        addMax(minTrbl, 'bottom', otherTrbl.top + LANE_MIN_HEIGHT);\n      }\n    }\n  });\n\n\n  // max top/bottom/left/right size based on flow nodes\n\n  var flowElements = lanesRoot.children.filter(function(s) {\n    return !s.hidden && !s.waypoints && (is(s, 'bpmn:FlowElement') || is(s, 'bpmn:Artifact'));\n  });\n\n  flowElements.forEach(function(flowElement) {\n\n    var flowElementTrbl = asTRBL(flowElement);\n\n    if (isFirst && /n/.test(resizeDirection)) {\n      addMin(minTrbl, 'top', flowElementTrbl.top - LANE_TOP_PADDING);\n    }\n\n    if (/e/.test(resizeDirection)) {\n      addMax(minTrbl, 'right', flowElementTrbl.right + LANE_RIGHT_PADDING);\n    }\n\n    if (isLast && /s/.test(resizeDirection)) {\n      addMax(minTrbl, 'bottom', flowElementTrbl.bottom + LANE_BOTTOM_PADDING);\n    }\n\n    if (/w/.test(resizeDirection)) {\n      addMin(minTrbl, 'left', flowElementTrbl.left - LANE_LEFT_PADDING);\n    }\n  });\n\n\n  return {\n    min: minTrbl,\n    max: maxTrbl\n  };\n}","import BpmnSnapping from './BpmnSnapping';\n\nexport default {\n  __init__: [ 'snapping' ],\n  snapping: [ 'type', BpmnSnapping ]\n};","import {\n  assign,\n  map\n} from 'min-dash';\n\nimport { is } from '../util/ModelUtil';\n\nimport {\n  isLabelExternal,\n  getExternalLabelBounds\n} from '../util/LabelUtil';\n\nimport {\n  getMid\n} from 'diagram-js/lib/layout/LayoutUtil';\n\nimport {\n  isExpanded\n} from '../util/DiUtil';\n\nimport {\n  elementToString\n} from './Util';\n\n\nfunction elementData(semantic, attrs) {\n  return assign({\n    id: semantic.id,\n    type: semantic.$type,\n    businessObject: semantic\n  }, attrs);\n}\n\nfunction collectWaypoints(waypoints) {\n  return map(waypoints, function(p) {\n    return { x: p.x, y: p.y };\n  });\n}\n\nfunction notYetDrawn(translate, semantic, refSemantic, property) {\n  return new Error(translate('element {element} referenced by {referenced}#{property} not yet drawn', {\n    element: elementToString(refSemantic),\n    referenced: elementToString(semantic),\n    property: property\n  }));\n}\n\n\n/**\n * An importer that adds bpmn elements to the canvas\n *\n * @param {EventBus} eventBus\n * @param {Canvas} canvas\n * @param {ElementFactory} elementFactory\n * @param {ElementRegistry} elementRegistry\n * @param {Function} translate\n * @param {TextRenderer} textRenderer\n */\nexport default function BpmnImporter(\n    eventBus, canvas, elementFactory,\n    elementRegistry, translate, textRenderer) {\n\n  this._eventBus = eventBus;\n  this._canvas = canvas;\n  this._elementFactory = elementFactory;\n  this._elementRegistry = elementRegistry;\n  this._translate = translate;\n  this._textRenderer = textRenderer;\n}\n\nBpmnImporter.$inject = [\n  'eventBus',\n  'canvas',\n  'elementFactory',\n  'elementRegistry',\n  'translate',\n  'textRenderer'\n];\n\n\n/**\n * Add bpmn element (semantic) to the canvas onto the\n * specified parent shape.\n */\nBpmnImporter.prototype.add = function(semantic, parentElement) {\n\n  var di = semantic.di,\n      element,\n      translate = this._translate,\n      hidden;\n\n  var parentIndex;\n\n  // ROOT ELEMENT\n  // handle the special case that we deal with a\n  // invisible root element (process or collaboration)\n  if (is(di, 'bpmndi:BPMNPlane')) {\n\n    // add a virtual element (not being drawn)\n    element = this._elementFactory.createRoot(elementData(semantic));\n\n    this._canvas.setRootElement(element);\n  }\n\n  // SHAPE\n  else if (is(di, 'bpmndi:BPMNShape')) {\n\n    var collapsed = !isExpanded(semantic);\n    hidden = parentElement && (parentElement.hidden || parentElement.collapsed);\n\n    var bounds = semantic.di.bounds;\n\n    element = this._elementFactory.createShape(elementData(semantic, {\n      collapsed: collapsed,\n      hidden: hidden,\n      x: Math.round(bounds.x),\n      y: Math.round(bounds.y),\n      width: Math.round(bounds.width),\n      height: Math.round(bounds.height)\n    }));\n\n    if (is(semantic, 'bpmn:BoundaryEvent')) {\n      this._attachBoundary(semantic, element);\n    }\n\n    // insert lanes behind other flow nodes (cf. #727)\n    if (is(semantic, 'bpmn:Lane')) {\n      parentIndex = 0;\n    }\n\n    if (is(semantic, 'bpmn:DataStoreReference')) {\n\n      // check wether data store is inside our outside of its semantic parent\n      if (!isPointInsideBBox(parentElement, getMid(bounds))) {\n        parentElement = this._canvas.getRootElement();\n      }\n    }\n\n    this._canvas.addShape(element, parentElement, parentIndex);\n  }\n\n  // CONNECTION\n  else if (is(di, 'bpmndi:BPMNEdge')) {\n\n    var source = this._getSource(semantic),\n        target = this._getTarget(semantic);\n\n    hidden = parentElement && (parentElement.hidden || parentElement.collapsed);\n\n    element = this._elementFactory.createConnection(elementData(semantic, {\n      hidden: hidden,\n      source: source,\n      target: target,\n      waypoints: collectWaypoints(semantic.di.waypoint)\n    }));\n\n    if (is(semantic, 'bpmn:DataAssociation')) {\n\n      // render always on top; this ensures DataAssociations\n      // are rendered correctly across different \"hacks\" people\n      // love to model such as cross participant / sub process\n      // associations\n      parentElement = null;\n    }\n\n    // insert sequence flows behind other flow nodes (cf. #727)\n    if (is(semantic, 'bpmn:SequenceFlow')) {\n      parentIndex = 0;\n    }\n\n    this._canvas.addConnection(element, parentElement, parentIndex);\n  } else {\n    throw new Error(translate('unknown di {di} for element {semantic}', {\n      di: elementToString(di),\n      semantic: elementToString(semantic)\n    }));\n  }\n  // (optional) LABEL\n  if (isLabelExternal(semantic) && semantic.name) {\n    this.addLabel(semantic, element);\n  }\n\n\n  this._eventBus.fire('bpmnElement.added', { element: element });\n\n  return element;\n};\n\n\n/**\n * Attach the boundary element to the given host\n *\n * @param {ModdleElement} boundarySemantic\n * @param {djs.model.Base} boundaryElement\n */\nBpmnImporter.prototype._attachBoundary = function(boundarySemantic, boundaryElement) {\n  var translate = this._translate;\n  var hostSemantic = boundarySemantic.attachedToRef;\n\n  if (!hostSemantic) {\n    throw new Error(translate('missing {semantic}#attachedToRef', {\n      semantic: elementToString(boundarySemantic)\n    }));\n  }\n\n  var host = this._elementRegistry.get(hostSemantic.id),\n      attachers = host && host.attachers;\n\n  if (!host) {\n    throw notYetDrawn(translate, boundarySemantic, hostSemantic, 'attachedToRef');\n  }\n\n  // wire element.host <> host.attachers\n  boundaryElement.host = host;\n\n  if (!attachers) {\n    host.attachers = attachers = [];\n  }\n\n  if (attachers.indexOf(boundaryElement) === -1) {\n    attachers.push(boundaryElement);\n  }\n};\n\n\n/**\n * add label for an element\n */\nBpmnImporter.prototype.addLabel = function(semantic, element) {\n  var bounds,\n      text,\n      label;\n\n  bounds = getExternalLabelBounds(semantic, element);\n\n  text = semantic.name;\n\n  if (text) {\n    // get corrected bounds from actual layouted text\n    bounds = this._textRenderer.getExternalLabelBounds(bounds, text);\n  }\n\n  label = this._elementFactory.createLabel(elementData(semantic, {\n    id: semantic.id + '_label',\n    labelTarget: element,\n    type: 'label',\n    hidden: element.hidden || !semantic.name,\n    x: Math.round(bounds.x),\n    y: Math.round(bounds.y),\n    width: Math.round(bounds.width),\n    height: Math.round(bounds.height)\n  }));\n\n  return this._canvas.addShape(label, element.parent);\n};\n\n/**\n * Return the drawn connection end based on the given side.\n *\n * @throws {Error} if the end is not yet drawn\n */\nBpmnImporter.prototype._getEnd = function(semantic, side) {\n\n  var element,\n      refSemantic,\n      type = semantic.$type,\n      translate = this._translate;\n\n  refSemantic = semantic[side + 'Ref'];\n\n  // handle mysterious isMany DataAssociation#sourceRef\n  if (side === 'source' && type === 'bpmn:DataInputAssociation') {\n    refSemantic = refSemantic && refSemantic[0];\n  }\n\n  // fix source / target for DataInputAssociation / DataOutputAssociation\n  if (side === 'source' && type === 'bpmn:DataOutputAssociation' ||\n      side === 'target' && type === 'bpmn:DataInputAssociation') {\n\n    refSemantic = semantic.$parent;\n  }\n\n  element = refSemantic && this._getElement(refSemantic);\n\n  if (element) {\n    return element;\n  }\n\n  if (refSemantic) {\n    throw notYetDrawn(translate, semantic, refSemantic, side + 'Ref');\n  } else {\n    throw new Error(translate('{semantic}#{side} Ref not specified', {\n      semantic: elementToString(semantic),\n      side: side\n    }));\n  }\n};\n\nBpmnImporter.prototype._getSource = function(semantic) {\n  return this._getEnd(semantic, 'source');\n};\n\nBpmnImporter.prototype._getTarget = function(semantic) {\n  return this._getEnd(semantic, 'target');\n};\n\n\nBpmnImporter.prototype._getElement = function(semantic) {\n  return this._elementRegistry.get(semantic.id);\n};\n\n\n// helpers ////////////////////\n\nfunction isPointInsideBBox(bbox, point) {\n  var x = point.x,\n      y = point.y;\n\n  return x >= bbox.x &&\n    x <= bbox.x + bbox.width &&\n    y >= bbox.y &&\n    y <= bbox.y + bbox.height;\n}","import {\n  filter,\n  find,\n  forEach\n} from 'min-dash';\n\nimport Refs from 'object-refs';\n\nimport {\n  elementToString\n} from './Util';\n\nvar diRefs = new Refs(\n  { name: 'bpmnElement', enumerable: true },\n  { name: 'di', configurable: true }\n);\n\n/**\n * Returns true if an element has the given meta-model type\n *\n * @param  {ModdleElement}  element\n * @param  {String}         type\n *\n * @return {Boolean}\n */\nfunction is(element, type) {\n  return element.$instanceOf(type);\n}\n\n\n/**\n * Find a suitable display candidate for definitions where the DI does not\n * correctly specify one.\n */\nfunction findDisplayCandidate(definitions) {\n  return find(definitions.rootElements, function(e) {\n    return is(e, 'bpmn:Process') || is(e, 'bpmn:Collaboration');\n  });\n}\n\n\nexport default function BpmnTreeWalker(handler, translate) {\n\n  // list of containers already walked\n  var handledElements = {};\n\n  // list of elements to handle deferred to ensure\n  // prerequisites are drawn\n  var deferred = [];\n\n  // Helpers //////////////////////\n\n  function contextual(fn, ctx) {\n    return function(e) {\n      fn(e, ctx);\n    };\n  }\n\n  function handled(element) {\n    handledElements[element.id] = element;\n  }\n\n  function isHandled(element) {\n    return handledElements[element.id];\n  }\n\n  function visit(element, ctx) {\n\n    var gfx = element.gfx;\n\n    // avoid multiple rendering of elements\n    if (gfx) {\n      throw new Error(\n        translate('already rendered {element}', { element: elementToString(element) })\n      );\n    }\n\n    // call handler\n    return handler.element(element, ctx);\n  }\n\n  function visitRoot(element, diagram) {\n    return handler.root(element, diagram);\n  }\n\n  function visitIfDi(element, ctx) {\n\n    try {\n      var gfx = element.di && visit(element, ctx);\n\n      handled(element);\n\n      return gfx;\n    } catch (e) {\n      logError(e.message, { element: element, error: e });\n\n      console.error(translate('failed to import {element}', { element: elementToString(element) }));\n      console.error(e);\n    }\n  }\n\n  function logError(message, context) {\n    handler.error(message, context);\n  }\n\n  // DI handling //////////////////////\n\n  function registerDi(di) {\n    var bpmnElement = di.bpmnElement;\n\n    if (bpmnElement) {\n      if (bpmnElement.di) {\n        logError(\n          translate('multiple DI elements defined for {element}', {\n            element: elementToString(bpmnElement)\n          }),\n          { element: bpmnElement }\n        );\n      } else {\n        diRefs.bind(bpmnElement, 'di');\n        bpmnElement.di = di;\n      }\n    } else {\n      logError(\n        translate('no bpmnElement referenced in {element}', {\n          element: elementToString(di)\n        }),\n        { element: di }\n      );\n    }\n  }\n\n  function handleDiagram(diagram) {\n    handlePlane(diagram.plane);\n  }\n\n  function handlePlane(plane) {\n    registerDi(plane);\n\n    forEach(plane.planeElement, handlePlaneElement);\n  }\n\n  function handlePlaneElement(planeElement) {\n    registerDi(planeElement);\n  }\n\n\n  // Semantic handling //////////////////////\n\n  /**\n   * Handle definitions and return the rendered diagram (if any)\n   *\n   * @param {ModdleElement} definitions to walk and import\n   * @param {ModdleElement} [diagram] specific diagram to import and display\n   *\n   * @throws {Error} if no diagram to display could be found\n   */\n  function handleDefinitions(definitions, diagram) {\n    // make sure we walk the correct bpmnElement\n\n    var diagrams = definitions.diagrams;\n\n    if (diagram && diagrams.indexOf(diagram) === -1) {\n      throw new Error(translate('diagram not part of bpmn:Definitions'));\n    }\n\n    if (!diagram && diagrams && diagrams.length) {\n      diagram = diagrams[0];\n    }\n\n    // no diagram -> nothing to import\n    if (!diagram) {\n      throw new Error(translate('no diagram to display'));\n    }\n\n    // load DI from selected diagram only\n    handleDiagram(diagram);\n\n\n    var plane = diagram.plane;\n\n    if (!plane) {\n      throw new Error(translate(\n        'no plane for {element}',\n        { element: elementToString(diagram) }\n      ));\n    }\n\n    var rootElement = plane.bpmnElement;\n\n    // ensure we default to a suitable display candidate (process or collaboration),\n    // even if non is specified in DI\n    if (!rootElement) {\n      rootElement = findDisplayCandidate(definitions);\n\n      if (!rootElement) {\n        throw new Error(translate('no process or collaboration to display'));\n      } else {\n\n        logError(\n          translate('correcting missing bpmnElement on {plane} to {rootElement}', {\n            plane: elementToString(plane),\n            rootElement: elementToString(rootElement)\n          })\n        );\n\n        // correct DI on the fly\n        plane.bpmnElement = rootElement;\n        registerDi(plane);\n      }\n    }\n\n\n    var ctx = visitRoot(rootElement, plane);\n\n    if (is(rootElement, 'bpmn:Process')) {\n      handleProcess(rootElement, ctx);\n    } else if (is(rootElement, 'bpmn:Collaboration')) {\n      handleCollaboration(rootElement, ctx);\n\n      // force drawing of everything not yet drawn that is part of the target DI\n      handleUnhandledProcesses(definitions.rootElements, ctx);\n    } else {\n      throw new Error(\n        translate('unsupported bpmnElement for {plane}: {rootElement}', {\n          plane: elementToString(plane),\n          rootElement: elementToString(rootElement)\n        })\n      );\n    }\n\n    // handle all deferred elements\n    handleDeferred(deferred);\n  }\n\n  function handleDeferred() {\n\n    var fn;\n\n    // drain deferred until empty\n    while (deferred.length) {\n      fn = deferred.shift();\n\n      fn();\n    }\n  }\n\n  function handleProcess(process, context) {\n    handleFlowElementsContainer(process, context);\n    handleIoSpecification(process.ioSpecification, context);\n\n    handleArtifacts(process.artifacts, context);\n\n    // log process handled\n    handled(process);\n  }\n\n  function handleUnhandledProcesses(rootElements) {\n\n    // walk through all processes that have not yet been drawn and draw them\n    // if they contain lanes with DI information.\n    // we do this to pass the free-floating lane test cases in the MIWG test suite\n    var processes = filter(rootElements, function(e) {\n      return !isHandled(e) && is(e, 'bpmn:Process') && e.laneSets;\n    });\n\n    processes.forEach(contextual(handleProcess));\n  }\n\n  function handleMessageFlow(messageFlow, context) {\n    visitIfDi(messageFlow, context);\n  }\n\n  function handleMessageFlows(messageFlows, context) {\n    forEach(messageFlows, contextual(handleMessageFlow, context));\n  }\n\n  function handleDataAssociation(association, context) {\n    visitIfDi(association, context);\n  }\n\n  function handleDataInput(dataInput, context) {\n    visitIfDi(dataInput, context);\n  }\n\n  function handleDataOutput(dataOutput, context) {\n    visitIfDi(dataOutput, context);\n  }\n\n  function handleArtifact(artifact, context) {\n\n    // bpmn:TextAnnotation\n    // bpmn:Group\n    // bpmn:Association\n\n    visitIfDi(artifact, context);\n  }\n\n  function handleArtifacts(artifacts, context) {\n\n    forEach(artifacts, function(e) {\n      if (is(e, 'bpmn:Association')) {\n        deferred.push(function() {\n          handleArtifact(e, context);\n        });\n      } else {\n        handleArtifact(e, context);\n      }\n    });\n  }\n\n  function handleIoSpecification(ioSpecification, context) {\n\n    if (!ioSpecification) {\n      return;\n    }\n\n    forEach(ioSpecification.dataInputs, contextual(handleDataInput, context));\n    forEach(ioSpecification.dataOutputs, contextual(handleDataOutput, context));\n  }\n\n  function handleSubProcess(subProcess, context) {\n    handleFlowElementsContainer(subProcess, context);\n    handleArtifacts(subProcess.artifacts, context);\n  }\n\n  function handleFlowNode(flowNode, context) {\n    var childCtx = visitIfDi(flowNode, context);\n\n    if (is(flowNode, 'bpmn:SubProcess')) {\n      handleSubProcess(flowNode, childCtx || context);\n    }\n\n    if (is(flowNode, 'bpmn:Activity')) {\n      handleIoSpecification(flowNode.ioSpecification, context);\n    }\n\n    // defer handling of associations\n    // affected types:\n    //\n    //   * bpmn:Activity\n    //   * bpmn:ThrowEvent\n    //   * bpmn:CatchEvent\n    //\n    deferred.push(function() {\n      forEach(flowNode.dataInputAssociations, contextual(handleDataAssociation, context));\n      forEach(flowNode.dataOutputAssociations, contextual(handleDataAssociation, context));\n    });\n  }\n\n  function handleSequenceFlow(sequenceFlow, context) {\n    visitIfDi(sequenceFlow, context);\n  }\n\n  function handleDataElement(dataObject, context) {\n    visitIfDi(dataObject, context);\n  }\n\n  function handleBoundaryEvent(dataObject, context) {\n    visitIfDi(dataObject, context);\n  }\n\n  function handleLane(lane, context) {\n\n    deferred.push(function() {\n\n      var newContext = visitIfDi(lane, context);\n\n      if (lane.childLaneSet) {\n        handleLaneSet(lane.childLaneSet, newContext || context);\n      }\n\n      wireFlowNodeRefs(lane);\n    });\n  }\n\n  function handleLaneSet(laneSet, context) {\n    forEach(laneSet.lanes, contextual(handleLane, context));\n  }\n\n  function handleLaneSets(laneSets, context) {\n    forEach(laneSets, contextual(handleLaneSet, context));\n  }\n\n  function handleFlowElementsContainer(container, context) {\n    handleFlowElements(container.flowElements, context);\n\n    if (container.laneSets) {\n      handleLaneSets(container.laneSets, context);\n    }\n  }\n\n  function handleFlowElements(flowElements, context) {\n    forEach(flowElements, function(e) {\n      if (is(e, 'bpmn:SequenceFlow')) {\n        deferred.push(function() {\n          handleSequenceFlow(e, context);\n        });\n      } else if (is(e, 'bpmn:BoundaryEvent')) {\n        deferred.unshift(function() {\n          handleBoundaryEvent(e, context);\n        });\n      } else if (is(e, 'bpmn:FlowNode')) {\n        handleFlowNode(e, context);\n      } else if (is(e, 'bpmn:DataObject')) {\n        // SKIP (assume correct referencing via DataObjectReference)\n      } else if (is(e, 'bpmn:DataStoreReference')) {\n        handleDataElement(e, context);\n      } else if (is(e, 'bpmn:DataObjectReference')) {\n        handleDataElement(e, context);\n      } else {\n        logError(\n          translate('unrecognized flowElement {element} in context {context}', {\n            element: elementToString(e),\n            context: (context ? elementToString(context.businessObject) : 'null')\n          }),\n          { element: e, context: context }\n        );\n      }\n    });\n  }\n\n  function handleParticipant(participant, context) {\n    var newCtx = visitIfDi(participant, context);\n\n    var process = participant.processRef;\n    if (process) {\n      handleProcess(process, newCtx || context);\n    }\n  }\n\n  function handleCollaboration(collaboration) {\n\n    forEach(collaboration.participants, contextual(handleParticipant));\n\n    handleArtifacts(collaboration.artifacts);\n\n    // handle message flows latest in the process\n    deferred.push(function() {\n      handleMessageFlows(collaboration.messageFlows);\n    });\n  }\n\n\n  function wireFlowNodeRefs(lane) {\n    // wire the virtual flowNodeRefs <-> relationship\n    forEach(lane.flowNodeRef, function(flowNode) {\n      var lanes = flowNode.get('lanes');\n\n      if (lanes) {\n        lanes.push(lane);\n      }\n    });\n  }\n\n  // API //////////////////////\n\n  return {\n    handleDeferred: handleDeferred,\n    handleDefinitions: handleDefinitions,\n    handleSubProcess: handleSubProcess,\n    registerDi: registerDi\n  };\n}","import BpmnTreeWalker from './BpmnTreeWalker';\n\n\n/**\n * Import the definitions into a diagram.\n *\n * Errors and warnings are reported through the specified callback.\n *\n * @param  {Diagram} diagram\n * @param  {ModdleElement} definitions\n * @param  {Function} done the callback, invoked with (err, [ warning ]) once the import is done\n */\nexport function importBpmnDiagram(diagram, definitions, done) {\n\n  var importer,\n      eventBus,\n      translate;\n\n  var error,\n      warnings = [];\n\n  /**\n   * Walk the diagram semantically, importing (=drawing)\n   * all elements you encounter.\n   *\n   * @param {ModdleElement} definitions\n   */\n  function render(definitions) {\n\n    var visitor = {\n\n      root: function(element) {\n        return importer.add(element);\n      },\n\n      element: function(element, parentShape) {\n        return importer.add(element, parentShape);\n      },\n\n      error: function(message, context) {\n        warnings.push({ message: message, context: context });\n      }\n    };\n\n    var walker = new BpmnTreeWalker(visitor, translate);\n\n    // traverse BPMN 2.0 document model,\n    // starting at definitions\n    walker.handleDefinitions(definitions);\n  }\n\n  try {\n    importer = diagram.get('bpmnImporter');\n    eventBus = diagram.get('eventBus');\n    translate = diagram.get('translate');\n\n    eventBus.fire('import.render.start', { definitions: definitions });\n\n    render(definitions);\n\n    eventBus.fire('import.render.complete', {\n      error: error,\n      warnings: warnings\n    });\n  } catch (e) {\n    error = e;\n  }\n\n  done(error, warnings);\n}","export function elementToString(e) {\n  if (!e) {\n    return '<null>';\n  }\n\n  return '<' + e.$type + (e.id ? ' id=\"' + e.id : '') + '\" />';\n}","import translate from 'diagram-js/lib/i18n/translate';\n\nimport BpmnImporter from './BpmnImporter';\n\nexport default {\n  __depends__: [\n    translate\n  ],\n  bpmnImporter: [ 'type', BpmnImporter ]\n};","import {\n  is,\n  getBusinessObject\n} from './ModelUtil';\n\nimport {\n  forEach\n} from 'min-dash';\n\n\nexport function isExpanded(element) {\n\n  if (is(element, 'bpmn:CallActivity')) {\n    return false;\n  }\n\n  if (is(element, 'bpmn:SubProcess')) {\n    return !!getBusinessObject(element).di.isExpanded;\n  }\n\n  if (is(element, 'bpmn:Participant')) {\n    return !!getBusinessObject(element).processRef;\n  }\n\n  return true;\n}\n\nexport function isInterrupting(element) {\n  return element && getBusinessObject(element).isInterrupting !== false;\n}\n\nexport function isEventSubProcess(element) {\n  return element && !!getBusinessObject(element).triggeredByEvent;\n}\n\nexport function hasEventDefinition(element, eventType) {\n  var bo = getBusinessObject(element),\n      hasEventDefinition = false;\n\n  if (bo.eventDefinitions) {\n    forEach(bo.eventDefinitions, function(event) {\n      if (is(event, eventType)) {\n        hasEventDefinition = true;\n      }\n    });\n  }\n\n  return hasEventDefinition;\n}\n\nexport function hasErrorEventDefinition(element) {\n  return hasEventDefinition(element, 'bpmn:ErrorEventDefinition');\n}\n\nexport function hasEscalationEventDefinition(element) {\n  return hasEventDefinition(element, 'bpmn:EscalationEventDefinition');\n}\n\nexport function hasCompensateEventDefinition(element) {\n  return hasEventDefinition(element, 'bpmn:CompensateEventDefinition');\n}\n","import {\n  assign\n} from 'min-dash';\n\nimport { is } from './ModelUtil';\n\n\nexport var DEFAULT_LABEL_SIZE = {\n  width: 90,\n  height: 20\n};\n\nexport var FLOW_LABEL_INDENT = 15;\n\n\n/**\n * Returns true if the given semantic has an external label\n *\n * @param {BpmnElement} semantic\n * @return {Boolean} true if has label\n */\nexport function isLabelExternal(semantic) {\n  return is(semantic, 'bpmn:Event') ||\n         is(semantic, 'bpmn:Gateway') ||\n         is(semantic, 'bpmn:DataStoreReference') ||\n         is(semantic, 'bpmn:DataObjectReference') ||\n         is(semantic, 'bpmn:SequenceFlow') ||\n         is(semantic, 'bpmn:MessageFlow');\n}\n\n/**\n * Returns true if the given element has an external label\n *\n * @param {djs.model.shape} element\n * @return {Boolean} true if has label\n */\nexport function hasExternalLabel(element) {\n  return isLabel(element.label);\n}\n\n/**\n * Get the position for sequence flow labels\n *\n * @param  {Array<Point>} waypoints\n * @return {Point} the label position\n */\nexport function getFlowLabelPosition(waypoints) {\n\n  // get the waypoints mid\n  var mid = waypoints.length / 2 - 1;\n\n  var first = waypoints[Math.floor(mid)];\n  var second = waypoints[Math.ceil(mid + 0.01)];\n\n  // get position\n  var position = getWaypointsMid(waypoints);\n\n  // calculate angle\n  var angle = Math.atan((second.y - first.y) / (second.x - first.x));\n\n  var x = position.x,\n      y = position.y;\n\n  if (Math.abs(angle) < Math.PI / 2) {\n    y -= FLOW_LABEL_INDENT;\n  } else {\n    x += FLOW_LABEL_INDENT;\n  }\n\n  return { x: x, y: y };\n}\n\n\n/**\n * Get the middle of a number of waypoints\n *\n * @param  {Array<Point>} waypoints\n * @return {Point} the mid point\n */\nexport function getWaypointsMid(waypoints) {\n\n  var mid = waypoints.length / 2 - 1;\n\n  var first = waypoints[Math.floor(mid)];\n  var second = waypoints[Math.ceil(mid + 0.01)];\n\n  return {\n    x: first.x + (second.x - first.x) / 2,\n    y: first.y + (second.y - first.y) / 2\n  };\n}\n\n\nexport function getExternalLabelMid(element) {\n\n  if (element.waypoints) {\n    return getFlowLabelPosition(element.waypoints);\n  } else {\n    return {\n      x: element.x + element.width / 2,\n      y: element.y + element.height + DEFAULT_LABEL_SIZE.height / 2\n    };\n  }\n}\n\n\n/**\n * Returns the bounds of an elements label, parsed from the elements DI or\n * generated from its bounds.\n *\n * @param {BpmnElement} semantic\n * @param {djs.model.Base} element\n */\nexport function getExternalLabelBounds(semantic, element) {\n\n  var mid,\n      size,\n      bounds,\n      di = semantic.di,\n      label = di.label;\n\n  if (label && label.bounds) {\n    bounds = label.bounds;\n\n    size = {\n      width: Math.max(DEFAULT_LABEL_SIZE.width, bounds.width),\n      height: bounds.height\n    };\n\n    mid = {\n      x: bounds.x + bounds.width / 2,\n      y: bounds.y + bounds.height / 2\n    };\n  } else {\n\n    mid = getExternalLabelMid(element);\n\n    size = DEFAULT_LABEL_SIZE;\n  }\n\n  return assign({\n    x: mid.x - size.width / 2,\n    y: mid.y - size.height / 2\n  }, size);\n}\n\nexport function isLabel(element) {\n  return element && element.labelTarget;\n}\n","/**\n * Is an element of the given BPMN type?\n *\n * @param  {djs.model.Base|ModdleElement} element\n * @param  {String} type\n *\n * @return {Boolean}\n */\nexport function is(element, type) {\n  var bo = getBusinessObject(element);\n\n  return bo && (typeof bo.$instanceOf === 'function') && bo.$instanceOf(type);\n}\n\n\n/**\n * Return the business object for a given element.\n *\n * @param  {djs.model.Base|ModdleElement} element\n *\n * @return {ModdleElement}\n */\nexport function getBusinessObject(element) {\n  return (element && element.businessObject) || element;\n}","/**\n * This file must not be changed or exchanged.\n *\n * @see http://bpmn.io/license for more information.\n */\n\nimport {\n  domify,\n  delegate as domDelegate\n} from 'min-dom';\n\n\n// inlined ../../resources/logo.svg\nvar BPMNIO_LOGO_SVG = '<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 960 960\"><path fill=\"#fff\" d=\"M960 60v839c0 33-27 61-60 61H60c-33 0-60-27-60-60V60C0 27 27 0 60 0h839c34 0 61 27 61 60z\"/><path fill=\"#52b415\" d=\"M217 548a205 205 0 0 0-144 58 202 202 0 0 0-4 286 202 202 0 0 0 285 3 200 200 0 0 0 48-219 203 203 0 0 0-185-128zM752 6a206 206 0 0 0-192 285 206 206 0 0 0 269 111 207 207 0 0 0 111-260A204 204 0 0 0 752 6zM62 0A62 62 0 0 0 0 62v398l60 46a259 259 0 0 1 89-36c5-28 10-57 14-85l99 2 12 85a246 246 0 0 1 88 38l70-52 69 71-52 68c17 30 29 58 35 90l86 14-2 100-86 12a240 240 0 0 1-38 89l43 58h413c37 0 60-27 60-61V407a220 220 0 0 1-44 40l21 85-93 39-45-76a258 258 0 0 1-98 1l-45 76-94-39 22-85a298 298 0 0 1-70-69l-86 22-38-94 76-45a258 258 0 0 1-1-98l-76-45 40-94 85 22a271 271 0 0 1 41-47z\"/></svg>';\n\nvar BPMNIO_LOGO_URL = 'data:image/svg+xml,' + encodeURIComponent(BPMNIO_LOGO_SVG);\n\nexport var BPMNIO_IMG = '<img width=\"52\" height=\"52\" src=\"' + BPMNIO_LOGO_URL + '\" />';\n\nfunction css(attrs) {\n  return attrs.join(';');\n}\n\nvar LIGHTBOX_STYLES = css([\n  'z-index: 1001',\n  'position: fixed',\n  'top: 0',\n  'left: 0',\n  'right: 0',\n  'bottom: 0'\n]);\n\nvar BACKDROP_STYLES = css([\n  'width: 100%',\n  'height: 100%',\n  'background: rgba(0,0,0,0.2)'\n]);\n\nvar NOTICE_STYLES = css([\n  'position: absolute',\n  'left: 50%',\n  'top: 40%',\n  'margin: 0 -130px',\n  'width: 260px',\n  'padding: 10px',\n  'background: white',\n  'border: solid 1px #AAA',\n  'border-radius: 3px',\n  'font-family: Helvetica, Arial, sans-serif',\n  'font-size: 14px',\n  'line-height: 1.2em'\n]);\n\nvar LIGHTBOX_MARKUP =\n  '<div class=\"bjs-powered-by-lightbox\" style=\"' + LIGHTBOX_STYLES + '\">' +\n    '<div class=\"backdrop\" style=\"' + BACKDROP_STYLES + '\"></div>' +\n    '<div class=\"notice\" style=\"' + NOTICE_STYLES + '\">' +\n      '<a href=\"http://bpmn.io\" target=\"_blank\" style=\"float: left; margin-right: 10px\">' +\n        BPMNIO_IMG +\n      '</a>' +\n      'Web-based tooling for BPMN, DMN and CMMN diagrams ' +\n      'powered by <a href=\"http://bpmn.io\" target=\"_blank\">bpmn.io</a>.' +\n    '</div>' +\n  '</div>';\n\n\nvar lightbox;\n\nexport function open() {\n\n  if (!lightbox) {\n    lightbox = domify(LIGHTBOX_MARKUP);\n\n    domDelegate.bind(lightbox, '.backdrop', 'click', function(event) {\n      document.body.removeChild(lightbox);\n    });\n  }\n\n  document.body.appendChild(lightbox);\n}","import {\n  forEach,\n  filter,\n  some,\n  sortBy,\n  isArray\n} from 'min-dash';\n\nimport {\n  IGNORED_PROPERTIES\n} from './ModelCloneUtils';\n\n\nfunction isAllowedIn(extProp, type) {\n  var allowedIn = extProp.meta.allowedIn;\n\n  // '*' is a wildcard, which means any element is allowed to use this property\n  if (allowedIn.length === 1 && allowedIn[0] === '*') {\n    return true;\n  }\n\n  return allowedIn.indexOf(type) !== -1;\n}\n\nfunction isType(element, types) {\n  return some(types, function(type) {\n    return typeof element === type;\n  });\n}\n\n/**\n * A bpmn properties cloning interface\n *\n */\nexport default function ModelCloneHelper(eventBus, bpmnFactory) {\n  this._eventBus = eventBus;\n  this._bpmnFactory = bpmnFactory;\n}\n\n\nModelCloneHelper.prototype.clone = function(refElement, newElement, properties) {\n\n  var self = this;\n\n  // hasNestedProperty: property allows us to avoid ending up with empty (xml) tags\n  // f.ex: if extensionElements.values is empty, don't set it\n  var context = {\n    newElement: newElement,\n    hasNestedProperty: false\n  };\n\n  // we want the extensionElements to be cloned last\n  // so that they can check certain properties\n  properties = sortBy(properties, function(prop) {\n    return prop === 'bpmn:extensionElements';\n  });\n\n  forEach(properties, function(propName) {\n    var refElementProp = refElement.get(propName),\n        newElementProp = newElement.get(propName),\n        propDescriptor = newElement.$model.getPropertyDescriptor(newElement, propName),\n        newProperty, name;\n\n    // we're not interested in cloning:\n    // - same values from simple types\n    // - cloning id's\n    // - cloning reference elements\n    if (newElementProp === refElementProp) {\n      return;\n    }\n\n    if (propDescriptor && (propDescriptor.isId || propDescriptor.isReference)) {\n      return;\n    }\n\n    // if the property is of type 'boolean', 'string', 'number' or 'null', just set it\n    if (isType(refElementProp, [ 'boolean', 'string', 'number' ]) || refElementProp === null) {\n      newElement.set(propName, refElementProp);\n\n      return;\n    }\n\n    if (isArray(refElementProp)) {\n\n      forEach(refElementProp, function(extElement) {\n        var newProp;\n\n        context.refTopLevelProperty = extElement;\n\n        newProp = self._deepClone(extElement, context);\n\n        if (context.hasNestedProperty) {\n          newProp.$parent = newElement;\n\n          newElementProp.push(newProp);\n        }\n\n        context.hasNestedProperty = false;\n      });\n\n    } else {\n      name = propName.replace(/bpmn:/, '');\n\n      context.refTopLevelProperty = refElementProp;\n\n      newProperty = self._deepClone(refElementProp, context);\n\n      if (context.hasNestedProperty) {\n        newProperty.$parent = newElement;\n\n        newElement.set(name, newProperty);\n      }\n\n      context.hasNestedProperty = false;\n    }\n  });\n\n  return newElement;\n};\n\nModelCloneHelper.prototype._deepClone = function _deepClone(propertyElement, context) {\n  var self = this;\n\n  var eventBus = this._eventBus;\n  var bpmnFactory = this._bpmnFactory;\n\n  var newProp = bpmnFactory.create(propertyElement.$type);\n\n  var properties = filter(Object.keys(propertyElement), function(prop) {\n    var descriptor = newProp.$model.getPropertyDescriptor(newProp, prop);\n\n    if (descriptor && (descriptor.isId || descriptor.isReference)) {\n      return false;\n    }\n\n    // we need to make sure we don't clone certain properties\n    // which we cannot easily know if they hold references or not\n    if (IGNORED_PROPERTIES.indexOf(prop) !== -1) {\n      return false;\n    }\n\n    // make sure we don't copy the type\n    return prop !== '$type';\n  });\n\n  if (!properties.length) {\n    context.hasNestedProperty = true;\n  }\n\n  forEach(properties, function(propName) {\n    // check if the propertyElement has this property defined\n    if (propertyElement[propName] !== undefined &&\n       (propertyElement[propName].$type || isArray(propertyElement[propName]))) {\n\n      if (isArray(propertyElement[propName])) {\n        newProp[propName] = [];\n\n        forEach(propertyElement[propName], function(property) {\n          var extProp = propertyElement.$model.getTypeDescriptor(property.$type),\n              newDeepProp;\n\n          // we're not going to copy undefined types\n          if (!extProp) {\n            return;\n          }\n\n          var canClone = eventBus.fire('property.clone', {\n            newElement: context.newElement,\n            refTopLevelProperty: context.refTopLevelProperty,\n            propertyDescriptor: extProp\n          });\n\n          if (!canClone) {\n            // if can clone is 'undefined' or 'false'\n            // check for the meta information if it is allowed\n            if (propertyElement.$type === 'bpmn:ExtensionElements' &&\n                extProp.meta && extProp.meta.allowedIn &&\n                !isAllowedIn(extProp, context.newElement.$type)) {\n              return false;\n            }\n          }\n\n          newDeepProp = self._deepClone(property, context);\n\n          newDeepProp.$parent = newProp;\n\n          if (!newProp[propName]) {\n            newProp[propName] = [];\n          }\n\n          context.hasNestedProperty = true;\n\n          newProp[propName].push(newDeepProp);\n        });\n\n      } else if (propertyElement[propName].$type) {\n        newProp[propName] = self._deepClone(propertyElement[propName], context);\n\n        if (newProp[propName]) {\n          context.hasNestedProperty = true;\n\n          newProp[propName].$parent = newProp;\n        }\n      }\n    } else {\n      context.hasNestedProperty = true;\n\n      // just assign directly if it's a value\n      newProp[propName] = propertyElement[propName];\n    }\n  });\n\n  return newProp;\n};\n","import {\n  forEach\n} from 'min-dash';\n\n\n/**\n * These are the properties that should be ignored when cloning elements.\n *\n * @type {Array}\n */\nexport var IGNORED_PROPERTIES = [\n  'lanes',\n  'incoming',\n  'outgoing',\n  'artifacts',\n  'default',\n  'flowElements',\n  'dataInputAssociations',\n  'dataOutputAssociations'\n];\n\n\nexport function getProperties(descriptor, keepDefault) {\n  var properties = [];\n\n  forEach(descriptor.properties, function(property) {\n\n    if (keepDefault && property.default) {\n      return;\n    }\n\n    properties.push(property.ns.name);\n  });\n\n  return properties;\n}","export {\n  default\n} from './lib/simple';","import {\n  isString,\n  isFunction,\n  assign\n} from 'min-dash';\n\nimport Moddle from 'moddle';\n\nimport {\n  Reader,\n  Writer\n} from 'moddle-xml';\n\n\n/**\n * A sub class of {@link Moddle} with support for import and export of BPMN 2.0 xml files.\n *\n * @class BpmnModdle\n * @extends Moddle\n *\n * @param {Object|Array} packages to use for instantiating the model\n * @param {Object} [options] additional options to pass over\n */\nexport default function BpmnModdle(packages, options) {\n  Moddle.call(this, packages, options);\n}\n\nBpmnModdle.prototype = Object.create(Moddle.prototype);\n\n\n/**\n * Instantiates a BPMN model tree from a given xml string.\n *\n * @param {String}   xmlStr\n * @param {String}   [typeName='bpmn:Definitions'] name of the root element\n * @param {Object}   [options]  options to pass to the underlying reader\n * @param {Function} done       callback that is invoked with (err, result, parseContext)\n *                              once the import completes\n */\nBpmnModdle.prototype.fromXML = function(xmlStr, typeName, options, done) {\n\n  if (!isString(typeName)) {\n    done = options;\n    options = typeName;\n    typeName = 'bpmn:Definitions';\n  }\n\n  if (isFunction(options)) {\n    done = options;\n    options = {};\n  }\n\n  var reader = new Reader(assign({ model: this, lax: true }, options));\n  var rootHandler = reader.handler(typeName);\n\n  reader.fromXML(xmlStr, rootHandler, done);\n};\n\n\n/**\n * Serializes a BPMN 2.0 object tree to XML.\n *\n * @param {String}   element    the root element, typically an instance of `bpmn:Definitions`\n * @param {Object}   [options]  to pass to the underlying writer\n * @param {Function} done       callback invoked with (err, xmlStr) once the import completes\n */\nBpmnModdle.prototype.toXML = function(element, options, done) {\n\n  if (isFunction(options)) {\n    done = options;\n    options = {};\n  }\n\n  var writer = new Writer(options);\n\n  var result;\n  var err;\n\n  try {\n    result = writer.toXML(element);\n  } catch (e) {\n    err = e;\n  }\n\n  return done(err, result);\n};\n","import {\n  assign\n} from 'min-dash';\n\nimport BpmnModdle from './bpmn-moddle';\n\nimport BpmnPackage from '../resources/bpmn/json/bpmn.json';\nimport BpmnDiPackage from '../resources/bpmn/json/bpmndi.json';\nimport DcPackage from '../resources/bpmn/json/dc.json';\nimport DiPackage from '../resources/bpmn/json/di.json';\nimport BiocPackage from '../resources/bpmn-io/json/bioc.json';\n\nvar packages = {\n  bpmn: BpmnPackage,\n  bpmndi: BpmnDiPackage,\n  dc: DcPackage,\n  di: DiPackage,\n  bioc: BiocPackage\n};\n\nexport default function(additionalPackages, options) {\n  var pks = assign({}, packages, additionalPackages);\n\n  return new BpmnModdle(pks, options);\n}\n","module.exports={\r\n  \"name\": \"bpmn.io colors for BPMN\",\r\n  \"uri\": \"http://bpmn.io/schema/bpmn/biocolor/1.0\",\r\n  \"prefix\": \"bioc\",\r\n  \"types\": [\r\n    {\r\n      \"name\": \"ColoredShape\",\r\n      \"extends\": [ \"bpmndi:BPMNShape\" ],\r\n      \"properties\": [\r\n        {\r\n          \"name\": \"stroke\",\r\n          \"isAttr\": true,\r\n          \"type\": \"String\"\r\n        },\r\n        {\r\n          \"name\": \"fill\",\r\n          \"isAttr\": true,\r\n          \"type\": \"String\"\r\n        }\r\n      ]\r\n    },\r\n    {\r\n      \"name\": \"ColoredEdge\",\r\n      \"extends\": [ \"bpmndi:BPMNEdge\" ],\r\n      \"properties\": [\r\n        {\r\n          \"name\": \"stroke\",\r\n          \"isAttr\": true,\r\n          \"type\": \"String\"\r\n        },\r\n        {\r\n          \"name\": \"fill\",\r\n          \"isAttr\": true,\r\n          \"type\": \"String\"\r\n        }\r\n      ]\r\n    }\r\n  ],\r\n  \"enumerations\": [],\r\n  \"associations\": []\r\n}\r\n","module.exports={\n  \"name\": \"BPMN20\",\n  \"uri\": \"http://www.omg.org/spec/BPMN/20100524/MODEL\",\n  \"associations\": [],\n  \"types\": [\n    {\n      \"name\": \"Interface\",\n      \"superClass\": [\n        \"RootElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"name\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"operations\",\n          \"type\": \"Operation\",\n          \"isMany\": true\n        },\n        {\n          \"name\": \"implementationRef\",\n          \"type\": \"String\",\n          \"isAttr\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"Operation\",\n      \"superClass\": [\n        \"BaseElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"name\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"inMessageRef\",\n          \"type\": \"Message\",\n          \"isReference\": true\n        },\n        {\n          \"name\": \"outMessageRef\",\n          \"type\": \"Message\",\n          \"isReference\": true\n        },\n        {\n          \"name\": \"errorRef\",\n          \"type\": \"Error\",\n          \"isMany\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"implementationRef\",\n          \"type\": \"String\",\n          \"isAttr\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"EndPoint\",\n      \"superClass\": [\n        \"RootElement\"\n      ]\n    },\n    {\n      \"name\": \"Auditing\",\n      \"superClass\": [\n        \"BaseElement\"\n      ]\n    },\n    {\n      \"name\": \"GlobalTask\",\n      \"superClass\": [\n        \"CallableElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"resources\",\n          \"type\": \"ResourceRole\",\n          \"isMany\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"Monitoring\",\n      \"superClass\": [\n        \"BaseElement\"\n      ]\n    },\n    {\n      \"name\": \"Performer\",\n      \"superClass\": [\n        \"ResourceRole\"\n      ]\n    },\n    {\n      \"name\": \"Process\",\n      \"superClass\": [\n        \"FlowElementsContainer\",\n        \"CallableElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"processType\",\n          \"type\": \"ProcessType\",\n          \"isAttr\": true\n        },\n        {\n          \"name\": \"isClosed\",\n          \"isAttr\": true,\n          \"type\": \"Boolean\"\n        },\n        {\n          \"name\": \"auditing\",\n          \"type\": \"Auditing\"\n        },\n        {\n          \"name\": \"monitoring\",\n          \"type\": \"Monitoring\"\n        },\n        {\n          \"name\": \"properties\",\n          \"type\": \"Property\",\n          \"isMany\": true\n        },\n        {\n          \"name\": \"laneSets\",\n          \"type\": \"LaneSet\",\n          \"isMany\": true,\n          \"replaces\": \"FlowElementsContainer#laneSets\"\n        },\n        {\n          \"name\": \"flowElements\",\n          \"type\": \"FlowElement\",\n          \"isMany\": true,\n          \"replaces\": \"FlowElementsContainer#flowElements\"\n        },\n        {\n          \"name\": \"artifacts\",\n          \"type\": \"Artifact\",\n          \"isMany\": true\n        },\n        {\n          \"name\": \"resources\",\n          \"type\": \"ResourceRole\",\n          \"isMany\": true\n        },\n        {\n          \"name\": \"correlationSubscriptions\",\n          \"type\": \"CorrelationSubscription\",\n          \"isMany\": true\n        },\n        {\n          \"name\": \"supports\",\n          \"type\": \"Process\",\n          \"isMany\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"definitionalCollaborationRef\",\n          \"type\": \"Collaboration\",\n          \"isAttr\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"isExecutable\",\n          \"isAttr\": true,\n          \"type\": \"Boolean\"\n        }\n      ]\n    },\n    {\n      \"name\": \"LaneSet\",\n      \"superClass\": [\n        \"BaseElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"lanes\",\n          \"type\": \"Lane\",\n          \"isMany\": true\n        },\n        {\n          \"name\": \"name\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        }\n      ]\n    },\n    {\n      \"name\": \"Lane\",\n      \"superClass\": [\n        \"BaseElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"name\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"partitionElementRef\",\n          \"type\": \"BaseElement\",\n          \"isAttr\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"partitionElement\",\n          \"type\": \"BaseElement\"\n        },\n        {\n          \"name\": \"flowNodeRef\",\n          \"type\": \"FlowNode\",\n          \"isMany\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"childLaneSet\",\n          \"type\": \"LaneSet\",\n          \"xml\": {\n            \"serialize\": \"xsi:type\"\n          }\n        }\n      ]\n    },\n    {\n      \"name\": \"GlobalManualTask\",\n      \"superClass\": [\n        \"GlobalTask\"\n      ]\n    },\n    {\n      \"name\": \"ManualTask\",\n      \"superClass\": [\n        \"Task\"\n      ]\n    },\n    {\n      \"name\": \"UserTask\",\n      \"superClass\": [\n        \"Task\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"renderings\",\n          \"type\": \"Rendering\",\n          \"isMany\": true\n        },\n        {\n          \"name\": \"implementation\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        }\n      ]\n    },\n    {\n      \"name\": \"Rendering\",\n      \"superClass\": [\n        \"BaseElement\"\n      ]\n    },\n    {\n      \"name\": \"HumanPerformer\",\n      \"superClass\": [\n        \"Performer\"\n      ]\n    },\n    {\n      \"name\": \"PotentialOwner\",\n      \"superClass\": [\n        \"HumanPerformer\"\n      ]\n    },\n    {\n      \"name\": \"GlobalUserTask\",\n      \"superClass\": [\n        \"GlobalTask\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"implementation\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"renderings\",\n          \"type\": \"Rendering\",\n          \"isMany\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"Gateway\",\n      \"isAbstract\": true,\n      \"superClass\": [\n        \"FlowNode\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"gatewayDirection\",\n          \"type\": \"GatewayDirection\",\n          \"default\": \"Unspecified\",\n          \"isAttr\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"EventBasedGateway\",\n      \"superClass\": [\n        \"Gateway\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"instantiate\",\n          \"default\": false,\n          \"isAttr\": true,\n          \"type\": \"Boolean\"\n        },\n        {\n          \"name\": \"eventGatewayType\",\n          \"type\": \"EventBasedGatewayType\",\n          \"isAttr\": true,\n          \"default\": \"Exclusive\"\n        }\n      ]\n    },\n    {\n      \"name\": \"ComplexGateway\",\n      \"superClass\": [\n        \"Gateway\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"activationCondition\",\n          \"type\": \"Expression\",\n          \"xml\": {\n            \"serialize\": \"xsi:type\"\n          }\n        },\n        {\n          \"name\": \"default\",\n          \"type\": \"SequenceFlow\",\n          \"isAttr\": true,\n          \"isReference\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"ExclusiveGateway\",\n      \"superClass\": [\n        \"Gateway\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"default\",\n          \"type\": \"SequenceFlow\",\n          \"isAttr\": true,\n          \"isReference\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"InclusiveGateway\",\n      \"superClass\": [\n        \"Gateway\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"default\",\n          \"type\": \"SequenceFlow\",\n          \"isAttr\": true,\n          \"isReference\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"ParallelGateway\",\n      \"superClass\": [\n        \"Gateway\"\n      ]\n    },\n    {\n      \"name\": \"RootElement\",\n      \"isAbstract\": true,\n      \"superClass\": [\n        \"BaseElement\"\n      ]\n    },\n    {\n      \"name\": \"Relationship\",\n      \"superClass\": [\n        \"BaseElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"type\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"direction\",\n          \"type\": \"RelationshipDirection\",\n          \"isAttr\": true\n        },\n        {\n          \"name\": \"source\",\n          \"isMany\": true,\n          \"isReference\": true,\n          \"type\": \"Element\"\n        },\n        {\n          \"name\": \"target\",\n          \"isMany\": true,\n          \"isReference\": true,\n          \"type\": \"Element\"\n        }\n      ]\n    },\n    {\n      \"name\": \"BaseElement\",\n      \"isAbstract\": true,\n      \"properties\": [\n        {\n          \"name\": \"id\",\n          \"isAttr\": true,\n          \"type\": \"String\",\n          \"isId\": true\n        },\n        {\n          \"name\": \"documentation\",\n          \"type\": \"Documentation\",\n          \"isMany\": true\n        },\n        {\n          \"name\": \"extensionDefinitions\",\n          \"type\": \"ExtensionDefinition\",\n          \"isMany\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"extensionElements\",\n          \"type\": \"ExtensionElements\"\n        }\n      ]\n    },\n    {\n      \"name\": \"Extension\",\n      \"properties\": [\n        {\n          \"name\": \"mustUnderstand\",\n          \"default\": false,\n          \"isAttr\": true,\n          \"type\": \"Boolean\"\n        },\n        {\n          \"name\": \"definition\",\n          \"type\": \"ExtensionDefinition\",\n          \"isAttr\": true,\n          \"isReference\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"ExtensionDefinition\",\n      \"properties\": [\n        {\n          \"name\": \"name\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"extensionAttributeDefinitions\",\n          \"type\": \"ExtensionAttributeDefinition\",\n          \"isMany\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"ExtensionAttributeDefinition\",\n      \"properties\": [\n        {\n          \"name\": \"name\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"type\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"isReference\",\n          \"default\": false,\n          \"isAttr\": true,\n          \"type\": \"Boolean\"\n        },\n        {\n          \"name\": \"extensionDefinition\",\n          \"type\": \"ExtensionDefinition\",\n          \"isAttr\": true,\n          \"isReference\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"ExtensionElements\",\n      \"properties\": [\n        {\n          \"name\": \"valueRef\",\n          \"isAttr\": true,\n          \"isReference\": true,\n          \"type\": \"Element\"\n        },\n        {\n          \"name\": \"values\",\n          \"type\": \"Element\",\n          \"isMany\": true\n        },\n        {\n          \"name\": \"extensionAttributeDefinition\",\n          \"type\": \"ExtensionAttributeDefinition\",\n          \"isAttr\": true,\n          \"isReference\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"Documentation\",\n      \"superClass\": [\n        \"BaseElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"text\",\n          \"type\": \"String\",\n          \"isBody\": true\n        },\n        {\n          \"name\": \"textFormat\",\n          \"default\": \"text/plain\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        }\n      ]\n    },\n    {\n      \"name\": \"Event\",\n      \"isAbstract\": true,\n      \"superClass\": [\n        \"FlowNode\",\n        \"InteractionNode\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"properties\",\n          \"type\": \"Property\",\n          \"isMany\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"IntermediateCatchEvent\",\n      \"superClass\": [\n        \"CatchEvent\"\n      ]\n    },\n    {\n      \"name\": \"IntermediateThrowEvent\",\n      \"superClass\": [\n        \"ThrowEvent\"\n      ]\n    },\n    {\n      \"name\": \"EndEvent\",\n      \"superClass\": [\n        \"ThrowEvent\"\n      ]\n    },\n    {\n      \"name\": \"StartEvent\",\n      \"superClass\": [\n        \"CatchEvent\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"isInterrupting\",\n          \"default\": true,\n          \"isAttr\": true,\n          \"type\": \"Boolean\"\n        }\n      ]\n    },\n    {\n      \"name\": \"ThrowEvent\",\n      \"isAbstract\": true,\n      \"superClass\": [\n        \"Event\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"dataInputs\",\n          \"type\": \"DataInput\",\n          \"isMany\": true\n        },\n        {\n          \"name\": \"dataInputAssociations\",\n          \"type\": \"DataInputAssociation\",\n          \"isMany\": true\n        },\n        {\n          \"name\": \"inputSet\",\n          \"type\": \"InputSet\"\n        },\n        {\n          \"name\": \"eventDefinitions\",\n          \"type\": \"EventDefinition\",\n          \"isMany\": true\n        },\n        {\n          \"name\": \"eventDefinitionRef\",\n          \"type\": \"EventDefinition\",\n          \"isMany\": true,\n          \"isReference\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"CatchEvent\",\n      \"isAbstract\": true,\n      \"superClass\": [\n        \"Event\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"parallelMultiple\",\n          \"isAttr\": true,\n          \"type\": \"Boolean\",\n          \"default\": false\n        },\n        {\n          \"name\": \"dataOutputs\",\n          \"type\": \"DataOutput\",\n          \"isMany\": true\n        },\n        {\n          \"name\": \"dataOutputAssociations\",\n          \"type\": \"DataOutputAssociation\",\n          \"isMany\": true\n        },\n        {\n          \"name\": \"outputSet\",\n          \"type\": \"OutputSet\"\n        },\n        {\n          \"name\": \"eventDefinitions\",\n          \"type\": \"EventDefinition\",\n          \"isMany\": true\n        },\n        {\n          \"name\": \"eventDefinitionRef\",\n          \"type\": \"EventDefinition\",\n          \"isMany\": true,\n          \"isReference\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"BoundaryEvent\",\n      \"superClass\": [\n        \"CatchEvent\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"cancelActivity\",\n          \"default\": true,\n          \"isAttr\": true,\n          \"type\": \"Boolean\"\n        },\n        {\n          \"name\": \"attachedToRef\",\n          \"type\": \"Activity\",\n          \"isAttr\": true,\n          \"isReference\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"EventDefinition\",\n      \"isAbstract\": true,\n      \"superClass\": [\n        \"RootElement\"\n      ]\n    },\n    {\n      \"name\": \"CancelEventDefinition\",\n      \"superClass\": [\n        \"EventDefinition\"\n      ]\n    },\n    {\n      \"name\": \"ErrorEventDefinition\",\n      \"superClass\": [\n        \"EventDefinition\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"errorRef\",\n          \"type\": \"Error\",\n          \"isAttr\": true,\n          \"isReference\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"TerminateEventDefinition\",\n      \"superClass\": [\n        \"EventDefinition\"\n      ]\n    },\n    {\n      \"name\": \"EscalationEventDefinition\",\n      \"superClass\": [\n        \"EventDefinition\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"escalationRef\",\n          \"type\": \"Escalation\",\n          \"isAttr\": true,\n          \"isReference\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"Escalation\",\n      \"properties\": [\n        {\n          \"name\": \"structureRef\",\n          \"type\": \"ItemDefinition\",\n          \"isAttr\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"name\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"escalationCode\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        }\n      ],\n      \"superClass\": [\n        \"RootElement\"\n      ]\n    },\n    {\n      \"name\": \"CompensateEventDefinition\",\n      \"superClass\": [\n        \"EventDefinition\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"waitForCompletion\",\n          \"isAttr\": true,\n          \"type\": \"Boolean\",\n          \"default\": true\n        },\n        {\n          \"name\": \"activityRef\",\n          \"type\": \"Activity\",\n          \"isAttr\": true,\n          \"isReference\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"TimerEventDefinition\",\n      \"superClass\": [\n        \"EventDefinition\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"timeDate\",\n          \"type\": \"Expression\",\n          \"xml\": {\n            \"serialize\": \"xsi:type\"\n          }\n        },\n        {\n          \"name\": \"timeCycle\",\n          \"type\": \"Expression\",\n          \"xml\": {\n            \"serialize\": \"xsi:type\"\n          }\n        },\n        {\n          \"name\": \"timeDuration\",\n          \"type\": \"Expression\",\n          \"xml\": {\n            \"serialize\": \"xsi:type\"\n          }\n        }\n      ]\n    },\n    {\n      \"name\": \"LinkEventDefinition\",\n      \"superClass\": [\n        \"EventDefinition\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"name\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"target\",\n          \"type\": \"LinkEventDefinition\",\n          \"isAttr\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"source\",\n          \"type\": \"LinkEventDefinition\",\n          \"isMany\": true,\n          \"isReference\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"MessageEventDefinition\",\n      \"superClass\": [\n        \"EventDefinition\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"messageRef\",\n          \"type\": \"Message\",\n          \"isAttr\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"operationRef\",\n          \"type\": \"Operation\",\n          \"isAttr\": true,\n          \"isReference\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"ConditionalEventDefinition\",\n      \"superClass\": [\n        \"EventDefinition\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"condition\",\n          \"type\": \"Expression\",\n          \"xml\": {\n            \"serialize\": \"xsi:type\"\n          }\n        }\n      ]\n    },\n    {\n      \"name\": \"SignalEventDefinition\",\n      \"superClass\": [\n        \"EventDefinition\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"signalRef\",\n          \"type\": \"Signal\",\n          \"isAttr\": true,\n          \"isReference\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"Signal\",\n      \"superClass\": [\n        \"RootElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"structureRef\",\n          \"type\": \"ItemDefinition\",\n          \"isAttr\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"name\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        }\n      ]\n    },\n    {\n      \"name\": \"ImplicitThrowEvent\",\n      \"superClass\": [\n        \"ThrowEvent\"\n      ]\n    },\n    {\n      \"name\": \"DataState\",\n      \"superClass\": [\n        \"BaseElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"name\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        }\n      ]\n    },\n    {\n      \"name\": \"ItemAwareElement\",\n      \"superClass\": [\n        \"BaseElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"itemSubjectRef\",\n          \"type\": \"ItemDefinition\",\n          \"isAttr\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"dataState\",\n          \"type\": \"DataState\"\n        }\n      ]\n    },\n    {\n      \"name\": \"DataAssociation\",\n      \"superClass\": [\n        \"BaseElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"assignment\",\n          \"type\": \"Assignment\",\n          \"isMany\": true\n        },\n        {\n          \"name\": \"sourceRef\",\n          \"type\": \"ItemAwareElement\",\n          \"isMany\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"targetRef\",\n          \"type\": \"ItemAwareElement\",\n          \"isReference\": true\n        },\n        {\n          \"name\": \"transformation\",\n          \"type\": \"FormalExpression\",\n          \"xml\": {\n            \"serialize\": \"property\"\n          }\n        }\n      ]\n    },\n    {\n      \"name\": \"DataInput\",\n      \"superClass\": [\n        \"ItemAwareElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"name\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"isCollection\",\n          \"default\": false,\n          \"isAttr\": true,\n          \"type\": \"Boolean\"\n        },\n        {\n          \"name\": \"inputSetRef\",\n          \"type\": \"InputSet\",\n          \"isVirtual\": true,\n          \"isMany\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"inputSetWithOptional\",\n          \"type\": \"InputSet\",\n          \"isVirtual\": true,\n          \"isMany\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"inputSetWithWhileExecuting\",\n          \"type\": \"InputSet\",\n          \"isVirtual\": true,\n          \"isMany\": true,\n          \"isReference\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"DataOutput\",\n      \"superClass\": [\n        \"ItemAwareElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"name\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"isCollection\",\n          \"default\": false,\n          \"isAttr\": true,\n          \"type\": \"Boolean\"\n        },\n        {\n          \"name\": \"outputSetRef\",\n          \"type\": \"OutputSet\",\n          \"isVirtual\": true,\n          \"isMany\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"outputSetWithOptional\",\n          \"type\": \"OutputSet\",\n          \"isVirtual\": true,\n          \"isMany\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"outputSetWithWhileExecuting\",\n          \"type\": \"OutputSet\",\n          \"isVirtual\": true,\n          \"isMany\": true,\n          \"isReference\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"InputSet\",\n      \"superClass\": [\n        \"BaseElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"name\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"dataInputRefs\",\n          \"type\": \"DataInput\",\n          \"isMany\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"optionalInputRefs\",\n          \"type\": \"DataInput\",\n          \"isMany\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"whileExecutingInputRefs\",\n          \"type\": \"DataInput\",\n          \"isMany\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"outputSetRefs\",\n          \"type\": \"OutputSet\",\n          \"isMany\": true,\n          \"isReference\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"OutputSet\",\n      \"superClass\": [\n        \"BaseElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"dataOutputRefs\",\n          \"type\": \"DataOutput\",\n          \"isMany\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"name\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"inputSetRefs\",\n          \"type\": \"InputSet\",\n          \"isMany\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"optionalOutputRefs\",\n          \"type\": \"DataOutput\",\n          \"isMany\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"whileExecutingOutputRefs\",\n          \"type\": \"DataOutput\",\n          \"isMany\": true,\n          \"isReference\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"Property\",\n      \"superClass\": [\n        \"ItemAwareElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"name\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        }\n      ]\n    },\n    {\n      \"name\": \"DataInputAssociation\",\n      \"superClass\": [\n        \"DataAssociation\"\n      ]\n    },\n    {\n      \"name\": \"DataOutputAssociation\",\n      \"superClass\": [\n        \"DataAssociation\"\n      ]\n    },\n    {\n      \"name\": \"InputOutputSpecification\",\n      \"superClass\": [\n        \"BaseElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"dataInputs\",\n          \"type\": \"DataInput\",\n          \"isMany\": true\n        },\n        {\n          \"name\": \"dataOutputs\",\n          \"type\": \"DataOutput\",\n          \"isMany\": true\n        },\n        {\n          \"name\": \"inputSets\",\n          \"type\": \"InputSet\",\n          \"isMany\": true\n        },\n        {\n          \"name\": \"outputSets\",\n          \"type\": \"OutputSet\",\n          \"isMany\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"DataObject\",\n      \"superClass\": [\n        \"FlowElement\",\n        \"ItemAwareElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"isCollection\",\n          \"default\": false,\n          \"isAttr\": true,\n          \"type\": \"Boolean\"\n        }\n      ]\n    },\n    {\n      \"name\": \"InputOutputBinding\",\n      \"properties\": [\n        {\n          \"name\": \"inputDataRef\",\n          \"type\": \"InputSet\",\n          \"isAttr\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"outputDataRef\",\n          \"type\": \"OutputSet\",\n          \"isAttr\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"operationRef\",\n          \"type\": \"Operation\",\n          \"isAttr\": true,\n          \"isReference\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"Assignment\",\n      \"superClass\": [\n        \"BaseElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"from\",\n          \"type\": \"Expression\",\n          \"xml\": {\n            \"serialize\": \"xsi:type\"\n          }\n        },\n        {\n          \"name\": \"to\",\n          \"type\": \"Expression\",\n          \"xml\": {\n            \"serialize\": \"xsi:type\"\n          }\n        }\n      ]\n    },\n    {\n      \"name\": \"DataStore\",\n      \"superClass\": [\n        \"RootElement\",\n        \"ItemAwareElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"name\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"capacity\",\n          \"isAttr\": true,\n          \"type\": \"Integer\"\n        },\n        {\n          \"name\": \"isUnlimited\",\n          \"default\": true,\n          \"isAttr\": true,\n          \"type\": \"Boolean\"\n        }\n      ]\n    },\n    {\n      \"name\": \"DataStoreReference\",\n      \"superClass\": [\n        \"ItemAwareElement\",\n        \"FlowElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"dataStoreRef\",\n          \"type\": \"DataStore\",\n          \"isAttr\": true,\n          \"isReference\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"DataObjectReference\",\n      \"superClass\": [\n        \"ItemAwareElement\",\n        \"FlowElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"dataObjectRef\",\n          \"type\": \"DataObject\",\n          \"isAttr\": true,\n          \"isReference\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"ConversationLink\",\n      \"superClass\": [\n        \"BaseElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"sourceRef\",\n          \"type\": \"InteractionNode\",\n          \"isAttr\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"targetRef\",\n          \"type\": \"InteractionNode\",\n          \"isAttr\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"name\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        }\n      ]\n    },\n    {\n      \"name\": \"ConversationAssociation\",\n      \"superClass\": [\n        \"BaseElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"innerConversationNodeRef\",\n          \"type\": \"ConversationNode\",\n          \"isAttr\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"outerConversationNodeRef\",\n          \"type\": \"ConversationNode\",\n          \"isAttr\": true,\n          \"isReference\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"CallConversation\",\n      \"superClass\": [\n        \"ConversationNode\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"calledCollaborationRef\",\n          \"type\": \"Collaboration\",\n          \"isAttr\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"participantAssociations\",\n          \"type\": \"ParticipantAssociation\",\n          \"isMany\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"Conversation\",\n      \"superClass\": [\n        \"ConversationNode\"\n      ]\n    },\n    {\n      \"name\": \"SubConversation\",\n      \"superClass\": [\n        \"ConversationNode\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"conversationNodes\",\n          \"type\": \"ConversationNode\",\n          \"isMany\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"ConversationNode\",\n      \"isAbstract\": true,\n      \"superClass\": [\n        \"InteractionNode\",\n        \"BaseElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"name\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"participantRef\",\n          \"type\": \"Participant\",\n          \"isMany\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"messageFlowRefs\",\n          \"type\": \"MessageFlow\",\n          \"isMany\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"correlationKeys\",\n          \"type\": \"CorrelationKey\",\n          \"isMany\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"GlobalConversation\",\n      \"superClass\": [\n        \"Collaboration\"\n      ]\n    },\n    {\n      \"name\": \"PartnerEntity\",\n      \"superClass\": [\n        \"RootElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"name\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"participantRef\",\n          \"type\": \"Participant\",\n          \"isMany\": true,\n          \"isReference\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"PartnerRole\",\n      \"superClass\": [\n        \"RootElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"name\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"participantRef\",\n          \"type\": \"Participant\",\n          \"isMany\": true,\n          \"isReference\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"CorrelationProperty\",\n      \"superClass\": [\n        \"RootElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"correlationPropertyRetrievalExpression\",\n          \"type\": \"CorrelationPropertyRetrievalExpression\",\n          \"isMany\": true\n        },\n        {\n          \"name\": \"name\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"type\",\n          \"type\": \"ItemDefinition\",\n          \"isAttr\": true,\n          \"isReference\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"Error\",\n      \"superClass\": [\n        \"RootElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"structureRef\",\n          \"type\": \"ItemDefinition\",\n          \"isAttr\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"name\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"errorCode\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        }\n      ]\n    },\n    {\n      \"name\": \"CorrelationKey\",\n      \"superClass\": [\n        \"BaseElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"correlationPropertyRef\",\n          \"type\": \"CorrelationProperty\",\n          \"isMany\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"name\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        }\n      ]\n    },\n    {\n      \"name\": \"Expression\",\n      \"superClass\": [\n        \"BaseElement\"\n      ],\n      \"isAbstract\": false,\n      \"properties\": [\n        {\n          \"name\": \"body\",\n          \"type\": \"String\",\n          \"isBody\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"FormalExpression\",\n      \"superClass\": [\n        \"Expression\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"language\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"evaluatesToTypeRef\",\n          \"type\": \"ItemDefinition\",\n          \"isAttr\": true,\n          \"isReference\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"Message\",\n      \"superClass\": [\n        \"RootElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"name\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"itemRef\",\n          \"type\": \"ItemDefinition\",\n          \"isAttr\": true,\n          \"isReference\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"ItemDefinition\",\n      \"superClass\": [\n        \"RootElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"itemKind\",\n          \"type\": \"ItemKind\",\n          \"isAttr\": true\n        },\n        {\n          \"name\": \"structureRef\",\n          \"type\": \"String\",\n          \"isAttr\": true\n        },\n        {\n          \"name\": \"isCollection\",\n          \"default\": false,\n          \"isAttr\": true,\n          \"type\": \"Boolean\"\n        },\n        {\n          \"name\": \"import\",\n          \"type\": \"Import\",\n          \"isAttr\": true,\n          \"isReference\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"FlowElement\",\n      \"isAbstract\": true,\n      \"superClass\": [\n        \"BaseElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"name\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"auditing\",\n          \"type\": \"Auditing\"\n        },\n        {\n          \"name\": \"monitoring\",\n          \"type\": \"Monitoring\"\n        },\n        {\n          \"name\": \"categoryValueRef\",\n          \"type\": \"CategoryValue\",\n          \"isMany\": true,\n          \"isReference\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"SequenceFlow\",\n      \"superClass\": [\n        \"FlowElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"isImmediate\",\n          \"isAttr\": true,\n          \"type\": \"Boolean\"\n        },\n        {\n          \"name\": \"conditionExpression\",\n          \"type\": \"Expression\",\n          \"xml\": {\n            \"serialize\": \"xsi:type\"\n          }\n        },\n        {\n          \"name\": \"sourceRef\",\n          \"type\": \"FlowNode\",\n          \"isAttr\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"targetRef\",\n          \"type\": \"FlowNode\",\n          \"isAttr\": true,\n          \"isReference\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"FlowElementsContainer\",\n      \"isAbstract\": true,\n      \"superClass\": [\n        \"BaseElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"laneSets\",\n          \"type\": \"LaneSet\",\n          \"isMany\": true\n        },\n        {\n          \"name\": \"flowElements\",\n          \"type\": \"FlowElement\",\n          \"isMany\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"CallableElement\",\n      \"isAbstract\": true,\n      \"superClass\": [\n        \"RootElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"name\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"ioSpecification\",\n          \"type\": \"InputOutputSpecification\",\n          \"xml\": {\n            \"serialize\": \"property\"\n          }\n        },\n        {\n          \"name\": \"supportedInterfaceRef\",\n          \"type\": \"Interface\",\n          \"isMany\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"ioBinding\",\n          \"type\": \"InputOutputBinding\",\n          \"isMany\": true,\n          \"xml\": {\n            \"serialize\": \"property\"\n          }\n        }\n      ]\n    },\n    {\n      \"name\": \"FlowNode\",\n      \"isAbstract\": true,\n      \"superClass\": [\n        \"FlowElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"incoming\",\n          \"type\": \"SequenceFlow\",\n          \"isMany\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"outgoing\",\n          \"type\": \"SequenceFlow\",\n          \"isMany\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"lanes\",\n          \"type\": \"Lane\",\n          \"isVirtual\": true,\n          \"isMany\": true,\n          \"isReference\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"CorrelationPropertyRetrievalExpression\",\n      \"superClass\": [\n        \"BaseElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"messagePath\",\n          \"type\": \"FormalExpression\"\n        },\n        {\n          \"name\": \"messageRef\",\n          \"type\": \"Message\",\n          \"isAttr\": true,\n          \"isReference\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"CorrelationPropertyBinding\",\n      \"superClass\": [\n        \"BaseElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"dataPath\",\n          \"type\": \"FormalExpression\"\n        },\n        {\n          \"name\": \"correlationPropertyRef\",\n          \"type\": \"CorrelationProperty\",\n          \"isAttr\": true,\n          \"isReference\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"Resource\",\n      \"superClass\": [\n        \"RootElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"name\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"resourceParameters\",\n          \"type\": \"ResourceParameter\",\n          \"isMany\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"ResourceParameter\",\n      \"superClass\": [\n        \"BaseElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"name\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"isRequired\",\n          \"isAttr\": true,\n          \"type\": \"Boolean\"\n        },\n        {\n          \"name\": \"type\",\n          \"type\": \"ItemDefinition\",\n          \"isAttr\": true,\n          \"isReference\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"CorrelationSubscription\",\n      \"superClass\": [\n        \"BaseElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"correlationKeyRef\",\n          \"type\": \"CorrelationKey\",\n          \"isAttr\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"correlationPropertyBinding\",\n          \"type\": \"CorrelationPropertyBinding\",\n          \"isMany\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"MessageFlow\",\n      \"superClass\": [\n        \"BaseElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"name\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"sourceRef\",\n          \"type\": \"InteractionNode\",\n          \"isAttr\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"targetRef\",\n          \"type\": \"InteractionNode\",\n          \"isAttr\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"messageRef\",\n          \"type\": \"Message\",\n          \"isAttr\": true,\n          \"isReference\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"MessageFlowAssociation\",\n      \"superClass\": [\n        \"BaseElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"innerMessageFlowRef\",\n          \"type\": \"MessageFlow\",\n          \"isAttr\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"outerMessageFlowRef\",\n          \"type\": \"MessageFlow\",\n          \"isAttr\": true,\n          \"isReference\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"InteractionNode\",\n      \"isAbstract\": true,\n      \"properties\": [\n        {\n          \"name\": \"incomingConversationLinks\",\n          \"type\": \"ConversationLink\",\n          \"isVirtual\": true,\n          \"isMany\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"outgoingConversationLinks\",\n          \"type\": \"ConversationLink\",\n          \"isVirtual\": true,\n          \"isMany\": true,\n          \"isReference\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"Participant\",\n      \"superClass\": [\n        \"InteractionNode\",\n        \"BaseElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"name\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"interfaceRef\",\n          \"type\": \"Interface\",\n          \"isMany\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"participantMultiplicity\",\n          \"type\": \"ParticipantMultiplicity\"\n        },\n        {\n          \"name\": \"endPointRefs\",\n          \"type\": \"EndPoint\",\n          \"isMany\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"processRef\",\n          \"type\": \"Process\",\n          \"isAttr\": true,\n          \"isReference\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"ParticipantAssociation\",\n      \"superClass\": [\n        \"BaseElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"innerParticipantRef\",\n          \"type\": \"Participant\",\n          \"isAttr\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"outerParticipantRef\",\n          \"type\": \"Participant\",\n          \"isAttr\": true,\n          \"isReference\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"ParticipantMultiplicity\",\n      \"properties\": [\n        {\n          \"name\": \"minimum\",\n          \"default\": 0,\n          \"isAttr\": true,\n          \"type\": \"Integer\"\n        },\n        {\n          \"name\": \"maximum\",\n          \"default\": 1,\n          \"isAttr\": true,\n          \"type\": \"Integer\"\n        }\n      ],\n      \"superClass\": [\n        \"BaseElement\"\n      ]\n    },\n    {\n      \"name\": \"Collaboration\",\n      \"superClass\": [\n        \"RootElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"name\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"isClosed\",\n          \"isAttr\": true,\n          \"type\": \"Boolean\"\n        },\n        {\n          \"name\": \"participants\",\n          \"type\": \"Participant\",\n          \"isMany\": true\n        },\n        {\n          \"name\": \"messageFlows\",\n          \"type\": \"MessageFlow\",\n          \"isMany\": true\n        },\n        {\n          \"name\": \"artifacts\",\n          \"type\": \"Artifact\",\n          \"isMany\": true\n        },\n        {\n          \"name\": \"conversations\",\n          \"type\": \"ConversationNode\",\n          \"isMany\": true\n        },\n        {\n          \"name\": \"conversationAssociations\",\n          \"type\": \"ConversationAssociation\"\n        },\n        {\n          \"name\": \"participantAssociations\",\n          \"type\": \"ParticipantAssociation\",\n          \"isMany\": true\n        },\n        {\n          \"name\": \"messageFlowAssociations\",\n          \"type\": \"MessageFlowAssociation\",\n          \"isMany\": true\n        },\n        {\n          \"name\": \"correlationKeys\",\n          \"type\": \"CorrelationKey\",\n          \"isMany\": true\n        },\n        {\n          \"name\": \"choreographyRef\",\n          \"type\": \"Choreography\",\n          \"isMany\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"conversationLinks\",\n          \"type\": \"ConversationLink\",\n          \"isMany\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"ChoreographyActivity\",\n      \"isAbstract\": true,\n      \"superClass\": [\n        \"FlowNode\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"participantRef\",\n          \"type\": \"Participant\",\n          \"isMany\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"initiatingParticipantRef\",\n          \"type\": \"Participant\",\n          \"isAttr\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"correlationKeys\",\n          \"type\": \"CorrelationKey\",\n          \"isMany\": true\n        },\n        {\n          \"name\": \"loopType\",\n          \"type\": \"ChoreographyLoopType\",\n          \"default\": \"None\",\n          \"isAttr\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"CallChoreography\",\n      \"superClass\": [\n        \"ChoreographyActivity\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"calledChoreographyRef\",\n          \"type\": \"Choreography\",\n          \"isAttr\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"participantAssociations\",\n          \"type\": \"ParticipantAssociation\",\n          \"isMany\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"SubChoreography\",\n      \"superClass\": [\n        \"ChoreographyActivity\",\n        \"FlowElementsContainer\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"artifacts\",\n          \"type\": \"Artifact\",\n          \"isMany\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"ChoreographyTask\",\n      \"superClass\": [\n        \"ChoreographyActivity\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"messageFlowRef\",\n          \"type\": \"MessageFlow\",\n          \"isMany\": true,\n          \"isReference\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"Choreography\",\n      \"superClass\": [\n        \"Collaboration\",\n        \"FlowElementsContainer\"\n      ]\n    },\n    {\n      \"name\": \"GlobalChoreographyTask\",\n      \"superClass\": [\n        \"Choreography\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"initiatingParticipantRef\",\n          \"type\": \"Participant\",\n          \"isAttr\": true,\n          \"isReference\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"TextAnnotation\",\n      \"superClass\": [\n        \"Artifact\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"text\",\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"textFormat\",\n          \"default\": \"text/plain\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        }\n      ]\n    },\n    {\n      \"name\": \"Group\",\n      \"superClass\": [\n        \"Artifact\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"categoryValueRef\",\n          \"type\": \"CategoryValue\",\n          \"isAttr\": true,\n          \"isReference\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"Association\",\n      \"superClass\": [\n        \"Artifact\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"associationDirection\",\n          \"type\": \"AssociationDirection\",\n          \"isAttr\": true\n        },\n        {\n          \"name\": \"sourceRef\",\n          \"type\": \"BaseElement\",\n          \"isAttr\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"targetRef\",\n          \"type\": \"BaseElement\",\n          \"isAttr\": true,\n          \"isReference\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"Category\",\n      \"superClass\": [\n        \"RootElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"categoryValue\",\n          \"type\": \"CategoryValue\",\n          \"isMany\": true\n        },\n        {\n          \"name\": \"name\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        }\n      ]\n    },\n    {\n      \"name\": \"Artifact\",\n      \"isAbstract\": true,\n      \"superClass\": [\n        \"BaseElement\"\n      ]\n    },\n    {\n      \"name\": \"CategoryValue\",\n      \"superClass\": [\n        \"BaseElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"categorizedFlowElements\",\n          \"type\": \"FlowElement\",\n          \"isVirtual\": true,\n          \"isMany\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"value\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        }\n      ]\n    },\n    {\n      \"name\": \"Activity\",\n      \"isAbstract\": true,\n      \"superClass\": [\n        \"FlowNode\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"isForCompensation\",\n          \"default\": false,\n          \"isAttr\": true,\n          \"type\": \"Boolean\"\n        },\n        {\n          \"name\": \"default\",\n          \"type\": \"SequenceFlow\",\n          \"isAttr\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"ioSpecification\",\n          \"type\": \"InputOutputSpecification\",\n          \"xml\": {\n            \"serialize\": \"property\"\n          }\n        },\n        {\n          \"name\": \"boundaryEventRefs\",\n          \"type\": \"BoundaryEvent\",\n          \"isMany\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"properties\",\n          \"type\": \"Property\",\n          \"isMany\": true\n        },\n        {\n          \"name\": \"dataInputAssociations\",\n          \"type\": \"DataInputAssociation\",\n          \"isMany\": true\n        },\n        {\n          \"name\": \"dataOutputAssociations\",\n          \"type\": \"DataOutputAssociation\",\n          \"isMany\": true\n        },\n        {\n          \"name\": \"startQuantity\",\n          \"default\": 1,\n          \"isAttr\": true,\n          \"type\": \"Integer\"\n        },\n        {\n          \"name\": \"resources\",\n          \"type\": \"ResourceRole\",\n          \"isMany\": true\n        },\n        {\n          \"name\": \"completionQuantity\",\n          \"default\": 1,\n          \"isAttr\": true,\n          \"type\": \"Integer\"\n        },\n        {\n          \"name\": \"loopCharacteristics\",\n          \"type\": \"LoopCharacteristics\"\n        }\n      ]\n    },\n    {\n      \"name\": \"ServiceTask\",\n      \"superClass\": [\n        \"Task\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"implementation\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"operationRef\",\n          \"type\": \"Operation\",\n          \"isAttr\": true,\n          \"isReference\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"SubProcess\",\n      \"superClass\": [\n        \"Activity\",\n        \"FlowElementsContainer\",\n        \"InteractionNode\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"triggeredByEvent\",\n          \"default\": false,\n          \"isAttr\": true,\n          \"type\": \"Boolean\"\n        },\n        {\n          \"name\": \"artifacts\",\n          \"type\": \"Artifact\",\n          \"isMany\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"LoopCharacteristics\",\n      \"isAbstract\": true,\n      \"superClass\": [\n        \"BaseElement\"\n      ]\n    },\n    {\n      \"name\": \"MultiInstanceLoopCharacteristics\",\n      \"superClass\": [\n        \"LoopCharacteristics\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"isSequential\",\n          \"default\": false,\n          \"isAttr\": true,\n          \"type\": \"Boolean\"\n        },\n        {\n          \"name\": \"behavior\",\n          \"type\": \"MultiInstanceBehavior\",\n          \"default\": \"All\",\n          \"isAttr\": true\n        },\n        {\n          \"name\": \"loopCardinality\",\n          \"type\": \"Expression\",\n          \"xml\": {\n            \"serialize\": \"xsi:type\"\n          }\n        },\n        {\n          \"name\": \"loopDataInputRef\",\n          \"type\": \"ItemAwareElement\",\n          \"isReference\": true\n        },\n        {\n          \"name\": \"loopDataOutputRef\",\n          \"type\": \"ItemAwareElement\",\n          \"isReference\": true\n        },\n        {\n          \"name\": \"inputDataItem\",\n          \"type\": \"DataInput\",\n          \"xml\": {\n            \"serialize\": \"property\"\n          }\n        },\n        {\n          \"name\": \"outputDataItem\",\n          \"type\": \"DataOutput\",\n          \"xml\": {\n            \"serialize\": \"property\"\n          }\n        },\n        {\n          \"name\": \"complexBehaviorDefinition\",\n          \"type\": \"ComplexBehaviorDefinition\",\n          \"isMany\": true\n        },\n        {\n          \"name\": \"completionCondition\",\n          \"type\": \"Expression\",\n          \"xml\": {\n            \"serialize\": \"xsi:type\"\n          }\n        },\n        {\n          \"name\": \"oneBehaviorEventRef\",\n          \"type\": \"EventDefinition\",\n          \"isAttr\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"noneBehaviorEventRef\",\n          \"type\": \"EventDefinition\",\n          \"isAttr\": true,\n          \"isReference\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"StandardLoopCharacteristics\",\n      \"superClass\": [\n        \"LoopCharacteristics\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"testBefore\",\n          \"default\": false,\n          \"isAttr\": true,\n          \"type\": \"Boolean\"\n        },\n        {\n          \"name\": \"loopCondition\",\n          \"type\": \"Expression\",\n          \"xml\": {\n            \"serialize\": \"xsi:type\"\n          }\n        },\n        {\n          \"name\": \"loopMaximum\",\n          \"type\": \"Integer\",\n          \"isAttr\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"CallActivity\",\n      \"superClass\": [\n        \"Activity\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"calledElement\",\n          \"type\": \"String\",\n          \"isAttr\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"Task\",\n      \"superClass\": [\n        \"Activity\",\n        \"InteractionNode\"\n      ]\n    },\n    {\n      \"name\": \"SendTask\",\n      \"superClass\": [\n        \"Task\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"implementation\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"operationRef\",\n          \"type\": \"Operation\",\n          \"isAttr\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"messageRef\",\n          \"type\": \"Message\",\n          \"isAttr\": true,\n          \"isReference\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"ReceiveTask\",\n      \"superClass\": [\n        \"Task\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"implementation\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"instantiate\",\n          \"default\": false,\n          \"isAttr\": true,\n          \"type\": \"Boolean\"\n        },\n        {\n          \"name\": \"operationRef\",\n          \"type\": \"Operation\",\n          \"isAttr\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"messageRef\",\n          \"type\": \"Message\",\n          \"isAttr\": true,\n          \"isReference\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"ScriptTask\",\n      \"superClass\": [\n        \"Task\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"scriptFormat\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"script\",\n          \"type\": \"String\"\n        }\n      ]\n    },\n    {\n      \"name\": \"BusinessRuleTask\",\n      \"superClass\": [\n        \"Task\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"implementation\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        }\n      ]\n    },\n    {\n      \"name\": \"AdHocSubProcess\",\n      \"superClass\": [\n        \"SubProcess\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"completionCondition\",\n          \"type\": \"Expression\",\n          \"xml\": {\n            \"serialize\": \"xsi:type\"\n          }\n        },\n        {\n          \"name\": \"ordering\",\n          \"type\": \"AdHocOrdering\",\n          \"isAttr\": true\n        },\n        {\n          \"name\": \"cancelRemainingInstances\",\n          \"default\": true,\n          \"isAttr\": true,\n          \"type\": \"Boolean\"\n        }\n      ]\n    },\n    {\n      \"name\": \"Transaction\",\n      \"superClass\": [\n        \"SubProcess\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"protocol\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"method\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        }\n      ]\n    },\n    {\n      \"name\": \"GlobalScriptTask\",\n      \"superClass\": [\n        \"GlobalTask\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"scriptLanguage\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"script\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        }\n      ]\n    },\n    {\n      \"name\": \"GlobalBusinessRuleTask\",\n      \"superClass\": [\n        \"GlobalTask\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"implementation\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        }\n      ]\n    },\n    {\n      \"name\": \"ComplexBehaviorDefinition\",\n      \"superClass\": [\n        \"BaseElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"condition\",\n          \"type\": \"FormalExpression\"\n        },\n        {\n          \"name\": \"event\",\n          \"type\": \"ImplicitThrowEvent\"\n        }\n      ]\n    },\n    {\n      \"name\": \"ResourceRole\",\n      \"superClass\": [\n        \"BaseElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"resourceRef\",\n          \"type\": \"Resource\",\n          \"isReference\": true\n        },\n        {\n          \"name\": \"resourceParameterBindings\",\n          \"type\": \"ResourceParameterBinding\",\n          \"isMany\": true\n        },\n        {\n          \"name\": \"resourceAssignmentExpression\",\n          \"type\": \"ResourceAssignmentExpression\"\n        },\n        {\n          \"name\": \"name\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        }\n      ]\n    },\n    {\n      \"name\": \"ResourceParameterBinding\",\n      \"properties\": [\n        {\n          \"name\": \"expression\",\n          \"type\": \"Expression\",\n          \"xml\": {\n            \"serialize\": \"xsi:type\"\n          }\n        },\n        {\n          \"name\": \"parameterRef\",\n          \"type\": \"ResourceParameter\",\n          \"isAttr\": true,\n          \"isReference\": true\n        }\n      ],\n      \"superClass\": [\n        \"BaseElement\"\n      ]\n    },\n    {\n      \"name\": \"ResourceAssignmentExpression\",\n      \"properties\": [\n        {\n          \"name\": \"expression\",\n          \"type\": \"Expression\",\n          \"xml\": {\n            \"serialize\": \"xsi:type\"\n          }\n        }\n      ],\n      \"superClass\": [\n        \"BaseElement\"\n      ]\n    },\n    {\n      \"name\": \"Import\",\n      \"properties\": [\n        {\n          \"name\": \"importType\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"location\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"namespace\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        }\n      ]\n    },\n    {\n      \"name\": \"Definitions\",\n      \"superClass\": [\n        \"BaseElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"name\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"targetNamespace\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"expressionLanguage\",\n          \"default\": \"http://www.w3.org/1999/XPath\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"typeLanguage\",\n          \"default\": \"http://www.w3.org/2001/XMLSchema\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"imports\",\n          \"type\": \"Import\",\n          \"isMany\": true\n        },\n        {\n          \"name\": \"extensions\",\n          \"type\": \"Extension\",\n          \"isMany\": true\n        },\n        {\n          \"name\": \"rootElements\",\n          \"type\": \"RootElement\",\n          \"isMany\": true\n        },\n        {\n          \"name\": \"diagrams\",\n          \"isMany\": true,\n          \"type\": \"bpmndi:BPMNDiagram\"\n        },\n        {\n          \"name\": \"exporter\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"relationships\",\n          \"type\": \"Relationship\",\n          \"isMany\": true\n        },\n        {\n          \"name\": \"exporterVersion\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        }\n      ]\n    }\n  ],\n  \"enumerations\": [\n    {\n      \"name\": \"ProcessType\",\n      \"literalValues\": [\n        {\n          \"name\": \"None\"\n        },\n        {\n          \"name\": \"Public\"\n        },\n        {\n          \"name\": \"Private\"\n        }\n      ]\n    },\n    {\n      \"name\": \"GatewayDirection\",\n      \"literalValues\": [\n        {\n          \"name\": \"Unspecified\"\n        },\n        {\n          \"name\": \"Converging\"\n        },\n        {\n          \"name\": \"Diverging\"\n        },\n        {\n          \"name\": \"Mixed\"\n        }\n      ]\n    },\n    {\n      \"name\": \"EventBasedGatewayType\",\n      \"literalValues\": [\n        {\n          \"name\": \"Parallel\"\n        },\n        {\n          \"name\": \"Exclusive\"\n        }\n      ]\n    },\n    {\n      \"name\": \"RelationshipDirection\",\n      \"literalValues\": [\n        {\n          \"name\": \"None\"\n        },\n        {\n          \"name\": \"Forward\"\n        },\n        {\n          \"name\": \"Backward\"\n        },\n        {\n          \"name\": \"Both\"\n        }\n      ]\n    },\n    {\n      \"name\": \"ItemKind\",\n      \"literalValues\": [\n        {\n          \"name\": \"Physical\"\n        },\n        {\n          \"name\": \"Information\"\n        }\n      ]\n    },\n    {\n      \"name\": \"ChoreographyLoopType\",\n      \"literalValues\": [\n        {\n          \"name\": \"None\"\n        },\n        {\n          \"name\": \"Standard\"\n        },\n        {\n          \"name\": \"MultiInstanceSequential\"\n        },\n        {\n          \"name\": \"MultiInstanceParallel\"\n        }\n      ]\n    },\n    {\n      \"name\": \"AssociationDirection\",\n      \"literalValues\": [\n        {\n          \"name\": \"None\"\n        },\n        {\n          \"name\": \"One\"\n        },\n        {\n          \"name\": \"Both\"\n        }\n      ]\n    },\n    {\n      \"name\": \"MultiInstanceBehavior\",\n      \"literalValues\": [\n        {\n          \"name\": \"None\"\n        },\n        {\n          \"name\": \"One\"\n        },\n        {\n          \"name\": \"All\"\n        },\n        {\n          \"name\": \"Complex\"\n        }\n      ]\n    },\n    {\n      \"name\": \"AdHocOrdering\",\n      \"literalValues\": [\n        {\n          \"name\": \"Parallel\"\n        },\n        {\n          \"name\": \"Sequential\"\n        }\n      ]\n    }\n  ],\n  \"prefix\": \"bpmn\",\n  \"xml\": {\n    \"tagAlias\": \"lowerCase\",\n    \"typePrefix\": \"t\"\n  }\n}","module.exports={\n  \"name\": \"BPMNDI\",\n  \"uri\": \"http://www.omg.org/spec/BPMN/20100524/DI\",\n  \"types\": [\n    {\n      \"name\": \"BPMNDiagram\",\n      \"properties\": [\n        {\n          \"name\": \"plane\",\n          \"type\": \"BPMNPlane\",\n          \"redefines\": \"di:Diagram#rootElement\"\n        },\n        {\n          \"name\": \"labelStyle\",\n          \"type\": \"BPMNLabelStyle\",\n          \"isMany\": true\n        }\n      ],\n      \"superClass\": [\n        \"di:Diagram\"\n      ]\n    },\n    {\n      \"name\": \"BPMNPlane\",\n      \"properties\": [\n        {\n          \"name\": \"bpmnElement\",\n          \"isAttr\": true,\n          \"isReference\": true,\n          \"type\": \"bpmn:BaseElement\",\n          \"redefines\": \"di:DiagramElement#modelElement\"\n        }\n      ],\n      \"superClass\": [\n        \"di:Plane\"\n      ]\n    },\n    {\n      \"name\": \"BPMNShape\",\n      \"properties\": [\n        {\n          \"name\": \"bpmnElement\",\n          \"isAttr\": true,\n          \"isReference\": true,\n          \"type\": \"bpmn:BaseElement\",\n          \"redefines\": \"di:DiagramElement#modelElement\"\n        },\n        {\n          \"name\": \"isHorizontal\",\n          \"isAttr\": true,\n          \"type\": \"Boolean\"\n        },\n        {\n          \"name\": \"isExpanded\",\n          \"isAttr\": true,\n          \"type\": \"Boolean\"\n        },\n        {\n          \"name\": \"isMarkerVisible\",\n          \"isAttr\": true,\n          \"type\": \"Boolean\"\n        },\n        {\n          \"name\": \"label\",\n          \"type\": \"BPMNLabel\"\n        },\n        {\n          \"name\": \"isMessageVisible\",\n          \"isAttr\": true,\n          \"type\": \"Boolean\"\n        },\n        {\n          \"name\": \"participantBandKind\",\n          \"type\": \"ParticipantBandKind\",\n          \"isAttr\": true\n        },\n        {\n          \"name\": \"choreographyActivityShape\",\n          \"type\": \"BPMNShape\",\n          \"isAttr\": true,\n          \"isReference\": true\n        }\n      ],\n      \"superClass\": [\n        \"di:LabeledShape\"\n      ]\n    },\n    {\n      \"name\": \"BPMNEdge\",\n      \"properties\": [\n        {\n          \"name\": \"label\",\n          \"type\": \"BPMNLabel\"\n        },\n        {\n          \"name\": \"bpmnElement\",\n          \"isAttr\": true,\n          \"isReference\": true,\n          \"type\": \"bpmn:BaseElement\",\n          \"redefines\": \"di:DiagramElement#modelElement\"\n        },\n        {\n          \"name\": \"sourceElement\",\n          \"isAttr\": true,\n          \"isReference\": true,\n          \"type\": \"di:DiagramElement\",\n          \"redefines\": \"di:Edge#source\"\n        },\n        {\n          \"name\": \"targetElement\",\n          \"isAttr\": true,\n          \"isReference\": true,\n          \"type\": \"di:DiagramElement\",\n          \"redefines\": \"di:Edge#target\"\n        },\n        {\n          \"name\": \"messageVisibleKind\",\n          \"type\": \"MessageVisibleKind\",\n          \"isAttr\": true,\n          \"default\": \"initiating\"\n        }\n      ],\n      \"superClass\": [\n        \"di:LabeledEdge\"\n      ]\n    },\n    {\n      \"name\": \"BPMNLabel\",\n      \"properties\": [\n        {\n          \"name\": \"labelStyle\",\n          \"type\": \"BPMNLabelStyle\",\n          \"isAttr\": true,\n          \"isReference\": true,\n          \"redefines\": \"di:DiagramElement#style\"\n        }\n      ],\n      \"superClass\": [\n        \"di:Label\"\n      ]\n    },\n    {\n      \"name\": \"BPMNLabelStyle\",\n      \"properties\": [\n        {\n          \"name\": \"font\",\n          \"type\": \"dc:Font\"\n        }\n      ],\n      \"superClass\": [\n        \"di:Style\"\n      ]\n    }\n  ],\n  \"enumerations\": [\n    {\n      \"name\": \"ParticipantBandKind\",\n      \"literalValues\": [\n        {\n          \"name\": \"top_initiating\"\n        },\n        {\n          \"name\": \"middle_initiating\"\n        },\n        {\n          \"name\": \"bottom_initiating\"\n        },\n        {\n          \"name\": \"top_non_initiating\"\n        },\n        {\n          \"name\": \"middle_non_initiating\"\n        },\n        {\n          \"name\": \"bottom_non_initiating\"\n        }\n      ]\n    },\n    {\n      \"name\": \"MessageVisibleKind\",\n      \"literalValues\": [\n        {\n          \"name\": \"initiating\"\n        },\n        {\n          \"name\": \"non_initiating\"\n        }\n      ]\n    }\n  ],\n  \"associations\": [],\n  \"prefix\": \"bpmndi\"\n}","module.exports={\n  \"name\": \"DC\",\n  \"uri\": \"http://www.omg.org/spec/DD/20100524/DC\",\n  \"types\": [\n    {\n      \"name\": \"Boolean\"\n    },\n    {\n      \"name\": \"Integer\"\n    },\n    {\n      \"name\": \"Real\"\n    },\n    {\n      \"name\": \"String\"\n    },\n    {\n      \"name\": \"Font\",\n      \"properties\": [\n        {\n          \"name\": \"name\",\n          \"type\": \"String\",\n          \"isAttr\": true\n        },\n        {\n          \"name\": \"size\",\n          \"type\": \"Real\",\n          \"isAttr\": true\n        },\n        {\n          \"name\": \"isBold\",\n          \"type\": \"Boolean\",\n          \"isAttr\": true\n        },\n        {\n          \"name\": \"isItalic\",\n          \"type\": \"Boolean\",\n          \"isAttr\": true\n        },\n        {\n          \"name\": \"isUnderline\",\n          \"type\": \"Boolean\",\n          \"isAttr\": true\n        },\n        {\n          \"name\": \"isStrikeThrough\",\n          \"type\": \"Boolean\",\n          \"isAttr\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"Point\",\n      \"properties\": [\n        {\n          \"name\": \"x\",\n          \"type\": \"Real\",\n          \"default\": \"0\",\n          \"isAttr\": true\n        },\n        {\n          \"name\": \"y\",\n          \"type\": \"Real\",\n          \"default\": \"0\",\n          \"isAttr\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"Bounds\",\n      \"properties\": [\n        {\n          \"name\": \"x\",\n          \"type\": \"Real\",\n          \"default\": \"0\",\n          \"isAttr\": true\n        },\n        {\n          \"name\": \"y\",\n          \"type\": \"Real\",\n          \"default\": \"0\",\n          \"isAttr\": true\n        },\n        {\n          \"name\": \"width\",\n          \"type\": \"Real\",\n          \"isAttr\": true\n        },\n        {\n          \"name\": \"height\",\n          \"type\": \"Real\",\n          \"isAttr\": true\n        }\n      ]\n    }\n  ],\n  \"prefix\": \"dc\",\n  \"associations\": []\n}","module.exports={\n  \"name\": \"DI\",\n  \"uri\": \"http://www.omg.org/spec/DD/20100524/DI\",\n  \"types\": [\n    {\n      \"name\": \"DiagramElement\",\n      \"isAbstract\": true,\n      \"properties\": [\n        {\n          \"name\": \"id\",\n          \"type\": \"String\",\n          \"isAttr\": true,\n          \"isId\": true\n        },\n        {\n          \"name\": \"extension\",\n          \"type\": \"Extension\"\n        },\n        {\n          \"name\": \"owningDiagram\",\n          \"type\": \"Diagram\",\n          \"isReadOnly\": true,\n          \"isVirtual\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"owningElement\",\n          \"type\": \"DiagramElement\",\n          \"isReadOnly\": true,\n          \"isVirtual\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"modelElement\",\n          \"isReadOnly\": true,\n          \"isVirtual\": true,\n          \"isReference\": true,\n          \"type\": \"Element\"\n        },\n        {\n          \"name\": \"style\",\n          \"type\": \"Style\",\n          \"isReadOnly\": true,\n          \"isVirtual\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"ownedElement\",\n          \"type\": \"DiagramElement\",\n          \"isReadOnly\": true,\n          \"isVirtual\": true,\n          \"isMany\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"Node\",\n      \"isAbstract\": true,\n      \"superClass\": [\n        \"DiagramElement\"\n      ]\n    },\n    {\n      \"name\": \"Edge\",\n      \"isAbstract\": true,\n      \"superClass\": [\n        \"DiagramElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"source\",\n          \"type\": \"DiagramElement\",\n          \"isReadOnly\": true,\n          \"isVirtual\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"target\",\n          \"type\": \"DiagramElement\",\n          \"isReadOnly\": true,\n          \"isVirtual\": true,\n          \"isReference\": true\n        },\n        {\n          \"name\": \"waypoint\",\n          \"isUnique\": false,\n          \"isMany\": true,\n          \"type\": \"dc:Point\",\n          \"xml\": {\n            \"serialize\": \"xsi:type\"\n          }\n        }\n      ]\n    },\n    {\n      \"name\": \"Diagram\",\n      \"isAbstract\": true,\n      \"properties\": [\n        {\n          \"name\": \"id\",\n          \"type\": \"String\",\n          \"isAttr\": true,\n          \"isId\": true\n        },\n        {\n          \"name\": \"rootElement\",\n          \"type\": \"DiagramElement\",\n          \"isReadOnly\": true,\n          \"isVirtual\": true\n        },\n        {\n          \"name\": \"name\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"documentation\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"resolution\",\n          \"isAttr\": true,\n          \"type\": \"Real\"\n        },\n        {\n          \"name\": \"ownedStyle\",\n          \"type\": \"Style\",\n          \"isReadOnly\": true,\n          \"isVirtual\": true,\n          \"isMany\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"Shape\",\n      \"isAbstract\": true,\n      \"superClass\": [\n        \"Node\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"bounds\",\n          \"type\": \"dc:Bounds\"\n        }\n      ]\n    },\n    {\n      \"name\": \"Plane\",\n      \"isAbstract\": true,\n      \"superClass\": [\n        \"Node\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"planeElement\",\n          \"type\": \"DiagramElement\",\n          \"subsettedProperty\": \"DiagramElement-ownedElement\",\n          \"isMany\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"LabeledEdge\",\n      \"isAbstract\": true,\n      \"superClass\": [\n        \"Edge\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"ownedLabel\",\n          \"type\": \"Label\",\n          \"isReadOnly\": true,\n          \"subsettedProperty\": \"DiagramElement-ownedElement\",\n          \"isVirtual\": true,\n          \"isMany\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"LabeledShape\",\n      \"isAbstract\": true,\n      \"superClass\": [\n        \"Shape\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"ownedLabel\",\n          \"type\": \"Label\",\n          \"isReadOnly\": true,\n          \"subsettedProperty\": \"DiagramElement-ownedElement\",\n          \"isVirtual\": true,\n          \"isMany\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"Label\",\n      \"isAbstract\": true,\n      \"superClass\": [\n        \"Node\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"bounds\",\n          \"type\": \"dc:Bounds\"\n        }\n      ]\n    },\n    {\n      \"name\": \"Style\",\n      \"isAbstract\": true,\n      \"properties\": [\n        {\n          \"name\": \"id\",\n          \"type\": \"String\",\n          \"isAttr\": true,\n          \"isId\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"Extension\",\n      \"properties\": [\n        {\n          \"name\": \"values\",\n          \"type\": \"Element\",\n          \"isMany\": true\n        }\n      ]\n    }\n  ],\n  \"associations\": [],\n  \"prefix\": \"di\",\n  \"xml\": {\n    \"tagAlias\": \"lowerCase\"\n  }\n}","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nvar objectCreate = Object.create || objectCreatePolyfill\nvar objectKeys = Object.keys || objectKeysPolyfill\nvar bind = Function.prototype.bind || functionBindPolyfill\n\nfunction EventEmitter() {\n  if (!this._events || !Object.prototype.hasOwnProperty.call(this, '_events')) {\n    this._events = objectCreate(null);\n    this._eventsCount = 0;\n  }\n\n  this._maxListeners = this._maxListeners || undefined;\n}\nmodule.exports = EventEmitter;\n\n// Backwards-compat with node 0.10.x\nEventEmitter.EventEmitter = EventEmitter;\n\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._maxListeners = undefined;\n\n// By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\nvar defaultMaxListeners = 10;\n\nvar hasDefineProperty;\ntry {\n  var o = {};\n  if (Object.defineProperty) Object.defineProperty(o, 'x', { value: 0 });\n  hasDefineProperty = o.x === 0;\n} catch (err) { hasDefineProperty = false }\nif (hasDefineProperty) {\n  Object.defineProperty(EventEmitter, 'defaultMaxListeners', {\n    enumerable: true,\n    get: function() {\n      return defaultMaxListeners;\n    },\n    set: function(arg) {\n      // check whether the input is a positive number (whose value is zero or\n      // greater and not a NaN).\n      if (typeof arg !== 'number' || arg < 0 || arg !== arg)\n        throw new TypeError('\"defaultMaxListeners\" must be a positive number');\n      defaultMaxListeners = arg;\n    }\n  });\n} else {\n  EventEmitter.defaultMaxListeners = defaultMaxListeners;\n}\n\n// Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\nEventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {\n  if (typeof n !== 'number' || n < 0 || isNaN(n))\n    throw new TypeError('\"n\" argument must be a positive number');\n  this._maxListeners = n;\n  return this;\n};\n\nfunction $getMaxListeners(that) {\n  if (that._maxListeners === undefined)\n    return EventEmitter.defaultMaxListeners;\n  return that._maxListeners;\n}\n\nEventEmitter.prototype.getMaxListeners = function getMaxListeners() {\n  return $getMaxListeners(this);\n};\n\n// These standalone emit* functions are used to optimize calling of event\n// handlers for fast cases because emit() itself often has a variable number of\n// arguments and can be deoptimized because of that. These functions always have\n// the same number of arguments and thus do not get deoptimized, so the code\n// inside them can execute faster.\nfunction emitNone(handler, isFn, self) {\n  if (isFn)\n    handler.call(self);\n  else {\n    var len = handler.length;\n    var listeners = arrayClone(handler, len);\n    for (var i = 0; i < len; ++i)\n      listeners[i].call(self);\n  }\n}\nfunction emitOne(handler, isFn, self, arg1) {\n  if (isFn)\n    handler.call(self, arg1);\n  else {\n    var len = handler.length;\n    var listeners = arrayClone(handler, len);\n    for (var i = 0; i < len; ++i)\n      listeners[i].call(self, arg1);\n  }\n}\nfunction emitTwo(handler, isFn, self, arg1, arg2) {\n  if (isFn)\n    handler.call(self, arg1, arg2);\n  else {\n    var len = handler.length;\n    var listeners = arrayClone(handler, len);\n    for (var i = 0; i < len; ++i)\n      listeners[i].call(self, arg1, arg2);\n  }\n}\nfunction emitThree(handler, isFn, self, arg1, arg2, arg3) {\n  if (isFn)\n    handler.call(self, arg1, arg2, arg3);\n  else {\n    var len = handler.length;\n    var listeners = arrayClone(handler, len);\n    for (var i = 0; i < len; ++i)\n      listeners[i].call(self, arg1, arg2, arg3);\n  }\n}\n\nfunction emitMany(handler, isFn, self, args) {\n  if (isFn)\n    handler.apply(self, args);\n  else {\n    var len = handler.length;\n    var listeners = arrayClone(handler, len);\n    for (var i = 0; i < len; ++i)\n      listeners[i].apply(self, args);\n  }\n}\n\nEventEmitter.prototype.emit = function emit(type) {\n  var er, handler, len, args, i, events;\n  var doError = (type === 'error');\n\n  events = this._events;\n  if (events)\n    doError = (doError && events.error == null);\n  else if (!doError)\n    return false;\n\n  // If there is no 'error' event listener then throw.\n  if (doError) {\n    if (arguments.length > 1)\n      er = arguments[1];\n    if (er instanceof Error) {\n      throw er; // Unhandled 'error' event\n    } else {\n      // At least give some kind of context to the user\n      var err = new Error('Unhandled \"error\" event. (' + er + ')');\n      err.context = er;\n      throw err;\n    }\n    return false;\n  }\n\n  handler = events[type];\n\n  if (!handler)\n    return false;\n\n  var isFn = typeof handler === 'function';\n  len = arguments.length;\n  switch (len) {\n      // fast cases\n    case 1:\n      emitNone(handler, isFn, this);\n      break;\n    case 2:\n      emitOne(handler, isFn, this, arguments[1]);\n      break;\n    case 3:\n      emitTwo(handler, isFn, this, arguments[1], arguments[2]);\n      break;\n    case 4:\n      emitThree(handler, isFn, this, arguments[1], arguments[2], arguments[3]);\n      break;\n      // slower\n    default:\n      args = new Array(len - 1);\n      for (i = 1; i < len; i++)\n        args[i - 1] = arguments[i];\n      emitMany(handler, isFn, this, args);\n  }\n\n  return true;\n};\n\nfunction _addListener(target, type, listener, prepend) {\n  var m;\n  var events;\n  var existing;\n\n  if (typeof listener !== 'function')\n    throw new TypeError('\"listener\" argument must be a function');\n\n  events = target._events;\n  if (!events) {\n    events = target._events = objectCreate(null);\n    target._eventsCount = 0;\n  } else {\n    // To avoid recursion in the case that type === \"newListener\"! Before\n    // adding it to the listeners, first emit \"newListener\".\n    if (events.newListener) {\n      target.emit('newListener', type,\n          listener.listener ? listener.listener : listener);\n\n      // Re-assign `events` because a newListener handler could have caused the\n      // this._events to be assigned to a new object\n      events = target._events;\n    }\n    existing = events[type];\n  }\n\n  if (!existing) {\n    // Optimize the case of one listener. Don't need the extra array object.\n    existing = events[type] = listener;\n    ++target._eventsCount;\n  } else {\n    if (typeof existing === 'function') {\n      // Adding the second element, need to change to array.\n      existing = events[type] =\n          prepend ? [listener, existing] : [existing, listener];\n    } else {\n      // If we've already got an array, just append.\n      if (prepend) {\n        existing.unshift(listener);\n      } else {\n        existing.push(listener);\n      }\n    }\n\n    // Check for listener leak\n    if (!existing.warned) {\n      m = $getMaxListeners(target);\n      if (m && m > 0 && existing.length > m) {\n        existing.warned = true;\n        var w = new Error('Possible EventEmitter memory leak detected. ' +\n            existing.length + ' \"' + String(type) + '\" listeners ' +\n            'added. Use emitter.setMaxListeners() to ' +\n            'increase limit.');\n        w.name = 'MaxListenersExceededWarning';\n        w.emitter = target;\n        w.type = type;\n        w.count = existing.length;\n        if (typeof console === 'object' && console.warn) {\n          console.warn('%s: %s', w.name, w.message);\n        }\n      }\n    }\n  }\n\n  return target;\n}\n\nEventEmitter.prototype.addListener = function addListener(type, listener) {\n  return _addListener(this, type, listener, false);\n};\n\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\nEventEmitter.prototype.prependListener =\n    function prependListener(type, listener) {\n      return _addListener(this, type, listener, true);\n    };\n\nfunction onceWrapper() {\n  if (!this.fired) {\n    this.target.removeListener(this.type, this.wrapFn);\n    this.fired = true;\n    switch (arguments.length) {\n      case 0:\n        return this.listener.call(this.target);\n      case 1:\n        return this.listener.call(this.target, arguments[0]);\n      case 2:\n        return this.listener.call(this.target, arguments[0], arguments[1]);\n      case 3:\n        return this.listener.call(this.target, arguments[0], arguments[1],\n            arguments[2]);\n      default:\n        var args = new Array(arguments.length);\n        for (var i = 0; i < args.length; ++i)\n          args[i] = arguments[i];\n        this.listener.apply(this.target, args);\n    }\n  }\n}\n\nfunction _onceWrap(target, type, listener) {\n  var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };\n  var wrapped = bind.call(onceWrapper, state);\n  wrapped.listener = listener;\n  state.wrapFn = wrapped;\n  return wrapped;\n}\n\nEventEmitter.prototype.once = function once(type, listener) {\n  if (typeof listener !== 'function')\n    throw new TypeError('\"listener\" argument must be a function');\n  this.on(type, _onceWrap(this, type, listener));\n  return this;\n};\n\nEventEmitter.prototype.prependOnceListener =\n    function prependOnceListener(type, listener) {\n      if (typeof listener !== 'function')\n        throw new TypeError('\"listener\" argument must be a function');\n      this.prependListener(type, _onceWrap(this, type, listener));\n      return this;\n    };\n\n// Emits a 'removeListener' event if and only if the listener was removed.\nEventEmitter.prototype.removeListener =\n    function removeListener(type, listener) {\n      var list, events, position, i, originalListener;\n\n      if (typeof listener !== 'function')\n        throw new TypeError('\"listener\" argument must be a function');\n\n      events = this._events;\n      if (!events)\n        return this;\n\n      list = events[type];\n      if (!list)\n        return this;\n\n      if (list === listener || list.listener === listener) {\n        if (--this._eventsCount === 0)\n          this._events = objectCreate(null);\n        else {\n          delete events[type];\n          if (events.removeListener)\n            this.emit('removeListener', type, list.listener || listener);\n        }\n      } else if (typeof list !== 'function') {\n        position = -1;\n\n        for (i = list.length - 1; i >= 0; i--) {\n          if (list[i] === listener || list[i].listener === listener) {\n            originalListener = list[i].listener;\n            position = i;\n            break;\n          }\n        }\n\n        if (position < 0)\n          return this;\n\n        if (position === 0)\n          list.shift();\n        else\n          spliceOne(list, position);\n\n        if (list.length === 1)\n          events[type] = list[0];\n\n        if (events.removeListener)\n          this.emit('removeListener', type, originalListener || listener);\n      }\n\n      return this;\n    };\n\nEventEmitter.prototype.removeAllListeners =\n    function removeAllListeners(type) {\n      var listeners, events, i;\n\n      events = this._events;\n      if (!events)\n        return this;\n\n      // not listening for removeListener, no need to emit\n      if (!events.removeListener) {\n        if (arguments.length === 0) {\n          this._events = objectCreate(null);\n          this._eventsCount = 0;\n        } else if (events[type]) {\n          if (--this._eventsCount === 0)\n            this._events = objectCreate(null);\n          else\n            delete events[type];\n        }\n        return this;\n      }\n\n      // emit removeListener for all listeners on all events\n      if (arguments.length === 0) {\n        var keys = objectKeys(events);\n        var key;\n        for (i = 0; i < keys.length; ++i) {\n          key = keys[i];\n          if (key === 'removeListener') continue;\n          this.removeAllListeners(key);\n        }\n        this.removeAllListeners('removeListener');\n        this._events = objectCreate(null);\n        this._eventsCount = 0;\n        return this;\n      }\n\n      listeners = events[type];\n\n      if (typeof listeners === 'function') {\n        this.removeListener(type, listeners);\n      } else if (listeners) {\n        // LIFO order\n        for (i = listeners.length - 1; i >= 0; i--) {\n          this.removeListener(type, listeners[i]);\n        }\n      }\n\n      return this;\n    };\n\nfunction _listeners(target, type, unwrap) {\n  var events = target._events;\n\n  if (!events)\n    return [];\n\n  var evlistener = events[type];\n  if (!evlistener)\n    return [];\n\n  if (typeof evlistener === 'function')\n    return unwrap ? [evlistener.listener || evlistener] : [evlistener];\n\n  return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);\n}\n\nEventEmitter.prototype.listeners = function listeners(type) {\n  return _listeners(this, type, true);\n};\n\nEventEmitter.prototype.rawListeners = function rawListeners(type) {\n  return _listeners(this, type, false);\n};\n\nEventEmitter.listenerCount = function(emitter, type) {\n  if (typeof emitter.listenerCount === 'function') {\n    return emitter.listenerCount(type);\n  } else {\n    return listenerCount.call(emitter, type);\n  }\n};\n\nEventEmitter.prototype.listenerCount = listenerCount;\nfunction listenerCount(type) {\n  var events = this._events;\n\n  if (events) {\n    var evlistener = events[type];\n\n    if (typeof evlistener === 'function') {\n      return 1;\n    } else if (evlistener) {\n      return evlistener.length;\n    }\n  }\n\n  return 0;\n}\n\nEventEmitter.prototype.eventNames = function eventNames() {\n  return this._eventsCount > 0 ? Reflect.ownKeys(this._events) : [];\n};\n\n// About 1.5x faster than the two-arg version of Array#splice().\nfunction spliceOne(list, index) {\n  for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1)\n    list[i] = list[k];\n  list.pop();\n}\n\nfunction arrayClone(arr, n) {\n  var copy = new Array(n);\n  for (var i = 0; i < n; ++i)\n    copy[i] = arr[i];\n  return copy;\n}\n\nfunction unwrapListeners(arr) {\n  var ret = new Array(arr.length);\n  for (var i = 0; i < ret.length; ++i) {\n    ret[i] = arr[i].listener || arr[i];\n  }\n  return ret;\n}\n\nfunction objectCreatePolyfill(proto) {\n  var F = function() {};\n  F.prototype = proto;\n  return new F;\n}\nfunction objectKeysPolyfill(obj) {\n  var keys = [];\n  for (var k in obj) if (Object.prototype.hasOwnProperty.call(obj, k)) {\n    keys.push(k);\n  }\n  return k;\n}\nfunction functionBindPolyfill(context) {\n  var fn = this;\n  return function () {\n    return fn.apply(context, arguments);\n  };\n}\n","module.exports={\n  \"name\": \"Camunda\",\n  \"uri\": \"http://camunda.org/schema/1.0/bpmn\",\n  \"prefix\": \"camunda\",\n  \"xml\": {\n    \"tagAlias\": \"lowerCase\"\n  },\n  \"associations\": [],\n  \"types\": [\n    {\n      \"name\": \"InOutBinding\",\n      \"superClass\": [\n        \"Element\"\n      ],\n      \"isAbstract\": true,\n      \"properties\": [\n        {\n          \"name\": \"source\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"sourceExpression\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"target\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"businessKey\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"local\",\n          \"isAttr\": true,\n          \"type\": \"Boolean\",\n          \"default\": false\n        },\n        {\n          \"name\": \"variables\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        }\n      ]\n    },\n    {\n      \"name\": \"In\",\n      \"superClass\": [\n        \"InOutBinding\"\n      ],\n      \"meta\": {\n        \"allowedIn\": [\n          \"bpmn:CallActivity\"\n        ]\n      }\n    },\n    {\n      \"name\": \"Out\",\n      \"superClass\": [\n        \"InOutBinding\"\n      ],\n      \"meta\": {\n        \"allowedIn\": [\n          \"bpmn:CallActivity\"\n        ]\n      }\n    },\n    {\n      \"name\": \"AsyncCapable\",\n      \"isAbstract\": true,\n      \"extends\": [\n        \"bpmn:Activity\",\n        \"bpmn:Gateway\",\n        \"bpmn:Event\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"async\",\n          \"isAttr\": true,\n          \"type\": \"Boolean\",\n          \"default\": false\n        },\n        {\n          \"name\": \"asyncBefore\",\n          \"isAttr\": true,\n          \"type\": \"Boolean\",\n          \"default\": false\n        },\n        {\n          \"name\": \"asyncAfter\",\n          \"isAttr\": true,\n          \"type\": \"Boolean\",\n          \"default\": false\n        },\n        {\n          \"name\": \"exclusive\",\n          \"isAttr\": true,\n          \"type\": \"Boolean\",\n          \"default\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"JobPriorized\",\n      \"isAbstract\": true,\n      \"extends\": [\n        \"bpmn:Process\",\n        \"camunda:AsyncCapable\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"jobPriority\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        }\n      ]\n    },\n    {\n      \"name\": \"SignalEventDefinition\",\n      \"isAbstract\": true,\n      \"extends\": [\n        \"bpmn:SignalEventDefinition\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"async\",\n          \"isAttr\": true,\n          \"type\": \"Boolean\",\n          \"default\": false\n        }\n      ]\n    },\n    {\n      \"name\": \"ErrorEventDefinition\",\n      \"isAbstract\": true,\n      \"extends\": [\n        \"bpmn:ErrorEventDefinition\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"errorCodeVariable\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"errorMessageVariable\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        }\n      ]\n    },\n    {\n      \"name\": \"PotentialStarter\",\n      \"superClass\": [\n        \"Element\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"resourceAssignmentExpression\",\n          \"type\": \"bpmn:ResourceAssignmentExpression\"\n        }\n      ]\n    },\n    {\n      \"name\": \"FormSupported\",\n      \"isAbstract\": true,\n      \"extends\": [\n        \"bpmn:StartEvent\",\n        \"bpmn:UserTask\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"formHandlerClass\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"formKey\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        }\n      ]\n    },\n    {\n      \"name\": \"TemplateSupported\",\n      \"isAbstract\": true,\n      \"extends\": [\n        \"bpmn:Process\",\n        \"bpmn:FlowElement\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"modelerTemplate\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        }\n      ]\n    },\n    {\n      \"name\": \"Initiator\",\n      \"isAbstract\": true,\n      \"extends\": [ \"bpmn:StartEvent\" ],\n      \"properties\": [\n        {\n          \"name\": \"initiator\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        }\n      ]\n    },\n    {\n      \"name\": \"ScriptTask\",\n      \"isAbstract\": true,\n      \"extends\": [\n        \"bpmn:ScriptTask\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"resultVariable\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"resource\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        }\n      ]\n    },\n    {\n      \"name\": \"Process\",\n      \"isAbstract\": true,\n      \"extends\": [\n        \"bpmn:Process\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"candidateStarterGroups\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"candidateStarterUsers\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"versionTag\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"historyTimeToLive\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"isStartableInTasklist\",\n          \"isAttr\": true,\n          \"type\": \"Boolean\",\n          \"default\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"EscalationEventDefinition\",\n      \"isAbstract\": true,\n      \"extends\": [\n        \"bpmn:EscalationEventDefinition\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"escalationCodeVariable\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        }\n      ]\n    },\n    {\n      \"name\": \"FormalExpression\",\n      \"isAbstract\": true,\n      \"extends\": [\n        \"bpmn:FormalExpression\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"resource\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        }\n      ]\n    },\n    {\n      \"name\": \"Assignable\",\n      \"extends\": [ \"bpmn:UserTask\" ],\n      \"properties\": [\n        {\n          \"name\": \"assignee\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"candidateUsers\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"candidateGroups\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"dueDate\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"followUpDate\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"priority\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        }\n      ]\n    },\n    {\n      \"name\": \"CallActivity\",\n      \"extends\": [ \"bpmn:CallActivity\" ],\n      \"properties\": [\n        {\n          \"name\": \"calledElementBinding\",\n          \"isAttr\": true,\n          \"type\": \"String\",\n          \"default\": \"latest\"\n        },\n        {\n          \"name\": \"calledElementVersion\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"calledElementVersionTag\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"calledElementTenantId\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"caseRef\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"caseBinding\",\n          \"isAttr\": true,\n          \"type\": \"String\",\n          \"default\": \"latest\"\n        },\n        {\n          \"name\": \"caseVersion\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"caseTenantId\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"variableMappingClass\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"variableMappingDelegateExpression\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        }\n      ]\n    },\n    {\n      \"name\": \"ServiceTaskLike\",\n      \"extends\": [\n        \"bpmn:ServiceTask\",\n        \"bpmn:BusinessRuleTask\",\n        \"bpmn:SendTask\",\n        \"bpmn:MessageEventDefinition\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"expression\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"class\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"delegateExpression\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"resultVariable\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        }\n      ]\n    },\n    {\n      \"name\": \"DmnCapable\",\n      \"extends\": [\n        \"bpmn:BusinessRuleTask\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"decisionRef\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"decisionRefBinding\",\n          \"isAttr\": true,\n          \"type\": \"String\",\n          \"default\": \"latest\"\n        },\n        {\n          \"name\": \"decisionRefVersion\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"mapDecisionResult\",\n          \"isAttr\": true,\n          \"type\": \"String\",\n          \"default\": \"resultList\"\n        },\n        {\n          \"name\": \"decisionRefTenantId\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        }\n      ]\n    },\n    {\n      \"name\": \"ExternalCapable\",\n      \"extends\": [\n        \"camunda:ServiceTaskLike\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"type\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"topic\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        }\n      ]\n    },\n    {\n      \"name\": \"TaskPriorized\",\n      \"extends\": [\n        \"bpmn:Process\",\n        \"camunda:ExternalCapable\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"taskPriority\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        }\n      ]\n    },\n    {\n      \"name\": \"Properties\",\n      \"superClass\": [\n        \"Element\"\n      ],\n      \"meta\": {\n        \"allowedIn\": [ \"*\" ]\n      },\n      \"properties\": [\n        {\n          \"name\": \"values\",\n          \"type\": \"Property\",\n          \"isMany\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"Property\",\n      \"superClass\": [\n        \"Element\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"id\",\n          \"type\": \"String\",\n          \"isAttr\": true\n        },\n        {\n          \"name\": \"name\",\n          \"type\": \"String\",\n          \"isAttr\": true\n        },\n        {\n          \"name\": \"value\",\n          \"type\": \"String\",\n          \"isAttr\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"Connector\",\n      \"superClass\": [\n        \"Element\"\n      ],\n      \"meta\": {\n        \"allowedIn\": [\n          \"bpmn:ServiceTask\",\n          \"bpmn:BusinessRuleTask\",\n          \"bpmn:SendTask\"\n        ]\n      },\n      \"properties\": [\n        {\n          \"name\": \"inputOutput\",\n          \"type\": \"InputOutput\"\n        },\n        {\n          \"name\": \"connectorId\",\n          \"type\": \"String\"\n        }\n      ]\n    },\n    {\n      \"name\": \"InputOutput\",\n      \"superClass\": [\n        \"Element\"\n      ],\n      \"meta\": {\n        \"allowedIn\": [\n          \"bpmn:Task\",\n          \"bpmn:UserTask\",\n          \"bpmn:ServiceTask\",\n          \"bpmn:SendTask\",\n          \"bpmn:BusinessRuleTask\",\n          \"bpmn:ReceiveTask\",\n          \"bpmn:ScriptTask\",\n          \"bpmn:ManualTask\",\n          \"bpmn:GlobalUserTask\",\n          \"bpmn:GlobalScriptTask\",\n          \"bpmn:GlobalBusinessRuleTask\",\n          \"bpmn:GlobalTask\",\n          \"bpmn:GlobalManualTask\",\n          \"bpmn:SubProcess\",\n          \"bpmn:Transaction\",\n          \"bpmn:IntermediateCatchEvent\",\n          \"bpmn:IntermediateThrowEvent\",\n          \"bpmn:EndEvent\",\n          \"bpmn:ThrowEvent\",\n          \"bpmn:CatchEvent\",\n          \"bpmn:ImplicitThrowEvent\",\n          \"bpmn:CallActivity\"\n        ]\n      },\n      \"properties\": [\n        {\n          \"name\": \"inputOutput\",\n          \"type\": \"InputOutput\"\n        },\n        {\n          \"name\": \"connectorId\",\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"inputParameters\",\n          \"isMany\": true,\n          \"type\": \"InputParameter\"\n        },\n        {\n          \"name\": \"outputParameters\",\n          \"isMany\": true,\n          \"type\": \"OutputParameter\"\n        }\n      ]\n    },\n    {\n      \"name\": \"InputOutputParameter\",\n      \"properties\": [\n        {\n          \"name\": \"name\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"value\",\n          \"isBody\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"definition\",\n          \"type\": \"InputOutputParameterDefinition\"\n        }\n      ]\n    },\n    {\n      \"name\": \"InputOutputParameterDefinition\",\n      \"isAbstract\": true\n    },\n    {\n      \"name\": \"List\",\n      \"superClass\": [ \"InputOutputParameterDefinition\" ],\n      \"properties\": [\n        {\n          \"name\": \"items\",\n          \"isMany\": true,\n          \"type\": \"InputOutputParameterDefinition\"\n        }\n      ]\n    },\n    {\n      \"name\": \"Map\",\n      \"superClass\": [ \"InputOutputParameterDefinition\" ],\n      \"properties\": [\n        {\n          \"name\": \"entries\",\n          \"isMany\": true,\n          \"type\": \"Entry\"\n        }\n      ]\n    },\n    {\n      \"name\": \"Entry\",\n      \"properties\": [\n        {\n          \"name\": \"key\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"value\",\n          \"isBody\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"definition\",\n          \"type\": \"InputOutputParameterDefinition\"\n        }\n      ]\n    },\n    {\n      \"name\": \"Value\",\n      \"superClass\": [\n        \"InputOutputParameterDefinition\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"id\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"name\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"value\",\n          \"isBody\": true,\n          \"type\": \"String\"\n        }\n      ]\n    },\n    {\n      \"name\": \"Script\",\n      \"superClass\": [ \"InputOutputParameterDefinition\" ],\n      \"properties\": [\n        {\n          \"name\": \"scriptFormat\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"resource\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"value\",\n          \"isBody\": true,\n          \"type\": \"String\"\n        }\n      ]\n    },\n    {\n      \"name\": \"Field\",\n      \"superClass\": [ \"Element\" ],\n      \"meta\": {\n        \"allowedIn\": [\n          \"bpmn:ServiceTask\",\n          \"bpmn:BusinessRuleTask\",\n          \"bpmn:SendTask\"\n        ]\n      },\n      \"properties\": [\n        {\n          \"name\": \"name\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"expression\",\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"stringValue\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"string\",\n          \"type\": \"String\"\n        }\n      ]\n    },\n    {\n      \"name\": \"InputParameter\",\n      \"superClass\": [ \"InputOutputParameter\" ]\n    },\n    {\n      \"name\": \"OutputParameter\",\n      \"superClass\": [ \"InputOutputParameter\" ]\n    },\n    {\n      \"name\": \"Collectable\",\n      \"isAbstract\": true,\n      \"extends\": [ \"bpmn:MultiInstanceLoopCharacteristics\" ],\n      \"superClass\": [ \"camunda:AsyncCapable\" ],\n      \"properties\": [\n        {\n          \"name\": \"collection\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"elementVariable\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        }\n      ]\n    },\n    {\n      \"name\": \"FailedJobRetryTimeCycle\",\n      \"superClass\": [ \"Element\" ],\n      \"meta\": {\n        \"allowedIn\": [\n          \"bpmn:Task\",\n          \"bpmn:ServiceTask\",\n          \"bpmn:SendTask\",\n          \"bpmn:UserTask\",\n          \"bpmn:BusinessRuleTask\",\n          \"bpmn:ScriptTask\",\n          \"bpmn:ReceiveTask\",\n          \"bpmn:CallActivity\",\n          \"bpmn:TimerEventDefinition\",\n          \"bpmn:SignalEventDefinition\",\n          \"bpmn:MultiInstanceLoopCharacteristics\"\n        ]\n      },\n      \"properties\": [\n        {\n          \"name\": \"body\",\n          \"isBody\": true,\n          \"type\": \"String\"\n        }\n      ]\n    },\n    {\n      \"name\": \"ExecutionListener\",\n      \"superClass\": [ \"Element\" ],\n      \"meta\": {\n        \"allowedIn\": [\n          \"bpmn:Task\",\n          \"bpmn:ServiceTask\",\n          \"bpmn:UserTask\",\n          \"bpmn:BusinessRuleTask\",\n          \"bpmn:ScriptTask\",\n          \"bpmn:ReceiveTask\",\n          \"bpmn:ManualTask\",\n          \"bpmn:ExclusiveGateway\",\n          \"bpmn:SequenceFlow\",\n          \"bpmn:ParallelGateway\",\n          \"bpmn:InclusiveGateway\",\n          \"bpmn:EventBasedGateway\",\n          \"bpmn:StartEvent\",\n          \"bpmn:IntermediateCatchEvent\",\n          \"bpmn:IntermediateThrowEvent\",\n          \"bpmn:EndEvent\",\n          \"bpmn:BoundaryEvent\",\n          \"bpmn:CallActivity\",\n          \"bpmn:SubProcess\"\n        ]\n      },\n      \"properties\": [\n        {\n          \"name\": \"expression\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"class\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"delegateExpression\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"event\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"script\",\n          \"type\": \"Script\"\n        },\n        {\n          \"name\": \"fields\",\n          \"type\": \"Field\",\n          \"isMany\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"TaskListener\",\n      \"superClass\": [ \"Element\" ],\n      \"meta\": {\n        \"allowedIn\": [\n          \"bpmn:UserTask\"\n        ]\n      },\n      \"properties\": [\n        {\n          \"name\": \"expression\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"class\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"delegateExpression\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"event\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"script\",\n          \"type\": \"Script\"\n        },\n        {\n          \"name\": \"fields\",\n          \"type\": \"Field\",\n          \"isMany\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"FormProperty\",\n      \"superClass\": [ \"Element\" ],\n      \"meta\": {\n        \"allowedIn\": [\n          \"bpmn:StartEvent\",\n          \"bpmn:UserTask\"\n        ]\n      },\n      \"properties\": [\n        {\n          \"name\": \"id\",\n          \"type\": \"String\",\n          \"isAttr\": true\n        },\n        {\n          \"name\": \"name\",\n          \"type\": \"String\",\n          \"isAttr\": true\n        },\n        {\n          \"name\": \"type\",\n          \"type\": \"String\",\n          \"isAttr\": true\n        },\n        {\n          \"name\": \"required\",\n          \"type\": \"String\",\n          \"isAttr\": true\n        },\n        {\n          \"name\": \"readable\",\n          \"type\": \"String\",\n          \"isAttr\": true\n        },\n        {\n          \"name\": \"writable\",\n          \"type\": \"String\",\n          \"isAttr\": true\n        },\n        {\n          \"name\": \"variable\",\n          \"type\": \"String\",\n          \"isAttr\": true\n        },\n        {\n          \"name\": \"expression\",\n          \"type\": \"String\",\n          \"isAttr\": true\n        },\n        {\n          \"name\": \"datePattern\",\n          \"type\": \"String\",\n          \"isAttr\": true\n        },\n        {\n          \"name\": \"default\",\n          \"type\": \"String\",\n          \"isAttr\": true\n        },\n        {\n          \"name\": \"values\",\n          \"type\": \"Value\",\n          \"isMany\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"FormData\",\n      \"superClass\": [ \"Element\" ],\n      \"meta\": {\n        \"allowedIn\": [\n          \"bpmn:StartEvent\",\n          \"bpmn:UserTask\"\n        ]\n      },\n      \"properties\": [\n        {\n          \"name\": \"fields\",\n          \"type\": \"FormField\",\n          \"isMany\": true\n        },\n        {\n          \"name\": \"businessKey\",\n          \"type\": \"String\",\n          \"isAttr\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"FormField\",\n      \"superClass\": [ \"Element\" ],\n      \"properties\": [\n        {\n          \"name\": \"id\",\n          \"type\": \"String\",\n          \"isAttr\": true\n        },\n        {\n          \"name\": \"label\",\n          \"type\": \"String\",\n          \"isAttr\": true\n        },\n        {\n          \"name\": \"type\",\n          \"type\": \"String\",\n          \"isAttr\": true\n        },\n        {\n          \"name\": \"datePattern\",\n          \"type\": \"String\",\n          \"isAttr\": true\n        },\n        {\n          \"name\": \"defaultValue\",\n          \"type\": \"String\",\n          \"isAttr\": true\n        },\n        {\n          \"name\": \"properties\",\n          \"type\": \"Properties\"\n        },\n        {\n          \"name\": \"validation\",\n          \"type\": \"Validation\"\n        },\n        {\n          \"name\": \"values\",\n          \"type\": \"Value\",\n          \"isMany\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"Validation\",\n      \"superClass\": [ \"Element\" ],\n      \"properties\": [\n        {\n          \"name\": \"constraints\",\n          \"type\": \"Constraint\",\n          \"isMany\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"Constraint\",\n      \"superClass\": [ \"Element\" ],\n      \"properties\": [\n        {\n          \"name\": \"name\",\n          \"type\": \"String\",\n          \"isAttr\": true\n        },\n        {\n          \"name\": \"config\",\n          \"type\": \"String\",\n          \"isAttr\": true\n        }\n      ]\n    },\n    {\n      \"name\": \"ConditionalEventDefinition\",\n      \"isAbstract\": true,\n      \"extends\": [\n        \"bpmn:ConditionalEventDefinition\"\n      ],\n      \"properties\": [\n        {\n          \"name\": \"variableName\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        },\n        {\n          \"name\": \"variableEvent\",\n          \"isAttr\": true,\n          \"type\": \"String\"\n        }\n      ]\n    }\n  ],\n  \"emumerations\": [ ]\n}\n","/**\n * Module dependencies.\n */\n\ntry {\n  var index = require('indexof');\n} catch (err) {\n  var index = require('component-indexof');\n}\n\n/**\n * Whitespace regexp.\n */\n\nvar re = /\\s+/;\n\n/**\n * toString reference.\n */\n\nvar toString = Object.prototype.toString;\n\n/**\n * Wrap `el` in a `ClassList`.\n *\n * @param {Element} el\n * @return {ClassList}\n * @api public\n */\n\nmodule.exports = function(el){\n  return new ClassList(el);\n};\n\n/**\n * Initialize a new ClassList for `el`.\n *\n * @param {Element} el\n * @api private\n */\n\nfunction ClassList(el) {\n  if (!el || !el.nodeType) {\n    throw new Error('A DOM element reference is required');\n  }\n  this.el = el;\n  this.list = el.classList;\n}\n\n/**\n * Add class `name` if not already present.\n *\n * @param {String} name\n * @return {ClassList}\n * @api public\n */\n\nClassList.prototype.add = function(name){\n  // classList\n  if (this.list) {\n    this.list.add(name);\n    return this;\n  }\n\n  // fallback\n  var arr = this.array();\n  var i = index(arr, name);\n  if (!~i) arr.push(name);\n  this.el.className = arr.join(' ');\n  return this;\n};\n\n/**\n * Remove class `name` when present, or\n * pass a regular expression to remove\n * any which match.\n *\n * @param {String|RegExp} name\n * @return {ClassList}\n * @api public\n */\n\nClassList.prototype.remove = function(name){\n  if ('[object RegExp]' == toString.call(name)) {\n    return this.removeMatching(name);\n  }\n\n  // classList\n  if (this.list) {\n    this.list.remove(name);\n    return this;\n  }\n\n  // fallback\n  var arr = this.array();\n  var i = index(arr, name);\n  if (~i) arr.splice(i, 1);\n  this.el.className = arr.join(' ');\n  return this;\n};\n\n/**\n * Remove all classes matching `re`.\n *\n * @param {RegExp} re\n * @return {ClassList}\n * @api private\n */\n\nClassList.prototype.removeMatching = function(re){\n  var arr = this.array();\n  for (var i = 0; i < arr.length; i++) {\n    if (re.test(arr[i])) {\n      this.remove(arr[i]);\n    }\n  }\n  return this;\n};\n\n/**\n * Toggle class `name`, can force state via `force`.\n *\n * For browsers that support classList, but do not support `force` yet,\n * the mistake will be detected and corrected.\n *\n * @param {String} name\n * @param {Boolean} force\n * @return {ClassList}\n * @api public\n */\n\nClassList.prototype.toggle = function(name, force){\n  // classList\n  if (this.list) {\n    if (\"undefined\" !== typeof force) {\n      if (force !== this.list.toggle(name, force)) {\n        this.list.toggle(name); // toggle again to correct\n      }\n    } else {\n      this.list.toggle(name);\n    }\n    return this;\n  }\n\n  // fallback\n  if (\"undefined\" !== typeof force) {\n    if (!force) {\n      this.remove(name);\n    } else {\n      this.add(name);\n    }\n  } else {\n    if (this.has(name)) {\n      this.remove(name);\n    } else {\n      this.add(name);\n    }\n  }\n\n  return this;\n};\n\n/**\n * Return an array of classes.\n *\n * @return {Array}\n * @api public\n */\n\nClassList.prototype.array = function(){\n  var className = this.el.getAttribute('class') || '';\n  var str = className.replace(/^\\s+|\\s+$/g, '');\n  var arr = str.split(re);\n  if ('' === arr[0]) arr.shift();\n  return arr;\n};\n\n/**\n * Check if class `name` is present.\n *\n * @param {String} name\n * @return {ClassList}\n * @api public\n */\n\nClassList.prototype.has =\nClassList.prototype.contains = function(name){\n  return this.list\n    ? this.list.contains(name)\n    : !! ~index(this.array(), name);\n};\n","var matches = require('matches-selector')\n\nmodule.exports = function (element, selector, checkYoSelf, root) {\n  element = checkYoSelf ? {parentNode: element} : element\n\n  root = root || document\n\n  // Make sure `element !== document` and `element != null`\n  // otherwise we get an illegal invocation\n  while ((element = element.parentNode) && element !== document) {\n    if (matches(element, selector))\n      return element\n    // After `matches` on the edge case that\n    // the selector matches the root\n    // (when the root is not the document)\n    if (element === root)\n      return\n  }\n}\n","/**\n * Module dependencies.\n */\n\ntry {\n  var closest = require('closest');\n} catch(err) {\n  var closest = require('component-closest');\n}\n\ntry {\n  var event = require('event');\n} catch(err) {\n  var event = require('component-event');\n}\n\n/**\n * Delegate event `type` to `selector`\n * and invoke `fn(e)`. A callback function\n * is returned which may be passed to `.unbind()`.\n *\n * @param {Element} el\n * @param {String} selector\n * @param {String} type\n * @param {Function} fn\n * @param {Boolean} capture\n * @return {Function}\n * @api public\n */\n\nexports.bind = function(el, selector, type, fn, capture){\n  return event.bind(el, type, function(e){\n    var target = e.target || e.srcElement;\n    e.delegateTarget = closest(target, selector, true, el);\n    if (e.delegateTarget) fn.call(el, e);\n  }, capture);\n};\n\n/**\n * Unbind event `type`'s callback `fn`.\n *\n * @param {Element} el\n * @param {String} type\n * @param {Function} fn\n * @param {Boolean} capture\n * @api public\n */\n\nexports.unbind = function(el, type, fn, capture){\n  event.unbind(el, type, fn, capture);\n};\n","var bind = window.addEventListener ? 'addEventListener' : 'attachEvent',\n    unbind = window.removeEventListener ? 'removeEventListener' : 'detachEvent',\n    prefix = bind !== 'addEventListener' ? 'on' : '';\n\n/**\n * Bind `el` event `type` to `fn`.\n *\n * @param {Element} el\n * @param {String} type\n * @param {Function} fn\n * @param {Boolean} capture\n * @return {Function}\n * @api public\n */\n\nexports.bind = function(el, type, fn, capture){\n  el[bind](prefix + type, fn, capture || false);\n  return fn;\n};\n\n/**\n * Unbind `el` event `type`'s callback `fn`.\n *\n * @param {Element} el\n * @param {String} type\n * @param {Function} fn\n * @param {Boolean} capture\n * @return {Function}\n * @api public\n */\n\nexports.unbind = function(el, type, fn, capture){\n  el[unbind](prefix + type, fn, capture || false);\n  return fn;\n};","module.exports = function(arr, obj){\n  if (arr.indexOf) return arr.indexOf(obj);\n  for (var i = 0; i < arr.length; ++i) {\n    if (arr[i] === obj) return i;\n  }\n  return -1;\n};","/**\n * Module dependencies.\n */\n\ntry {\n  var query = require('query');\n} catch (err) {\n  var query = require('component-query');\n}\n\n/**\n * Element prototype.\n */\n\nvar proto = Element.prototype;\n\n/**\n * Vendor function.\n */\n\nvar vendor = proto.matches\n  || proto.webkitMatchesSelector\n  || proto.mozMatchesSelector\n  || proto.msMatchesSelector\n  || proto.oMatchesSelector;\n\n/**\n * Expose `match()`.\n */\n\nmodule.exports = match;\n\n/**\n * Match `el` to `selector`.\n *\n * @param {Element} el\n * @param {String} selector\n * @return {Boolean}\n * @api public\n */\n\nfunction match(el, selector) {\n  if (!el || el.nodeType !== 1) return false;\n  if (vendor) return vendor.call(el, selector);\n  var nodes = query.all(selector, el.parentNode);\n  for (var i = 0; i < nodes.length; ++i) {\n    if (nodes[i] == el) return true;\n  }\n  return false;\n}\n","function one(selector, el) {\n  return el.querySelector(selector);\n}\n\nexports = module.exports = function(selector, el){\n  el = el || document;\n  return one(selector, el);\n};\n\nexports.all = function(selector, el){\n  el = el || document;\n  return el.querySelectorAll(selector);\n};\n\nexports.engine = function(obj){\n  if (!obj.one) throw new Error('.one callback required');\n  if (!obj.all) throw new Error('.all callback required');\n  one = obj.one;\n  exports.all = obj.all;\n  return exports;\n};\n","/*! https://mths.be/cssescape v1.5.1 by @mathias | MIT license */\n;(function(root, factory) {\n\t// https://github.com/umdjs/umd/blob/master/returnExports.js\n\tif (typeof exports == 'object') {\n\t\t// For Node.js.\n\t\tmodule.exports = factory(root);\n\t} else if (typeof define == 'function' && define.amd) {\n\t\t// For AMD. Register as an anonymous module.\n\t\tdefine([], factory.bind(root, root));\n\t} else {\n\t\t// For browser globals (not exposing the function separately).\n\t\tfactory(root);\n\t}\n}(typeof global != 'undefined' ? global : this, function(root) {\n\n\tif (root.CSS && root.CSS.escape) {\n\t\treturn root.CSS.escape;\n\t}\n\n\t// https://drafts.csswg.org/cssom/#serialize-an-identifier\n\tvar cssEscape = function(value) {\n\t\tif (arguments.length == 0) {\n\t\t\tthrow new TypeError('`CSS.escape` requires an argument.');\n\t\t}\n\t\tvar string = String(value);\n\t\tvar length = string.length;\n\t\tvar index = -1;\n\t\tvar codeUnit;\n\t\tvar result = '';\n\t\tvar firstCodeUnit = string.charCodeAt(0);\n\t\twhile (++index < length) {\n\t\t\tcodeUnit = string.charCodeAt(index);\n\t\t\t// Note: there’s no need to special-case astral symbols, surrogate\n\t\t\t// pairs, or lone surrogates.\n\n\t\t\t// If the character is NULL (U+0000), then the REPLACEMENT CHARACTER\n\t\t\t// (U+FFFD).\n\t\t\tif (codeUnit == 0x0000) {\n\t\t\t\tresult += '\\uFFFD';\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tif (\n\t\t\t\t// If the character is in the range [\\1-\\1F] (U+0001 to U+001F) or is\n\t\t\t\t// U+007F, […]\n\t\t\t\t(codeUnit >= 0x0001 && codeUnit <= 0x001F) || codeUnit == 0x007F ||\n\t\t\t\t// If the character is the first character and is in the range [0-9]\n\t\t\t\t// (U+0030 to U+0039), […]\n\t\t\t\t(index == 0 && codeUnit >= 0x0030 && codeUnit <= 0x0039) ||\n\t\t\t\t// If the character is the second character and is in the range [0-9]\n\t\t\t\t// (U+0030 to U+0039) and the first character is a `-` (U+002D), […]\n\t\t\t\t(\n\t\t\t\t\tindex == 1 &&\n\t\t\t\t\tcodeUnit >= 0x0030 && codeUnit <= 0x0039 &&\n\t\t\t\t\tfirstCodeUnit == 0x002D\n\t\t\t\t)\n\t\t\t) {\n\t\t\t\t// https://drafts.csswg.org/cssom/#escape-a-character-as-code-point\n\t\t\t\tresult += '\\\\' + codeUnit.toString(16) + ' ';\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tif (\n\t\t\t\t// If the character is the first character and is a `-` (U+002D), and\n\t\t\t\t// there is no second character, […]\n\t\t\t\tindex == 0 &&\n\t\t\t\tlength == 1 &&\n\t\t\t\tcodeUnit == 0x002D\n\t\t\t) {\n\t\t\t\tresult += '\\\\' + string.charAt(index);\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t// If the character is not handled by one of the above rules and is\n\t\t\t// greater than or equal to U+0080, is `-` (U+002D) or `_` (U+005F), or\n\t\t\t// is in one of the ranges [0-9] (U+0030 to U+0039), [A-Z] (U+0041 to\n\t\t\t// U+005A), or [a-z] (U+0061 to U+007A), […]\n\t\t\tif (\n\t\t\t\tcodeUnit >= 0x0080 ||\n\t\t\t\tcodeUnit == 0x002D ||\n\t\t\t\tcodeUnit == 0x005F ||\n\t\t\t\tcodeUnit >= 0x0030 && codeUnit <= 0x0039 ||\n\t\t\t\tcodeUnit >= 0x0041 && codeUnit <= 0x005A ||\n\t\t\t\tcodeUnit >= 0x0061 && codeUnit <= 0x007A\n\t\t\t) {\n\t\t\t\t// the character itself\n\t\t\t\tresult += string.charAt(index);\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t// Otherwise, the escaped character.\n\t\t\t// https://drafts.csswg.org/cssom/#escape-a-character\n\t\t\tresult += '\\\\' + string.charAt(index);\n\n\t\t}\n\t\treturn result;\n\t};\n\n\tif (!root.CSS) {\n\t\troot.CSS = {};\n\t}\n\n\troot.CSS.escape = cssEscape;\n\treturn cssEscape;\n\n}));\n","import InteractionEventsModule from 'diagram-js/lib/features/interaction-events';\n\nimport DirectEditing from './lib/DirectEditing';\n\nexport default {\n  __depends__: [\n    InteractionEventsModule\n  ],\n  __init__: [ 'directEditing' ],\n  directEditing: [ 'type', DirectEditing ]\n};","import {\n  bind,\n  find\n} from 'min-dash';\n\nimport TextBox from './TextBox';\n\n\n/**\n * A direct editing component that allows users\n * to edit an elements text directly in the diagram\n *\n * @param {EventBus} eventBus the event bus\n */\nexport default function DirectEditing(eventBus, canvas) {\n\n  this._eventBus = eventBus;\n\n  this._providers = [];\n  this._textbox = new TextBox({\n    container: canvas.getContainer(),\n    keyHandler: bind(this._handleKey, this),\n    resizeHandler: bind(this._handleResize, this)\n  });\n}\n\nDirectEditing.$inject = [ 'eventBus', 'canvas' ];\n\n\n/**\n * Register a direct editing provider\n\n * @param {Object} provider the provider, must expose an #activate(element) method that returns\n *                          an activation context ({ bounds: {x, y, width, height }, text }) if\n *                          direct editing is available for the given element.\n *                          Additionally the provider must expose a #update(element, value) method\n *                          to receive direct editing updates.\n */\nDirectEditing.prototype.registerProvider = function(provider) {\n  this._providers.push(provider);\n};\n\n\n/**\n * Returns true if direct editing is currently active\n *\n * @return {Boolean}\n */\nDirectEditing.prototype.isActive = function() {\n  return !!this._active;\n};\n\n\n/**\n * Cancel direct editing, if it is currently active\n */\nDirectEditing.prototype.cancel = function() {\n  if (!this._active) {\n    return;\n  }\n\n  this._fire('cancel');\n  this.close();\n};\n\n\nDirectEditing.prototype._fire = function(event, context) {\n  this._eventBus.fire('directEditing.' + event, context || { active: this._active });\n};\n\nDirectEditing.prototype.close = function() {\n  this._textbox.destroy();\n\n  this._fire('deactivate');\n\n  this._active = null;\n\n  this.resizable = undefined;\n};\n\n\nDirectEditing.prototype.complete = function() {\n\n  var active = this._active;\n\n  if (!active) {\n    return;\n  }\n\n  var text = this.getValue();\n\n  var bounds = this.$textbox.getBoundingClientRect();\n\n  if (text !== active.context.text || this.resizable) {\n    active.provider.update(active.element, text, active.context.text, {\n      x: bounds.top,\n      y: bounds.left,\n      width: bounds.width,\n      height: bounds.height\n    });\n  }\n\n  this._fire('complete');\n\n  this.close();\n};\n\n\nDirectEditing.prototype.getValue = function() {\n  return this._textbox.getValue();\n};\n\n\nDirectEditing.prototype._handleKey = function(e) {\n\n  // stop bubble\n  e.stopPropagation();\n\n  var key = e.keyCode || e.charCode;\n\n  // ESC\n  if (key === 27) {\n    e.preventDefault();\n    return this.cancel();\n  }\n\n  // Enter\n  if (key === 13 && !e.shiftKey) {\n    e.preventDefault();\n    return this.complete();\n  }\n};\n\n\nDirectEditing.prototype._handleResize = function(event) {\n  this._fire('resize', event);\n};\n\n\n/**\n * Activate direct editing on the given element\n *\n * @param {Object} ElementDescriptor the descriptor for a shape or connection\n * @return {Boolean} true if the activation was possible\n */\nDirectEditing.prototype.activate = function(element) {\n  if (this.isActive()) {\n    this.cancel();\n  }\n\n  // the direct editing context\n  var context;\n\n  var provider = find(this._providers, function(p) {\n    return (context = p.activate(element)) ? p : null;\n  });\n\n  // check if activation took place\n  if (context) {\n    this.$textbox = this._textbox.create(\n      context.bounds,\n      context.style,\n      context.text,\n      context.options\n    );\n\n    this._active = {\n      element: element,\n      context: context,\n      provider: provider\n    };\n\n    if (context.options && context.options.resizable) {\n      this.resizable = true;\n    }\n\n    this._fire('activate');\n  }\n\n  return !!context;\n};","import {\n  assign,\n  bind,\n  pick\n} from 'min-dash';\n\nimport {\n  domify,\n  query as domQuery,\n  event as domEvent,\n  remove as domRemove\n} from 'min-dom';\n\nvar min = Math.min,\n    max = Math.max;\n\nfunction preventDefault(e) {\n  e.preventDefault();\n}\n\nfunction stopPropagation(e) {\n  e.stopPropagation();\n}\n\nfunction isTextNode(node) {\n  return node.nodeType === Node.TEXT_NODE;\n}\n\nfunction toArray(nodeList) {\n  return [].slice.call(nodeList);\n}\n\n/**\n * Initializes a container for a content editable div.\n *\n * Structure:\n *\n * container\n *   parent\n *     content\n *     resize-handle\n *\n * @param {object} options\n * @param {DOMElement} options.container The DOM element to append the contentContainer to\n * @param {Function} options.keyHandler Handler for key events\n * @param {Function} options.resizeHandler Handler for resize events\n */\nexport default function TextBox(options) {\n  this.container = options.container;\n\n  this.parent = domify(\n    '<div class=\"djs-direct-editing-parent\">' +\n      '<div class=\"djs-direct-editing-content\" contenteditable=\"true\"></div>' +\n    '</div>'\n  );\n\n  this.content = domQuery('[contenteditable]', this.parent);\n\n  this.keyHandler = options.keyHandler || function() {};\n  this.resizeHandler = options.resizeHandler || function() {};\n\n  this.autoResize = bind(this.autoResize, this);\n  this.handlePaste = bind(this.handlePaste, this);\n}\n\n\n/**\n * Create a text box with the given position, size, style and text content\n *\n * @param {Object} bounds\n * @param {Number} bounds.x absolute x position\n * @param {Number} bounds.y absolute y position\n * @param {Number} [bounds.width] fixed width value\n * @param {Number} [bounds.height] fixed height value\n * @param {Number} [bounds.maxWidth] maximum width value\n * @param {Number} [bounds.maxHeight] maximum height value\n * @param {Number} [bounds.minWidth] minimum width value\n * @param {Number} [bounds.minHeight] minimum height value\n * @param {Object} [style]\n * @param {String} value text content\n *\n * @return {DOMElement} The created content DOM element\n */\nTextBox.prototype.create = function(bounds, style, value, options) {\n  var self = this;\n\n  var parent = this.parent,\n      content = this.content,\n      container = this.container;\n\n  options = this.options = options || {};\n\n  style = this.style = style || {};\n\n  var parentStyle = pick(style, [\n    'width',\n    'height',\n    'maxWidth',\n    'maxHeight',\n    'minWidth',\n    'minHeight',\n    'left',\n    'top',\n    'backgroundColor',\n    'position',\n    'overflow',\n    'border',\n    'wordWrap',\n    'textAlign',\n    'outline',\n    'transform'\n  ]);\n\n  assign(parent.style, {\n    width: bounds.width + 'px',\n    height: bounds.height + 'px',\n    maxWidth: bounds.maxWidth + 'px',\n    maxHeight: bounds.maxHeight + 'px',\n    minWidth: bounds.minWidth + 'px',\n    minHeight: bounds.minHeight + 'px',\n    left: bounds.x + 'px',\n    top: bounds.y + 'px',\n    backgroundColor: '#ffffff',\n    position: 'absolute',\n    overflow: 'visible',\n    border: '1px solid #ccc',\n    boxSizing: 'border-box',\n    wordWrap: 'normal',\n    textAlign: 'center',\n    outline: 'none'\n  }, parentStyle);\n\n  var contentStyle = pick(style, [\n    'fontFamily',\n    'fontSize',\n    'fontWeight',\n    'lineHeight',\n    'padding',\n    'paddingTop',\n    'paddingRight',\n    'paddingBottom',\n    'paddingLeft'\n  ]);\n\n  assign(content.style, {\n    boxSizing: 'border-box',\n    width: '100%',\n    outline: 'none',\n    wordWrap: 'break-word'\n  }, contentStyle);\n\n  if (options.centerVertically) {\n    assign(content.style, {\n      position: 'absolute',\n      top: '50%',\n      transform: 'translate(0, -50%)'\n    }, contentStyle);\n  }\n\n  content.innerText = value;\n\n  domEvent.bind(content, 'keydown', this.keyHandler);\n  domEvent.bind(content, 'mousedown', stopPropagation);\n  domEvent.bind(content, 'paste', self.handlePaste);\n\n  if (options.autoResize) {\n    domEvent.bind(content, 'input', this.autoResize);\n  }\n\n  if (options.resizable) {\n    this.resizable(style);\n  }\n\n  container.appendChild(parent);\n\n  // set selection to end of text\n  this.setSelection(content.lastChild, content.lastChild && content.lastChild.length);\n\n  return parent;\n};\n\n/**\n * Intercept paste events to remove formatting from pasted text.\n */\nTextBox.prototype.handlePaste = function(e) {\n  var self = this;\n\n  var options = this.options,\n      style = this.style;\n\n  e.preventDefault();\n\n  var text;\n\n  if (e.clipboardData) {\n\n    // Chrome, Firefox, Safari\n    text = e.clipboardData.getData('text/plain');\n  } else {\n\n    // Internet Explorer\n    text = window.clipboardData.getData('Text');\n  }\n\n  // insertHTML command not supported by Internet Explorer\n  var success = document.execCommand('insertHTML', false, text);\n\n  if (!success) {\n\n    // Internet Explorer\n    var range = this.getSelection(),\n        startContainer = range.startContainer,\n        endContainer = range.endContainer,\n        startOffset = range.startOffset,\n        endOffset = range.endOffset,\n        commonAncestorContainer = range.commonAncestorContainer;\n\n    var childNodesArray = toArray(commonAncestorContainer.childNodes);\n\n    var container,\n        offset;\n\n    if (isTextNode(commonAncestorContainer)) {\n      var containerTextContent = startContainer.textContent;\n\n      startContainer.textContent =\n        containerTextContent.substring(0, startOffset)\n        + text\n        + containerTextContent.substring(endOffset);\n\n      container = startContainer;\n      offset = startOffset + text.length;\n\n    } else if (startContainer === this.content && endContainer === this.content) {\n      var textNode = document.createTextNode(text);\n\n      this.content.insertBefore(textNode, childNodesArray[startOffset]);\n\n      container = textNode;\n      offset = textNode.textContent.length;\n    } else {\n      var startContainerChildIndex = childNodesArray.indexOf(startContainer),\n          endContainerChildIndex = childNodesArray.indexOf(endContainer);\n\n      childNodesArray.forEach(function(childNode, index) {\n\n        if (index === startContainerChildIndex) {\n          childNode.textContent =\n            startContainer.textContent.substring(0, startOffset) +\n            text +\n            endContainer.textContent.substring(endOffset);\n        } else if (index > startContainerChildIndex && index <= endContainerChildIndex) {\n          domRemove(childNode);\n        }\n      });\n\n      container = startContainer;\n      offset = startOffset + text.length;\n    }\n\n    if (container && offset !== undefined) {\n\n      // is necessary in Internet Explorer\n      setTimeout(function() {\n        self.setSelection(container, offset);\n      });\n    }\n  }\n\n  if (options.autoResize) {\n    var hasResized = this.autoResize(style);\n\n    if (hasResized) {\n      this.resizeHandler(hasResized);\n    }\n  }\n};\n\n/**\n * Automatically resize element vertically to fit its content.\n */\nTextBox.prototype.autoResize = function() {\n  var parent = this.parent,\n      content = this.content;\n\n  var fontSize = parseInt(this.style.fontSize) || 12;\n\n  if (content.scrollHeight > parent.offsetHeight ||\n      content.scrollHeight < parent.offsetHeight - fontSize) {\n    var bounds = parent.getBoundingClientRect();\n\n    var height = content.scrollHeight;\n    parent.style.height = height + 'px';\n\n    this.resizeHandler({\n      width: bounds.width,\n      height: bounds.height,\n      dx: 0,\n      dy: height - bounds.height\n    });\n  }\n};\n\n/**\n * Make an element resizable by adding a resize handle.\n */\nTextBox.prototype.resizable = function() {\n  var self = this;\n\n  var parent = this.parent,\n      resizeHandle = this.resizeHandle;\n\n  var minWidth = parseInt(this.style.minWidth) || 0,\n      minHeight = parseInt(this.style.minHeight) || 0,\n      maxWidth = parseInt(this.style.maxWidth) || Infinity,\n      maxHeight = parseInt(this.style.maxHeight) || Infinity;\n\n  if (!resizeHandle) {\n    resizeHandle = this.resizeHandle = domify(\n      '<div class=\"djs-direct-editing-resize-handle\"></div>'\n    );\n\n    var startX, startY, startWidth, startHeight;\n\n    var onMouseDown = function(e) {\n      preventDefault(e);\n      stopPropagation(e);\n\n      startX = e.clientX;\n      startY = e.clientY;\n\n      var bounds = parent.getBoundingClientRect();\n\n      startWidth = bounds.width;\n      startHeight = bounds.height;\n\n      domEvent.bind(document, 'mousemove', onMouseMove);\n      domEvent.bind(document, 'mouseup', onMouseUp);\n    };\n\n    var onMouseMove = function(e) {\n      preventDefault(e);\n      stopPropagation(e);\n\n      var newWidth = min(max(startWidth + e.clientX - startX, minWidth), maxWidth);\n      var newHeight = min(max(startHeight + e.clientY - startY, minHeight), maxHeight);\n\n      parent.style.width = newWidth + 'px';\n      parent.style.height = newHeight + 'px';\n\n      self.resizeHandler({\n        width: startWidth,\n        height: startHeight,\n        dx: e.clientX - startX,\n        dy: e.clientY - startY\n      });\n    };\n\n    var onMouseUp = function(e) {\n      preventDefault(e);\n      stopPropagation(e);\n\n      domEvent.unbind(document,'mousemove', onMouseMove, false);\n      domEvent.unbind(document, 'mouseup', onMouseUp, false);\n    };\n\n    domEvent.bind(resizeHandle, 'mousedown', onMouseDown);\n  }\n\n  assign(resizeHandle.style, {\n    position: 'absolute',\n    bottom: '0px',\n    right: '0px',\n    cursor: 'nwse-resize',\n    width: '0',\n    height: '0',\n    borderTop: (parseInt(this.style.fontSize) / 4 || 3) + 'px solid transparent',\n    borderRight: (parseInt(this.style.fontSize) / 4 || 3) + 'px solid #ccc',\n    borderBottom: (parseInt(this.style.fontSize) / 4 || 3) + 'px solid #ccc',\n    borderLeft: (parseInt(this.style.fontSize) / 4 || 3) + 'px solid transparent'\n  });\n\n  parent.appendChild(resizeHandle);\n};\n\n\n/**\n * Clear content and style of the textbox, unbind listeners and\n * reset CSS style.\n */\nTextBox.prototype.destroy = function() {\n  var parent = this.parent,\n      content = this.content,\n      resizeHandle = this.resizeHandle;\n\n  // clear content\n  content.innerText = '';\n\n  // clear styles\n  parent.removeAttribute('style');\n  content.removeAttribute('style');\n\n  domEvent.unbind(content, 'keydown', this.keyHandler);\n  domEvent.unbind(content, 'mousedown', stopPropagation);\n  domEvent.unbind(content, 'input', this.autoResize);\n  domEvent.unbind(content, 'paste', this.handlePaste);\n\n  if (resizeHandle) {\n    resizeHandle.removeAttribute('style');\n\n    domRemove(resizeHandle);\n  }\n\n  domRemove(parent);\n};\n\n\nTextBox.prototype.getValue = function() {\n  return this.content.innerText;\n};\n\n\nTextBox.prototype.getSelection = function() {\n  var selection = window.getSelection(),\n      range = selection.getRangeAt(0);\n\n  return range;\n};\n\n\nTextBox.prototype.setSelection = function(container, offset) {\n  var range = document.createRange();\n\n  if (container === null) {\n    range.selectNodeContents(this.content);\n  } else {\n    range.setStart(container, offset);\n    range.setEnd(container, offset);\n  }\n\n  var selection = window.getSelection();\n\n  selection.removeAllRanges();\n  selection.addRange(range);\n};\n","export { default } from './lib/Diagram';","import { Injector } from 'didi';\n\nimport CoreModule from './core';\n\n\n/**\n * Bootstrap an injector from a list of modules, instantiating a number of default components\n *\n * @ignore\n * @param {Array<didi.Module>} bootstrapModules\n *\n * @return {didi.Injector} a injector to use to access the components\n */\nfunction bootstrap(bootstrapModules) {\n\n  var modules = [],\n      components = [];\n\n  function hasModule(m) {\n    return modules.indexOf(m) >= 0;\n  }\n\n  function addModule(m) {\n    modules.push(m);\n  }\n\n  function visit(m) {\n    if (hasModule(m)) {\n      return;\n    }\n\n    (m.__depends__ || []).forEach(visit);\n\n    if (hasModule(m)) {\n      return;\n    }\n\n    addModule(m);\n\n    (m.__init__ || []).forEach(function(c) {\n      components.push(c);\n    });\n  }\n\n  bootstrapModules.forEach(visit);\n\n  var injector = new Injector(modules);\n\n  components.forEach(function(c) {\n\n    try {\n      // eagerly resolve component (fn or string)\n      injector[typeof c === 'string' ? 'get' : 'invoke'](c);\n    } catch (e) {\n      console.error('Failed to instantiate component');\n      console.error(e.stack);\n\n      throw e;\n    }\n  });\n\n  return injector;\n}\n\n/**\n * Creates an injector from passed options.\n *\n * @ignore\n * @param  {Object} options\n * @return {didi.Injector}\n */\nfunction createInjector(options) {\n\n  options = options || {};\n\n  var configModule = {\n    'config': ['value', options]\n  };\n\n  var modules = [ configModule, CoreModule ].concat(options.modules || []);\n\n  return bootstrap(modules);\n}\n\n\n/**\n * The main diagram-js entry point that bootstraps the diagram with the given\n * configuration.\n *\n * To register extensions with the diagram, pass them as Array<didi.Module> to the constructor.\n *\n * @class djs.Diagram\n * @memberOf djs\n * @constructor\n *\n * @example\n *\n * <caption>Creating a plug-in that logs whenever a shape is added to the canvas.</caption>\n *\n * // plug-in implemenentation\n * function MyLoggingPlugin(eventBus) {\n *   eventBus.on('shape.added', function(event) {\n *     console.log('shape ', event.shape, ' was added to the diagram');\n *   });\n * }\n *\n * // export as module\n * export default {\n *   __init__: [ 'myLoggingPlugin' ],\n *     myLoggingPlugin: [ 'type', MyLoggingPlugin ]\n * };\n *\n *\n * // instantiate the diagram with the new plug-in\n *\n * import MyLoggingModule from 'path-to-my-logging-plugin';\n *\n * var diagram = new Diagram({\n *   modules: [\n *     MyLoggingModule\n *   ]\n * });\n *\n * diagram.invoke([ 'canvas', function(canvas) {\n *   // add shape to drawing canvas\n *   canvas.addShape({ x: 10, y: 10 });\n * });\n *\n * // 'shape ... was added to the diagram' logged to console\n *\n * @param {Object} options\n * @param {Array<didi.Module>} [options.modules] external modules to instantiate with the diagram\n * @param {didi.Injector} [injector] an (optional) injector to bootstrap the diagram with\n */\nexport default function Diagram(options, injector) {\n\n  // create injector unless explicitly specified\n  this.injector = injector = injector || createInjector(options);\n\n  // API\n\n  /**\n   * Resolves a diagram service\n   *\n   * @method Diagram#get\n   *\n   * @param {String} name the name of the diagram service to be retrieved\n   * @param {Boolean} [strict=true] if false, resolve missing services to null\n   */\n  this.get = injector.get;\n\n  /**\n   * Executes a function into which diagram services are injected\n   *\n   * @method Diagram#invoke\n   *\n   * @param {Function|Object[]} fn the function to resolve\n   * @param {Object} locals a number of locals to use to resolve certain dependencies\n   */\n  this.invoke = injector.invoke;\n\n  // init\n\n  // indicate via event\n\n\n  /**\n   * An event indicating that all plug-ins are loaded.\n   *\n   * Use this event to fire other events to interested plug-ins\n   *\n   * @memberOf Diagram\n   *\n   * @event diagram.init\n   *\n   * @example\n   *\n   * eventBus.on('diagram.init', function() {\n   *   eventBus.fire('my-custom-event', { foo: 'BAR' });\n   * });\n   *\n   * @type {Object}\n   */\n  this.get('eventBus').fire('diagram.init');\n}\n\n\n/**\n * Destroys the diagram\n *\n * @method  Diagram#destroy\n */\nDiagram.prototype.destroy = function() {\n  this.get('eventBus').fire('diagram.destroy');\n};\n\n/**\n * Clear the diagram, removing all contents.\n */\nDiagram.prototype.clear = function() {\n  this.get('eventBus').fire('diagram.clear');\n};\n","import {\n  forEach,\n  isFunction,\n  isArray,\n  isNumber,\n  isObject\n} from 'min-dash';\n\n\nvar DEFAULT_PRIORITY = 1000;\n\n/**\n * A utility that can be used to plug-in into the command execution for\n * extension and/or validation.\n *\n * @param {EventBus} eventBus\n *\n * @example\n *\n * import inherits from 'inherits';\n *\n * import CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';\n *\n * function CommandLogger(eventBus) {\n *   CommandInterceptor.call(this, eventBus);\n *\n *   this.preExecute(function(event) {\n *     console.log('command pre-execute', event);\n *   });\n * }\n *\n * inherits(CommandLogger, CommandInterceptor);\n *\n */\nexport default function CommandInterceptor(eventBus) {\n  this._eventBus = eventBus;\n}\n\nCommandInterceptor.$inject = [ 'eventBus' ];\n\nfunction unwrapEvent(fn, that) {\n  return function(event) {\n    return fn.call(that || null, event.context, event.command, event);\n  };\n}\n\n/**\n * Register an interceptor for a command execution\n *\n * @param {String|Array<String>} [events] list of commands to register on\n * @param {String} [hook] command hook, i.e. preExecute, executed to listen on\n * @param {Number} [priority] the priority on which to hook into the execution\n * @param {Function} handlerFn interceptor to be invoked with (event)\n * @param {Boolean} unwrap if true, unwrap the event and pass (context, command, event) to the\n *                          listener instead\n * @param {Object} [that] Pass context (`this`) to the handler function\n */\nCommandInterceptor.prototype.on = function(events, hook, priority, handlerFn, unwrap, that) {\n\n  if (isFunction(hook) || isNumber(hook)) {\n    that = unwrap;\n    unwrap = handlerFn;\n    handlerFn = priority;\n    priority = hook;\n    hook = null;\n  }\n\n  if (isFunction(priority)) {\n    that = unwrap;\n    unwrap = handlerFn;\n    handlerFn = priority;\n    priority = DEFAULT_PRIORITY;\n  }\n\n  if (isObject(unwrap)) {\n    that = unwrap;\n    unwrap = false;\n  }\n\n  if (!isFunction(handlerFn)) {\n    throw new Error('handlerFn must be a function');\n  }\n\n  if (!isArray(events)) {\n    events = [ events ];\n  }\n\n  var eventBus = this._eventBus;\n\n  forEach(events, function(event) {\n    // concat commandStack(.event)?(.hook)?\n    var fullEvent = [ 'commandStack', event, hook ].filter(function(e) { return e; }).join('.');\n\n    eventBus.on(fullEvent, priority, unwrap ? unwrapEvent(handlerFn, that) : handlerFn, that);\n  });\n};\n\n\nvar hooks = [\n  'canExecute',\n  'preExecute',\n  'preExecuted',\n  'execute',\n  'executed',\n  'postExecute',\n  'postExecuted',\n  'revert',\n  'reverted'\n];\n\n/*\n * Install hook shortcuts\n *\n * This will generate the CommandInterceptor#(preExecute|...|reverted) methods\n * which will in term forward to CommandInterceptor#on.\n */\nforEach(hooks, function(hook) {\n\n  /**\n   * {canExecute|preExecute|preExecuted|execute|executed|postExecute|postExecuted|revert|reverted}\n   *\n   * A named hook for plugging into the command execution\n   *\n   * @param {String|Array<String>} [events] list of commands to register on\n   * @param {Number} [priority] the priority on which to hook into the execution\n   * @param {Function} handlerFn interceptor to be invoked with (event)\n   * @param {Boolean} [unwrap=false] if true, unwrap the event and pass (context, command, event) to the\n   *                          listener instead\n   * @param {Object} [that] Pass context (`this`) to the handler function\n   */\n  CommandInterceptor.prototype[hook] = function(events, priority, handlerFn, unwrap, that) {\n\n    if (isFunction(events) || isNumber(events)) {\n      that = unwrap;\n      unwrap = handlerFn;\n      handlerFn = priority;\n      priority = events;\n      events = null;\n    }\n\n    this.on(events, hook, priority, handlerFn, unwrap, that);\n  };\n});\n","import {\n  uniqueBy,\n  isArray\n} from 'min-dash';\n\n\n/**\n * A service that offers un- and redoable execution of commands.\n *\n * The command stack is responsible for executing modeling actions\n * in a un- and redoable manner. To do this it delegates the actual\n * command execution to {@link CommandHandler}s.\n *\n * Command handlers provide {@link CommandHandler#execute(ctx)} and\n * {@link CommandHandler#revert(ctx)} methods to un- and redo a command\n * identified by a command context.\n *\n *\n * ## Life-Cycle events\n *\n * In the process the command stack fires a number of life-cycle events\n * that other components to participate in the command execution.\n *\n *    * preExecute\n *    * preExecuted\n *    * execute\n *    * executed\n *    * postExecute\n *    * postExecuted\n *    * revert\n *    * reverted\n *\n * A special event is used for validating, whether a command can be\n * performed prior to its execution.\n *\n *    * canExecute\n *\n * Each of the events is fired as `commandStack.{eventName}` and\n * `commandStack.{commandName}.{eventName}`, respectively. This gives\n * components fine grained control on where to hook into.\n *\n * The event object fired transports `command`, the name of the\n * command and `context`, the command context.\n *\n *\n * ## Creating Command Handlers\n *\n * Command handlers should provide the {@link CommandHandler#execute(ctx)}\n * and {@link CommandHandler#revert(ctx)} methods to implement\n * redoing and undoing of a command.\n *\n * A command handler _must_ ensure undo is performed properly in order\n * not to break the undo chain. It must also return the shapes that\n * got changed during the `execute` and `revert` operations.\n *\n * Command handlers may execute other modeling operations (and thus\n * commands) in their `preExecute` and `postExecute` phases. The command\n * stack will properly group all commands together into a logical unit\n * that may be re- and undone atomically.\n *\n * Command handlers must not execute other commands from within their\n * core implementation (`execute`, `revert`).\n *\n *\n * ## Change Tracking\n *\n * During the execution of the CommandStack it will keep track of all\n * elements that have been touched during the command's execution.\n *\n * At the end of the CommandStack execution it will notify interested\n * components via an 'elements.changed' event with all the dirty\n * elements.\n *\n * The event can be picked up by components that are interested in the fact\n * that elements have been changed. One use case for this is updating\n * their graphical representation after moving / resizing or deletion.\n *\n * @see CommandHandler\n *\n * @param {EventBus} eventBus\n * @param {Injector} injector\n */\nexport default function CommandStack(eventBus, injector) {\n\n  /**\n   * A map of all registered command handlers.\n   *\n   * @type {Object}\n   */\n  this._handlerMap = {};\n\n  /**\n   * A stack containing all re/undoable actions on the diagram\n   *\n   * @type {Array<Object>}\n   */\n  this._stack = [];\n\n  /**\n   * The current index on the stack\n   *\n   * @type {Number}\n   */\n  this._stackIdx = -1;\n\n  /**\n   * Current active commandStack execution\n   *\n   * @type {Object}\n   */\n  this._currentExecution = {\n    actions: [],\n    dirty: []\n  };\n\n\n  this._injector = injector;\n  this._eventBus = eventBus;\n\n  this._uid = 1;\n\n  eventBus.on([\n    'diagram.destroy',\n    'diagram.clear'\n  ], function() {\n    this.clear(false);\n  }, this);\n}\n\nCommandStack.$inject = [ 'eventBus', 'injector' ];\n\n\n/**\n * Execute a command\n *\n * @param {String} command the command to execute\n * @param {Object} context the environment to execute the command in\n */\nCommandStack.prototype.execute = function(command, context) {\n  if (!command) {\n    throw new Error('command required');\n  }\n\n  var action = { command: command, context: context };\n\n  this._pushAction(action);\n  this._internalExecute(action);\n  this._popAction(action);\n};\n\n\n/**\n * Ask whether a given command can be executed.\n *\n * Implementors may hook into the mechanism on two ways:\n *\n *   * in event listeners:\n *\n *     Users may prevent the execution via an event listener.\n *     It must prevent the default action for `commandStack.(<command>.)canExecute` events.\n *\n *   * in command handlers:\n *\n *     If the method {@link CommandHandler#canExecute} is implemented in a handler\n *     it will be called to figure out whether the execution is allowed.\n *\n * @param  {String} command the command to execute\n * @param  {Object} context the environment to execute the command in\n *\n * @return {Boolean} true if the command can be executed\n */\nCommandStack.prototype.canExecute = function(command, context) {\n\n  var action = { command: command, context: context };\n\n  var handler = this._getHandler(command);\n\n  var result = this._fire(command, 'canExecute', action);\n\n  // handler#canExecute will only be called if no listener\n  // decided on a result already\n  if (result === undefined) {\n    if (!handler) {\n      return false;\n    }\n\n    if (handler.canExecute) {\n      result = handler.canExecute(context);\n    }\n  }\n\n  return result;\n};\n\n\n/**\n * Clear the command stack, erasing all undo / redo history\n */\nCommandStack.prototype.clear = function(emit) {\n  this._stack.length = 0;\n  this._stackIdx = -1;\n\n  if (emit !== false) {\n    this._fire('changed');\n  }\n};\n\n\n/**\n * Undo last command(s)\n */\nCommandStack.prototype.undo = function() {\n  var action = this._getUndoAction(),\n      next;\n\n  if (action) {\n    this._pushAction(action);\n\n    while (action) {\n      this._internalUndo(action);\n      next = this._getUndoAction();\n\n      if (!next || next.id !== action.id) {\n        break;\n      }\n\n      action = next;\n    }\n\n    this._popAction();\n  }\n};\n\n\n/**\n * Redo last command(s)\n */\nCommandStack.prototype.redo = function() {\n  var action = this._getRedoAction(),\n      next;\n\n  if (action) {\n    this._pushAction(action);\n\n    while (action) {\n      this._internalExecute(action, true);\n      next = this._getRedoAction();\n\n      if (!next || next.id !== action.id) {\n        break;\n      }\n\n      action = next;\n    }\n\n    this._popAction();\n  }\n};\n\n\n/**\n * Register a handler instance with the command stack\n *\n * @param {String} command\n * @param {CommandHandler} handler\n */\nCommandStack.prototype.register = function(command, handler) {\n  this._setHandler(command, handler);\n};\n\n\n/**\n * Register a handler type with the command stack\n * by instantiating it and injecting its dependencies.\n *\n * @param {String} command\n * @param {Function} a constructor for a {@link CommandHandler}\n */\nCommandStack.prototype.registerHandler = function(command, handlerCls) {\n\n  if (!command || !handlerCls) {\n    throw new Error('command and handlerCls must be defined');\n  }\n\n  var handler = this._injector.instantiate(handlerCls);\n  this.register(command, handler);\n};\n\nCommandStack.prototype.canUndo = function() {\n  return !!this._getUndoAction();\n};\n\nCommandStack.prototype.canRedo = function() {\n  return !!this._getRedoAction();\n};\n\n// stack access  //////////////////////\n\nCommandStack.prototype._getRedoAction = function() {\n  return this._stack[this._stackIdx + 1];\n};\n\n\nCommandStack.prototype._getUndoAction = function() {\n  return this._stack[this._stackIdx];\n};\n\n\n// internal functionality //////////////////////\n\nCommandStack.prototype._internalUndo = function(action) {\n  var self = this;\n\n  var command = action.command,\n      context = action.context;\n\n  var handler = this._getHandler(command);\n\n  // guard against illegal nested command stack invocations\n  this._atomicDo(function() {\n    self._fire(command, 'revert', action);\n\n    if (handler.revert) {\n      self._markDirty(handler.revert(context));\n    }\n\n    self._revertedAction(action);\n\n    self._fire(command, 'reverted', action);\n  });\n};\n\n\nCommandStack.prototype._fire = function(command, qualifier, event) {\n  if (arguments.length < 3) {\n    event = qualifier;\n    qualifier = null;\n  }\n\n  var names = qualifier ? [ command + '.' + qualifier, qualifier ] : [ command ],\n      i, name, result;\n\n  event = this._eventBus.createEvent(event);\n\n  for (i = 0; (name = names[i]); i++) {\n    result = this._eventBus.fire('commandStack.' + name, event);\n\n    if (event.cancelBubble) {\n      break;\n    }\n  }\n\n  return result;\n};\n\nCommandStack.prototype._createId = function() {\n  return this._uid++;\n};\n\nCommandStack.prototype._atomicDo = function(fn) {\n\n  var execution = this._currentExecution;\n\n  execution.atomic = true;\n\n  try {\n    fn();\n  } finally {\n    execution.atomic = false;\n  }\n};\n\nCommandStack.prototype._internalExecute = function(action, redo) {\n  var self = this;\n\n  var command = action.command,\n      context = action.context;\n\n  var handler = this._getHandler(command);\n\n  if (!handler) {\n    throw new Error('no command handler registered for <' + command + '>');\n  }\n\n  this._pushAction(action);\n\n  if (!redo) {\n    this._fire(command, 'preExecute', action);\n\n    if (handler.preExecute) {\n      handler.preExecute(context);\n    }\n\n    this._fire(command, 'preExecuted', action);\n  }\n\n  // guard against illegal nested command stack invocations\n  this._atomicDo(function() {\n\n    self._fire(command, 'execute', action);\n\n    if (handler.execute) {\n      // actual execute + mark return results as dirty\n      self._markDirty(handler.execute(context));\n    }\n\n    // log to stack\n    self._executedAction(action, redo);\n\n    self._fire(command, 'executed', action);\n  });\n\n  if (!redo) {\n    this._fire(command, 'postExecute', action);\n\n    if (handler.postExecute) {\n      handler.postExecute(context);\n    }\n\n    this._fire(command, 'postExecuted', action);\n  }\n\n  this._popAction(action);\n};\n\n\nCommandStack.prototype._pushAction = function(action) {\n\n  var execution = this._currentExecution,\n      actions = execution.actions;\n\n  var baseAction = actions[0];\n\n  if (execution.atomic) {\n    throw new Error('illegal invocation in <execute> or <revert> phase (action: ' + action.command + ')');\n  }\n\n  if (!action.id) {\n    action.id = (baseAction && baseAction.id) || this._createId();\n  }\n\n  actions.push(action);\n};\n\n\nCommandStack.prototype._popAction = function() {\n  var execution = this._currentExecution,\n      actions = execution.actions,\n      dirty = execution.dirty;\n\n  actions.pop();\n\n  if (!actions.length) {\n    this._eventBus.fire('elements.changed', { elements: uniqueBy('id', dirty) });\n\n    dirty.length = 0;\n\n    this._fire('changed');\n  }\n};\n\n\nCommandStack.prototype._markDirty = function(elements) {\n  var execution = this._currentExecution;\n\n  if (!elements) {\n    return;\n  }\n\n  elements = isArray(elements) ? elements : [ elements ];\n\n  execution.dirty = execution.dirty.concat(elements);\n};\n\n\nCommandStack.prototype._executedAction = function(action, redo) {\n  var stackIdx = ++this._stackIdx;\n\n  if (!redo) {\n    this._stack.splice(stackIdx, this._stack.length, action);\n  }\n};\n\n\nCommandStack.prototype._revertedAction = function(action) {\n  this._stackIdx--;\n};\n\n\nCommandStack.prototype._getHandler = function(command) {\n  return this._handlerMap[command];\n};\n\nCommandStack.prototype._setHandler = function(command, handler) {\n  if (!command || !handler) {\n    throw new Error('command and handler required');\n  }\n\n  if (this._handlerMap[command]) {\n    throw new Error('overriding handler for command <' + command + '>');\n  }\n\n  this._handlerMap[command] = handler;\n};\n","import CommandStack from './CommandStack';\n\nexport default {\n  commandStack: [ 'type', CommandStack ]\n};\n","import {\n  isNumber,\n  assign,\n  forEach,\n  every,\n  debounce,\n  bind,\n  reduce\n} from 'min-dash';\n\nimport {\n  add as collectionAdd,\n  remove as collectionRemove\n} from '../util/Collections';\n\nimport {\n  getType\n} from '../util/Elements';\n\nimport {\n  append as svgAppend,\n  attr as svgAttr,\n  classes as svgClasses,\n  create as svgCreate,\n  transform as svgTransform\n} from 'tiny-svg';\n\nimport { createMatrix as createMatrix } from 'tiny-svg';\n\n\nfunction round(number, resolution) {\n  return Math.round(number * resolution) / resolution;\n}\n\nfunction ensurePx(number) {\n  return isNumber(number) ? number + 'px' : number;\n}\n\n/**\n * Creates a HTML container element for a SVG element with\n * the given configuration\n *\n * @param  {Object} options\n * @return {HTMLElement} the container element\n */\nfunction createContainer(options) {\n\n  options = assign({}, { width: '100%', height: '100%' }, options);\n\n  var container = options.container || document.body;\n\n  // create a <div> around the svg element with the respective size\n  // this way we can always get the correct container size\n  // (this is impossible for <svg> elements at the moment)\n  var parent = document.createElement('div');\n  parent.setAttribute('class', 'djs-container');\n\n  assign(parent.style, {\n    position: 'relative',\n    overflow: 'hidden',\n    width: ensurePx(options.width),\n    height: ensurePx(options.height)\n  });\n\n  container.appendChild(parent);\n\n  return parent;\n}\n\nfunction createGroup(parent, cls, childIndex) {\n  var group = svgCreate('g');\n  svgClasses(group).add(cls);\n\n  var index = childIndex !== undefined ? childIndex : parent.childNodes.length - 1;\n\n  // must ensure second argument is node or _null_\n  // cf. https://developer.mozilla.org/en-US/docs/Web/API/Node/insertBefore\n  parent.insertBefore(group, parent.childNodes[index] || null);\n\n  return group;\n}\n\nvar BASE_LAYER = 'base';\n\n\nvar REQUIRED_MODEL_ATTRS = {\n  shape: [ 'x', 'y', 'width', 'height' ],\n  connection: [ 'waypoints' ]\n};\n\n/**\n * The main drawing canvas.\n *\n * @class\n * @constructor\n *\n * @emits Canvas#canvas.init\n *\n * @param {Object} config\n * @param {EventBus} eventBus\n * @param {GraphicsFactory} graphicsFactory\n * @param {ElementRegistry} elementRegistry\n */\nexport default function Canvas(config, eventBus, graphicsFactory, elementRegistry) {\n\n  this._eventBus = eventBus;\n  this._elementRegistry = elementRegistry;\n  this._graphicsFactory = graphicsFactory;\n\n  this._init(config || {});\n}\n\nCanvas.$inject = [\n  'config.canvas',\n  'eventBus',\n  'graphicsFactory',\n  'elementRegistry'\n];\n\n\nCanvas.prototype._init = function(config) {\n\n  var eventBus = this._eventBus;\n\n  // Creates a <svg> element that is wrapped into a <div>.\n  // This way we are always able to correctly figure out the size of the svg element\n  // by querying the parent node.\n  //\n  // (It is not possible to get the size of a svg element cross browser @ 2014-04-01)\n  //\n  // <div class=\"djs-container\" style=\"width: {desired-width}, height: {desired-height}\">\n  //   <svg width=\"100%\" height=\"100%\">\n  //    ...\n  //   </svg>\n  // </div>\n\n  // html container\n  var container = this._container = createContainer(config);\n\n  var svg = this._svg = svgCreate('svg');\n  svgAttr(svg, { width: '100%', height: '100%' });\n\n  svgAppend(container, svg);\n\n  var viewport = this._viewport = createGroup(svg, 'viewport');\n\n  this._layers = {};\n\n  // debounce canvas.viewbox.changed events\n  // for smoother diagram interaction\n  if (config.deferUpdate !== false) {\n    this._viewboxChanged = debounce(bind(this._viewboxChanged, this), 300);\n  }\n\n  eventBus.on('diagram.init', function() {\n\n    /**\n     * An event indicating that the canvas is ready to be drawn on.\n     *\n     * @memberOf Canvas\n     *\n     * @event canvas.init\n     *\n     * @type {Object}\n     * @property {SVGElement} svg the created svg element\n     * @property {SVGElement} viewport the direct parent of diagram elements and shapes\n     */\n    eventBus.fire('canvas.init', {\n      svg: svg,\n      viewport: viewport\n    });\n\n  }, this);\n\n  // reset viewbox on shape changes to\n  // recompute the viewbox\n  eventBus.on([\n    'shape.added',\n    'connection.added',\n    'shape.removed',\n    'connection.removed',\n    'elements.changed'\n  ], function() {\n    delete this._cachedViewbox;\n  }, this);\n\n  eventBus.on('diagram.destroy', 500, this._destroy, this);\n  eventBus.on('diagram.clear', 500, this._clear, this);\n};\n\nCanvas.prototype._destroy = function(emit) {\n  this._eventBus.fire('canvas.destroy', {\n    svg: this._svg,\n    viewport: this._viewport\n  });\n\n  var parent = this._container.parentNode;\n\n  if (parent) {\n    parent.removeChild(this._container);\n  }\n\n  delete this._svg;\n  delete this._container;\n  delete this._layers;\n  delete this._rootElement;\n  delete this._viewport;\n};\n\nCanvas.prototype._clear = function() {\n\n  var self = this;\n\n  var allElements = this._elementRegistry.getAll();\n\n  // remove all elements\n  allElements.forEach(function(element) {\n    var type = getType(element);\n\n    if (type === 'root') {\n      self.setRootElement(null, true);\n    } else {\n      self._removeElement(element, type);\n    }\n  });\n\n  // force recomputation of view box\n  delete this._cachedViewbox;\n};\n\n/**\n * Returns the default layer on which\n * all elements are drawn.\n *\n * @returns {SVGElement}\n */\nCanvas.prototype.getDefaultLayer = function() {\n  return this.getLayer(BASE_LAYER, 0);\n};\n\n/**\n * Returns a layer that is used to draw elements\n * or annotations on it.\n *\n * Non-existing layers retrieved through this method\n * will be created. During creation, the optional index\n * may be used to create layers below or above existing layers.\n * A layer with a certain index is always created above all\n * existing layers with the same index.\n *\n * @param {String} name\n * @param {Number} index\n *\n * @returns {SVGElement}\n */\nCanvas.prototype.getLayer = function(name, index) {\n\n  if (!name) {\n    throw new Error('must specify a name');\n  }\n\n  var layer = this._layers[name];\n\n  if (!layer) {\n    layer = this._layers[name] = this._createLayer(name, index);\n  }\n\n  // throw an error if layer creation / retrival is\n  // requested on different index\n  if (typeof index !== 'undefined' && layer.index !== index) {\n    throw new Error('layer <' + name + '> already created at index <' + index + '>');\n  }\n\n  return layer.group;\n};\n\n/**\n * Creates a given layer and returns it.\n *\n * @param {String} name\n * @param {Number} [index=0]\n *\n * @return {Object} layer descriptor with { index, group: SVGGroup }\n */\nCanvas.prototype._createLayer = function(name, index) {\n\n  if (!index) {\n    index = 0;\n  }\n\n  var childIndex = reduce(this._layers, function(childIndex, layer) {\n    if (index >= layer.index) {\n      childIndex++;\n    }\n\n    return childIndex;\n  }, 0);\n\n  return {\n    group: createGroup(this._viewport, 'layer-' + name, childIndex),\n    index: index\n  };\n\n};\n\n/**\n * Returns the html element that encloses the\n * drawing canvas.\n *\n * @return {DOMNode}\n */\nCanvas.prototype.getContainer = function() {\n  return this._container;\n};\n\n\n// markers //////////////////////\n\nCanvas.prototype._updateMarker = function(element, marker, add) {\n  var container;\n\n  if (!element.id) {\n    element = this._elementRegistry.get(element);\n  }\n\n  // we need to access all\n  container = this._elementRegistry._elements[element.id];\n\n  if (!container) {\n    return;\n  }\n\n  forEach([ container.gfx, container.secondaryGfx ], function(gfx) {\n    if (gfx) {\n      // invoke either addClass or removeClass based on mode\n      if (add) {\n        svgClasses(gfx).add(marker);\n      } else {\n        svgClasses(gfx).remove(marker);\n      }\n    }\n  });\n\n  /**\n   * An event indicating that a marker has been updated for an element\n   *\n   * @event element.marker.update\n   * @type {Object}\n   * @property {djs.model.Element} element the shape\n   * @property {Object} gfx the graphical representation of the shape\n   * @property {String} marker\n   * @property {Boolean} add true if the marker was added, false if it got removed\n   */\n  this._eventBus.fire('element.marker.update', { element: element, gfx: container.gfx, marker: marker, add: !!add });\n};\n\n\n/**\n * Adds a marker to an element (basically a css class).\n *\n * Fires the element.marker.update event, making it possible to\n * integrate extension into the marker life-cycle, too.\n *\n * @example\n * canvas.addMarker('foo', 'some-marker');\n *\n * var fooGfx = canvas.getGraphics('foo');\n *\n * fooGfx; // <g class=\"... some-marker\"> ... </g>\n *\n * @param {String|djs.model.Base} element\n * @param {String} marker\n */\nCanvas.prototype.addMarker = function(element, marker) {\n  this._updateMarker(element, marker, true);\n};\n\n\n/**\n * Remove a marker from an element.\n *\n * Fires the element.marker.update event, making it possible to\n * integrate extension into the marker life-cycle, too.\n *\n * @param  {String|djs.model.Base} element\n * @param  {String} marker\n */\nCanvas.prototype.removeMarker = function(element, marker) {\n  this._updateMarker(element, marker, false);\n};\n\n/**\n * Check the existence of a marker on element.\n *\n * @param  {String|djs.model.Base} element\n * @param  {String} marker\n */\nCanvas.prototype.hasMarker = function(element, marker) {\n  if (!element.id) {\n    element = this._elementRegistry.get(element);\n  }\n\n  var gfx = this.getGraphics(element);\n\n  return svgClasses(gfx).has(marker);\n};\n\n/**\n * Toggles a marker on an element.\n *\n * Fires the element.marker.update event, making it possible to\n * integrate extension into the marker life-cycle, too.\n *\n * @param  {String|djs.model.Base} element\n * @param  {String} marker\n */\nCanvas.prototype.toggleMarker = function(element, marker) {\n  if (this.hasMarker(element, marker)) {\n    this.removeMarker(element, marker);\n  } else {\n    this.addMarker(element, marker);\n  }\n};\n\nCanvas.prototype.getRootElement = function() {\n  if (!this._rootElement) {\n    this.setRootElement({ id: '__implicitroot', children: [] });\n  }\n\n  return this._rootElement;\n};\n\n\n\n// root element handling //////////////////////\n\n/**\n * Sets a given element as the new root element for the canvas\n * and returns the new root element.\n *\n * @param {Object|djs.model.Root} element\n * @param {Boolean} [override] whether to override the current root element, if any\n *\n * @return {Object|djs.model.Root} new root element\n */\nCanvas.prototype.setRootElement = function(element, override) {\n\n  if (element) {\n    this._ensureValid('root', element);\n  }\n\n  var currentRoot = this._rootElement,\n      elementRegistry = this._elementRegistry,\n      eventBus = this._eventBus;\n\n  if (currentRoot) {\n    if (!override) {\n      throw new Error('rootElement already set, need to specify override');\n    }\n\n    // simulate element remove event sequence\n    eventBus.fire('root.remove', { element: currentRoot });\n    eventBus.fire('root.removed', { element: currentRoot });\n\n    elementRegistry.remove(currentRoot);\n  }\n\n  if (element) {\n    var gfx = this.getDefaultLayer();\n\n    // resemble element add event sequence\n    eventBus.fire('root.add', { element: element });\n\n    elementRegistry.add(element, gfx, this._svg);\n\n    eventBus.fire('root.added', { element: element, gfx: gfx });\n  }\n\n  this._rootElement = element;\n\n  return element;\n};\n\n\n\n// add functionality //////////////////////\n\nCanvas.prototype._ensureValid = function(type, element) {\n  if (!element.id) {\n    throw new Error('element must have an id');\n  }\n\n  if (this._elementRegistry.get(element.id)) {\n    throw new Error('element with id ' + element.id + ' already exists');\n  }\n\n  var requiredAttrs = REQUIRED_MODEL_ATTRS[type];\n\n  var valid = every(requiredAttrs, function(attr) {\n    return typeof element[attr] !== 'undefined';\n  });\n\n  if (!valid) {\n    throw new Error(\n      'must supply { ' + requiredAttrs.join(', ') + ' } with ' + type);\n  }\n};\n\nCanvas.prototype._setParent = function(element, parent, parentIndex) {\n  collectionAdd(parent.children, element, parentIndex);\n  element.parent = parent;\n};\n\n/**\n * Adds an element to the canvas.\n *\n * This wires the parent <-> child relationship between the element and\n * a explicitly specified parent or an implicit root element.\n *\n * During add it emits the events\n *\n *  * <{type}.add> (element, parent)\n *  * <{type}.added> (element, gfx)\n *\n * Extensions may hook into these events to perform their magic.\n *\n * @param {String} type\n * @param {Object|djs.model.Base} element\n * @param {Object|djs.model.Base} [parent]\n * @param {Number} [parentIndex]\n *\n * @return {Object|djs.model.Base} the added element\n */\nCanvas.prototype._addElement = function(type, element, parent, parentIndex) {\n\n  parent = parent || this.getRootElement();\n\n  var eventBus = this._eventBus,\n      graphicsFactory = this._graphicsFactory;\n\n  this._ensureValid(type, element);\n\n  eventBus.fire(type + '.add', { element: element, parent: parent });\n\n  this._setParent(element, parent, parentIndex);\n\n  // create graphics\n  var gfx = graphicsFactory.create(type, element, parentIndex);\n\n  this._elementRegistry.add(element, gfx);\n\n  // update its visual\n  graphicsFactory.update(type, element, gfx);\n\n  eventBus.fire(type + '.added', { element: element, gfx: gfx });\n\n  return element;\n};\n\n/**\n * Adds a shape to the canvas\n *\n * @param {Object|djs.model.Shape} shape to add to the diagram\n * @param {djs.model.Base} [parent]\n * @param {Number} [parentIndex]\n *\n * @return {djs.model.Shape} the added shape\n */\nCanvas.prototype.addShape = function(shape, parent, parentIndex) {\n  return this._addElement('shape', shape, parent, parentIndex);\n};\n\n/**\n * Adds a connection to the canvas\n *\n * @param {Object|djs.model.Connection} connection to add to the diagram\n * @param {djs.model.Base} [parent]\n * @param {Number} [parentIndex]\n *\n * @return {djs.model.Connection} the added connection\n */\nCanvas.prototype.addConnection = function(connection, parent, parentIndex) {\n  return this._addElement('connection', connection, parent, parentIndex);\n};\n\n\n/**\n * Internal remove element\n */\nCanvas.prototype._removeElement = function(element, type) {\n\n  var elementRegistry = this._elementRegistry,\n      graphicsFactory = this._graphicsFactory,\n      eventBus = this._eventBus;\n\n  element = elementRegistry.get(element.id || element);\n\n  if (!element) {\n    // element was removed already\n    return;\n  }\n\n  eventBus.fire(type + '.remove', { element: element });\n\n  graphicsFactory.remove(element);\n\n  // unset parent <-> child relationship\n  collectionRemove(element.parent && element.parent.children, element);\n  element.parent = null;\n\n  eventBus.fire(type + '.removed', { element: element });\n\n  elementRegistry.remove(element);\n\n  return element;\n};\n\n\n/**\n * Removes a shape from the canvas\n *\n * @param {String|djs.model.Shape} shape or shape id to be removed\n *\n * @return {djs.model.Shape} the removed shape\n */\nCanvas.prototype.removeShape = function(shape) {\n\n  /**\n   * An event indicating that a shape is about to be removed from the canvas.\n   *\n   * @memberOf Canvas\n   *\n   * @event shape.remove\n   * @type {Object}\n   * @property {djs.model.Shape} element the shape descriptor\n   * @property {Object} gfx the graphical representation of the shape\n   */\n\n  /**\n   * An event indicating that a shape has been removed from the canvas.\n   *\n   * @memberOf Canvas\n   *\n   * @event shape.removed\n   * @type {Object}\n   * @property {djs.model.Shape} element the shape descriptor\n   * @property {Object} gfx the graphical representation of the shape\n   */\n  return this._removeElement(shape, 'shape');\n};\n\n\n/**\n * Removes a connection from the canvas\n *\n * @param {String|djs.model.Connection} connection or connection id to be removed\n *\n * @return {djs.model.Connection} the removed connection\n */\nCanvas.prototype.removeConnection = function(connection) {\n\n  /**\n   * An event indicating that a connection is about to be removed from the canvas.\n   *\n   * @memberOf Canvas\n   *\n   * @event connection.remove\n   * @type {Object}\n   * @property {djs.model.Connection} element the connection descriptor\n   * @property {Object} gfx the graphical representation of the connection\n   */\n\n  /**\n   * An event indicating that a connection has been removed from the canvas.\n   *\n   * @memberOf Canvas\n   *\n   * @event connection.removed\n   * @type {Object}\n   * @property {djs.model.Connection} element the connection descriptor\n   * @property {Object} gfx the graphical representation of the connection\n   */\n  return this._removeElement(connection, 'connection');\n};\n\n\n/**\n * Return the graphical object underlaying a certain diagram element\n *\n * @param {String|djs.model.Base} element descriptor of the element\n * @param {Boolean} [secondary=false] whether to return the secondary connected element\n *\n * @return {SVGElement}\n */\nCanvas.prototype.getGraphics = function(element, secondary) {\n  return this._elementRegistry.getGraphics(element, secondary);\n};\n\n\n/**\n * Perform a viewbox update via a given change function.\n *\n * @param {Function} changeFn\n */\nCanvas.prototype._changeViewbox = function(changeFn) {\n\n  // notify others of the upcoming viewbox change\n  this._eventBus.fire('canvas.viewbox.changing');\n\n  // perform actual change\n  changeFn.apply(this);\n\n  // reset the cached viewbox so that\n  // a new get operation on viewbox or zoom\n  // triggers a viewbox re-computation\n  this._cachedViewbox = null;\n\n  // notify others of the change; this step\n  // may or may not be debounced\n  this._viewboxChanged();\n};\n\nCanvas.prototype._viewboxChanged = function() {\n  this._eventBus.fire('canvas.viewbox.changed', { viewbox: this.viewbox() });\n};\n\n\n/**\n * Gets or sets the view box of the canvas, i.e. the\n * area that is currently displayed.\n *\n * The getter may return a cached viewbox (if it is currently\n * changing). To force a recomputation, pass `false` as the first argument.\n *\n * @example\n *\n * canvas.viewbox({ x: 100, y: 100, width: 500, height: 500 })\n *\n * // sets the visible area of the diagram to (100|100) -> (600|100)\n * // and and scales it according to the diagram width\n *\n * var viewbox = canvas.viewbox(); // pass `false` to force recomputing the box.\n *\n * console.log(viewbox);\n * // {\n * //   inner: Dimensions,\n * //   outer: Dimensions,\n * //   scale,\n * //   x, y,\n * //   width, height\n * // }\n *\n * // if the current diagram is zoomed and scrolled, you may reset it to the\n * // default zoom via this method, too:\n *\n * var zoomedAndScrolledViewbox = canvas.viewbox();\n *\n * canvas.viewbox({\n *   x: 0,\n *   y: 0,\n *   width: zoomedAndScrolledViewbox.outer.width,\n *   height: zoomedAndScrolledViewbox.outer.height\n * });\n *\n * @param  {Object} [box] the new view box to set\n * @param  {Number} box.x the top left X coordinate of the canvas visible in view box\n * @param  {Number} box.y the top left Y coordinate of the canvas visible in view box\n * @param  {Number} box.width the visible width\n * @param  {Number} box.height\n *\n * @return {Object} the current view box\n */\nCanvas.prototype.viewbox = function(box) {\n\n  if (box === undefined && this._cachedViewbox) {\n    return this._cachedViewbox;\n  }\n\n  var viewport = this._viewport,\n      innerBox,\n      outerBox = this.getSize(),\n      matrix,\n      transform,\n      scale,\n      x, y;\n\n  if (!box) {\n    // compute the inner box based on the\n    // diagrams default layer. This allows us to exclude\n    // external components, such as overlays\n    innerBox = this.getDefaultLayer().getBBox();\n\n    transform = svgTransform(viewport);\n    matrix = transform ? transform.matrix : createMatrix();\n    scale = round(matrix.a, 1000);\n\n    x = round(-matrix.e || 0, 1000);\n    y = round(-matrix.f || 0, 1000);\n\n    box = this._cachedViewbox = {\n      x: x ? x / scale : 0,\n      y: y ? y / scale : 0,\n      width: outerBox.width / scale,\n      height: outerBox.height / scale,\n      scale: scale,\n      inner: {\n        width: innerBox.width,\n        height: innerBox.height,\n        x: innerBox.x,\n        y: innerBox.y\n      },\n      outer: outerBox\n    };\n\n    return box;\n  } else {\n\n    this._changeViewbox(function() {\n      scale = Math.min(outerBox.width / box.width, outerBox.height / box.height);\n\n      var matrix = this._svg.createSVGMatrix()\n        .scale(scale)\n        .translate(-box.x, -box.y);\n\n      svgTransform(viewport, matrix);\n    });\n  }\n\n  return box;\n};\n\n\n/**\n * Gets or sets the scroll of the canvas.\n *\n * @param {Object} [delta] the new scroll to apply.\n *\n * @param {Number} [delta.dx]\n * @param {Number} [delta.dy]\n */\nCanvas.prototype.scroll = function(delta) {\n\n  var node = this._viewport;\n  var matrix = node.getCTM();\n\n  if (delta) {\n    this._changeViewbox(function() {\n      delta = assign({ dx: 0, dy: 0 }, delta || {});\n\n      matrix = this._svg.createSVGMatrix().translate(delta.dx, delta.dy).multiply(matrix);\n\n      setCTM(node, matrix);\n    });\n  }\n\n  return { x: matrix.e, y: matrix.f };\n};\n\n\n/**\n * Gets or sets the current zoom of the canvas, optionally zooming\n * to the specified position.\n *\n * The getter may return a cached zoom level. Call it with `false` as\n * the first argument to force recomputation of the current level.\n *\n * @param {String|Number} [newScale] the new zoom level, either a number, i.e. 0.9,\n *                                   or `fit-viewport` to adjust the size to fit the current viewport\n * @param {String|Point} [center] the reference point { x: .., y: ..} to zoom to, 'auto' to zoom into mid or null\n *\n * @return {Number} the current scale\n */\nCanvas.prototype.zoom = function(newScale, center) {\n\n  if (!newScale) {\n    return this.viewbox(newScale).scale;\n  }\n\n  if (newScale === 'fit-viewport') {\n    return this._fitViewport(center);\n  }\n\n  var outer,\n      matrix;\n\n  this._changeViewbox(function() {\n\n    if (typeof center !== 'object') {\n      outer = this.viewbox().outer;\n\n      center = {\n        x: outer.width / 2,\n        y: outer.height / 2\n      };\n    }\n\n    matrix = this._setZoom(newScale, center);\n  });\n\n  return round(matrix.a, 1000);\n};\n\nfunction setCTM(node, m) {\n  var mstr = 'matrix(' + m.a + ',' + m.b + ',' + m.c + ',' + m.d + ',' + m.e + ',' + m.f + ')';\n  node.setAttribute('transform', mstr);\n}\n\nCanvas.prototype._fitViewport = function(center) {\n\n  var vbox = this.viewbox(),\n      outer = vbox.outer,\n      inner = vbox.inner,\n      newScale,\n      newViewbox;\n\n  // display the complete diagram without zooming in.\n  // instead of relying on internal zoom, we perform a\n  // hard reset on the canvas viewbox to realize this\n  //\n  // if diagram does not need to be zoomed in, we focus it around\n  // the diagram origin instead\n\n  if (inner.x >= 0 &&\n      inner.y >= 0 &&\n      inner.x + inner.width <= outer.width &&\n      inner.y + inner.height <= outer.height &&\n      !center) {\n\n    newViewbox = {\n      x: 0,\n      y: 0,\n      width: Math.max(inner.width + inner.x, outer.width),\n      height: Math.max(inner.height + inner.y, outer.height)\n    };\n  } else {\n\n    newScale = Math.min(1, outer.width / inner.width, outer.height / inner.height);\n    newViewbox = {\n      x: inner.x + (center ? inner.width / 2 - outer.width / newScale / 2 : 0),\n      y: inner.y + (center ? inner.height / 2 - outer.height / newScale / 2 : 0),\n      width: outer.width / newScale,\n      height: outer.height / newScale\n    };\n  }\n\n  this.viewbox(newViewbox);\n\n  return this.viewbox(false).scale;\n};\n\n\nCanvas.prototype._setZoom = function(scale, center) {\n\n  var svg = this._svg,\n      viewport = this._viewport;\n\n  var matrix = svg.createSVGMatrix();\n  var point = svg.createSVGPoint();\n\n  var centerPoint,\n      originalPoint,\n      currentMatrix,\n      scaleMatrix,\n      newMatrix;\n\n  currentMatrix = viewport.getCTM();\n\n  var currentScale = currentMatrix.a;\n\n  if (center) {\n    centerPoint = assign(point, center);\n\n    // revert applied viewport transformations\n    originalPoint = centerPoint.matrixTransform(currentMatrix.inverse());\n\n    // create scale matrix\n    scaleMatrix = matrix\n      .translate(originalPoint.x, originalPoint.y)\n      .scale(1 / currentScale * scale)\n      .translate(-originalPoint.x, -originalPoint.y);\n\n    newMatrix = currentMatrix.multiply(scaleMatrix);\n  } else {\n    newMatrix = matrix.scale(scale);\n  }\n\n  setCTM(this._viewport, newMatrix);\n\n  return newMatrix;\n};\n\n\n/**\n * Returns the size of the canvas\n *\n * @return {Dimensions}\n */\nCanvas.prototype.getSize = function() {\n  return {\n    width: this._container.clientWidth,\n    height: this._container.clientHeight\n  };\n};\n\n\n/**\n * Return the absolute bounding box for the given element\n *\n * The absolute bounding box may be used to display overlays in the\n * callers (browser) coordinate system rather than the zoomed in/out\n * canvas coordinates.\n *\n * @param  {ElementDescriptor} element\n * @return {Bounds} the absolute bounding box\n */\nCanvas.prototype.getAbsoluteBBox = function(element) {\n  var vbox = this.viewbox();\n  var bbox;\n\n  // connection\n  // use svg bbox\n  if (element.waypoints) {\n    var gfx = this.getGraphics(element);\n\n    bbox = gfx.getBBox();\n  }\n  // shapes\n  // use data\n  else {\n    bbox = element;\n  }\n\n  var x = bbox.x * vbox.scale - vbox.x * vbox.scale;\n  var y = bbox.y * vbox.scale - vbox.y * vbox.scale;\n\n  var width = bbox.width * vbox.scale;\n  var height = bbox.height * vbox.scale;\n\n  return {\n    x: x,\n    y: y,\n    width: width,\n    height: height\n  };\n};\n\n/**\n * Fires an event in order other modules can react to the\n * canvas resizing\n */\nCanvas.prototype.resized = function() {\n\n  // force recomputation of view box\n  delete this._cachedViewbox;\n\n  this._eventBus.fire('canvas.resized');\n};\n","import {\n  create\n} from '../model';\n\nimport { assign } from 'min-dash';\n\n/**\n * A factory for diagram-js shapes\n */\nexport default function ElementFactory() {\n  this._uid = 12;\n}\n\n\nElementFactory.prototype.createRoot = function(attrs) {\n  return this.create('root', attrs);\n};\n\nElementFactory.prototype.createLabel = function(attrs) {\n  return this.create('label', attrs);\n};\n\nElementFactory.prototype.createShape = function(attrs) {\n  return this.create('shape', attrs);\n};\n\nElementFactory.prototype.createConnection = function(attrs) {\n  return this.create('connection', attrs);\n};\n\n/**\n * Create a model element with the given type and\n * a number of pre-set attributes.\n *\n * @param  {String} type\n * @param  {Object} attrs\n * @return {djs.model.Base} the newly created model instance\n */\nElementFactory.prototype.create = function(type, attrs) {\n\n  attrs = assign({}, attrs || {});\n\n  if (!attrs.id) {\n    attrs.id = type + '_' + (this._uid++);\n  }\n\n  return create(type, attrs);\n};","var ELEMENT_ID = 'data-element-id';\n\nimport { attr as svgAttr } from 'tiny-svg';\n\n\n/**\n * @class\n *\n * A registry that keeps track of all shapes in the diagram.\n */\nexport default function ElementRegistry(eventBus) {\n  this._elements = {};\n\n  this._eventBus = eventBus;\n}\n\nElementRegistry.$inject = [ 'eventBus' ];\n\n/**\n * Register a pair of (element, gfx, (secondaryGfx)).\n *\n * @param {djs.model.Base} element\n * @param {SVGElement} gfx\n * @param {SVGElement} [secondaryGfx] optional other element to register, too\n */\nElementRegistry.prototype.add = function(element, gfx, secondaryGfx) {\n\n  var id = element.id;\n\n  this._validateId(id);\n\n  // associate dom node with element\n  svgAttr(gfx, ELEMENT_ID, id);\n\n  if (secondaryGfx) {\n    svgAttr(secondaryGfx, ELEMENT_ID, id);\n  }\n\n  this._elements[id] = { element: element, gfx: gfx, secondaryGfx: secondaryGfx };\n};\n\n/**\n * Removes an element from the registry.\n *\n * @param {djs.model.Base} element\n */\nElementRegistry.prototype.remove = function(element) {\n  var elements = this._elements,\n      id = element.id || element,\n      container = id && elements[id];\n\n  if (container) {\n\n    // unset element id on gfx\n    svgAttr(container.gfx, ELEMENT_ID, '');\n\n    if (container.secondaryGfx) {\n      svgAttr(container.secondaryGfx, ELEMENT_ID, '');\n    }\n\n    delete elements[id];\n  }\n};\n\n/**\n * Update the id of an element\n *\n * @param {djs.model.Base} element\n * @param {String} newId\n */\nElementRegistry.prototype.updateId = function(element, newId) {\n\n  this._validateId(newId);\n\n  if (typeof element === 'string') {\n    element = this.get(element);\n  }\n\n  this._eventBus.fire('element.updateId', {\n    element: element,\n    newId: newId\n  });\n\n  var gfx = this.getGraphics(element),\n      secondaryGfx = this.getGraphics(element, true);\n\n  this.remove(element);\n\n  element.id = newId;\n\n  this.add(element, gfx, secondaryGfx);\n};\n\n/**\n * Return the model element for a given id or graphics.\n *\n * @example\n *\n * elementRegistry.get('SomeElementId_1');\n * elementRegistry.get(gfx);\n *\n *\n * @param {String|SVGElement} filter for selecting the element\n *\n * @return {djs.model.Base}\n */\nElementRegistry.prototype.get = function(filter) {\n  var id;\n\n  if (typeof filter === 'string') {\n    id = filter;\n  } else {\n    id = filter && svgAttr(filter, ELEMENT_ID);\n  }\n\n  var container = this._elements[id];\n  return container && container.element;\n};\n\n/**\n * Return all elements that match a given filter function.\n *\n * @param {Function} fn\n *\n * @return {Array<djs.model.Base>}\n */\nElementRegistry.prototype.filter = function(fn) {\n\n  var filtered = [];\n\n  this.forEach(function(element, gfx) {\n    if (fn(element, gfx)) {\n      filtered.push(element);\n    }\n  });\n\n  return filtered;\n};\n\n/**\n * Return all rendered model elements.\n *\n * @return {Array<djs.model.Base>}\n */\nElementRegistry.prototype.getAll = function() {\n  return this.filter(function(e) { return e; });\n};\n\n/**\n * Iterate over all diagram elements.\n *\n * @param {Function} fn\n */\nElementRegistry.prototype.forEach = function(fn) {\n\n  var map = this._elements;\n\n  Object.keys(map).forEach(function(id) {\n    var container = map[id],\n        element = container.element,\n        gfx = container.gfx;\n\n    return fn(element, gfx);\n  });\n};\n\n/**\n * Return the graphical representation of an element or its id.\n *\n * @example\n * elementRegistry.getGraphics('SomeElementId_1');\n * elementRegistry.getGraphics(rootElement); // <g ...>\n *\n * elementRegistry.getGraphics(rootElement, true); // <svg ...>\n *\n *\n * @param {String|djs.model.Base} filter\n * @param {Boolean} [secondary=false] whether to return the secondary connected element\n *\n * @return {SVGElement}\n */\nElementRegistry.prototype.getGraphics = function(filter, secondary) {\n  var id = filter.id || filter;\n\n  var container = this._elements[id];\n  return container && (secondary ? container.secondaryGfx : container.gfx);\n};\n\n/**\n * Validate the suitability of the given id and signals a problem\n * with an exception.\n *\n * @param {String} id\n *\n * @throws {Error} if id is empty or already assigned\n */\nElementRegistry.prototype._validateId = function(id) {\n  if (!id) {\n    throw new Error('element must have an id');\n  }\n\n  if (this._elements[id]) {\n    throw new Error('element with id ' + id + ' already added');\n  }\n};\n","import {\n  isFunction,\n  isArray,\n  isNumber,\n  bind,\n  assign\n} from 'min-dash';\n\nvar FN_REF = '__fn';\n\nvar DEFAULT_PRIORITY = 1000;\n\nvar slice = Array.prototype.slice;\n\n/**\n * A general purpose event bus.\n *\n * This component is used to communicate across a diagram instance.\n * Other parts of a diagram can use it to listen to and broadcast events.\n *\n *\n * ## Registering for Events\n *\n * The event bus provides the {@link EventBus#on} and {@link EventBus#once}\n * methods to register for events. {@link EventBus#off} can be used to\n * remove event registrations. Listeners receive an instance of {@link Event}\n * as the first argument. It allows them to hook into the event execution.\n *\n * ```javascript\n *\n * // listen for event\n * eventBus.on('foo', function(event) {\n *\n *   // access event type\n *   event.type; // 'foo'\n *\n *   // stop propagation to other listeners\n *   event.stopPropagation();\n *\n *   // prevent event default\n *   event.preventDefault();\n * });\n *\n * // listen for event with custom payload\n * eventBus.on('bar', function(event, payload) {\n *   console.log(payload);\n * });\n *\n * // listen for event returning value\n * eventBus.on('foobar', function(event) {\n *\n *   // stop event propagation + prevent default\n *   return false;\n *\n *   // stop event propagation + return custom result\n *   return {\n *     complex: 'listening result'\n *   };\n * });\n *\n *\n * // listen with custom priority (default=1000, higher is better)\n * eventBus.on('priorityfoo', 1500, function(event) {\n *   console.log('invoked first!');\n * });\n *\n *\n * // listen for event and pass the context (`this`)\n * eventBus.on('foobar', function(event) {\n *   this.foo();\n * }, this);\n * ```\n *\n *\n * ## Emitting Events\n *\n * Events can be emitted via the event bus using {@link EventBus#fire}.\n *\n * ```javascript\n *\n * // false indicates that the default action\n * // was prevented by listeners\n * if (eventBus.fire('foo') === false) {\n *   console.log('default has been prevented!');\n * };\n *\n *\n * // custom args + return value listener\n * eventBus.on('sum', function(event, a, b) {\n *   return a + b;\n * });\n *\n * // you can pass custom arguments + retrieve result values.\n * var sum = eventBus.fire('sum', 1, 2);\n * console.log(sum); // 3\n * ```\n */\nexport default function EventBus() {\n  this._listeners = {};\n\n  // cleanup on destroy on lowest priority to allow\n  // message passing until the bitter end\n  this.on('diagram.destroy', 1, this._destroy, this);\n}\n\n\n/**\n * Register an event listener for events with the given name.\n *\n * The callback will be invoked with `event, ...additionalArguments`\n * that have been passed to {@link EventBus#fire}.\n *\n * Returning false from a listener will prevent the events default action\n * (if any is specified). To stop an event from being processed further in\n * other listeners execute {@link Event#stopPropagation}.\n *\n * Returning anything but `undefined` from a listener will stop the listener propagation.\n *\n * @param {String|Array<String>} events\n * @param {Number} [priority=1000] the priority in which this listener is called, larger is higher\n * @param {Function} callback\n * @param {Object} [that] Pass context (`this`) to the callback\n */\nEventBus.prototype.on = function(events, priority, callback, that) {\n\n  events = isArray(events) ? events : [ events ];\n\n  if (isFunction(priority)) {\n    that = callback;\n    callback = priority;\n    priority = DEFAULT_PRIORITY;\n  }\n\n  if (!isNumber(priority)) {\n    throw new Error('priority must be a number');\n  }\n\n  var actualCallback = callback;\n\n  if (that) {\n    actualCallback = bind(callback, that);\n\n    // make sure we remember and are able to remove\n    // bound callbacks via {@link #off} using the original\n    // callback\n    actualCallback[FN_REF] = callback[FN_REF] || callback;\n  }\n\n  var self = this;\n\n  events.forEach(function(e) {\n    self._addListener(e, {\n      priority: priority,\n      callback: actualCallback,\n      next: null\n    });\n  });\n};\n\n\n/**\n * Register an event listener that is executed only once.\n *\n * @param {String} event the event name to register for\n * @param {Function} callback the callback to execute\n * @param {Object} [that] Pass context (`this`) to the callback\n */\nEventBus.prototype.once = function(event, priority, callback, that) {\n  var self = this;\n\n  if (isFunction(priority)) {\n    that = callback;\n    callback = priority;\n    priority = DEFAULT_PRIORITY;\n  }\n\n  if (!isNumber(priority)) {\n    throw new Error('priority must be a number');\n  }\n\n  function wrappedCallback() {\n    var result = callback.apply(that, arguments);\n\n    self.off(event, wrappedCallback);\n\n    return result;\n  }\n\n  // make sure we remember and are able to remove\n  // bound callbacks via {@link #off} using the original\n  // callback\n  wrappedCallback[FN_REF] = callback;\n\n  this.on(event, priority, wrappedCallback);\n};\n\n\n/**\n * Removes event listeners by event and callback.\n *\n * If no callback is given, all listeners for a given event name are being removed.\n *\n * @param {String|Array<String>} events\n * @param {Function} [callback]\n */\nEventBus.prototype.off = function(events, callback) {\n\n  events = isArray(events) ? events : [ events ];\n\n  var self = this;\n\n  events.forEach(function(event) {\n    self._removeListener(event, callback);\n  });\n\n};\n\n\n/**\n * Create an EventBus event.\n *\n * @param {Object} data\n *\n * @return {Object} event, recognized by the eventBus\n */\nEventBus.prototype.createEvent = function(data) {\n  var event = new InternalEvent();\n\n  event.init(data);\n\n  return event;\n};\n\n\n/**\n * Fires a named event.\n *\n * @example\n *\n * // fire event by name\n * events.fire('foo');\n *\n * // fire event object with nested type\n * var event = { type: 'foo' };\n * events.fire(event);\n *\n * // fire event with explicit type\n * var event = { x: 10, y: 20 };\n * events.fire('element.moved', event);\n *\n * // pass additional arguments to the event\n * events.on('foo', function(event, bar) {\n *   alert(bar);\n * });\n *\n * events.fire({ type: 'foo' }, 'I am bar!');\n *\n * @param {String} [name] the optional event name\n * @param {Object} [event] the event object\n * @param {...Object} additional arguments to be passed to the callback functions\n *\n * @return {Boolean} the events return value, if specified or false if the\n *                   default action was prevented by listeners\n */\nEventBus.prototype.fire = function(type, data) {\n\n  var event,\n      firstListener,\n      returnValue,\n      args;\n\n  args = slice.call(arguments);\n\n  if (typeof type === 'object') {\n    event = type;\n    type = event.type;\n  }\n\n  if (!type) {\n    throw new Error('no event type specified');\n  }\n\n  firstListener = this._listeners[type];\n\n  if (!firstListener) {\n    return;\n  }\n\n  // we make sure we fire instances of our home made\n  // events here. We wrap them only once, though\n  if (data instanceof InternalEvent) {\n    // we are fine, we alread have an event\n    event = data;\n  } else {\n    event = this.createEvent(data);\n  }\n\n  // ensure we pass the event as the first parameter\n  args[0] = event;\n\n  // original event type (in case we delegate)\n  var originalType = event.type;\n\n  // update event type before delegation\n  if (type !== originalType) {\n    event.type = type;\n  }\n\n  try {\n    returnValue = this._invokeListeners(event, args, firstListener);\n  } finally {\n    // reset event type after delegation\n    if (type !== originalType) {\n      event.type = originalType;\n    }\n  }\n\n  // set the return value to false if the event default\n  // got prevented and no other return value exists\n  if (returnValue === undefined && event.defaultPrevented) {\n    returnValue = false;\n  }\n\n  return returnValue;\n};\n\n\nEventBus.prototype.handleError = function(error) {\n  return this.fire('error', { error: error }) === false;\n};\n\n\nEventBus.prototype._destroy = function() {\n  this._listeners = {};\n};\n\nEventBus.prototype._invokeListeners = function(event, args, listener) {\n\n  var returnValue;\n\n  while (listener) {\n\n    // handle stopped propagation\n    if (event.cancelBubble) {\n      break;\n    }\n\n    returnValue = this._invokeListener(event, args, listener);\n\n    listener = listener.next;\n  }\n\n  return returnValue;\n};\n\nEventBus.prototype._invokeListener = function(event, args, listener) {\n\n  var returnValue;\n\n  try {\n    // returning false prevents the default action\n    returnValue = invokeFunction(listener.callback, args);\n\n    // stop propagation on return value\n    if (returnValue !== undefined) {\n      event.returnValue = returnValue;\n      event.stopPropagation();\n    }\n\n    // prevent default on return false\n    if (returnValue === false) {\n      event.preventDefault();\n    }\n  } catch (e) {\n    if (!this.handleError(e)) {\n      console.error('unhandled error in event listener');\n      console.error(e.stack);\n\n      throw e;\n    }\n  }\n\n  return returnValue;\n};\n\n/*\n * Add new listener with a certain priority to the list\n * of listeners (for the given event).\n *\n * The semantics of listener registration / listener execution are\n * first register, first serve: New listeners will always be inserted\n * after existing listeners with the same priority.\n *\n * Example: Inserting two listeners with priority 1000 and 1300\n *\n *    * before: [ 1500, 1500, 1000, 1000 ]\n *    * after: [ 1500, 1500, (new=1300), 1000, 1000, (new=1000) ]\n *\n * @param {String} event\n * @param {Object} listener { priority, callback }\n */\nEventBus.prototype._addListener = function(event, newListener) {\n\n  var listener = this._getListeners(event),\n      previousListener;\n\n  // no prior listeners\n  if (!listener) {\n    this._setListeners(event, newListener);\n\n    return;\n  }\n\n  // ensure we order listeners by priority from\n  // 0 (high) to n > 0 (low)\n  while (listener) {\n\n    if (listener.priority < newListener.priority) {\n\n      newListener.next = listener;\n\n      if (previousListener) {\n        previousListener.next = newListener;\n      } else {\n        this._setListeners(event, newListener);\n      }\n\n      return;\n    }\n\n    previousListener = listener;\n    listener = listener.next;\n  }\n\n  // add new listener to back\n  previousListener.next = newListener;\n};\n\n\nEventBus.prototype._getListeners = function(name) {\n  return this._listeners[name];\n};\n\nEventBus.prototype._setListeners = function(name, listener) {\n  this._listeners[name] = listener;\n};\n\nEventBus.prototype._removeListener = function(event, callback) {\n\n  var listener = this._getListeners(event),\n      nextListener,\n      previousListener,\n      listenerCallback;\n\n  if (!callback) {\n    // clear listeners\n    this._setListeners(event, null);\n\n    return;\n  }\n\n  while (listener) {\n\n    nextListener = listener.next;\n\n    listenerCallback = listener.callback;\n\n    if (listenerCallback === callback || listenerCallback[FN_REF] === callback) {\n      if (previousListener) {\n        previousListener.next = nextListener;\n      } else {\n        // new first listener\n        this._setListeners(event, nextListener);\n      }\n    }\n\n    previousListener = listener;\n    listener = nextListener;\n  }\n};\n\n/**\n * A event that is emitted via the event bus.\n */\nfunction InternalEvent() { }\n\nInternalEvent.prototype.stopPropagation = function() {\n  this.cancelBubble = true;\n};\n\nInternalEvent.prototype.preventDefault = function() {\n  this.defaultPrevented = true;\n};\n\nInternalEvent.prototype.init = function(data) {\n  assign(this, data || {});\n};\n\n\n/**\n * Invoke function. Be fast...\n *\n * @param {Function} fn\n * @param {Array<Object>} args\n *\n * @return {Any}\n */\nfunction invokeFunction(fn, args) {\n  return fn.apply(null, args);\n}\n","import {\n  forEach,\n  reduce\n} from 'min-dash';\n\nimport {\n  getChildren,\n  getVisual\n} from '../util/GraphicsUtil';\n\nimport { translate } from '../util/SvgTransformUtil';\n\nimport { clear as domClear } from 'min-dom';\n\nimport {\n  append as svgAppend,\n  attr as svgAttr,\n  classes as svgClasses,\n  create as svgCreate,\n  remove as svgRemove\n} from 'tiny-svg';\n\n\n/**\n * A factory that creates graphical elements\n *\n * @param {EventBus} eventBus\n * @param {ElementRegistry} elementRegistry\n */\nexport default function GraphicsFactory(eventBus, elementRegistry) {\n  this._eventBus = eventBus;\n  this._elementRegistry = elementRegistry;\n}\n\nGraphicsFactory.$inject = [ 'eventBus' , 'elementRegistry' ];\n\n\nGraphicsFactory.prototype._getChildren = function(element) {\n\n  var gfx = this._elementRegistry.getGraphics(element);\n\n  var childrenGfx;\n\n  // root element\n  if (!element.parent) {\n    childrenGfx = gfx;\n  } else {\n    childrenGfx = getChildren(gfx);\n    if (!childrenGfx) {\n      childrenGfx = svgCreate('g');\n      svgClasses(childrenGfx).add('djs-children');\n\n      svgAppend(gfx.parentNode, childrenGfx);\n    }\n  }\n\n  return childrenGfx;\n};\n\n/**\n * Clears the graphical representation of the element and returns the\n * cleared visual (the <g class=\"djs-visual\" /> element).\n */\nGraphicsFactory.prototype._clear = function(gfx) {\n  var visual = getVisual(gfx);\n\n  domClear(visual);\n\n  return visual;\n};\n\n/**\n * Creates a gfx container for shapes and connections\n *\n * The layout is as follows:\n *\n * <g class=\"djs-group\">\n *\n *   <!-- the gfx -->\n *   <g class=\"djs-element djs-(shape|connection)\">\n *     <g class=\"djs-visual\">\n *       <!-- the renderer draws in here -->\n *     </g>\n *\n *     <!-- extensions (overlays, click box, ...) goes here\n *   </g>\n *\n *   <!-- the gfx child nodes -->\n *   <g class=\"djs-children\"></g>\n * </g>\n *\n * @param {Object} parent\n * @param {String} type the type of the element, i.e. shape | connection\n * @param {Number} [parentIndex] position to create container in parent\n */\nGraphicsFactory.prototype._createContainer = function(type, childrenGfx, parentIndex) {\n  var outerGfx = svgCreate('g');\n  svgClasses(outerGfx).add('djs-group');\n\n  // insert node at position\n  if (typeof parentIndex !== 'undefined') {\n    prependTo(outerGfx, childrenGfx, childrenGfx.childNodes[parentIndex]);\n  } else {\n    svgAppend(childrenGfx, outerGfx);\n  }\n\n  var gfx = svgCreate('g');\n  svgClasses(gfx).add('djs-element');\n  svgClasses(gfx).add('djs-' + type);\n\n  svgAppend(outerGfx, gfx);\n\n  // create visual\n  var visual = svgCreate('g');\n  svgClasses(visual).add('djs-visual');\n\n  svgAppend(gfx, visual);\n\n  return gfx;\n};\n\nGraphicsFactory.prototype.create = function(type, element, parentIndex) {\n  var childrenGfx = this._getChildren(element.parent);\n  return this._createContainer(type, childrenGfx, parentIndex);\n};\n\nGraphicsFactory.prototype.updateContainments = function(elements) {\n\n  var self = this,\n      elementRegistry = this._elementRegistry,\n      parents;\n\n  parents = reduce(elements, function(map, e) {\n\n    if (e.parent) {\n      map[e.parent.id] = e.parent;\n    }\n\n    return map;\n  }, {});\n\n  // update all parents of changed and reorganized their children\n  // in the correct order (as indicated in our model)\n  forEach(parents, function(parent) {\n\n    var children = parent.children;\n\n    if (!children) {\n      return;\n    }\n\n    var childGfx = self._getChildren(parent);\n\n    forEach(children.slice().reverse(), function(c) {\n      var gfx = elementRegistry.getGraphics(c);\n\n      prependTo(gfx.parentNode, childGfx);\n    });\n  });\n};\n\nGraphicsFactory.prototype.drawShape = function(visual, element) {\n  var eventBus = this._eventBus;\n\n  return eventBus.fire('render.shape', { gfx: visual, element: element });\n};\n\nGraphicsFactory.prototype.getShapePath = function(element) {\n  var eventBus = this._eventBus;\n\n  return eventBus.fire('render.getShapePath', element);\n};\n\nGraphicsFactory.prototype.drawConnection = function(visual, element) {\n  var eventBus = this._eventBus;\n\n  return eventBus.fire('render.connection', { gfx: visual, element: element });\n};\n\nGraphicsFactory.prototype.getConnectionPath = function(waypoints) {\n  var eventBus = this._eventBus;\n\n  return eventBus.fire('render.getConnectionPath', waypoints);\n};\n\nGraphicsFactory.prototype.update = function(type, element, gfx) {\n  // Do not update root element\n  if (!element.parent) {\n    return;\n  }\n\n  var visual = this._clear(gfx);\n\n  // redraw\n  if (type === 'shape') {\n    this.drawShape(visual, element);\n\n    // update positioning\n    translate(gfx, element.x, element.y);\n  } else\n  if (type === 'connection') {\n    this.drawConnection(visual, element);\n  } else {\n    throw new Error('unknown type: ' + type);\n  }\n\n  if (element.hidden) {\n    svgAttr(gfx, 'display', 'none');\n  } else {\n    svgAttr(gfx, 'display', 'block');\n  }\n};\n\nGraphicsFactory.prototype.remove = function(element) {\n  var gfx = this._elementRegistry.getGraphics(element);\n\n  // remove\n  svgRemove(gfx.parentNode);\n};\n\n\n// helpers //////////////////////\n\nfunction prependTo(newNode, parentNode, siblingNode) {\n  parentNode.insertBefore(newNode, siblingNode || parentNode.firstChild);\n}\n","import DrawModule from '../draw';\n\nimport Canvas from './Canvas';\nimport ElementRegistry from './ElementRegistry';\nimport ElementFactory from './ElementFactory';\nimport EventBus from './EventBus';\nimport GraphicsFactory from './GraphicsFactory';\n\nexport default {\n  __depends__: [ DrawModule ],\n  __init__: [ 'canvas' ],\n  canvas: [ 'type', Canvas ],\n  elementRegistry: [ 'type', ElementRegistry ],\n  elementFactory: [ 'type', ElementFactory ],\n  eventBus: [ 'type', EventBus ],\n  graphicsFactory: [ 'type', GraphicsFactory ]\n};","var DEFAULT_RENDER_PRIORITY = 1000;\n\n/**\n * The base implementation of shape and connection renderers.\n *\n * @param {EventBus} eventBus\n * @param {Number} [renderPriority=1000]\n */\nexport default function BaseRenderer(eventBus, renderPriority) {\n  var self = this;\n\n  renderPriority = renderPriority || DEFAULT_RENDER_PRIORITY;\n\n  eventBus.on([ 'render.shape', 'render.connection' ], renderPriority, function(evt, context) {\n    var type = evt.type,\n        element = context.element,\n        visuals = context.gfx;\n\n    if (self.canRender(element)) {\n      if (type === 'render.shape') {\n        return self.drawShape(visuals, element);\n      } else {\n        return self.drawConnection(visuals, element);\n      }\n    }\n  });\n\n  eventBus.on([ 'render.getShapePath', 'render.getConnectionPath'], renderPriority, function(evt, element) {\n    if (self.canRender(element)) {\n      if (evt.type === 'render.getShapePath') {\n        return self.getShapePath(element);\n      } else {\n        return self.getConnectionPath(element);\n      }\n    }\n  });\n}\n\n/**\n * Should check whether *this* renderer can render\n * the element/connection.\n *\n * @param {element} element\n *\n * @returns {Boolean}\n */\nBaseRenderer.prototype.canRender = function() {};\n\n/**\n * Provides the shape's snap svg element to be drawn on the `canvas`.\n *\n * @param {djs.Graphics} visuals\n * @param {Shape} shape\n *\n * @returns {Snap.svg} [returns a Snap.svg paper element ]\n */\nBaseRenderer.prototype.drawShape = function() {};\n\n/**\n * Provides the shape's snap svg element to be drawn on the `canvas`.\n *\n * @param {djs.Graphics} visuals\n * @param {Connection} connection\n *\n * @returns {Snap.svg} [returns a Snap.svg paper element ]\n */\nBaseRenderer.prototype.drawConnection = function() {};\n\n/**\n * Gets the SVG path of a shape that represents it's visual bounds.\n *\n * @param {Shape} shape\n *\n * @return {string} svg path\n */\nBaseRenderer.prototype.getShapePath = function() {};\n\n/**\n * Gets the SVG path of a connection that represents it's visual bounds.\n *\n * @param {Connection} connection\n *\n * @return {string} svg path\n */\nBaseRenderer.prototype.getConnectionPath = function() {};\n","import inherits from 'inherits';\n\nimport BaseRenderer from './BaseRenderer';\n\nimport {\n  componentsToPath,\n  createLine\n} from '../util/RenderUtil';\n\nimport {\n  append as svgAppend,\n  attr as svgAttr,\n  create as svgCreate\n} from 'tiny-svg';\n\n// apply default renderer with lowest possible priority\n// so that it only kicks in if noone else could render\nvar DEFAULT_RENDER_PRIORITY = 1;\n\n/**\n * The default renderer used for shapes and connections.\n *\n * @param {EventBus} eventBus\n * @param {Styles} styles\n */\nexport default function DefaultRenderer(eventBus, styles) {\n  //\n  BaseRenderer.call(this, eventBus, DEFAULT_RENDER_PRIORITY);\n\n  this.CONNECTION_STYLE = styles.style([ 'no-fill' ], { strokeWidth: 5, stroke: 'fuchsia' });\n  this.SHAPE_STYLE = styles.style({ fill: 'white', stroke: 'fuchsia', strokeWidth: 2 });\n}\n\ninherits(DefaultRenderer, BaseRenderer);\n\n\nDefaultRenderer.prototype.canRender = function() {\n  return true;\n};\n\nDefaultRenderer.prototype.drawShape = function drawShape(visuals, element) {\n\n  var rect = svgCreate('rect');\n  svgAttr(rect, {\n    x: 0,\n    y: 0,\n    width: element.width || 0,\n    height: element.height || 0\n  });\n  svgAttr(rect, this.SHAPE_STYLE);\n\n  svgAppend(visuals, rect);\n\n  return rect;\n};\n\nDefaultRenderer.prototype.drawConnection = function drawConnection(visuals, connection) {\n\n  var line = createLine(connection.waypoints, this.CONNECTION_STYLE);\n  svgAppend(visuals, line);\n\n  return line;\n};\n\nDefaultRenderer.prototype.getShapePath = function getShapePath(shape) {\n\n  var x = shape.x,\n      y = shape.y,\n      width = shape.width,\n      height = shape.height;\n\n  var shapePath = [\n    ['M', x, y],\n    ['l', width, 0],\n    ['l', 0, height],\n    ['l', -width, 0],\n    ['z']\n  ];\n\n  return componentsToPath(shapePath);\n};\n\nDefaultRenderer.prototype.getConnectionPath = function getConnectionPath(connection) {\n  var waypoints = connection.waypoints;\n\n  var idx, point, connectionPath = [];\n\n  for (idx = 0; (point = waypoints[idx]); idx++) {\n\n    // take invisible docking into account\n    // when creating the path\n    point = point.original || point;\n\n    connectionPath.push([ idx === 0 ? 'M' : 'L', point.x, point.y ]);\n  }\n\n  return componentsToPath(connectionPath);\n};\n\n\nDefaultRenderer.$inject = [ 'eventBus', 'styles' ];\n","import {\n  isArray,\n  assign,\n  reduce\n} from 'min-dash';\n\n\n/**\n * A component that manages shape styles\n */\nexport default function Styles() {\n\n  var defaultTraits = {\n\n    'no-fill': {\n      fill: 'none'\n    },\n    'no-border': {\n      strokeOpacity: 0.0\n    },\n    'no-events': {\n      pointerEvents: 'none'\n    }\n  };\n\n  var self = this;\n\n  /**\n   * Builds a style definition from a className, a list of traits and an object of additional attributes.\n   *\n   * @param  {String} className\n   * @param  {Array<String>} traits\n   * @param  {Object} additionalAttrs\n   *\n   * @return {Object} the style defintion\n   */\n  this.cls = function(className, traits, additionalAttrs) {\n    var attrs = this.style(traits, additionalAttrs);\n\n    return assign(attrs, { 'class': className });\n  };\n\n  /**\n   * Builds a style definition from a list of traits and an object of additional attributes.\n   *\n   * @param  {Array<String>} traits\n   * @param  {Object} additionalAttrs\n   *\n   * @return {Object} the style defintion\n   */\n  this.style = function(traits, additionalAttrs) {\n\n    if (!isArray(traits) && !additionalAttrs) {\n      additionalAttrs = traits;\n      traits = [];\n    }\n\n    var attrs = reduce(traits, function(attrs, t) {\n      return assign(attrs, defaultTraits[t] || {});\n    }, {});\n\n    return additionalAttrs ? assign(attrs, additionalAttrs) : attrs;\n  };\n\n  this.computeStyle = function(custom, traits, defaultStyles) {\n    if (!isArray(traits)) {\n      defaultStyles = traits;\n      traits = [];\n    }\n\n    return self.style(traits || [], assign({}, defaultStyles, custom || {}));\n  };\n}\n","import DefaultRenderer from './DefaultRenderer';\nimport Styles from './Styles';\n\nexport default {\n  __init__: [ 'defaultRenderer' ],\n  defaultRenderer: [ 'type', DefaultRenderer ],\n  styles: [ 'type', Styles ]\n};\n","import {\n  filter,\n  forEach,\n  sortBy\n} from 'min-dash';\n\nfunction last(arr) {\n  return arr && arr[arr.length - 1];\n}\n\nfunction sortTopOrMiddle(element) {\n  return element.y;\n}\n\nfunction sortLeftOrCenter(element) {\n  return element.x;\n}\n\n/**\n * Sorting functions for different types of alignment\n *\n * @type {Object}\n *\n * @return {Function}\n */\nvar ALIGNMENT_SORTING = {\n  left: sortLeftOrCenter,\n  center: sortLeftOrCenter,\n  right: function(element) {\n    return element.x + element.width;\n  },\n  top: sortTopOrMiddle,\n  middle: sortTopOrMiddle,\n  bottom: function(element) {\n    return element.y + element.height;\n  }\n};\n\n\nexport default function AlignElements(modeling) {\n  this._modeling = modeling;\n}\n\nAlignElements.$inject = [ 'modeling' ];\n\n\n/**\n * Get the relevant \"axis\" and \"dimension\" related to the current type of alignment\n *\n * @param  {String} type left|right|center|top|bottom|middle\n *\n * @return {Object} { axis, dimension }\n */\nAlignElements.prototype._getOrientationDetails = function(type) {\n  var vertical = [ 'top', 'bottom', 'middle' ],\n      axis = 'x',\n      dimension = 'width';\n\n  if (vertical.indexOf(type) !== -1) {\n    axis = 'y';\n    dimension = 'height';\n  }\n\n  return {\n    axis: axis,\n    dimension: dimension\n  };\n};\n\nAlignElements.prototype._isType = function(type, types) {\n  return types.indexOf(type) !== -1;\n};\n\n/**\n * Get a point on the relevant axis where elements should align to\n *\n * @param  {String} type left|right|center|top|bottom|middle\n * @param  {Array} sortedElements\n *\n * @return {Object}\n */\nAlignElements.prototype._alignmentPosition = function(type, sortedElements) {\n  var orientation = this._getOrientationDetails(type),\n      axis = orientation.axis,\n      dimension = orientation.dimension,\n      alignment = {},\n      centers = {},\n      hasSharedCenters = false,\n      centeredElements,\n      firstElement,\n      lastElement;\n\n  function getMiddleOrTop(first, last) {\n    return Math.round((first[axis] + last[axis] + last[dimension]) / 2);\n  }\n\n  if (this._isType(type, [ 'left', 'top' ])) {\n    alignment[type] = sortedElements[0][axis];\n\n  } else if (this._isType(type, [ 'right', 'bottom' ])) {\n    lastElement = last(sortedElements);\n\n    alignment[type] = lastElement[axis] + lastElement[dimension];\n\n  } else if (this._isType(type, [ 'center', 'middle' ])) {\n\n    // check if there is a center shared by more than one shape\n    // if not, just take the middle of the range\n    forEach(sortedElements, function(element) {\n      var center = element[axis] + Math.round(element[dimension] / 2);\n\n      if (centers[center]) {\n        centers[center].elements.push(element);\n      } else {\n        centers[center] = {\n          elements: [ element ],\n          center: center\n        };\n      }\n    });\n\n    centeredElements = sortBy(centers, function(center) {\n      if (center.elements.length > 1) {\n        hasSharedCenters = true;\n      }\n\n      return center.elements.length;\n    });\n\n    if (hasSharedCenters) {\n      alignment[type] = last(centeredElements).center;\n\n      return alignment;\n    }\n\n    firstElement = sortedElements[0];\n\n    sortedElements = sortBy(sortedElements, function(element) {\n      return element[axis] + element[dimension];\n    });\n\n    lastElement = last(sortedElements);\n\n    alignment[type] = getMiddleOrTop(firstElement, lastElement);\n  }\n\n  return alignment;\n};\n\n/**\n * Executes the alignment of a selection of elements\n *\n * @param  {Array} elements [description]\n * @param  {String} type left|right|center|top|bottom|middle\n */\nAlignElements.prototype.trigger = function(elements, type) {\n  var modeling = this._modeling;\n\n  var filteredElements = filter(elements, function(element) {\n    return !(element.waypoints || element.host || element.labelTarget);\n  });\n\n  var sortFn = ALIGNMENT_SORTING[type];\n\n  var sortedElements = sortBy(filteredElements, sortFn);\n\n  var alignment = this._alignmentPosition(type, sortedElements);\n\n  modeling.alignElements(sortedElements, alignment);\n};\n","import AlignElements from './AlignElements';\n\nexport default {\n  __init__: [ 'alignElements' ],\n  alignElements: [ 'type', AlignElements ]\n};\n","import {\n  flatten,\n  filter,\n  forEach,\n  groupBy,\n  map,\n  unionBy\n} from 'min-dash';\n\nimport { saveClear } from '../../util/Removal';\n\nimport {\n  remove as collectionRemove\n} from '../../util/Collections';\n\nimport { getNewAttachShapeDelta } from '../../util/AttachUtil';\n\nimport inherits from 'inherits';\n\nvar LOW_PRIORITY = 251,\n    HIGH_PRIORITY = 1401;\n\nimport CommandInterceptor from '../../command/CommandInterceptor';\n\n\n/**\n * Adds the notion of attached elements to the modeler.\n *\n * Optionally depends on `diagram-js/lib/features/move` to render\n * the attached elements during move preview.\n *\n * Optionally depends on `diagram-js/lib/features/label-support`\n * to render attached labels during move preview.\n *\n * @param {didi.Injector} injector\n * @param {EventBus} eventBus\n * @param {Rules} rules\n * @param {Modeling} modeling\n */\nexport default function AttachSupport(injector, eventBus, rules, modeling) {\n\n  CommandInterceptor.call(this, eventBus);\n\n  var movePreview = injector.get('movePreview', false);\n\n\n  // remove all the attached elements from the shapes to be validated\n  // add all the attached shapes to the overall list of moved shapes\n  eventBus.on('shape.move.start', HIGH_PRIORITY, function(e) {\n\n    var context = e.context,\n        shapes = context.shapes,\n        validatedShapes = context.validatedShapes;\n\n    context.shapes = addAttached(shapes);\n\n    context.validatedShapes = removeAttached(validatedShapes);\n  });\n\n  // add attachers to the visual's group\n  movePreview && eventBus.on('shape.move.start', LOW_PRIORITY, function(e) {\n\n    var context = e.context,\n        shapes = context.shapes,\n        attachers = getAttachers(shapes);\n\n    forEach(attachers, function(attacher) {\n      movePreview.makeDraggable(context, attacher, true);\n\n      forEach(attacher.labels, function(label) {\n        movePreview.makeDraggable(context, label, true);\n      });\n    });\n  });\n\n\n  // add all attachers to move closure\n  this.preExecuted('elements.move', HIGH_PRIORITY, function(e) {\n    var context = e.context,\n        closure = context.closure,\n        shapes = context.shapes,\n        attachers = getAttachers(shapes);\n\n    forEach(attachers, function(attacher) {\n      closure.add(attacher, closure.topLevel[attacher.host.id]);\n    });\n  });\n\n  // perform the attaching after shapes are done moving\n  this.postExecuted('elements.move', function(e) {\n\n    var context = e.context,\n        shapes = context.shapes,\n        newHost = context.newHost,\n        attachers;\n\n    // we only support attachment / detachment of one element\n    if (shapes.length > 1) {\n      return;\n    }\n\n    if (newHost) {\n\n      attachers = shapes;\n    } else {\n\n      attachers = filter(shapes, function(s) {\n        return !!s.host;\n      });\n    }\n\n    forEach(attachers, function(attacher) {\n      modeling.updateAttachment(attacher, newHost);\n    });\n  });\n\n  // ensure invalid attachment connections are removed\n  this.postExecuted('elements.move', function(e) {\n\n    var shapes = e.context.shapes;\n\n    forEach(shapes, function(shape) {\n\n      forEach(shape.attachers, function(attacher) {\n\n        // remove invalid outgoing connections\n        forEach(attacher.outgoing.slice(), function(connection) {\n          var allowed = rules.allowed('connection.reconnectStart', {\n            connection: connection,\n            source: connection.source,\n            target: connection.target\n          });\n\n          if (!allowed) {\n            modeling.removeConnection(connection);\n          }\n        });\n\n        // remove invalid incoming connections\n        forEach(attacher.incoming.slice(), function(connection) {\n          var allowed = rules.allowed('connection.reconnectEnd', {\n            connection: connection,\n            source: connection.source,\n            target: connection.target\n          });\n\n          if (!allowed) {\n            modeling.removeConnection(connection);\n          }\n        });\n      });\n    });\n  });\n\n  this.postExecute('shape.create', function(e) {\n    var context = e.context,\n        shape = context.shape,\n        host = context.host;\n\n    if (host) {\n      modeling.updateAttachment(shape, host);\n    }\n  });\n\n  // update attachments if the host is replaced\n  this.postExecute('shape.replace', function(e) {\n\n    var context = e.context,\n        oldShape = context.oldShape,\n        newShape = context.newShape;\n\n    // move the attachers to the new host\n    saveClear(oldShape.attachers, function(attacher) {\n      var allowed = rules.allowed('elements.move', {\n        target: newShape,\n        shapes: [attacher]\n      });\n\n      if (allowed === 'attach') {\n        modeling.updateAttachment(attacher, newShape);\n      } else {\n        modeling.removeShape(attacher);\n      }\n    });\n\n    // move attachers if new host has different size\n    if (newShape.attachers.length) {\n\n      forEach(newShape.attachers, function(attacher) {\n        var delta = getNewAttachShapeDelta(attacher, oldShape, newShape);\n        modeling.moveShape(attacher, delta, attacher.parent);\n      });\n    }\n\n  });\n\n  // move shape on host resize\n  this.postExecute('shape.resize', function(event) {\n    var context = event.context,\n        shape = context.shape,\n        oldBounds = context.oldBounds,\n        newBounds = context.newBounds,\n        attachers = shape.attachers;\n\n    forEach(attachers, function(attacher) {\n      var delta = getNewAttachShapeDelta(attacher, oldBounds, newBounds);\n\n      modeling.moveShape(attacher, delta, attacher.parent);\n\n      forEach(attacher.labels, function(label) {\n        modeling.moveShape(label, delta, label.parent);\n      });\n    });\n  });\n\n  // remove attachments\n  this.preExecute('shape.delete', function(event) {\n\n    var shape = event.context.shape;\n\n    saveClear(shape.attachers, function(attacher) {\n      modeling.removeShape(attacher);\n    });\n\n    if (shape.host) {\n      modeling.updateAttachment(shape, null);\n    }\n  });\n\n\n  // Prevent attachers and their labels from moving, when the space tool is performed.\n  // Otherwise the attachers and their labels would be moved twice.\n  eventBus.on('spaceTool.move', function(event) {\n\n    var context = event.context,\n        initialized = context.initialized,\n        attachSupportInitialized = context.attachSupportInitialized;\n\n    if (!initialized || attachSupportInitialized) {\n      return;\n    }\n\n    var movingShapes = context.movingShapes;\n\n    // collect attachers whose host is not being moved using the space tool\n    var staticAttachers = filter(movingShapes, function(shape) {\n      var host = shape.host;\n\n      return host && movingShapes.indexOf(host) === -1;\n    });\n\n    // remove attachers that are not going to be moved from moving shapes\n    forEach(staticAttachers, function(shape) {\n      collectionRemove(movingShapes, shape);\n\n      forEach(shape.labels, function(label) {\n        collectionRemove(movingShapes, shape.label);\n      });\n    });\n\n    context.attachSupportInitialized = true;\n  });\n}\n\ninherits(AttachSupport, CommandInterceptor);\n\nAttachSupport.$inject = [\n  'injector',\n  'eventBus',\n  'rules',\n  'modeling'\n];\n\n\n/**\n * Return attachers of the given shapes\n *\n * @param {Array<djs.model.Base>} shapes\n * @return {Array<djs.model.Base>}\n */\nfunction getAttachers(shapes) {\n  return flatten(map(shapes, function(s) {\n    return s.attachers || [];\n  }));\n}\n\n/**\n * Return a combined list of elements and\n * attachers.\n *\n * @param {Array<djs.model.Base>} elements\n * @return {Array<djs.model.Base>} filtered\n */\nfunction addAttached(elements) {\n  var attachers = getAttachers(elements);\n\n  return unionBy('id', elements, attachers);\n}\n\n/**\n * Return a filtered list of elements that do not\n * contain attached elements with hosts being part\n * of the selection.\n *\n * @param  {Array<djs.model.Base>} elements\n *\n * @return {Array<djs.model.Base>} filtered\n */\nfunction removeAttached(elements) {\n\n  var ids = groupBy(elements, 'id');\n\n  return filter(elements, function(element) {\n    while (element) {\n\n      // host in selection\n      if (element.host && ids[element.host.id]) {\n        return false;\n      }\n\n      element = element.parent;\n    }\n\n    return true;\n  });\n}\n","import RulesModule from '../rules';\n\nimport AttachSupport from './AttachSupport';\n\nexport default {\n  __depends__: [\n    RulesModule\n  ],\n  __init__: [ 'attachSupport' ],\n  attachSupport: [ 'type', AttachSupport ]\n};\n","import inherits from 'inherits';\n\nimport { getBBox as getBoundingBox } from '../../util/Elements';\n\nimport {\n  asTRBL,\n  asBounds\n} from '../../layout/LayoutUtil';\n\nimport {\n  assign,\n  flatten,\n  forEach,\n  isArray,\n  values,\n  groupBy\n} from 'min-dash';\n\nimport CommandInterceptor from '../../command/CommandInterceptor';\n\n\n/**\n * An auto resize component that takes care of expanding a parent element\n * if child elements are created or moved close the parents edge.\n *\n * @param {EventBus} eventBus\n * @param {ElementRegistry} elementRegistry\n * @param {Modeling} modeling\n * @param {Rules} rules\n */\nexport default function AutoResize(eventBus, elementRegistry, modeling, rules) {\n\n  CommandInterceptor.call(this, eventBus);\n\n  this._elementRegistry = elementRegistry;\n  this._modeling = modeling;\n  this._rules = rules;\n\n  var self = this;\n\n  this.postExecuted([ 'shape.create' ], function(event) {\n    var context = event.context,\n        hints = context.hints,\n        shape = context.shape,\n        parent = context.parent || context.newParent;\n\n    if (hints && (hints.root === false || hints.autoResize === false)) {\n      return;\n    }\n\n    self._expand([ shape ], parent);\n  });\n\n  this.postExecuted([ 'elements.move' ], function(event) {\n    var context = event.context,\n        elements = flatten(values(context.closure.topLevel)),\n        hints = context.hints;\n\n    var autoResize = hints ? hints.autoResize : true;\n\n    if (autoResize === false) {\n      return;\n    }\n\n    var expandings = groupBy(elements, function(element) {\n      return element.parent.id;\n    });\n\n    forEach(expandings, function(elements, parentId) {\n\n      // optionally filter elements to be considered when resizing\n      if (isArray(autoResize)) {\n        elements = elements.filter(function(element) {\n          return autoResize.indexOf(element) !== -1;\n        });\n      }\n\n      self._expand(elements, parentId);\n    });\n  });\n\n  this.postExecuted([ 'shape.toggleCollapse' ], function(event) {\n    var context = event.context,\n        hints = context.hints,\n        shape = context.shape;\n\n    if (hints && (hints.root === false || hints.autoResize === false)) {\n      return;\n    }\n\n    if (shape.collapsed) {\n      return;\n    }\n\n    self._expand(shape.children || [], shape);\n  });\n\n  this.postExecuted([ 'shape.resize' ], function(event) {\n    var context = event.context,\n        hints = context.hints,\n        shape = context.shape,\n        parent = shape.parent;\n\n    if (hints && (hints.root === false || hints.autoResize === false)) {\n      return;\n    }\n\n    if (parent) {\n      self._expand([ shape ], parent);\n    }\n  });\n\n}\n\nAutoResize.$inject = [\n  'eventBus',\n  'elementRegistry',\n  'modeling',\n  'rules'\n];\n\ninherits(AutoResize, CommandInterceptor);\n\n\n/**\n * Calculate the new bounds of the target shape, given\n * a number of elements have been moved or added into the parent.\n *\n * This method considers the current size, the added elements as well as\n * the provided padding for the new bounds.\n *\n * @param {Array<djs.model.Shape>} elements\n * @param {djs.model.Shape} target\n */\nAutoResize.prototype._getOptimalBounds = function(elements, target) {\n\n  var offset = this.getOffset(target),\n      padding = this.getPadding(target);\n\n  var elementsTrbl = asTRBL(getBoundingBox(elements)),\n      targetTrbl = asTRBL(target);\n\n  var newTrbl = {};\n\n  if (elementsTrbl.top - targetTrbl.top < padding.top) {\n    newTrbl.top = elementsTrbl.top - offset.top;\n  }\n\n  if (elementsTrbl.left - targetTrbl.left < padding.left) {\n    newTrbl.left = elementsTrbl.left - offset.left;\n  }\n\n  if (targetTrbl.right - elementsTrbl.right < padding.right) {\n    newTrbl.right = elementsTrbl.right + offset.right;\n  }\n\n  if (targetTrbl.bottom - elementsTrbl.bottom < padding.bottom) {\n    newTrbl.bottom = elementsTrbl.bottom + offset.bottom;\n  }\n\n  return asBounds(assign({}, targetTrbl, newTrbl));\n};\n\n\n/**\n * Expand the target shape respecting rules, offset and padding\n *\n * @param {Array<djs.model.Shape>} elements\n * @param {djs.model.Shape|String} target|targetId\n */\nAutoResize.prototype._expand = function(elements, target) {\n\n  if (typeof target === 'string') {\n    target = this._elementRegistry.get(target);\n  }\n\n  var allowed = this._rules.allowed('element.autoResize', {\n    elements: elements,\n    target: target\n  });\n\n  if (!allowed) {\n    return;\n  }\n\n  // calculate the new bounds\n  var newBounds = this._getOptimalBounds(elements, target);\n\n  if (!boundsChanged(newBounds, target)) {\n    return;\n  }\n\n  // resize the parent shape\n  this.resize(target, newBounds);\n\n  var parent = target.parent;\n\n  // recursively expand parent elements\n  if (parent) {\n    this._expand([ target ], parent);\n  }\n};\n\n\n/**\n * Get the amount to expand the given shape in each direction.\n *\n * @param {djs.model.Shape} shape\n *\n * @return {Object} {top, bottom, left, right}\n */\nAutoResize.prototype.getOffset = function(shape) {\n  return { top: 60, bottom: 60, left: 100, right: 100 };\n};\n\n\n/**\n * Get the activation threshold for each side for which\n * resize triggers.\n *\n * @param {djs.model.Shape} shape\n *\n * @return {Object} {top, bottom, left, right}\n */\nAutoResize.prototype.getPadding = function(shape) {\n  return { top: 2, bottom: 2, left: 15, right: 15 };\n};\n\n\n/**\n * Perform the actual resize operation.\n *\n * @param {djs.model.Shape} target\n * @param {Object} newBounds\n */\nAutoResize.prototype.resize = function(target, newBounds) {\n  this._modeling.resizeShape(target, newBounds);\n};\n\n\nfunction boundsChanged(newBounds, oldBounds) {\n  return (\n    newBounds.x !== oldBounds.x ||\n    newBounds.y !== oldBounds.y ||\n    newBounds.width !== oldBounds.width ||\n    newBounds.height !== oldBounds.height\n  );\n}","import RuleProvider from '../rules/RuleProvider';\n\nimport inherits from 'inherits';\n\n/**\n * This is a base rule provider for the element.autoResize rule.\n */\nexport default function AutoResizeProvider(eventBus) {\n\n  RuleProvider.call(this, eventBus);\n\n  var self = this;\n\n  this.addRule('element.autoResize', function(context) {\n    return self.canResize(context.elements, context.target);\n  });\n}\n\nAutoResizeProvider.$inject = [ 'eventBus' ];\n\ninherits(AutoResizeProvider, RuleProvider);\n\n/**\n * Needs to be implemented by sub classes to allow actual auto resize\n *\n * @param  {Array<djs.model.Shape>} elements\n * @param  {djs.model.Shape} target\n *\n * @return {Boolean}\n */\nAutoResizeProvider.prototype.canResize = function(elements, target) {\n  return false;\n};","import { assign } from 'min-dash';\n\nimport {\n  toPoint\n} from '../../util/Event';\n\n\n/**\n * Initiates canvas scrolling if current cursor point is close to a border.\n * Cancelled when current point moves back inside the scrolling borders\n * or cancelled manually.\n *\n * Default options :\n *   scrollThresholdIn: [ 20, 20, 20, 20 ],\n *   scrollThresholdOut: [ 0, 0, 0, 0 ],\n *   scrollRepeatTimeout: 15,\n *   scrollStep: 10\n *\n * Threshold order:\n *   [ left, top, right, bottom ]\n */\nexport default function AutoScroll(config, eventBus, canvas, mouseTracking) {\n\n  this._canvas = canvas;\n  this._mouseTracking = mouseTracking;\n\n  this._opts = assign({\n    scrollThresholdIn: [ 20, 20, 20, 20 ],\n    scrollThresholdOut: [ 0, 0, 0, 0 ],\n    scrollRepeatTimeout: 15,\n    scrollStep: 10\n  }, config);\n\n  var self = this;\n\n  eventBus.on('drag.move', function(e) {\n    var point = self._toBorderPoint(e);\n\n    self.startScroll(point);\n  });\n\n  eventBus.on([ 'drag.cleanup' ], function() {\n    self.stopScroll();\n  });\n}\n\nAutoScroll.$inject = [\n  'config.autoScroll',\n  'eventBus',\n  'canvas',\n  'mouseTracking'\n];\n\n\n/**\n * Starts scrolling loop.\n * Point is given in global scale in canvas container box plane.\n *\n * @param  {Object} point { x: X, y: Y }\n */\nAutoScroll.prototype.startScroll = function(point) {\n\n  var canvas = this._canvas;\n  var opts = this._opts;\n  var self = this;\n\n  var clientRect = canvas.getContainer().getBoundingClientRect();\n\n  var diff = [\n    point.x,\n    point.y,\n    clientRect.width - point.x,\n    clientRect.height - point.y\n  ];\n\n  this.stopScroll();\n\n  var dx = 0,\n      dy = 0;\n\n  for (var i = 0; i < 4; i++) {\n    if (between(diff[i], opts.scrollThresholdOut[i], opts.scrollThresholdIn[i])) {\n      if (i === 0) {\n        dx = opts.scrollStep;\n      } else if (i == 1) {\n        dy = opts.scrollStep;\n      } else if (i == 2) {\n        dx = -opts.scrollStep;\n      } else if (i == 3) {\n        dy = -opts.scrollStep;\n      }\n    }\n  }\n\n  if (dx !== 0 || dy !== 0) {\n    canvas.scroll({ dx: dx, dy: dy });\n\n    this._scrolling = setTimeout(function() {\n      self.startScroll(point);\n    }, opts.scrollRepeatTimeout);\n  }\n};\n\nfunction between(val, start, end) {\n  if (start < val && val < end) {\n    return true;\n  }\n\n  return false;\n}\n\n\n/**\n * Stops scrolling loop.\n */\nAutoScroll.prototype.stopScroll = function() {\n  clearTimeout(this._scrolling);\n};\n\n\n/**\n * Overrides defaults options.\n *\n * @param  {Object} options\n */\nAutoScroll.prototype.setOptions = function(options) {\n  this._opts = assign({}, this._opts, options);\n};\n\n\n/**\n * Converts event to a point in canvas container plane in global scale.\n *\n * @param  {Event} event\n * @return {Point}\n */\nAutoScroll.prototype._toBorderPoint = function(event) {\n  var clientRect = this._canvas._container.getBoundingClientRect();\n\n  var globalPosition = toPoint(event.originalEvent);\n\n  return {\n    x: globalPosition.x - clientRect.left,\n    y: globalPosition.y - clientRect.top\n  };\n};","import DraggingModule from '../dragging';\nimport MouseTrackingModule from '../mouse-tracking';\n\nimport AutoScroll from './AutoScroll';\n\n\nexport default {\n  __depends__: [\n    DraggingModule,\n    MouseTrackingModule\n  ],\n  __init__: [ 'autoScroll' ],\n  autoScroll: [ 'type', AutoScroll ]\n};","import {\n  pointDistance,\n  pointsOnLine\n} from '../../util/Geometry';\n\nimport {\n  addBendpoint\n} from './BendpointUtil';\n\nvar MARKER_OK = 'connect-ok',\n    MARKER_NOT_OK = 'connect-not-ok',\n    MARKER_CONNECT_HOVER = 'connect-hover',\n    MARKER_CONNECT_UPDATING = 'djs-updating';\n\nvar COMMAND_BENDPOINT_UPDATE = 'connection.updateWaypoints',\n    COMMAND_RECONNECT_START = 'connection.reconnectStart',\n    COMMAND_RECONNECT_END = 'connection.reconnectEnd';\n\nvar round = Math.round;\n\nimport {\n  classes as svgClasses,\n  remove as svgRemove\n} from 'tiny-svg';\n\nimport { translate } from '../../util/SvgTransformUtil';\n\n\n/**\n * A component that implements moving of bendpoints\n */\nexport default function BendpointMove(\n    injector, eventBus, canvas,\n    dragging, graphicsFactory, rules,\n    modeling) {\n\n\n  // optional connection docking integration\n  var connectionDocking = injector.get('connectionDocking', false);\n\n\n  // API\n\n  this.start = function(event, connection, bendpointIndex, insert) {\n\n    var type,\n        context,\n        waypoints = connection.waypoints,\n        gfx = canvas.getGraphics(connection);\n\n    if (!insert && bendpointIndex === 0) {\n      type = COMMAND_RECONNECT_START;\n    } else\n    if (!insert && bendpointIndex === waypoints.length - 1) {\n      type = COMMAND_RECONNECT_END;\n    } else {\n      type = COMMAND_BENDPOINT_UPDATE;\n    }\n\n    context = {\n      connection: connection,\n      bendpointIndex: bendpointIndex,\n      insert: insert,\n      type: type\n    };\n\n    dragging.init(event, 'bendpoint.move', {\n      data: {\n        connection: connection,\n        connectionGfx: gfx,\n        context: context\n      }\n    });\n  };\n\n\n  // DRAGGING IMPLEMENTATION\n\n\n  function redrawConnection(data) {\n    graphicsFactory.update('connection', data.connection, data.connectionGfx);\n  }\n\n  function filterRedundantWaypoints(waypoints) {\n\n    // alter copy of waypoints, not original\n    waypoints = waypoints.slice();\n\n    var idx = 0,\n        point,\n        previousPoint,\n        nextPoint;\n\n    while (waypoints[idx]) {\n      point = waypoints[idx];\n      previousPoint = waypoints[idx - 1];\n      nextPoint = waypoints[idx + 1];\n\n      if (pointDistance(point, nextPoint) === 0 ||\n          pointsOnLine(previousPoint, nextPoint, point)) {\n\n        // remove point, if overlapping with {nextPoint}\n        // or on line with {previousPoint} -> {point} -> {nextPoint}\n        waypoints.splice(idx, 1);\n      } else {\n        idx++;\n      }\n    }\n\n    return waypoints;\n  }\n\n  eventBus.on('bendpoint.move.start', function(e) {\n\n    var context = e.context,\n        connection = context.connection,\n        originalWaypoints = connection.waypoints,\n        waypoints = originalWaypoints.slice(),\n        insert = context.insert,\n        idx = context.bendpointIndex;\n\n    context.originalWaypoints = originalWaypoints;\n\n    if (insert) {\n      // insert placeholder for bendpoint to-be-added\n      waypoints.splice(idx, 0, null);\n    }\n\n    connection.waypoints = waypoints;\n\n    // add dragger gfx\n    context.draggerGfx = addBendpoint(canvas.getLayer('overlays'));\n    svgClasses(context.draggerGfx).add('djs-dragging');\n\n    canvas.addMarker(connection, MARKER_CONNECT_UPDATING);\n  });\n\n  eventBus.on('bendpoint.move.hover', function(e) {\n    var context = e.context;\n\n    context.hover = e.hover;\n\n    if (e.hover) {\n      canvas.addMarker(e.hover, MARKER_CONNECT_HOVER);\n\n      // asks whether reconnect / bendpoint move / bendpoint add\n      // is allowed at the given position\n      var allowed = context.allowed = rules.allowed(context.type, context);\n\n      if (allowed) {\n        canvas.removeMarker(context.hover, MARKER_NOT_OK);\n        canvas.addMarker(context.hover, MARKER_OK);\n\n        context.target = context.hover;\n      } else if (allowed === false) {\n        canvas.removeMarker(context.hover, MARKER_OK);\n        canvas.addMarker(context.hover, MARKER_NOT_OK);\n\n        context.target = null;\n      }\n    }\n  });\n\n  eventBus.on([\n    'bendpoint.move.out',\n    'bendpoint.move.cleanup'\n  ], function(e) {\n\n    // remove connect marker\n    // if it was added\n    var hover = e.context.hover;\n\n    if (hover) {\n      canvas.removeMarker(hover, MARKER_CONNECT_HOVER);\n      canvas.removeMarker(hover, e.context.target ? MARKER_OK : MARKER_NOT_OK);\n    }\n  });\n\n  eventBus.on('bendpoint.move.move', function(e) {\n\n    var context = e.context,\n        moveType = context.type,\n        connection = e.connection,\n        source, target;\n\n    connection.waypoints[context.bendpointIndex] = { x: e.x, y: e.y };\n\n    if (connectionDocking) {\n\n      if (context.hover) {\n        if (moveType === COMMAND_RECONNECT_START) {\n          source = context.hover;\n        }\n\n        if (moveType === COMMAND_RECONNECT_END) {\n          target = context.hover;\n        }\n      }\n\n      connection.waypoints = connectionDocking.getCroppedWaypoints(connection, source, target);\n    }\n\n    // add dragger gfx\n    translate(context.draggerGfx, e.x, e.y);\n\n    redrawConnection(e);\n  });\n\n  eventBus.on([\n    'bendpoint.move.end',\n    'bendpoint.move.cancel'\n  ], function(e) {\n\n    var context = e.context,\n        hover = context.hover,\n        connection = context.connection;\n\n    // remove dragger gfx\n    svgRemove(context.draggerGfx);\n    context.newWaypoints = connection.waypoints.slice();\n    connection.waypoints = context.originalWaypoints;\n    canvas.removeMarker(connection, MARKER_CONNECT_UPDATING);\n\n    if (hover) {\n      canvas.removeMarker(hover, MARKER_OK);\n      canvas.removeMarker(hover, MARKER_NOT_OK);\n    }\n  });\n\n  eventBus.on('bendpoint.move.end', function(e) {\n\n    var context = e.context,\n        waypoints = context.newWaypoints,\n        bendpointIndex = context.bendpointIndex,\n        bendpoint = waypoints[bendpointIndex],\n        allowed = context.allowed,\n        hints;\n\n    // ensure we have actual pixel values bendpoint\n    // coordinates (important when zoom level was > 1 during move)\n    bendpoint.x = round(bendpoint.x);\n    bendpoint.y = round(bendpoint.y);\n\n    if (allowed && context.type === COMMAND_RECONNECT_START) {\n      modeling.reconnectStart(context.connection, context.target, bendpoint);\n    } else\n    if (allowed && context.type === COMMAND_RECONNECT_END) {\n      modeling.reconnectEnd(context.connection, context.target, bendpoint);\n    } else\n    if (allowed !== false && context.type === COMMAND_BENDPOINT_UPDATE) {\n\n      // pass hints on the actual moved bendpoint\n      // this is useful for connection and label layouting\n      hints = {\n        bendpointMove: {\n          insert: e.context.insert,\n          bendpointIndex: bendpointIndex\n        }\n      };\n\n      modeling.updateWaypoints(context.connection, filterRedundantWaypoints(waypoints), hints);\n    } else {\n      redrawConnection(e);\n\n      return false;\n    }\n  });\n\n  eventBus.on('bendpoint.move.cancel', function(e) {\n    redrawConnection(e);\n  });\n}\n\nBendpointMove.$inject = [\n  'injector',\n  'eventBus',\n  'canvas',\n  'dragging',\n  'graphicsFactory',\n  'rules',\n  'modeling'\n];","import {\n  assign,\n  forEach,\n  isArray\n} from 'min-dash';\n\nvar abs= Math.abs,\n    round = Math.round;\n\nvar TOLERANCE = 10;\n\n\nexport default function BendpointSnapping(eventBus) {\n\n  function snapTo(values, value) {\n\n    if (isArray(values)) {\n      var i = values.length;\n\n      while (i--) if (abs(values[i] - value) <= TOLERANCE) {\n        return values[i];\n      }\n    } else {\n      values = +values;\n      var rem = value % values;\n\n      if (rem < TOLERANCE) {\n        return value - rem;\n      }\n\n      if (rem > values - TOLERANCE) {\n        return value - rem + values;\n      }\n    }\n\n    return value;\n  }\n\n  function mid(element) {\n    if (element.width) {\n      return {\n        x: round(element.width / 2 + element.x),\n        y: round(element.height / 2 + element.y)\n      };\n    }\n  }\n\n  // connection segment snapping //////////////////////\n\n  function getConnectionSegmentSnaps(context) {\n\n    var snapPoints = context.snapPoints,\n        connection = context.connection,\n        waypoints = connection.waypoints,\n        segmentStart = context.segmentStart,\n        segmentStartIndex = context.segmentStartIndex,\n        segmentEnd = context.segmentEnd,\n        segmentEndIndex = context.segmentEndIndex,\n        axis = context.axis;\n\n    if (snapPoints) {\n      return snapPoints;\n    }\n\n    var referenceWaypoints = [\n      waypoints[segmentStartIndex - 1],\n      segmentStart,\n      segmentEnd,\n      waypoints[segmentEndIndex + 1]\n    ];\n\n    if (segmentStartIndex < 2) {\n      referenceWaypoints.unshift(mid(connection.source));\n    }\n\n    if (segmentEndIndex > waypoints.length - 3) {\n      referenceWaypoints.unshift(mid(connection.target));\n    }\n\n    context.snapPoints = snapPoints = { horizontal: [] , vertical: [] };\n\n    forEach(referenceWaypoints, function(p) {\n      // we snap on existing bendpoints only,\n      // not placeholders that are inserted during add\n      if (p) {\n        p = p.original || p;\n\n        if (axis === 'y') {\n          snapPoints.horizontal.push(p.y);\n        }\n\n        if (axis === 'x') {\n          snapPoints.vertical.push(p.x);\n        }\n      }\n    });\n\n    return snapPoints;\n  }\n\n  eventBus.on('connectionSegment.move.move', 1500, function(event) {\n    var context = event.context,\n        snapPoints = getConnectionSegmentSnaps(context),\n        x = event.x,\n        y = event.y,\n        sx, sy;\n\n    if (!snapPoints) {\n      return;\n    }\n\n    // snap\n    sx = snapTo(snapPoints.vertical, x);\n    sy = snapTo(snapPoints.horizontal, y);\n\n\n    // correction x/y\n    var cx = (x - sx),\n        cy = (y - sy);\n\n    // update delta\n    assign(event, {\n      dx: event.dx - cx,\n      dy: event.dy - cy,\n      x: sx,\n      y: sy\n    });\n  });\n\n\n  // bendpoint snapping //////////////////////\n\n  function getBendpointSnaps(context) {\n\n    var snapPoints = context.snapPoints,\n        waypoints = context.connection.waypoints,\n        bendpointIndex = context.bendpointIndex;\n\n    if (snapPoints) {\n      return snapPoints;\n    }\n\n    var referenceWaypoints = [ waypoints[bendpointIndex - 1], waypoints[bendpointIndex + 1] ];\n\n    context.snapPoints = snapPoints = { horizontal: [] , vertical: [] };\n\n    forEach(referenceWaypoints, function(p) {\n      // we snap on existing bendpoints only,\n      // not placeholders that are inserted during add\n      if (p) {\n        p = p.original || p;\n\n        snapPoints.horizontal.push(p.y);\n        snapPoints.vertical.push(p.x);\n      }\n    });\n\n    return snapPoints;\n  }\n\n\n  eventBus.on('bendpoint.move.move', 1500, function(event) {\n\n    var context = event.context,\n        snapPoints = getBendpointSnaps(context),\n        target = context.target,\n        targetMid = target && mid(target),\n        x = event.x,\n        y = event.y,\n        sx, sy;\n\n    if (!snapPoints) {\n      return;\n    }\n\n    // snap\n    sx = snapTo(targetMid ? snapPoints.vertical.concat([ targetMid.x ]) : snapPoints.vertical, x);\n    sy = snapTo(targetMid ? snapPoints.horizontal.concat([ targetMid.y ]) : snapPoints.horizontal, y);\n\n\n    // correction x/y\n    var cx = (x - sx),\n        cy = (y - sy);\n\n    // update delta\n    assign(event, {\n      dx: event.dx - cx,\n      dy: event.dy - cy,\n      x: event.x - cx,\n      y: event.y - cy\n    });\n  });\n}\n\n\nBendpointSnapping.$inject = [ 'eventBus' ];","import {\n  toPoint\n} from '../../util/Event';\n\nimport {\n  getMidPoint,\n  pointsAligned\n} from '../../util/Geometry';\n\nimport {\n  append as svgAppend,\n  attr as svgAttr,\n  classes as svgClasses,\n  create as svgCreate\n} from 'tiny-svg';\n\nimport {\n  rotate,\n  translate\n} from '../../util/SvgTransformUtil';\n\n\nexport var BENDPOINT_CLS = 'djs-bendpoint';\nexport var SEGMENT_DRAGGER_CLS = 'djs-segment-dragger';\n\nexport function toCanvasCoordinates(canvas, event) {\n\n  var position = toPoint(event),\n      clientRect = canvas._container.getBoundingClientRect(),\n      offset;\n\n  // canvas relative position\n\n  offset = {\n    x: clientRect.left,\n    y: clientRect.top\n  };\n\n  // update actual event payload with canvas relative measures\n\n  var viewbox = canvas.viewbox();\n\n  return {\n    x: viewbox.x + (position.x - offset.x) / viewbox.scale,\n    y: viewbox.y + (position.y - offset.y) / viewbox.scale\n  };\n}\n\nexport function addBendpoint(parentGfx, cls) {\n  var groupGfx = svgCreate('g');\n  svgClasses(groupGfx).add(BENDPOINT_CLS);\n\n  svgAppend(parentGfx, groupGfx);\n\n  var visual = svgCreate('circle');\n  svgAttr(visual, {\n    cx: 0,\n    cy: 0,\n    r: 4\n  });\n  svgClasses(visual).add('djs-visual');\n\n  svgAppend(groupGfx, visual);\n\n  var hit = svgCreate('circle');\n  svgAttr(hit, {\n    cx: 0,\n    cy: 0,\n    r: 10\n  });\n  svgClasses(hit).add('djs-hit');\n\n  svgAppend(groupGfx, hit);\n\n  if (cls) {\n    svgClasses(groupGfx).add(cls);\n  }\n\n  return groupGfx;\n}\n\nfunction createParallelDragger(parentGfx, position, alignment) {\n  var draggerGfx = svgCreate('g');\n\n  svgAppend(parentGfx, draggerGfx);\n\n  var width = 14,\n      height = 3,\n      padding = 6,\n      hitWidth = width + padding,\n      hitHeight = height + padding;\n\n  var visual = svgCreate('rect');\n  svgAttr(visual, {\n    x: -width / 2,\n    y: -height / 2,\n    width: width,\n    height: height\n  });\n  svgClasses(visual).add('djs-visual');\n\n  svgAppend(draggerGfx, visual);\n\n  var hit = svgCreate('rect');\n  svgAttr(hit, {\n    x: -hitWidth / 2,\n    y: -hitHeight / 2,\n    width: hitWidth,\n    height: hitHeight\n  });\n  svgClasses(hit).add('djs-hit');\n\n  svgAppend(draggerGfx, hit);\n\n  rotate(draggerGfx, alignment === 'h' ? 90 : 0, 0, 0);\n\n  return draggerGfx;\n}\n\n\nexport function addSegmentDragger(parentGfx, segmentStart, segmentEnd) {\n\n  var groupGfx = svgCreate('g'),\n      mid = getMidPoint(segmentStart, segmentEnd),\n      alignment = pointsAligned(segmentStart, segmentEnd);\n\n  svgAppend(parentGfx, groupGfx);\n\n  createParallelDragger(groupGfx, mid, alignment);\n\n  svgClasses(groupGfx).add(SEGMENT_DRAGGER_CLS);\n  svgClasses(groupGfx).add(alignment === 'h' ? 'vertical' : 'horizontal');\n\n  translate(groupGfx, mid.x, mid.y);\n\n  return groupGfx;\n}\n","import { forEach } from 'min-dash';\n\nimport {\n  event as domEvent,\n  query as domQuery,\n  queryAll as domQueryAll\n} from 'min-dom';\n\nimport {\n  BENDPOINT_CLS,\n  SEGMENT_DRAGGER_CLS,\n  addBendpoint,\n  addSegmentDragger,\n  toCanvasCoordinates\n} from './BendpointUtil';\n\nimport cssEscape from 'css.escape';\n\nimport {\n  pointsAligned,\n  getMidPoint\n} from '../../util/Geometry';\n\nimport {\n  getApproxIntersection\n} from '../../util/LineIntersection';\n\nimport {\n  append as svgAppend,\n  attr as svgAttr,\n  classes as svgClasses,\n  create as svgCreate,\n  remove as svgRemove\n} from 'tiny-svg';\n\nimport { translate } from '../../util/SvgTransformUtil';\n\n\n/**\n * A service that adds editable bendpoints to connections.\n */\nexport default function Bendpoints(\n    eventBus, canvas, interactionEvents,\n    bendpointMove, connectionSegmentMove) {\n\n  function getConnectionIntersection(waypoints, event) {\n    var localPosition = toCanvasCoordinates(canvas, event),\n        intersection = getApproxIntersection(waypoints, localPosition);\n\n    return intersection;\n  }\n\n  function isIntersectionMiddle(intersection, waypoints, treshold) {\n    var idx = intersection.index,\n        p = intersection.point,\n        p0, p1, mid, aligned, xDelta, yDelta;\n\n    if (idx <= 0 || intersection.bendpoint) {\n      return false;\n    }\n\n    p0 = waypoints[idx - 1];\n    p1 = waypoints[idx];\n    mid = getMidPoint(p0, p1),\n    aligned = pointsAligned(p0, p1);\n    xDelta = Math.abs(p.x - mid.x);\n    yDelta = Math.abs(p.y - mid.y);\n\n    return aligned && xDelta <= treshold && yDelta <= treshold;\n  }\n\n  function activateBendpointMove(event, connection) {\n    var waypoints = connection.waypoints,\n        intersection = getConnectionIntersection(waypoints, event);\n\n    if (!intersection) {\n      return;\n    }\n\n    if (isIntersectionMiddle(intersection, waypoints, 10)) {\n      connectionSegmentMove.start(event, connection, intersection.index);\n    } else {\n      bendpointMove.start(event, connection, intersection.index, !intersection.bendpoint);\n    }\n\n    // we've handled the event\n    return true;\n  }\n\n  function bindInteractionEvents(node, eventName, element) {\n\n    domEvent.bind(node, eventName, function(event) {\n      interactionEvents.triggerMouseEvent(eventName, event, element);\n      event.stopPropagation();\n    });\n  }\n\n  function getBendpointsContainer(element, create) {\n\n    var layer = canvas.getLayer('overlays'),\n        gfx = domQuery('.djs-bendpoints[data-element-id=\"' + cssEscape(element.id) + '\"]', layer);\n\n    if (!gfx && create) {\n      gfx = svgCreate('g');\n      svgAttr(gfx, { 'data-element-id': element.id });\n      svgClasses(gfx).add('djs-bendpoints');\n\n      svgAppend(layer, gfx);\n\n      bindInteractionEvents(gfx, 'mousedown', element);\n      bindInteractionEvents(gfx, 'click', element);\n      bindInteractionEvents(gfx, 'dblclick', element);\n    }\n\n    return gfx;\n  }\n\n  function createBendpoints(gfx, connection) {\n    connection.waypoints.forEach(function(p, idx) {\n      var bendpoint = addBendpoint(gfx);\n\n      svgAppend(gfx, bendpoint);\n\n      translate(bendpoint, p.x, p.y);\n    });\n\n    // add floating bendpoint\n    addBendpoint(gfx, 'floating');\n  }\n\n  function createSegmentDraggers(gfx, connection) {\n\n    var waypoints = connection.waypoints;\n\n    var segmentStart,\n        segmentEnd;\n\n    for (var i = 1; i < waypoints.length; i++) {\n\n      segmentStart = waypoints[i - 1];\n      segmentEnd = waypoints[i];\n\n      if (pointsAligned(segmentStart, segmentEnd)) {\n        addSegmentDragger(gfx, segmentStart, segmentEnd);\n      }\n    }\n  }\n\n  function clearBendpoints(gfx) {\n    forEach(domQueryAll('.' + BENDPOINT_CLS, gfx), function(node) {\n      svgRemove(node);\n    });\n  }\n\n  function clearSegmentDraggers(gfx) {\n    forEach(domQueryAll('.' + SEGMENT_DRAGGER_CLS, gfx), function(node) {\n      svgRemove(node);\n    });\n  }\n\n  function addHandles(connection) {\n\n    var gfx = getBendpointsContainer(connection);\n\n    if (!gfx) {\n      gfx = getBendpointsContainer(connection, true);\n\n      createBendpoints(gfx, connection);\n      createSegmentDraggers(gfx, connection);\n    }\n\n    return gfx;\n  }\n\n  function updateHandles(connection) {\n\n    var gfx = getBendpointsContainer(connection);\n\n    if (gfx) {\n      clearSegmentDraggers(gfx);\n      clearBendpoints(gfx);\n      createSegmentDraggers(gfx, connection);\n      createBendpoints(gfx, connection);\n    }\n  }\n\n  eventBus.on('connection.changed', function(event) {\n    updateHandles(event.element);\n  });\n\n  eventBus.on('connection.remove', function(event) {\n    var gfx = getBendpointsContainer(event.element);\n\n    if (gfx) {\n      svgRemove(gfx);\n    }\n  });\n\n  eventBus.on('element.marker.update', function(event) {\n\n    var element = event.element,\n        bendpointsGfx;\n\n    if (!element.waypoints) {\n      return;\n    }\n\n    bendpointsGfx = addHandles(element);\n\n    if (event.add) {\n      svgClasses(bendpointsGfx).add(event.marker);\n    } else {\n      svgClasses(bendpointsGfx).remove(event.marker);\n    }\n  });\n\n  eventBus.on('element.mousemove', function(event) {\n\n    var element = event.element,\n        waypoints = element.waypoints,\n        bendpointsGfx,\n        floating,\n        intersection;\n\n    if (waypoints) {\n      bendpointsGfx = getBendpointsContainer(element, true);\n      floating = domQuery('.floating', bendpointsGfx);\n\n      if (!floating) {\n        return;\n      }\n\n      intersection = getConnectionIntersection(waypoints, event.originalEvent);\n\n      if (intersection) {\n        translate(floating, intersection.point.x, intersection.point.y);\n      }\n    }\n  });\n\n  eventBus.on('element.mousedown', function(event) {\n\n    var originalEvent = event.originalEvent,\n        element = event.element,\n        waypoints = element.waypoints;\n\n    if (!waypoints) {\n      return;\n    }\n\n    return activateBendpointMove(originalEvent, element, waypoints);\n  });\n\n  eventBus.on('selection.changed', function(event) {\n    var newSelection = event.newSelection,\n        primary = newSelection[0];\n\n    if (primary && primary.waypoints) {\n      addHandles(primary);\n    }\n  });\n\n  eventBus.on('element.hover', function(event) {\n    var element = event.element;\n\n    if (element.waypoints) {\n      addHandles(element);\n      interactionEvents.registerEvent(event.gfx, 'mousemove', 'element.mousemove');\n    }\n  });\n\n  eventBus.on('element.out', function(event) {\n    interactionEvents.unregisterEvent(event.gfx, 'mousemove', 'element.mousemove');\n  });\n\n  // update bendpoint container data attribute on element ID change\n  eventBus.on('element.updateId', function(context) {\n    var element = context.element,\n        newId = context.newId;\n\n    if (element.waypoints) {\n      var bendpointContainer = getBendpointsContainer(element);\n\n      if (bendpointContainer) {\n        svgAttr(bendpointContainer, { 'data-element-id': newId });\n      }\n    }\n  });\n\n  // API\n\n  this.addHandles = addHandles;\n  this.updateHandles = updateHandles;\n  this.getBendpointsContainer = getBendpointsContainer;\n}\n\nBendpoints.$inject = [\n  'eventBus',\n  'canvas',\n  'interactionEvents',\n  'bendpointMove',\n  'connectionSegmentMove'\n];\n","import {\n  pointsAligned,\n  pointsOnLine\n} from '../../util/Geometry';\n\nimport {\n  addSegmentDragger\n} from './BendpointUtil';\n\nimport {\n  getMid,\n  getOrientation\n} from '../../layout/LayoutUtil';\n\nvar MARKER_CONNECT_HOVER = 'connect-hover',\n    MARKER_CONNECT_UPDATING = 'djs-updating';\n\nimport {\n  classes as svgClasses,\n  remove as svgRemove\n} from 'tiny-svg';\n\nimport {\n  translate\n} from '../../util/SvgTransformUtil';\n\n\nfunction axisAdd(point, axis, delta) {\n  return axisSet(point, axis, point[axis] + delta);\n}\n\nfunction axisSet(point, axis, value) {\n  return {\n    x: (axis === 'x' ? value : point.x),\n    y: (axis === 'y' ? value : point.y)\n  };\n}\n\nfunction axisFenced(position, segmentStart, segmentEnd, axis) {\n\n  var maxValue = Math.max(segmentStart[axis], segmentEnd[axis]),\n      minValue = Math.min(segmentStart[axis], segmentEnd[axis]);\n\n  var padding = 20;\n\n  var fencedValue = Math.min(Math.max(minValue + padding, position[axis]), maxValue - padding);\n\n  return axisSet(segmentStart, axis, fencedValue);\n}\n\nfunction flipAxis(axis) {\n  return axis === 'x' ? 'y' : 'x';\n}\n\n/**\n * Get the docking point on the given element.\n *\n * Compute a reasonable docking, if non exists.\n *\n * @param  {Point} point\n * @param  {djs.model.Shape} referenceElement\n * @param  {String} moveAxis (x|y)\n *\n * @return {Point}\n */\nfunction getDocking(point, referenceElement, moveAxis) {\n\n  var referenceMid,\n      inverseAxis;\n\n  if (point.original) {\n    return point.original;\n  } else {\n    referenceMid = getMid(referenceElement);\n    inverseAxis = flipAxis(moveAxis);\n\n    return axisSet(point, inverseAxis, referenceMid[inverseAxis]);\n  }\n}\n\n/**\n * A component that implements moving of bendpoints\n */\nexport default function ConnectionSegmentMove(\n    injector, eventBus, canvas,\n    dragging, graphicsFactory, rules,\n    modeling) {\n\n  // optional connection docking integration\n  var connectionDocking = injector.get('connectionDocking', false);\n\n\n  // API\n\n  this.start = function(event, connection, idx) {\n\n    var context,\n        gfx = canvas.getGraphics(connection),\n        segmentStartIndex = idx - 1,\n        segmentEndIndex = idx,\n        waypoints = connection.waypoints,\n        segmentStart = waypoints[segmentStartIndex],\n        segmentEnd = waypoints[segmentEndIndex],\n        direction,\n        axis;\n\n    direction = pointsAligned(segmentStart, segmentEnd);\n\n    // do not move diagonal connection\n    if (!direction) {\n      return;\n    }\n\n    // the axis where we are going to move things\n    axis = direction === 'v' ? 'y' : 'x';\n\n    if (segmentStartIndex === 0) {\n      segmentStart = getDocking(segmentStart, connection.source, axis);\n    }\n\n    if (segmentEndIndex === waypoints.length - 1) {\n      segmentEnd = getDocking(segmentEnd, connection.target, axis);\n    }\n\n    context = {\n      connection: connection,\n      segmentStartIndex: segmentStartIndex,\n      segmentEndIndex: segmentEndIndex,\n      segmentStart: segmentStart,\n      segmentEnd: segmentEnd,\n      axis: axis\n    };\n\n    dragging.init(event, {\n      x: (segmentStart.x + segmentEnd.x)/2,\n      y: (segmentStart.y + segmentEnd.y)/2\n    }, 'connectionSegment.move', {\n      cursor: axis === 'x' ? 'resize-ew' : 'resize-ns',\n      data: {\n        connection: connection,\n        connectionGfx: gfx,\n        context: context\n      }\n    });\n  };\n\n  /**\n   * Crop connection if connection cropping is provided.\n   *\n   * @param {Connection} connection\n   * @param {Array<Point>} newWaypoints\n   *\n   * @return {Array<Point>} cropped connection waypoints\n   */\n  function cropConnection(connection, newWaypoints) {\n\n    // crop connection, if docking service is provided only\n    if (!connectionDocking) {\n      return newWaypoints;\n    }\n\n    var oldWaypoints = connection.waypoints,\n        croppedWaypoints;\n\n    // temporary set new waypoints\n    connection.waypoints = newWaypoints;\n\n    croppedWaypoints = connectionDocking.getCroppedWaypoints(connection);\n\n    // restore old waypoints\n    connection.waypoints = oldWaypoints;\n\n    return croppedWaypoints;\n  }\n\n  // DRAGGING IMPLEMENTATION\n\n  function redrawConnection(data) {\n    graphicsFactory.update('connection', data.connection, data.connectionGfx);\n  }\n\n  function updateDragger(context, segmentOffset, event) {\n\n    var newWaypoints = context.newWaypoints,\n        segmentStartIndex = context.segmentStartIndex + segmentOffset,\n        segmentStart = newWaypoints[segmentStartIndex],\n        segmentEndIndex = context.segmentEndIndex + segmentOffset,\n        segmentEnd = newWaypoints[segmentEndIndex],\n        axis = flipAxis(context.axis);\n\n    // make sure the dragger does not move\n    // outside the connection\n    var draggerPosition = axisFenced(event, segmentStart, segmentEnd, axis);\n\n    // update dragger\n    translate(context.draggerGfx, draggerPosition.x, draggerPosition.y);\n  }\n\n  /**\n   * Filter waypoints for redundant ones (i.e. on the same axis).\n   * Returns the filtered waypoints and the offset related to the segment move.\n   *\n   * @param {Array<Point>} waypoints\n   * @param {Integer} segmentStartIndex of moved segment start\n   *\n   * @return {Object} { filteredWaypoints, segmentOffset }\n   */\n  function filterRedundantWaypoints(waypoints, segmentStartIndex) {\n\n    var segmentOffset = 0;\n\n    var filteredWaypoints = waypoints.filter(function(r, idx) {\n      if (pointsOnLine(waypoints[idx - 1], waypoints[idx + 1], r)) {\n\n        // remove point and increment offset\n        segmentOffset = idx <= segmentStartIndex ? segmentOffset - 1 : segmentOffset;\n        return false;\n      }\n\n      // dont remove point\n      return true;\n    });\n\n    return {\n      waypoints: filteredWaypoints,\n      segmentOffset: segmentOffset\n    };\n  }\n\n  eventBus.on('connectionSegment.move.start', function(e) {\n\n    var context = e.context,\n        connection = e.connection,\n        layer = canvas.getLayer('overlays');\n\n    context.originalWaypoints = connection.waypoints.slice();\n\n    // add dragger gfx\n    context.draggerGfx = addSegmentDragger(layer, context.segmentStart, context.segmentEnd);\n    svgClasses(context.draggerGfx).add('djs-dragging');\n\n    canvas.addMarker(connection, MARKER_CONNECT_UPDATING);\n  });\n\n  eventBus.on('connectionSegment.move.move', function(e) {\n\n    var context = e.context,\n        connection = context.connection,\n        segmentStartIndex = context.segmentStartIndex,\n        segmentEndIndex = context.segmentEndIndex,\n        segmentStart = context.segmentStart,\n        segmentEnd = context.segmentEnd,\n        axis = context.axis;\n\n    var newWaypoints = context.originalWaypoints.slice(),\n        newSegmentStart = axisAdd(segmentStart, axis, e['d' + axis]),\n        newSegmentEnd = axisAdd(segmentEnd, axis, e['d' + axis]);\n\n    // original waypoint count and added / removed\n    // from start waypoint delta. We use the later\n    // to retrieve the updated segmentStartIndex / segmentEndIndex\n    var waypointCount = newWaypoints.length,\n        segmentOffset = 0;\n\n    // move segment start / end by axis delta\n    newWaypoints[segmentStartIndex] = newSegmentStart;\n    newWaypoints[segmentEndIndex] = newSegmentEnd;\n\n    var sourceToSegmentOrientation,\n        targetToSegmentOrientation;\n\n    // handle first segment\n    if (segmentStartIndex < 2) {\n      sourceToSegmentOrientation = getOrientation(connection.source, newSegmentStart);\n\n      // first bendpoint, remove first segment if intersecting\n      if (segmentStartIndex === 1) {\n\n        if (sourceToSegmentOrientation === 'intersect') {\n          newWaypoints.shift();\n          newWaypoints[0] = newSegmentStart;\n          segmentOffset--;\n        }\n      }\n\n      // docking point, add segment if not intersecting anymore\n      else {\n        if (sourceToSegmentOrientation !== 'intersect') {\n          newWaypoints.unshift(segmentStart);\n          segmentOffset++;\n        }\n      }\n    }\n\n    // handle last segment\n    if (segmentEndIndex > waypointCount - 3) {\n      targetToSegmentOrientation = getOrientation(connection.target, newSegmentEnd);\n\n      // last bendpoint, remove last segment if intersecting\n      if (segmentEndIndex === waypointCount - 2) {\n\n        if (targetToSegmentOrientation === 'intersect') {\n          newWaypoints.pop();\n          newWaypoints[newWaypoints.length - 1] = newSegmentEnd;\n        }\n      }\n\n      // last bendpoint, remove last segment if intersecting\n      else {\n        if (targetToSegmentOrientation !== 'intersect') {\n          newWaypoints.push(segmentEnd);\n        }\n      }\n    }\n\n    // update connection waypoints\n    context.newWaypoints = connection.waypoints = cropConnection(connection, newWaypoints);\n\n    // update dragger position\n    updateDragger(context, segmentOffset, e);\n\n    // save segmentOffset in context\n    context.newSegmentStartIndex = segmentStartIndex + segmentOffset;\n\n    // redraw connection\n    redrawConnection(e);\n  });\n\n  eventBus.on('connectionSegment.move.hover', function(e) {\n\n    e.context.hover = e.hover;\n    canvas.addMarker(e.hover, MARKER_CONNECT_HOVER);\n  });\n\n  eventBus.on([\n    'connectionSegment.move.out',\n    'connectionSegment.move.cleanup'\n  ], function(e) {\n\n    // remove connect marker\n    // if it was added\n    var hover = e.context.hover;\n\n    if (hover) {\n      canvas.removeMarker(hover, MARKER_CONNECT_HOVER);\n    }\n  });\n\n  eventBus.on('connectionSegment.move.cleanup', function(e) {\n\n    var context = e.context,\n        connection = context.connection;\n\n    // remove dragger gfx\n    if (context.draggerGfx) {\n      svgRemove(context.draggerGfx);\n    }\n\n    canvas.removeMarker(connection, MARKER_CONNECT_UPDATING);\n  });\n\n  eventBus.on([\n    'connectionSegment.move.cancel',\n    'connectionSegment.move.end'\n  ], function(e) {\n    var context = e.context,\n        connection = context.connection;\n\n    connection.waypoints = context.originalWaypoints;\n\n    redrawConnection(e);\n  });\n\n  eventBus.on('connectionSegment.move.end', function(e) {\n\n    var context = e.context,\n        connection = context.connection,\n        newWaypoints = context.newWaypoints,\n        newSegmentStartIndex = context.newSegmentStartIndex;\n\n    // ensure we have actual pixel values bendpoint\n    // coordinates (important when zoom level was > 1 during move)\n    newWaypoints = newWaypoints.map(function(p) {\n      return {\n        original: p.original,\n        x: Math.round(p.x),\n        y: Math.round(p.y)\n      };\n    });\n\n    // apply filter redunant waypoints\n    var filtered = filterRedundantWaypoints(newWaypoints, newSegmentStartIndex);\n\n    // get filtered waypoints\n    var filteredWaypoints = filtered.waypoints,\n        croppedWaypoints = cropConnection(connection, filteredWaypoints),\n        segmentOffset = filtered.segmentOffset;\n\n    var hints = {\n      segmentMove: {\n        segmentStartIndex: context.segmentStartIndex,\n        newSegmentStartIndex: newSegmentStartIndex + segmentOffset\n      }\n    };\n\n    modeling.updateWaypoints(connection, croppedWaypoints, hints);\n  });\n}\n\nConnectionSegmentMove.$inject = [\n  'injector',\n  'eventBus',\n  'canvas',\n  'dragging',\n  'graphicsFactory',\n  'rules',\n  'modeling'\n];\n","import DraggingModule from '../dragging';\nimport RulesModule from '../rules';\n\nimport Bendpoints from './Bendpoints';\nimport BendpointMove from './BendpointMove';\nimport ConnectionSegmentMove from './ConnectionSegmentMove';\nimport BendpointSnapping from './BendpointSnapping';\n\n\nexport default {\n  __depends__: [\n    DraggingModule,\n    RulesModule\n  ],\n  __init__: [ 'bendpoints', 'bendpointSnapping' ],\n  bendpoints: [ 'type', Bendpoints ],\n  bendpointMove: [ 'type', BendpointMove ],\n  connectionSegmentMove: [ 'type', ConnectionSegmentMove ],\n  bendpointSnapping: [ 'type', BendpointSnapping ]\n};\n","import {\n  getType as getElementType\n} from '../../util/Elements';\n\n/**\n * Adds change support to the diagram, including\n *\n * <ul>\n *   <li>redrawing shapes and connections on change</li>\n * </ul>\n *\n * @param {EventBus} eventBus\n * @param {Canvas} canvas\n * @param {ElementRegistry} elementRegistry\n * @param {GraphicsFactory} graphicsFactory\n */\nexport default function ChangeSupport(\n    eventBus, canvas, elementRegistry,\n    graphicsFactory) {\n\n\n  // redraw shapes / connections on change\n\n  eventBus.on('element.changed', function(event) {\n\n    var element = event.element;\n\n    // element might have been deleted and replaced by new element with same ID\n    // thus check for parent of element except for root element\n    if (element.parent || element === canvas.getRootElement()) {\n      event.gfx = elementRegistry.getGraphics(element);\n    }\n\n    // shape + gfx may have been deleted\n    if (!event.gfx) {\n      return;\n    }\n\n    eventBus.fire(getElementType(element) + '.changed', event);\n  });\n\n  eventBus.on('elements.changed', function(event) {\n\n    var elements = event.elements;\n\n    elements.forEach(function(e) {\n      eventBus.fire('element.changed', { element: e });\n    });\n\n    graphicsFactory.updateContainments(elements);\n  });\n\n  eventBus.on('shape.changed', function(event) {\n    graphicsFactory.update('shape', event.element, event.gfx);\n  });\n\n  eventBus.on('connection.changed', function(event) {\n    graphicsFactory.update('connection', event.element, event.gfx);\n  });\n}\n\nChangeSupport.$inject = [\n  'eventBus',\n  'canvas',\n  'elementRegistry',\n  'graphicsFactory'\n];","import ChangeSupport from './ChangeSupport';\n\nexport default {\n  __init__: [ 'changeSupport'],\n  changeSupport: [ 'type', ChangeSupport ]\n};","/**\n * A clip board stub\n */\nexport default function Clipboard() {}\n\n\nClipboard.prototype.get = function() {\n  return this._data;\n};\n\nClipboard.prototype.set = function(data) {\n  this._data = data;\n};\n\nClipboard.prototype.clear = function() {\n  var data = this._data;\n\n  delete this._data;\n\n  return data;\n};\n\nClipboard.prototype.isEmpty = function() {\n  return !this._data;\n};","import Clipboard from './Clipboard';\n\nexport default {\n  clipboard: [ 'type', Clipboard ]\n};\n","import {\n  getElementLineIntersection\n} from '../../layout/LayoutUtil';\n\nimport {\n  getMid\n} from '../../layout/LayoutUtil';\n\nvar MARKER_OK = 'connect-ok',\n    MARKER_NOT_OK = 'connect-not-ok';\n\nimport {\n  append as svgAppend,\n  attr as svgAttr,\n  create as svgCreate,\n  remove as svgRemove\n} from 'tiny-svg';\n\n\nexport default function Connect(\n    eventBus, dragging, modeling,\n    rules, canvas, graphicsFactory) {\n\n  // TODO(nre): separate UI and events\n\n  // rules\n\n  function canConnect(source, target) {\n    return rules.allowed('connection.create', {\n      source: source,\n      target: target\n    });\n  }\n\n\n  // layouting\n\n  function crop(start, end, source, target) {\n\n    var sourcePath = graphicsFactory.getShapePath(source),\n        targetPath = target && graphicsFactory.getShapePath(target),\n        connectionPath = graphicsFactory.getConnectionPath({ waypoints: [ start, end ] });\n\n    start = getElementLineIntersection(sourcePath, connectionPath, true) || start;\n    end = (target && getElementLineIntersection(targetPath, connectionPath, false)) || end;\n\n    return [ start, end ];\n  }\n\n\n  // event handlers\n\n  eventBus.on('connect.move', function(event) {\n\n    var context = event.context,\n        source = context.source,\n        target = context.target,\n        visual = context.visual,\n        sourcePosition = context.sourcePosition,\n        endPosition,\n        waypoints;\n\n    // update connection visuals during drag\n\n    endPosition = {\n      x: event.x,\n      y: event.y\n    };\n\n    waypoints = crop(sourcePosition, endPosition, source, target);\n\n    svgAttr(visual, { 'points': [ waypoints[0].x, waypoints[0].y, waypoints[1].x, waypoints[1].y ] });\n  });\n\n  eventBus.on('connect.hover', function(event) {\n    var context = event.context,\n        source = context.source,\n        hover = event.hover,\n        canExecute;\n\n    canExecute = context.canExecute = canConnect(source, hover);\n\n    // simply ignore hover\n    if (canExecute === null) {\n      return;\n    }\n\n    context.target = hover;\n\n    canvas.addMarker(hover, canExecute ? MARKER_OK : MARKER_NOT_OK);\n  });\n\n  eventBus.on([ 'connect.out', 'connect.cleanup' ], function(event) {\n    var context = event.context;\n\n    if (context.target) {\n      canvas.removeMarker(context.target, context.canExecute ? MARKER_OK : MARKER_NOT_OK);\n    }\n\n    context.target = null;\n    context.canExecute = false;\n  });\n\n  eventBus.on('connect.cleanup', function(event) {\n    var context = event.context;\n\n    if (context.visual) {\n      svgRemove(context.visual);\n    }\n  });\n\n  eventBus.on('connect.start', function(event) {\n    var context = event.context,\n        visual;\n\n    visual = svgCreate('polyline');\n    svgAttr(visual, {\n      'stroke': '#333',\n      'strokeDasharray': [ 1 ],\n      'strokeWidth': 2,\n      'pointer-events': 'none'\n    });\n\n    svgAppend(canvas.getDefaultLayer(), visual);\n\n    context.visual = visual;\n  });\n\n  eventBus.on('connect.end', function(event) {\n\n    var context = event.context,\n        source = context.source,\n        sourcePosition = context.sourcePosition,\n        target = context.target,\n        targetPosition = {\n          x: event.x,\n          y: event.y\n        },\n        canExecute = context.canExecute || canConnect(source, target);\n\n    if (!canExecute) {\n      return false;\n    }\n\n    var attrs = null,\n        hints = {\n          connectionStart: sourcePosition,\n          connectionEnd: targetPosition\n        };\n\n    if (typeof canExecute === 'object') {\n      attrs = canExecute;\n    }\n\n    modeling.connect(source, target, attrs, hints);\n  });\n\n\n  // API\n\n  /**\n   * Start connect operation.\n   *\n   * @param {DOMEvent} event\n   * @param {djs.model.Base} source\n   * @param {Point} [sourcePosition]\n   * @param {Boolean} [autoActivate=false]\n   */\n  this.start = function(event, source, sourcePosition, autoActivate) {\n\n    if (typeof sourcePosition !== 'object') {\n      autoActivate = sourcePosition;\n      sourcePosition = getMid(source);\n    }\n\n    dragging.init(event, 'connect', {\n      autoActivate: autoActivate,\n      data: {\n        shape: source,\n        context: {\n          source: source,\n          sourcePosition: sourcePosition\n        }\n      }\n    });\n  };\n}\n\nConnect.$inject = [\n  'eventBus',\n  'dragging',\n  'modeling',\n  'rules',\n  'canvas',\n  'graphicsFactory'\n];","import SelectionModule from '../selection';\nimport RulesModule from '../rules';\nimport DraggingModule from '../dragging';\n\nimport Connect from './Connect';\n\nexport default {\n  __depends__: [\n    SelectionModule,\n    RulesModule,\n    DraggingModule\n  ],\n  connect: [ 'type', Connect ]\n};\n","import {\n  assign,\n  isFunction,\n  isArray,\n  forEach,\n  isDefined\n} from 'min-dash';\n\nimport {\n  delegate as domDelegate,\n  event as domEvent,\n  attr as domAttr,\n  query as domQuery,\n  classes as domClasses,\n  domify as domify\n} from 'min-dom';\n\nvar entrySelector = '.entry';\n\n\n/**\n * A context pad that displays element specific, contextual actions next\n * to a diagram element.\n *\n * @param {Object} config\n * @param {Boolean|Object} [config.scale={ min: 1.0, max: 1.5 }]\n * @param {Number} [config.scale.min]\n * @param {Number} [config.scale.max]\n * @param {EventBus} eventBus\n * @param {Overlays} overlays\n */\nexport default function ContextPad(config, eventBus, overlays) {\n\n  this._providers = [];\n\n  this._eventBus = eventBus;\n  this._overlays = overlays;\n\n  var scale = isDefined(config && config.scale) ? config.scale : {\n    min: 1,\n    max: 1.5\n  };\n\n  this._overlaysConfig = {\n    position: {\n      right: -9,\n      top: -6\n    },\n    scale: scale\n  };\n\n  this._current = null;\n\n  this._init();\n}\n\nContextPad.$inject = [\n  'config.contextPad',\n  'eventBus',\n  'overlays'\n];\n\n\n/**\n * Registers events needed for interaction with other components\n */\nContextPad.prototype._init = function() {\n\n  var eventBus = this._eventBus;\n\n  var self = this;\n\n  eventBus.on('selection.changed', function(e) {\n\n    var selection = e.newSelection;\n\n    if (selection.length === 1) {\n      self.open(selection[0]);\n    } else {\n      self.close();\n    }\n  });\n\n  eventBus.on('elements.delete', function(event) {\n    var elements = event.elements;\n\n    forEach(elements, function(e) {\n      if (self.isOpen(e)) {\n        self.close();\n      }\n    });\n  });\n\n  eventBus.on('element.changed', function(event) {\n    var element = event.element,\n        current = self._current;\n\n    // force reopen if element for which we are currently opened changed\n    if (current && current.element === element) {\n      self.open(element, true);\n    }\n  });\n};\n\n\n/**\n * Register a provider with the context pad\n *\n * @param  {ContextPadProvider} provider\n */\nContextPad.prototype.registerProvider = function(provider) {\n  this._providers.push(provider);\n};\n\n\n/**\n * Returns the context pad entries for a given element\n *\n * @param {djs.element.Base} element\n *\n * @return {Array<ContextPadEntryDescriptor>} list of entries\n */\nContextPad.prototype.getEntries = function(element) {\n  var entries = {};\n\n  // loop through all providers and their entries.\n  // group entries by id so that overriding an entry is possible\n  forEach(this._providers, function(provider) {\n    var e = provider.getContextPadEntries(element);\n\n    forEach(e, function(entry, id) {\n      entries[id] = entry;\n    });\n  });\n\n  return entries;\n};\n\n\n/**\n * Trigger an action available on the opened context pad\n *\n * @param  {String} action\n * @param  {Event} event\n * @param  {Boolean} [autoActivate=false]\n */\nContextPad.prototype.trigger = function(action, event, autoActivate) {\n\n  var element = this._current.element,\n      entries = this._current.entries,\n      entry,\n      handler,\n      originalEvent,\n      button = event.delegateTarget || event.target;\n\n  if (!button) {\n    return event.preventDefault();\n  }\n\n  entry = entries[domAttr(button, 'data-action')];\n  handler = entry.action;\n\n  originalEvent = event.originalEvent || event;\n\n  // simple action (via callback function)\n  if (isFunction(handler)) {\n    if (action === 'click') {\n      return handler(originalEvent, element, autoActivate);\n    }\n  } else {\n    if (handler[action]) {\n      return handler[action](originalEvent, element, autoActivate);\n    }\n  }\n\n  // silence other actions\n  event.preventDefault();\n};\n\n\n/**\n * Open the context pad for the given element\n *\n * @param {djs.model.Base} element\n * @param {Boolean} force if true, force reopening the context pad\n */\nContextPad.prototype.open = function(element, force) {\n  if (!force && this.isOpen(element)) {\n    return;\n  }\n\n  this.close();\n  this._updateAndOpen(element);\n};\n\n\nContextPad.prototype._updateAndOpen = function(element) {\n\n  var entries = this.getEntries(element),\n      pad = this.getPad(element),\n      html = pad.html;\n\n  forEach(entries, function(entry, id) {\n    var grouping = entry.group || 'default',\n        control = domify(entry.html || '<div class=\"entry\" draggable=\"true\"></div>'),\n        container;\n\n    domAttr(control, 'data-action', id);\n\n    container = domQuery('[data-group=' + grouping + ']', html);\n    if (!container) {\n      container = domify('<div class=\"group\" data-group=\"' + grouping + '\"></div>');\n      html.appendChild(container);\n    }\n\n    container.appendChild(control);\n\n    if (entry.className) {\n      addClasses(control, entry.className);\n    }\n\n    if (entry.title) {\n      domAttr(control, 'title', entry.title);\n    }\n\n    if (entry.imageUrl) {\n      control.appendChild(domify('<img src=\"' + entry.imageUrl + '\">'));\n    }\n  });\n\n  domClasses(html).add('open');\n\n  this._current = {\n    element: element,\n    pad: pad,\n    entries: entries\n  };\n\n  this._eventBus.fire('contextPad.open', { current: this._current });\n};\n\n\nContextPad.prototype.getPad = function(element) {\n  if (this.isOpen()) {\n    return this._current.pad;\n  }\n\n  var self = this;\n\n  var overlays = this._overlays;\n\n  var html = domify('<div class=\"djs-context-pad\"></div>');\n\n  var overlaysConfig = assign({\n    html: html\n  }, this._overlaysConfig);\n\n  domDelegate.bind(html, entrySelector, 'click', function(event) {\n    self.trigger('click', event);\n  });\n\n  domDelegate.bind(html, entrySelector, 'dragstart', function(event) {\n    self.trigger('dragstart', event);\n  });\n\n  // stop propagation of mouse events\n  domEvent.bind(html, 'mousedown', function(event) {\n    event.stopPropagation();\n  });\n\n  this._overlayId = overlays.add(element, 'context-pad', overlaysConfig);\n\n  var pad = overlays.get(this._overlayId);\n\n  this._eventBus.fire('contextPad.create', { element: element, pad: pad });\n\n  return pad;\n};\n\n\n/**\n * Close the context pad\n */\nContextPad.prototype.close = function() {\n  if (!this.isOpen()) {\n    return;\n  }\n\n  this._overlays.remove(this._overlayId);\n\n  this._overlayId = null;\n\n  this._eventBus.fire('contextPad.close', { current: this._current });\n\n  this._current = null;\n};\n\n/**\n * Check if pad is open. If element is given, will check\n * if pad is opened with given element.\n *\n * @param {Element} element\n * @return {Boolean}\n */\nContextPad.prototype.isOpen = function(element) {\n  return !!this._current && (!element ? true : this._current.element === element);\n};\n\n\n\n\n// helpers //////////////////////\n\nfunction addClasses(element, classNames) {\n\n  var classes = domClasses(element);\n\n  var actualClassNames = isArray(classNames) ? classNames : classNames.split(/\\s+/g);\n  actualClassNames.forEach(function(cls) {\n    classes.add(cls);\n  });\n}","import InteractionEventsModule from '../interaction-events';\nimport OverlaysModule from '../overlays';\n\nimport ContextPad from './ContextPad';\n\n\nexport default {\n  __depends__: [\n    InteractionEventsModule,\n    OverlaysModule\n  ],\n  contextPad: [ 'type', ContextPad ]\n};","import {\n  isArray,\n  forEach,\n  map,\n  matchPattern,\n  find,\n  findIndex,\n  sortBy,\n  reduce\n} from 'min-dash';\n\nimport { getBBox } from '../../util/Elements';\n\nimport {\n  center,\n  delta as posDelta\n} from '../../util/PositionUtil';\n\nimport {\n  getTopLevel\n} from '../../util/CopyPasteUtil';\n\nimport {\n  eachElement\n} from '../../util/Elements';\n\n\nexport default function CopyPaste(\n    eventBus, modeling, elementFactory,\n    rules, clipboard, canvas) {\n\n  this._eventBus = eventBus;\n  this._modeling = modeling;\n  this._elementFactory = elementFactory;\n  this._rules = rules;\n  this._canvas = canvas;\n\n  this._clipboard = clipboard;\n\n  this._descriptors = [];\n\n\n  // Element creation priorities:\n  // - 1: Independent shapes\n  // - 2: Attached shapes\n  // - 3: Connections\n  // - 4: labels\n  this.registerDescriptor(function(element, descriptor) {\n    // Base priority\n    descriptor.priority = 1;\n\n    descriptor.id = element.id;\n\n    if (element.parent) {\n      descriptor.parent = element.parent.id;\n    }\n\n    if (element.labelTarget) {\n      // Labels priority\n      descriptor.priority = 4;\n      descriptor.labelTarget = element.labelTarget.id;\n    }\n\n    if (element.host) {\n      // Attached shapes priority\n      descriptor.priority = 2;\n      descriptor.host = element.host.id;\n    }\n\n    if (typeof element.x === 'number') {\n      descriptor.x = element.x;\n      descriptor.y = element.y;\n    }\n\n    if (element.width) {\n      descriptor.width = element.width;\n      descriptor.height = element.height;\n    }\n\n    if (element.waypoints) {\n      // Connections priority\n      descriptor.priority = 3;\n      descriptor.waypoints = [];\n\n      forEach(element.waypoints, function(waypoint) {\n        var wp = {\n          x: waypoint.x,\n          y: waypoint.y\n        };\n\n        if (waypoint.original) {\n          wp.original = {\n            x: waypoint.original.x,\n            y: waypoint.original.y\n          };\n        }\n\n        descriptor.waypoints.push(wp);\n      });\n    }\n\n    if (element.source && element.target) {\n      descriptor.source = element.source.id;\n      descriptor.target = element.target.id;\n    }\n\n    return descriptor;\n  });\n}\n\nCopyPaste.$inject = [\n  'eventBus',\n  'modeling',\n  'elementFactory',\n  'rules',\n  'clipboard',\n  'canvas'\n];\n\n\n/**\n * Copy a number of elements.\n *\n * @param {djs.model.Base} selectedElements\n *\n * @return {Object} the copied tree\n */\nCopyPaste.prototype.copy = function(selectedElements) {\n  var clipboard = this._clipboard,\n      tree, bbox;\n\n  if (!isArray(selectedElements)) {\n    selectedElements = selectedElements ? [ selectedElements ] : [];\n  }\n\n  if (!selectedElements.length) {\n    return;\n  }\n\n  tree = this.createTree(selectedElements);\n\n  bbox = this._bbox = center(getBBox(tree.allShapes));\n\n  // not needed after computing the center position of the copied elements\n  delete tree.allShapes;\n\n  forEach(tree, function(elements) {\n\n    forEach(elements, function(element) {\n      var delta, labelTarget;\n\n      // set label's relative position to their label target\n      if (element.labelTarget) {\n        labelTarget = find(elements, matchPattern({ id: element.labelTarget }));\n\n        // just grab the delta from the first waypoint\n        if (labelTarget.waypoints) {\n          delta = posDelta(element, labelTarget.waypoints[0]);\n        } else {\n          delta = posDelta(element, labelTarget);\n        }\n\n      } else\n      if (element.priority === 3) {\n        // connections have priority 3\n        delta = [];\n\n        forEach(element.waypoints, function(waypoint) {\n          var waypointDelta = posDelta(waypoint, bbox);\n\n          delta.push(waypointDelta);\n        });\n      } else {\n        delta = posDelta(element, bbox);\n      }\n\n      element.delta = delta;\n    });\n  });\n\n  this._eventBus.fire('elements.copy', { context: { tree: tree } });\n\n  // if tree is empty, means that nothing can be or is allowed to be copied\n  if (Object.keys(tree).length === 0) {\n    clipboard.clear();\n  } else {\n    clipboard.set(tree);\n  }\n\n  this._eventBus.fire('elements.copied', { context: { tree: tree } });\n\n  return tree;\n};\n\n\n// Allow pasting under the cursor\nCopyPaste.prototype.paste = function(context) {\n  var clipboard = this._clipboard,\n      modeling = this._modeling,\n      eventBus = this._eventBus,\n      rules = this._rules;\n\n  var tree = clipboard.get(),\n      topParent = context.element,\n      position = context.point,\n      newTree, canPaste;\n\n  if (clipboard.isEmpty()) {\n    return;\n  }\n\n  newTree = reduce(tree, function(pasteTree, elements, depthStr) {\n    var depth = parseInt(depthStr, 10);\n\n    if (isNaN(depth)) {\n      return pasteTree;\n    }\n\n    pasteTree[depth] = elements;\n\n    return pasteTree;\n  }, {});\n\n\n  canPaste = rules.allowed('elements.paste', {\n    tree: newTree,\n    target: topParent\n  });\n\n  if (!canPaste) {\n    eventBus.fire('elements.paste.rejected', {\n      context: {\n        tree: newTree,\n        position: position,\n        target: topParent\n      }\n    });\n\n    return;\n  }\n\n  modeling.pasteElements(newTree, topParent, position);\n};\n\n\nCopyPaste.prototype._computeDelta = function(elements, element) {\n  var bbox = this._bbox,\n      delta = {};\n\n  // set label's relative position to their label target\n  if (element.labelTarget) {\n    return posDelta(element, element.labelTarget);\n  }\n\n  // connections have prority 3\n  if (element.priority === 3) {\n    delta = [];\n\n    forEach(element.waypoints, function(waypoint) {\n      var waypointDelta = posDelta(waypoint, bbox);\n\n      delta.push(waypointDelta);\n    });\n  } else {\n    delta = posDelta(element, bbox);\n  }\n\n  return delta;\n};\n\n\n/**\n * Checks if the element in question has a relations to other elements.\n * Possible dependants: connections, labels, attachers\n *\n * @param  {Array} elements\n * @param  {Object} element\n *\n * @return {Boolean}\n */\nCopyPaste.prototype.hasRelations = function(elements, element) {\n  var source, target, labelTarget;\n\n  if (element.waypoints) {\n    source = find(elements, matchPattern({ id: element.source.id }));\n    target = find(elements, matchPattern({ id: element.target.id }));\n\n    if (!source || !target) {\n      return false;\n    }\n  }\n\n  if (element.labelTarget) {\n    labelTarget = find(elements, matchPattern({ id: element.labelTarget.id }));\n\n    if (!labelTarget) {\n      return false;\n    }\n  }\n\n  return true;\n};\n\n\nCopyPaste.prototype.registerDescriptor = function(descriptor) {\n  if (typeof descriptor !== 'function') {\n    throw new Error('the descriptor must be a function');\n  }\n\n  if (this._descriptors.indexOf(descriptor) !== -1) {\n    throw new Error('this descriptor is already registered');\n  }\n\n  this._descriptors.push(descriptor);\n};\n\n\nCopyPaste.prototype._executeDescriptors = function(data) {\n  if (!data.descriptor) {\n    data.descriptor = {};\n  }\n\n  forEach(this._descriptors, function(descriptor) {\n    data.descriptor = descriptor(data.element, data.descriptor);\n  });\n\n  return data;\n};\n\n/**\n * Creates a tree like structure from an arbitrary collection of elements\n *\n * @example\n * tree: {\n *\t0: [\n *\t\t{ id: 'shape_12da', priority: 1, ... },\n *\t\t{ id: 'shape_01bj', priority: 1, ... },\n *\t\t{ id: 'connection_79fa', source: 'shape_12da', target: 'shape_01bj', priority: 3, ... },\n *\t],\n *\t1: [ ... ]\n * };\n *\n * @param  {Array} elements\n * @return {Object}\n */\nCopyPaste.prototype.createTree = function(elements) {\n  var rules = this._rules,\n      self = this;\n\n  var tree = {},\n      includedElements = [],\n      _elements;\n\n  var topLevel = getTopLevel(elements);\n\n  tree.allShapes = [];\n\n  function canCopy(collection, element) {\n    return rules.allowed('element.copy', {\n      collection: collection,\n      element: element\n    });\n  }\n\n  function includeElement(data) {\n    var idx = findIndex(includedElements, matchPattern({ element: data.element })),\n        element;\n\n    if (idx !== -1) {\n      element = includedElements[idx];\n    } else {\n      return includedElements.push(data);\n    }\n\n    // makes sure that it has the correct depth\n    if (element.depth < data.depth) {\n      includedElements.splice(idx, 1);\n\n      includedElements.push(data);\n    }\n  }\n\n\n  eachElement(topLevel, function(element, i, depth) {\n    var nestedChildren = element.children;\n\n    // don't add labels directly\n    if (element.labelTarget) {\n      return;\n    }\n\n    function getNested(lists) {\n      forEach(lists, function(list) {\n        if (list && list.length) {\n\n          forEach(list, function(elem) {\n\n            forEach(elem.labels, function(label) {\n              includeElement({\n                element: label,\n                depth: depth\n              });\n            });\n\n            includeElement({\n              element: elem,\n              depth: depth\n            });\n          });\n        }\n      });\n    }\n\n    // fetch element's labels\n    forEach(element.labels, function(label) {\n\n      includeElement({\n        element: label,\n        depth: depth\n      });\n    });\n\n    getNested([ element.attachers, element.incoming, element.outgoing ]);\n\n    includeElement({\n      element: element,\n      depth: depth\n    });\n\n    if (nestedChildren) {\n      return nestedChildren;\n    }\n  });\n\n  includedElements = map(includedElements, function(data) {\n    // this is where other registered descriptors hook in\n    return self._executeDescriptors(data);\n  });\n\n  // order the elements to check if the ones dependant on others (by relationship)\n  // can be copied. f.ex: label needs it's label target\n  includedElements = sortBy(includedElements, function(data) {\n    return data.descriptor.priority;\n  });\n\n  _elements = map(includedElements, function(data) {\n    return data.element;\n  });\n\n  forEach(includedElements, function(data) {\n    var depth = data.depth;\n\n    if (!self.hasRelations(tree.allShapes, data.element)) {\n      return;\n    }\n\n    if (!canCopy(_elements, data.element)) {\n      return;\n    }\n\n    tree.allShapes.push(data.element);\n\n    // create depth branches\n    if (!tree[depth]) {\n      tree[depth] = [];\n    }\n\n    tree[depth].push(data.descriptor);\n  });\n\n  return tree;\n};\n","import ClipboardModule from '../clipboard';\nimport RulesModule from '../rules';\nimport MouseTrackingModule from '../mouse-tracking';\n\nimport CopyPaste from './CopyPaste';\n\n\nexport default {\n  __depends__: [\n    ClipboardModule,\n    RulesModule,\n    MouseTrackingModule\n  ],\n  __init__: [ 'copyPaste' ],\n  copyPaste: [ 'type', CopyPaste ]\n};\n","var LOW_PRIORITY = 750;\n\nvar MARKER_OK = 'drop-ok',\n    MARKER_NOT_OK = 'drop-not-ok',\n    MARKER_ATTACH = 'attach-ok',\n    MARKER_NEW_PARENT = 'new-parent';\n\nimport {\n  append as svgAppend,\n  attr as svgAttr,\n  classes as svgClasses,\n  create as svgCreate,\n  remove as svgRemove\n} from 'tiny-svg';\n\nimport {\n  translate\n} from '../../util/SvgTransformUtil';\n\n\n/**\n * Adds the ability to create new shapes via drag and drop.\n *\n * Create must be activated via {@link Create#start}. From that\n * point on, create will invoke `shape.create` and `shape.attach`\n * rules to query whether or not creation or attachment on a certain\n * position is allowed.\n *\n * If create or attach is allowed and a source is given, Create it\n * will invoke `connection.create` rules to query whether a connection\n * can be drawn between source and new shape. During rule evaluation\n * the target is not attached yet, however\n *\n *   hints = { targetParent, targetAttach }\n *\n * are passed to the evaluating rules.\n *\n *\n * ## Rule Return Values\n *\n * Return values interpreted from  `shape.create`:\n *\n *   * `true`: create is allowed\n *   * `false`: create is disallowed\n *   * `null`: create is not allowed but should be ignored visually\n *\n * Return values interpreted from `shape.attach`:\n *\n *   * `true`: attach is allowed\n *   * `Any`: attach is allowed with the constraints\n *   * `false`: attach is disallowed\n *\n * Return values interpreted from `connection.create`:\n *\n *   * `true`: connection can be created\n *   * `Any`: connection with the given attributes can be created\n *   * `false`: connection can't be created\n *\n *\n * @param {EventBus} eventBus\n * @param {Dragging} dragging\n * @param {Rules} rules\n * @param {Modeling} modeling\n * @param {Canvas} canvas\n * @param {Styles} styles\n * @param {GraphicsFactory} graphicsFactory\n */\nexport default function Create(\n    eventBus, dragging, rules, modeling,\n    canvas, styles, graphicsFactory) {\n\n  // rules\n\n  function canCreate(shape, target, source, position) {\n\n    if (!target) {\n      return false;\n    }\n\n    var ctx = {\n      source: source,\n      shape: shape,\n      target: target,\n      position: position\n    };\n\n    var create,\n        attach,\n        connect;\n\n    attach = rules.allowed('shape.attach', ctx);\n\n    if (!attach) {\n      create = rules.allowed('shape.create', ctx);\n    }\n\n    if (create || attach) {\n\n      connect = source && rules.allowed('connection.create', {\n        source: source,\n        target: shape,\n        hints: {\n          targetParent: target,\n          targetAttach: attach\n        }\n      });\n    }\n\n    if (create || attach) {\n      return {\n        attach: attach,\n        connect: connect\n      };\n    }\n\n    return false;\n  }\n\n\n  /** set drop marker on an element */\n  function setMarker(element, marker) {\n\n    [ MARKER_ATTACH, MARKER_OK, MARKER_NOT_OK, MARKER_NEW_PARENT ].forEach(function(m) {\n\n      if (m === marker) {\n        canvas.addMarker(element, m);\n      } else {\n        canvas.removeMarker(element, m);\n      }\n    });\n  }\n\n\n  // visual helpers\n\n  function createVisual(shape) {\n    var group, preview, visual;\n\n    group = svgCreate('g');\n    svgAttr(group, styles.cls('djs-drag-group', [ 'no-events' ]));\n\n    svgAppend(canvas.getDefaultLayer(), group);\n\n    preview = svgCreate('g');\n    svgClasses(preview).add('djs-dragger');\n\n    svgAppend(group, preview);\n\n    translate(preview, shape.width / -2, shape.height / -2);\n\n    var visualGroup = svgCreate('g');\n    svgClasses(visualGroup).add('djs-visual');\n\n    svgAppend(preview, visualGroup);\n\n    visual = visualGroup;\n\n    // hijack renderer to draw preview\n    graphicsFactory.drawShape(visual, shape);\n\n    return group;\n  }\n\n\n  // event handlers\n\n  eventBus.on('create.move', function(event) {\n\n    var context = event.context,\n        hover = event.hover,\n        shape = context.shape,\n        source = context.source,\n        canExecute;\n\n    var position = {\n      x: event.x,\n      y: event.y\n    };\n\n    canExecute = context.canExecute = hover && canCreate(shape, hover, source, position);\n\n    // ignore hover visually if canExecute is null\n    if (hover && canExecute !== null) {\n      context.target = hover;\n\n      if (canExecute && canExecute.attach) {\n        setMarker(hover, MARKER_ATTACH);\n      } else {\n        setMarker(hover, canExecute ? MARKER_NEW_PARENT : MARKER_NOT_OK);\n      }\n    }\n  });\n\n  eventBus.on('create.move', LOW_PRIORITY, function(event) {\n\n    var context = event.context,\n        shape = context.shape,\n        visual = context.visual;\n\n    // lazy init drag visual once we received the first real\n    // drag move event (this allows us to get the proper canvas local coordinates)\n    if (!visual) {\n      visual = context.visual = createVisual(shape);\n    }\n\n    translate(visual, event.x, event.y);\n  });\n\n\n  eventBus.on([ 'create.end', 'create.out', 'create.cleanup' ], function(event) {\n    var context = event.context,\n        target = context.target;\n\n    if (target) {\n      setMarker(target, null);\n    }\n  });\n\n  eventBus.on('create.end', function(event) {\n    var context = event.context,\n        source = context.source,\n        shape = context.shape,\n        target = context.target,\n        canExecute = context.canExecute,\n        attach = canExecute && canExecute.attach,\n        connect = canExecute && canExecute.connect,\n        position = {\n          x: event.x,\n          y: event.y\n        };\n\n    if (!canExecute) {\n      return false;\n    }\n\n    if (connect) {\n      // invoke append if connect is set via rules\n      shape = modeling.appendShape(source, shape, position, target, {\n        attach: attach,\n        connection: connect === true ? {} : connect\n      });\n    } else {\n      // invoke create, if connect is not set\n      shape = modeling.createShape(shape, position, target, {\n        attach: attach\n      });\n    }\n\n    // make sure we provide the actual attached\n    // shape with the context so that selection and\n    // other components can use it right after the create\n    // operation ends\n    context.shape = shape;\n  });\n\n\n  eventBus.on('create.cleanup', function(event) {\n    var context = event.context;\n\n    if (context.visual) {\n      svgRemove(context.visual);\n    }\n  });\n\n  // API\n\n  this.start = function(event, shape, source) {\n\n    dragging.init(event, 'create', {\n      cursor: 'grabbing',\n      autoActivate: true,\n      data: {\n        shape: shape,\n        context: {\n          shape: shape,\n          source: source\n        }\n      }\n    });\n  };\n}\n\nCreate.$inject = [\n  'eventBus',\n  'dragging',\n  'rules',\n  'modeling',\n  'canvas',\n  'styles',\n  'graphicsFactory'\n];","import DraggingModule from '../dragging';\nimport SelectionModule from '../selection';\nimport RulesModule from '../rules';\n\nimport Create from './Create';\n\n\nexport default {\n  __depends__: [\n    DraggingModule,\n    SelectionModule,\n    RulesModule\n  ],\n  create: [ 'type', Create ]\n};\n","import {\n  sortBy,\n  forEach,\n  filter\n} from 'min-dash';\n\nvar AXIS_DIMENSIONS = {\n  horizontal: [ 'x', 'width' ],\n  vertical: [ 'y', 'height' ]\n};\n\nvar THRESHOLD = 5;\n\n\n/**\n * Groups and filters elements and then trigger even distribution.\n */\nexport default function DistributeElements(modeling) {\n  this._modeling = modeling;\n\n  this._filters = [];\n\n  // register filter for filtering big elements\n  this.registerFilter(function(elements, axis, dimension) {\n    var elementsSize = 0,\n        numOfShapes = 0,\n        avgDimension;\n\n    forEach(elements, function(element) {\n      if (element.waypoints || element.labelTarget) {\n        return;\n      }\n\n      elementsSize += element[dimension];\n\n      numOfShapes += 1;\n    });\n\n    avgDimension = Math.round(elementsSize / numOfShapes);\n\n    return filter(elements, function(element) {\n      return element[dimension] < (avgDimension + 50);\n    });\n  });\n\n}\n\nDistributeElements.$inject = [ 'modeling' ];\n\n\n/**\n * Registers filter functions that allow external parties to filter\n * out certain elements.\n *\n * @param  {Function} filterFn\n */\nDistributeElements.prototype.registerFilter = function(filterFn) {\n  if (typeof filterFn !== 'function') {\n    throw new Error('the filter has to be a function');\n  }\n\n  this._filters.push(filterFn);\n};\n\n/**\n * Distributes the elements with a given orientation\n *\n * @param  {Array} elements    [description]\n * @param  {String} orientation [description]\n */\nDistributeElements.prototype.trigger = function(elements, orientation) {\n  var modeling = this._modeling;\n\n  var groups,\n      distributableElements;\n\n  if (elements.length < 3) {\n    return;\n  }\n\n  this._setOrientation(orientation);\n\n  distributableElements = this._filterElements(elements);\n\n  groups = this._createGroups(distributableElements);\n\n  // nothing to distribute\n  if (groups.length <= 2) {\n    return;\n  }\n\n  modeling.distributeElements(groups, this._axis, this._dimension);\n\n  return groups;\n};\n\n/**\n * Filters the elements with provided filters by external parties\n *\n * @param  {Array[Elements]} elements\n *\n * @return {Array[Elements]}\n */\nDistributeElements.prototype._filterElements = function(elements) {\n  var filters = this._filters,\n      axis = this._axis,\n      dimension = this._dimension,\n      distributableElements = [].concat(elements);\n\n  if (!filters.length) {\n    return elements;\n  }\n\n  forEach(filters, function(filterFn) {\n    distributableElements = filterFn(distributableElements, axis, dimension);\n  });\n\n  return distributableElements;\n};\n\n\n/**\n * Create range (min, max) groups. Also tries to group elements\n * together that share the same range.\n *\n * @example\n * \tvar distributableElements = [\n * \t\t{\n * \t\t\trange: {\n * \t\t\t\tmin: 100,\n * \t\t\t\tmax: 200\n * \t\t\t},\n * \t\t\telements: [ { id: 'shape1', .. }]\n * \t\t}\n * \t]\n *\n * @param  {Array} elements\n *\n * @return {Array[Objects]}\n */\nDistributeElements.prototype._createGroups = function(elements) {\n  var rangeGroups = [],\n      self = this,\n      axis = this._axis,\n      dimension = this._dimension;\n\n  if (!axis) {\n    throw new Error('must have a defined \"axis\" and \"dimension\"');\n  }\n\n  // sort by 'left->right' or 'top->bottom'\n  var sortedElements = sortBy(elements, axis);\n\n  forEach(sortedElements, function(element, idx) {\n    var elementRange = self._findRange(element, axis, dimension),\n        range;\n\n    var previous = rangeGroups[rangeGroups.length - 1];\n\n    if (previous && self._hasIntersection(previous.range, elementRange)) {\n      rangeGroups[rangeGroups.length - 1].elements.push(element);\n    } else {\n      range = { range: elementRange, elements: [ element ] };\n\n      rangeGroups.push(range);\n    }\n  });\n\n  return rangeGroups;\n};\n\n\n/**\n * Maps a direction to the according axis and dimension\n *\n * @param  {String} direction 'horizontal' or 'vertical'\n */\nDistributeElements.prototype._setOrientation = function(direction) {\n  var orientation = AXIS_DIMENSIONS[direction];\n\n  this._axis = orientation[0];\n  this._dimension = orientation[1];\n};\n\n\n/**\n * Checks if the two ranges intercept each other\n *\n * @param  {Object} rangeA {min, max}\n * @param  {Object} rangeB {min, max}\n *\n * @return {Boolean}\n */\nDistributeElements.prototype._hasIntersection = function(rangeA, rangeB) {\n  return Math.max(rangeA.min, rangeA.max) >= Math.min(rangeB.min, rangeB.max) &&\n         Math.min(rangeA.min, rangeA.max) <= Math.max(rangeB.min, rangeB.max);\n};\n\n\n/**\n * Returns the min and max values for an element\n *\n * @param  {[type]} element   [description]\n * @param  {[type]} axis      [description]\n * @param  {[type]} dimension [description]\n *\n * @return {[type]}           [description]\n */\nDistributeElements.prototype._findRange = function(element) {\n  var axis = element[this._axis],\n      dimension = element[this._dimension];\n\n  return {\n    min: axis + THRESHOLD,\n    max: axis + dimension - THRESHOLD\n  };\n};\n","import DistributeElements from './DistributeElements';\n\nexport default {\n  __init__: [ 'distributeElements' ],\n  distributeElements: [ 'type', DistributeElements ]\n};\n","/* global TouchEvent */\n\nvar round = Math.round;\n\nimport { assign } from 'min-dash';\n\nimport {\n  event as domEvent\n} from 'min-dom';\n\nimport {\n  getOriginal,\n  toPoint,\n  stopPropagation\n} from '../../util/Event';\n\nimport {\n  set as cursorSet,\n  unset as cursorUnset\n} from '../../util/Cursor';\n\nimport {\n  install as installClickTrap\n} from '../../util/ClickTrap';\n\nimport {\n  delta as deltaPos\n} from '../../util/PositionUtil';\n\nvar DRAG_ACTIVE_CLS = 'djs-drag-active';\n\n\nfunction preventDefault(event) {\n  event.preventDefault();\n}\n\nfunction isTouchEvent(event) {\n  // check for TouchEvent being available first\n  // (i.e. not available on desktop Firefox)\n  return typeof TouchEvent !== 'undefined' && event instanceof TouchEvent;\n}\n\nfunction getLength(point) {\n  return Math.sqrt(Math.pow(point.x, 2) + Math.pow(point.y, 2));\n}\n\n/**\n * A helper that fires canvas localized drag events and realizes\n * the general \"drag-and-drop\" look and feel.\n *\n * Calling {@link Dragging#activate} activates dragging on a canvas.\n *\n * It provides the following:\n *\n *   * emits life cycle events, namespaced with a prefix assigned\n *     during dragging activation\n *   * sets and restores the cursor\n *   * sets and restores the selection\n *   * ensures there can be only one drag operation active at a time\n *\n * Dragging may be canceled manually by calling {@link Dragging#cancel}\n * or by pressing ESC.\n *\n *\n * ## Life-cycle events\n *\n * Dragging can be in three different states, off, initialized\n * and active.\n *\n * (1) off: no dragging operation is in progress\n * (2) initialized: a new drag operation got initialized but not yet\n *                  started (i.e. because of no initial move)\n * (3) started: dragging is in progress\n *\n * Eventually dragging will be off again after a drag operation has\n * been ended or canceled via user click or ESC key press.\n *\n * To indicate transitions between these states dragging emits generic\n * life-cycle events with the `drag.` prefix _and_ events namespaced\n * to a prefix choosen by a user during drag initialization.\n *\n * The following events are emitted (appropriately prefixed) via\n * the {@link EventBus}.\n *\n * * `init`\n * * `start`\n * * `move`\n * * `end`\n * * `ended` (dragging already in off state)\n * * `cancel` (only if previously started)\n * * `canceled` (dragging already in off state, only if previously started)\n * * `cleanup`\n *\n *\n * @example\n *\n * function MyDragComponent(eventBus, dragging) {\n *\n *   eventBus.on('mydrag.start', function(event) {\n *     console.log('yes, we start dragging');\n *   });\n *\n *   eventBus.on('mydrag.move', function(event) {\n *     console.log('canvas local coordinates', event.x, event.y, event.dx, event.dy);\n *\n *     // local drag data is passed with the event\n *     event.context.foo; // \"BAR\"\n *\n *     // the original mouse event, too\n *     event.originalEvent; // MouseEvent(...)\n *   });\n *\n *   eventBus.on('element.click', function(event) {\n *     dragging.init(event, 'mydrag', {\n *       cursor: 'grabbing',\n *       data: {\n *         context: {\n *           foo: \"BAR\"\n *         }\n *       }\n *     });\n *   });\n * }\n */\nexport default function Dragging(eventBus, canvas, selection) {\n\n  var defaultOptions = {\n    threshold: 5,\n    trapClick: true\n  };\n\n  // the currently active drag operation\n  // dragging is active as soon as this context exists.\n  //\n  // it is visually _active_ only when a context.active flag is set to true.\n  var context;\n\n  /* convert a global event into local coordinates */\n  function toLocalPoint(globalPosition) {\n\n    var viewbox = canvas.viewbox();\n\n    var clientRect = canvas._container.getBoundingClientRect();\n\n    return {\n      x: viewbox.x + (globalPosition.x - clientRect.left) / viewbox.scale,\n      y: viewbox.y + (globalPosition.y - clientRect.top) / viewbox.scale\n    };\n  }\n\n  // helpers\n\n  function fire(type, dragContext) {\n    dragContext = dragContext || context;\n\n    var event = eventBus.createEvent(\n      assign(\n        {},\n        dragContext.payload,\n        dragContext.data,\n        { isTouch: dragContext.isTouch }\n      )\n    );\n\n    // default integration\n    if (eventBus.fire('drag.' + type, event) === false) {\n      return false;\n    }\n\n    return eventBus.fire(dragContext.prefix + '.' + type, event);\n  }\n\n  // event listeners\n\n  function move(event, activate) {\n    var payload = context.payload,\n        displacement = context.displacement;\n\n    var globalStart = context.globalStart,\n        globalCurrent = toPoint(event),\n        globalDelta = deltaPos(globalCurrent, globalStart);\n\n    var localStart = context.localStart,\n        localCurrent = toLocalPoint(globalCurrent),\n        localDelta = deltaPos(localCurrent, localStart);\n\n\n    // activate context explicitly or once threshold is reached\n    if (!context.active && (activate || getLength(globalDelta) > context.threshold)) {\n\n      // fire start event with original\n      // starting coordinates\n\n      assign(payload, {\n        x: round(localStart.x + displacement.x),\n        y: round(localStart.y + displacement.y),\n        dx: 0,\n        dy: 0\n      }, { originalEvent: event });\n\n      if (false === fire('start')) {\n        return cancel();\n      }\n\n      context.active = true;\n\n      // unset selection and remember old selection\n      // the previous (old) selection will always passed\n      // with the event via the event.previousSelection property\n      if (!context.keepSelection) {\n        payload.previousSelection = selection.get();\n        selection.select(null);\n      }\n\n      // allow custom cursor\n      if (context.cursor) {\n        cursorSet(context.cursor);\n      }\n\n      // indicate dragging via marker on root element\n      canvas.addMarker(canvas.getRootElement(), DRAG_ACTIVE_CLS);\n    }\n\n    stopPropagation(event);\n\n    if (context.active) {\n\n      // update payload with actual coordinates\n      assign(payload, {\n        x: round(localCurrent.x + displacement.x),\n        y: round(localCurrent.y + displacement.y),\n        dx: round(localDelta.x),\n        dy: round(localDelta.y)\n      }, { originalEvent: event });\n\n      // emit move event\n      fire('move');\n    }\n  }\n\n  function end(event) {\n    var previousContext,\n        returnValue = true;\n\n    if (context.active) {\n\n      if (event) {\n        context.payload.originalEvent = event;\n\n        // suppress original event (click, ...)\n        // because we just ended a drag operation\n        stopPropagation(event);\n      }\n\n      // implementations may stop restoring the\n      // original state (selections, ...) by preventing the\n      // end events default action\n      returnValue = fire('end');\n    }\n\n    if (returnValue === false) {\n      fire('rejected');\n    }\n\n    previousContext = cleanup(returnValue !== true);\n\n    // last event to be fired when all drag operations are done\n    // at this point in time no drag operation is in progress anymore\n    fire('ended', previousContext);\n  }\n\n\n  // cancel active drag operation if the user presses\n  // the ESC key on the keyboard\n\n  function checkCancel(event) {\n\n    if (event.which === 27) {\n      preventDefault(event);\n\n      cancel();\n    }\n  }\n\n\n  // prevent ghost click that might occur after a finished\n  // drag and drop session\n\n  function trapClickAndEnd(event) {\n\n    var untrap;\n\n    // trap the click in case we are part of an active\n    // drag operation. This will effectively prevent\n    // the ghost click that cannot be canceled otherwise.\n    if (context.active) {\n\n      untrap = installClickTrap(eventBus);\n\n      // remove trap after minimal delay\n      setTimeout(untrap, 400);\n\n      // prevent default action (click)\n      preventDefault(event);\n    }\n\n    end(event);\n  }\n\n  function trapTouch(event) {\n    move(event);\n  }\n\n  // update the drag events hover (djs.model.Base) and hoverGfx (Snap<SVGElement>)\n  // properties during hover and out and fire {prefix}.hover and {prefix}.out properties\n  // respectively\n\n  function hover(event) {\n    var payload = context.payload;\n\n    payload.hoverGfx = event.gfx;\n    payload.hover = event.element;\n\n    fire('hover');\n  }\n\n  function out(event) {\n    fire('out');\n\n    var payload = context.payload;\n\n    payload.hoverGfx = null;\n    payload.hover = null;\n  }\n\n\n  // life-cycle methods\n\n  function cancel(restore) {\n    var previousContext;\n\n    if (!context) {\n      return;\n    }\n\n    var wasActive = context.active;\n\n    if (wasActive) {\n      fire('cancel');\n    }\n\n    previousContext = cleanup(restore);\n\n    if (wasActive) {\n      // last event to be fired when all drag operations are done\n      // at this point in time no drag operation is in progress anymore\n      fire('canceled', previousContext);\n    }\n  }\n\n  function cleanup(restore) {\n    var previousContext,\n        endDrag;\n\n    fire('cleanup');\n\n    // reset cursor\n    cursorUnset();\n\n    if (context.trapClick) {\n      endDrag = trapClickAndEnd;\n    } else {\n      endDrag = end;\n    }\n\n    // reset dom listeners\n    domEvent.unbind(document, 'mousemove', move);\n\n    domEvent.unbind(document, 'dragstart', preventDefault);\n    domEvent.unbind(document, 'selectstart', preventDefault);\n\n    domEvent.unbind(document, 'mousedown', endDrag, true);\n    domEvent.unbind(document, 'mouseup', endDrag, true);\n\n    domEvent.unbind(document, 'keyup', checkCancel);\n\n    domEvent.unbind(document, 'touchstart', trapTouch, true);\n    domEvent.unbind(document, 'touchcancel', cancel, true);\n    domEvent.unbind(document, 'touchmove', move, true);\n    domEvent.unbind(document, 'touchend', end, true);\n\n    eventBus.off('element.hover', hover);\n    eventBus.off('element.out', out);\n\n    // remove drag marker on root element\n    canvas.removeMarker(canvas.getRootElement(), DRAG_ACTIVE_CLS);\n\n    // restore selection, unless it has changed\n    var previousSelection = context.payload.previousSelection;\n\n    if (restore !== false && previousSelection && !selection.get().length) {\n      selection.select(previousSelection);\n    }\n\n    previousContext = context;\n\n    context = null;\n\n    return previousContext;\n  }\n\n  /**\n   * Initialize a drag operation.\n   *\n   * If `localPosition` is given, drag events will be emitted\n   * relative to it.\n   *\n   * @param {MouseEvent|TouchEvent} [event]\n   * @param {Point} [localPosition] actual diagram local position this drag operation should start at\n   * @param {String} prefix\n   * @param {Object} [options]\n   */\n  function init(event, relativeTo, prefix, options) {\n\n    // only one drag operation may be active, at a time\n    if (context) {\n      cancel(false);\n    }\n\n    if (typeof relativeTo === 'string') {\n      options = prefix;\n      prefix = relativeTo;\n      relativeTo = null;\n    }\n\n    options = assign({}, defaultOptions, options || {});\n\n    var data = options.data || {},\n        originalEvent,\n        globalStart,\n        localStart,\n        endDrag,\n        isTouch;\n\n    if (options.trapClick) {\n      endDrag = trapClickAndEnd;\n    } else {\n      endDrag = end;\n    }\n\n    if (event) {\n      originalEvent = getOriginal(event) || event;\n      globalStart = toPoint(event);\n\n      stopPropagation(event);\n\n      // prevent default browser dragging behavior\n      if (originalEvent.type === 'dragstart') {\n        preventDefault(originalEvent);\n      }\n    } else {\n      originalEvent = null;\n      globalStart = { x: 0, y: 0 };\n    }\n\n    localStart = toLocalPoint(globalStart);\n\n    if (!relativeTo) {\n      relativeTo = localStart;\n    }\n\n    isTouch = isTouchEvent(originalEvent);\n\n    context = assign({\n      prefix: prefix,\n      data: data,\n      payload: {},\n      globalStart: globalStart,\n      displacement: deltaPos(relativeTo, localStart),\n      localStart: localStart,\n      isTouch: isTouch\n    }, options);\n\n    // skip dom registration if trigger\n    // is set to manual (during testing)\n    if (!options.manual) {\n\n      // add dom listeners\n\n      if (isTouch) {\n        domEvent.bind(document, 'touchstart', trapTouch, true);\n        domEvent.bind(document, 'touchcancel', cancel, true);\n        domEvent.bind(document, 'touchmove', move, true);\n        domEvent.bind(document, 'touchend', end, true);\n      } else {\n        // assume we use the mouse to interact per default\n        domEvent.bind(document, 'mousemove', move);\n\n        // prevent default browser drag and text selection behavior\n        domEvent.bind(document, 'dragstart', preventDefault);\n        domEvent.bind(document, 'selectstart', preventDefault);\n\n        domEvent.bind(document, 'mousedown', endDrag, true);\n        domEvent.bind(document, 'mouseup', endDrag, true);\n      }\n\n      domEvent.bind(document, 'keyup', checkCancel);\n\n      eventBus.on('element.hover', hover);\n      eventBus.on('element.out', out);\n    }\n\n    fire('init');\n\n    if (options.autoActivate) {\n      move(event, true);\n    }\n  }\n\n  // cancel on diagram destruction\n  eventBus.on('diagram.destroy', cancel);\n\n\n  // API\n\n  this.init = init;\n  this.move = move;\n  this.hover = hover;\n  this.out = out;\n  this.end = end;\n\n  this.cancel = cancel;\n\n  // for introspection\n\n  this.context = function() {\n    return context;\n  };\n\n  this.setOptions = function(options) {\n    assign(defaultOptions, options);\n  };\n}\n\nDragging.$inject = [\n  'eventBus',\n  'canvas',\n  'selection'\n];\n","import {\n  closest as domClosest\n} from 'min-dom';\n\nimport {\n  toPoint\n} from '../../util/Event';\n\nfunction getGfx(target) {\n  var node = domClosest(target, 'svg, .djs-element', true);\n  return node;\n}\n\n\n/**\n * Browsers may swallow the hover event if users are to\n * fast with the mouse.\n *\n * @see http://stackoverflow.com/questions/7448468/why-cant-i-reliably-capture-a-mouseout-event\n *\n * The fix implemented in this component ensure that we\n * have a hover state after a successive drag.move event.\n *\n * @param {EventBus} eventBus\n * @param {Dragging} dragging\n * @param {ElementRegistry} elementRegistry\n */\nexport default function HoverFix(eventBus, dragging, elementRegistry) {\n\n  var self = this;\n\n  // we wait for a specific sequence of events before\n  // emitting a fake drag.hover event.\n  //\n  // Event Sequence:\n  //\n  // drag.start\n  // drag.move\n  // drag.move >> ensure we are hovering\n  //\n  eventBus.on('drag.start', function(event) {\n\n    eventBus.once('drag.move', function() {\n\n      eventBus.once('drag.move', function(event) {\n\n        self.ensureHover(event);\n      });\n    });\n  });\n\n  /**\n   * Make sure we are god damn hovering!\n   *\n   * @param {Event} dragging event\n   */\n  this.ensureHover = function(event) {\n\n    if (event.hover) {\n      return;\n    }\n\n    var originalEvent = event.originalEvent,\n        position,\n        target,\n        element,\n        gfx;\n\n    if (!(originalEvent instanceof MouseEvent)) {\n      return;\n    }\n\n    position = toPoint(originalEvent);\n\n    // damn expensive operation, ouch!\n    target = document.elementFromPoint(position.x, position.y);\n\n    gfx = getGfx(target);\n\n    if (gfx) {\n      element = elementRegistry.get(gfx);\n\n      dragging.hover({ element: element, gfx: gfx });\n    }\n  };\n\n}\n\nHoverFix.$inject = [\n  'eventBus',\n  'dragging',\n  'elementRegistry'\n];\n","import SelectionModule from '../selection';\n\nimport Dragging from './Dragging';\nimport HoverFix from './HoverFix';\n\nexport default {\n  __init__: [\n    'hoverFix'\n  ],\n  __depends__: [\n    SelectionModule\n  ],\n  dragging: [ 'type', Dragging ],\n  hoverFix: [ 'type', HoverFix ]\n};","import {\n  forEach,\n  isArray\n} from 'min-dash';\n\nvar NOT_REGISTERED_ERROR = 'is not a registered action',\n    IS_REGISTERED_ERROR = 'is already registered';\n\n\n/**\n * An interface that provides access to modeling actions by decoupling\n * the one who requests the action to be triggered and the trigger itself.\n *\n * It's possible to add new actions by registering them with ´registerAction´\n * and likewise unregister existing ones with ´unregisterAction´.\n *\n *\n * ## Life-Cycle and configuration\n *\n * The editor actions will wait for diagram initialization before\n * registering default actions _and_ firing an `editorActions.init` event.\n *\n * Interested parties may listen to the `editorActions.init` event with\n * low priority to check, which actions got registered. Other components\n * may use the event to register their own actions via `registerAction`.\n *\n * @param {EventBus} eventBus\n * @param {Injector} injector\n */\nexport default function EditorActions(eventBus, injector) {\n\n  // initialize actions\n  this._actions = {};\n\n  var self = this;\n\n  eventBus.on('diagram.init', function() {\n\n    // all diagram modules got loaded; check which ones\n    // are available and register the respective default actions\n    self._registerDefaultActions(injector);\n\n    // ask interested parties to register available editor\n    // actions on diagram initialization\n    eventBus.fire('editorActions.init', {\n      editorActions: self\n    });\n  });\n\n}\n\nEditorActions.$inject = [\n  'eventBus',\n  'injector'\n];\n\n/**\n * Register default actions.\n *\n * @param {Injector} injector\n */\nEditorActions.prototype._registerDefaultActions = function(injector) {\n\n  // (1) retrieve optional components to integrate with\n\n  var commandStack = injector.get('commandStack', false);\n  var modeling = injector.get('modeling', false);\n  var selection = injector.get('selection', false);\n  var zoomScroll = injector.get('zoomScroll', false);\n  var copyPaste = injector.get('copyPaste', false);\n  var canvas = injector.get('canvas', false);\n  var rules = injector.get('rules', false);\n  var mouseTracking = injector.get('mouseTracking', false);\n  var keyboardMove = injector.get('keyboardMove', false);\n  var keyboardMoveSelection = injector.get('keyboardMoveSelection', false);\n\n  // (2) check components and register actions\n\n  if (commandStack) {\n    this.register('undo', function() {\n      commandStack.undo();\n    });\n\n    this.register('redo', function() {\n      commandStack.redo();\n    });\n  }\n\n  if (copyPaste && selection) {\n    this.register('copy', function() {\n      var selectedElements = selection.get();\n\n      copyPaste.copy(selectedElements);\n    });\n  }\n\n  if (mouseTracking && copyPaste) {\n    this.register('paste', function() {\n      var context = mouseTracking.getHoverContext();\n\n      copyPaste.paste(context);\n    });\n  }\n\n  if (zoomScroll) {\n    this.register('stepZoom', function(opts) {\n      zoomScroll.stepZoom(opts.value);\n    });\n  }\n\n  if (canvas) {\n    this.register('zoom', function(opts) {\n      canvas.zoom(opts.value);\n    });\n  }\n\n  if (modeling && selection && rules) {\n    this.register('removeSelection', function() {\n\n      var selectedElements = selection.get();\n\n      if (!selectedElements.length) {\n        return;\n      }\n\n      var allowed = rules.allowed('elements.delete', { elements: selectedElements }),\n          removableElements;\n\n      if (allowed === false) {\n        return;\n      }\n      else if (isArray(allowed)) {\n        removableElements = allowed;\n      }\n      else {\n        removableElements = selectedElements;\n      }\n\n      if (removableElements.length) {\n        modeling.removeElements(removableElements.slice());\n      }\n    });\n  }\n\n  if (keyboardMove) {\n    this.register('moveCanvas', function(opts) {\n      keyboardMove.moveCanvas(opts);\n    });\n  }\n\n  if (keyboardMoveSelection) {\n    this.register('moveSelection', function(opts) {\n      keyboardMoveSelection.moveSelection(opts.direction, opts.accelerated);\n    });\n  }\n\n};\n\n\n/**\n * Triggers a registered action\n *\n * @param  {String} action\n * @param  {Object} opts\n *\n * @return {Unknown} Returns what the registered listener returns\n */\nEditorActions.prototype.trigger = function(action, opts) {\n  if (!this._actions[action]) {\n    throw error(action, NOT_REGISTERED_ERROR);\n  }\n\n  return this._actions[action](opts);\n};\n\n\n/**\n * Registers a collections of actions.\n * The key of the object will be the name of the action.\n *\n * @example\n * ´´´\n * var actions = {\n *   spaceTool: function() {\n *     spaceTool.activateSelection();\n *   },\n *   lassoTool: function() {\n *     lassoTool.activateSelection();\n *   }\n * ];\n *\n * editorActions.register(actions);\n *\n * editorActions.isRegistered('spaceTool'); // true\n * ´´´\n *\n * @param  {Object} actions\n */\nEditorActions.prototype.register = function(actions, listener) {\n  var self = this;\n\n  if (typeof actions === 'string') {\n    return this._registerAction(actions, listener);\n  }\n\n  forEach(actions, function(listener, action) {\n    self._registerAction(action, listener);\n  });\n};\n\n/**\n * Registers a listener to an action key\n *\n * @param  {String} action\n * @param  {Function} listener\n */\nEditorActions.prototype._registerAction = function(action, listener) {\n  if (this.isRegistered(action)) {\n    throw error(action, IS_REGISTERED_ERROR);\n  }\n\n  this._actions[action] = listener;\n};\n\n/**\n * Unregister an existing action\n *\n * @param {String} action\n */\nEditorActions.prototype.unregister = function(action) {\n  if (!this.isRegistered(action)) {\n    throw error(action, NOT_REGISTERED_ERROR);\n  }\n\n  this._actions[action] = undefined;\n};\n\n/**\n * Returns the number of actions that are currently registered\n *\n * @return {Number}\n */\nEditorActions.prototype.getActions = function() {\n  return Object.keys(this._actions);\n};\n\n/**\n * Checks wether the given action is registered\n *\n * @param {String} action\n *\n * @return {Boolean}\n */\nEditorActions.prototype.isRegistered = function(action) {\n  return !!this._actions[action];\n};\n\n\nfunction error(action, message) {\n  return new Error(action + ' ' + message);\n}\n","import EditorActions from './EditorActions';\n\nexport default {\n  __init__: [ 'editorActions' ],\n  editorActions: [ 'type', EditorActions ]\n};\n","var MARKER_OK = 'connect-ok',\n    MARKER_NOT_OK = 'connect-not-ok';\n\n/**\n * @class\n * @constructor\n *\n * @param {EventBus} eventBus\n * @param {Dragging} dragging\n * @param {Connect} connect\n * @param {Canvas} canvas\n * @param {ToolManager} toolManager\n * @param {Rules} rules\n */\nexport default function GlobalConnect(\n    eventBus, dragging, connect,\n    canvas, toolManager, rules) {\n\n  var self = this;\n\n  this._dragging = dragging;\n  this._rules = rules;\n\n  toolManager.registerTool('global-connect', {\n    tool: 'global-connect',\n    dragging: 'global-connect.drag'\n  });\n\n  eventBus.on('global-connect.hover', function(event) {\n    var context = event.context,\n        startTarget = event.hover;\n\n    var canStartConnect = context.canStartConnect = self.canStartConnect(startTarget);\n\n    // simply ignore hover\n    if (canStartConnect === null) {\n      return;\n    }\n\n    context.startTarget = startTarget;\n\n    canvas.addMarker(startTarget, canStartConnect ? MARKER_OK : MARKER_NOT_OK);\n  });\n\n\n  eventBus.on([ 'global-connect.out', 'global-connect.cleanup' ], function(event) {\n    var startTarget = event.context.startTarget,\n        canStartConnect = event.context.canStartConnect;\n\n    if (startTarget) {\n      canvas.removeMarker(startTarget, canStartConnect ? MARKER_OK : MARKER_NOT_OK);\n    }\n  });\n\n\n  eventBus.on([ 'global-connect.ended' ], function(event) {\n    var context = event.context,\n        startTarget = context.startTarget,\n        startPosition = {\n          x: event.x,\n          y: event.y\n        };\n\n    var canStartConnect = self.canStartConnect(startTarget);\n\n    if (!canStartConnect) {\n      return;\n    }\n\n    eventBus.once('element.out', function() {\n      eventBus.once([ 'connect.ended', 'connect.canceled' ], function() {\n        eventBus.fire('global-connect.drag.ended');\n      });\n\n      connect.start(null, startTarget, startPosition);\n    });\n\n    return false;\n  });\n}\n\nGlobalConnect.$inject = [\n  'eventBus',\n  'dragging',\n  'connect',\n  'canvas',\n  'toolManager',\n  'rules'\n];\n\n/**\n * Initiates tool activity.\n */\nGlobalConnect.prototype.start = function(event) {\n  this._dragging.init(event, 'global-connect', {\n    trapClick: false,\n    data: {\n      context: {}\n    }\n  });\n};\n\nGlobalConnect.prototype.toggle = function() {\n  if (this.isActive()) {\n    this._dragging.cancel();\n  } else {\n    this.start();\n  }\n};\n\nGlobalConnect.prototype.isActive = function() {\n  var context = this._dragging.context();\n\n  return context && /^global-connect/.test(context.prefix);\n};\n\n/**\n * Check if source shape can initiate connection.\n *\n * @param  {Shape} startTarget\n * @return {Boolean}\n */\nGlobalConnect.prototype.canStartConnect = function(startTarget) {\n  return this._rules.allowed('connection.start', { source: startTarget });\n};\n","import ConnectModule from '../connect';\nimport RulesModule from '../rules';\nimport DraggingModule from '../dragging';\nimport ToolManagerModule from '../tool-manager';\n\nimport GlobalConnect from './GlobalConnect';\n\nexport default {\n  __depends__: [\n    ConnectModule,\n    RulesModule,\n    DraggingModule,\n    ToolManagerModule\n  ],\n  globalConnect: [ 'type', GlobalConnect ]\n};\n","import { hasPrimaryModifier } from '../../util/Mouse';\n\nvar HIGH_PRIORITY = 1500;\nvar HAND_CURSOR = 'grab';\n\n\nexport default function HandTool(eventBus, canvas, dragging, toolManager) {\n  this._dragging = dragging;\n\n\n  toolManager.registerTool('hand', {\n    tool: 'hand',\n    dragging: 'hand.move'\n  });\n\n  eventBus.on('element.mousedown', HIGH_PRIORITY, function(event) {\n    if (hasPrimaryModifier(event)) {\n      this.activateMove(event.originalEvent);\n\n      return false;\n    }\n  }, this);\n\n\n  eventBus.on('hand.end', function(event) {\n    var target = event.originalEvent.target;\n\n    // only reactive on diagram click\n    // on some occasions, event.hover is not set and we have to check if the target is an svg\n    if (!event.hover && !(target instanceof SVGElement)) {\n      return false;\n    }\n\n    eventBus.once('hand.ended', function() {\n      this.activateMove(event.originalEvent, { reactivate: true });\n    }, this);\n\n  }, this);\n\n\n  eventBus.on('hand.move.move', function(event) {\n    var scale = canvas.viewbox().scale;\n\n    canvas.scroll({\n      dx: event.dx * scale,\n      dy: event.dy * scale\n    });\n  });\n\n  eventBus.on('hand.move.end', function(event) {\n    var context = event.context,\n        reactivate = context.reactivate;\n\n    // Don't reactivate if the user is using the keyboard keybinding\n    if (!hasPrimaryModifier(event) && reactivate) {\n\n      eventBus.once('hand.move.ended', function(event) {\n        this.activateHand(event.originalEvent, true, true);\n      }, this);\n\n    }\n\n    return false;\n  }, this);\n\n}\n\nHandTool.$inject = [\n  'eventBus',\n  'canvas',\n  'dragging',\n  'toolManager'\n];\n\n\nHandTool.prototype.activateMove = function(event, autoActivate, context) {\n  if (typeof autoActivate === 'object') {\n    context = autoActivate;\n    autoActivate = false;\n  }\n\n  this._dragging.init(event, 'hand.move', {\n    autoActivate: autoActivate,\n    cursor: HAND_CURSOR,\n    data: {\n      context: context || {}\n    }\n  });\n};\n\nHandTool.prototype.activateHand = function(event, autoActivate, reactivate) {\n  this._dragging.init(event, 'hand', {\n    trapClick: false,\n    autoActivate: autoActivate,\n    cursor: HAND_CURSOR,\n    data: {\n      context: {\n        reactivate: reactivate\n      }\n    }\n  });\n};\n\nHandTool.prototype.toggle = function() {\n  if (this.isActive()) {\n    this._dragging.cancel();\n  } else {\n    this.activateHand();\n  }\n};\n\nHandTool.prototype.isActive = function() {\n  var context = this._dragging.context();\n\n  return context && /^hand/.test(context.prefix);\n};\n","import ToolManagerModule from '../tool-manager';\n\nimport HandTool from './HandTool';\n\nexport default {\n  __depends__: [\n    ToolManagerModule\n  ],\n  __init__: [ 'handTool' ],\n  handTool: [ 'type', HandTool ]\n};\n","import {\n  forEach\n} from 'min-dash';\n\nimport {\n  delegate as domDelegate,\n  query as domQuery\n} from 'min-dom';\n\nimport { isPrimaryButton } from '../../util/Mouse';\n\nimport {\n  append as svgAppend,\n  attr as svgAttr,\n  create as svgCreate\n} from 'tiny-svg';\n\nimport {\n  createLine,\n  updateLine\n} from '../../util/RenderUtil';\n\nfunction allowAll(e) { return true; }\n\nvar LOW_PRIORITY = 500;\n\n/**\n * A plugin that provides interaction events for diagram elements.\n *\n * It emits the following events:\n *\n *   * element.hover\n *   * element.out\n *   * element.click\n *   * element.dblclick\n *   * element.mousedown\n *   * element.contextmenu\n *\n * Each event is a tuple { element, gfx, originalEvent }.\n *\n * Canceling the event via Event#preventDefault()\n * prevents the original DOM operation.\n *\n * @param {EventBus} eventBus\n */\nexport default function InteractionEvents(eventBus, elementRegistry, styles) {\n\n  var HIT_STYLE = styles.cls('djs-hit', [ 'no-fill', 'no-border' ], {\n    stroke: 'white',\n    strokeWidth: 15\n  });\n\n  /**\n   * Fire an interaction event.\n   *\n   * @param {String} type local event name, e.g. element.click.\n   * @param {DOMEvent} event native event\n   * @param {djs.model.Base} [element] the diagram element to emit the event on;\n   *                                   defaults to the event target\n   */\n  function fire(type, event, element) {\n\n    if (isIgnored(type, event)) {\n      return;\n    }\n\n    var target, gfx, returnValue;\n\n    if (!element) {\n      target = event.delegateTarget || event.target;\n\n      if (target) {\n        gfx = target;\n        element = elementRegistry.get(gfx);\n      }\n    } else {\n      gfx = elementRegistry.getGraphics(element);\n    }\n\n    if (!gfx || !element) {\n      return;\n    }\n\n    returnValue = eventBus.fire(type, {\n      element: element,\n      gfx: gfx,\n      originalEvent: event\n    });\n\n    if (returnValue === false) {\n      event.stopPropagation();\n      event.preventDefault();\n    }\n  }\n\n  // TODO(nikku): document this\n  var handlers = {};\n\n  function mouseHandler(localEventName) {\n    return handlers[localEventName];\n  }\n\n  function isIgnored(localEventName, event) {\n\n    var filter = ignoredFilters[localEventName] || isPrimaryButton;\n\n    // only react on left mouse button interactions\n    // except for interaction events that are enabled\n    // for secundary mouse button\n    return !filter(event);\n  }\n\n  var bindings = {\n    mouseover: 'element.hover',\n    mouseout: 'element.out',\n    click: 'element.click',\n    dblclick: 'element.dblclick',\n    mousedown: 'element.mousedown',\n    mouseup: 'element.mouseup',\n    contextmenu: 'element.contextmenu'\n  };\n\n  var ignoredFilters = {\n    'element.contextmenu': allowAll\n  };\n\n\n  // manual event trigger\n\n  /**\n   * Trigger an interaction event (based on a native dom event)\n   * on the target shape or connection.\n   *\n   * @param {String} eventName the name of the triggered DOM event\n   * @param {MouseEvent} event\n   * @param {djs.model.Base} targetElement\n   */\n  function triggerMouseEvent(eventName, event, targetElement) {\n\n    // i.e. element.mousedown...\n    var localEventName = bindings[eventName];\n\n    if (!localEventName) {\n      throw new Error('unmapped DOM event name <' + eventName + '>');\n    }\n\n    return fire(localEventName, event, targetElement);\n  }\n\n\n  var elementSelector = 'svg, .djs-element';\n\n  // event registration\n\n  function registerEvent(node, event, localEvent, ignoredFilter) {\n\n    var handler = handlers[localEvent] = function(event) {\n      fire(localEvent, event);\n    };\n\n    if (ignoredFilter) {\n      ignoredFilters[localEvent] = ignoredFilter;\n    }\n\n    handler.$delegate = domDelegate.bind(node, elementSelector, event, handler);\n  }\n\n  function unregisterEvent(node, event, localEvent) {\n\n    var handler = mouseHandler(localEvent);\n\n    if (!handler) {\n      return;\n    }\n\n    domDelegate.unbind(node, event, handler.$delegate);\n  }\n\n  function registerEvents(svg) {\n    forEach(bindings, function(val, key) {\n      registerEvent(svg, key, val);\n    });\n  }\n\n  function unregisterEvents(svg) {\n    forEach(bindings, function(val, key) {\n      unregisterEvent(svg, key, val);\n    });\n  }\n\n  eventBus.on('canvas.destroy', function(event) {\n    unregisterEvents(event.svg);\n  });\n\n  eventBus.on('canvas.init', function(event) {\n    registerEvents(event.svg);\n  });\n\n\n  eventBus.on([ 'shape.added', 'connection.added' ], function(event) {\n    var element = event.element,\n        gfx = event.gfx,\n        hit;\n\n    if (element.waypoints) {\n      hit = createLine(element.waypoints);\n    } else {\n      hit = svgCreate('rect');\n      svgAttr(hit, {\n        x: 0,\n        y: 0,\n        width: element.width,\n        height: element.height\n      });\n    }\n\n    svgAttr(hit, HIT_STYLE);\n\n    svgAppend(gfx, hit);\n  });\n\n  // Update djs-hit on change.\n  // A low priortity is necessary, because djs-hit of labels has to be updated\n  // after the label bounds have been updated in the renderer.\n  eventBus.on('shape.changed', LOW_PRIORITY, function(event) {\n\n    var element = event.element,\n        gfx = event.gfx,\n        hit = domQuery('.djs-hit', gfx);\n\n    svgAttr(hit, {\n      width: element.width,\n      height: element.height\n    });\n  });\n\n  eventBus.on('connection.changed', function(event) {\n\n    var element = event.element,\n        gfx = event.gfx,\n        hit = domQuery('.djs-hit', gfx);\n\n    updateLine(hit, element.waypoints);\n  });\n\n\n  // API\n\n  this.fire = fire;\n\n  this.triggerMouseEvent = triggerMouseEvent;\n\n  this.mouseHandler = mouseHandler;\n\n  this.registerEvent = registerEvent;\n  this.unregisterEvent = unregisterEvent;\n}\n\n\nInteractionEvents.$inject = [\n  'eventBus',\n  'elementRegistry',\n  'styles'\n];\n\n\n/**\n * An event indicating that the mouse hovered over an element\n *\n * @event element.hover\n *\n * @type {Object}\n * @property {djs.model.Base} element\n * @property {SVGElement} gfx\n * @property {Event} originalEvent\n */\n\n/**\n * An event indicating that the mouse has left an element\n *\n * @event element.out\n *\n * @type {Object}\n * @property {djs.model.Base} element\n * @property {SVGElement} gfx\n * @property {Event} originalEvent\n */\n\n/**\n * An event indicating that the mouse has clicked an element\n *\n * @event element.click\n *\n * @type {Object}\n * @property {djs.model.Base} element\n * @property {SVGElement} gfx\n * @property {Event} originalEvent\n */\n\n/**\n * An event indicating that the mouse has double clicked an element\n *\n * @event element.dblclick\n *\n * @type {Object}\n * @property {djs.model.Base} element\n * @property {SVGElement} gfx\n * @property {Event} originalEvent\n */\n\n/**\n * An event indicating that the mouse has gone down on an element.\n *\n * @event element.mousedown\n *\n * @type {Object}\n * @property {djs.model.Base} element\n * @property {SVGElement} gfx\n * @property {Event} originalEvent\n */\n\n/**\n * An event indicating that the mouse has gone up on an element.\n *\n * @event element.mouseup\n *\n * @type {Object}\n * @property {djs.model.Base} element\n * @property {SVGElement} gfx\n * @property {Event} originalEvent\n */\n\n/**\n * An event indicating that the context menu action is triggered\n * via mouse or touch controls.\n *\n * @event element.contextmenu\n *\n * @type {Object}\n * @property {djs.model.Base} element\n * @property {SVGElement} gfx\n * @property {Event} originalEvent\n */","import InteractionEvents from './InteractionEvents';\n\nexport default {\n  __init__: [ 'interactionEvents' ],\n  interactionEvents: [ 'type', InteractionEvents ]\n};","import {\n  assign\n} from 'min-dash';\n\n\nvar DEFAULT_CONFIG = {\n  moveSpeed: 1,\n  moveSpeedAccelerated: 10\n};\n\nvar HIGHER_PRIORITY = 1500;\n\nvar LEFT = 'left';\nvar UP = 'up';\nvar RIGHT = 'right';\nvar DOWN = 'down';\n\nvar KEY_TO_DIRECTION = {\n  ArrowLeft: LEFT,\n  Left: LEFT,\n  ArrowUp: UP,\n  Up: UP,\n  ArrowRight: RIGHT,\n  Right: RIGHT,\n  ArrowDown: DOWN,\n  Down: DOWN\n};\n\nvar DIRECTIONS_DELTA = {\n  left: function(speed) {\n    return {\n      x: -speed,\n      y: 0\n    };\n  },\n  up: function(speed) {\n    return {\n      x: 0,\n      y: -speed\n    };\n  },\n  right: function(speed) {\n    return {\n      x: speed,\n      y: 0\n    };\n  },\n  down: function(speed) {\n    return {\n      x: 0,\n      y: speed\n    };\n  }\n};\n\n\n/**\n * Enables to move selection with keyboard arrows.\n * Use with Shift for modified speed (default=1, with Shift=10).\n * Pressed Cmd/Ctrl turns the feature off.\n *\n * @param {Object} config\n * @param {Number} [config.moveSpeed=1]\n * @param {Number} [config.moveSpeedAccelerated=10]\n * @param {Keyboard} keyboard\n * @param {Modeling} modeling\n * @param {Selection} selection\n */\nexport default function KeyboardMoveSelection(\n    config, keyboard,\n    modeling, selection\n) {\n\n  var self = this;\n\n  this._config = assign({}, DEFAULT_CONFIG, config || {});\n\n  keyboard.addListener(HIGHER_PRIORITY, function(event) {\n\n    var keyEvent = event.keyEvent;\n\n    var direction = KEY_TO_DIRECTION[keyEvent.key];\n\n    if (!direction) {\n      return;\n    }\n\n    if (keyboard.isCmd(keyEvent)) {\n      return;\n    }\n\n    var accelerated = keyboard.isShift(keyEvent);\n\n    self.moveSelection(direction, accelerated);\n\n    return true;\n  });\n\n\n  /**\n   * Move selected elements in the given direction,\n   * optionally specifying accelerated movement.\n   *\n   * @param {String} direction\n   * @param {Boolean} [accelerated=false]\n   */\n  this.moveSelection = function(direction, accelerated) {\n\n    var selectedElements = selection.get();\n\n    if (!selectedElements.length) {\n      return;\n    }\n\n    var speed = this._config[\n      accelerated ?\n        'moveSpeedAccelerated' :\n        'moveSpeed'\n    ];\n\n    var delta = DIRECTIONS_DELTA[direction](speed);\n\n    modeling.moveElements(selectedElements, delta);\n  };\n\n}\n\nKeyboardMoveSelection.$inject = [\n  'config.keyboardMoveSelection',\n  'keyboard',\n  'modeling',\n  'selection'\n];","import KeyboardModule from '../keyboard';\nimport SelectionModule from '../selection';\n\nimport KeyboardMoveSelection from './KeyboardMoveSelection';\n\nexport default {\n  __depends__: [\n    KeyboardModule,\n    SelectionModule\n  ],\n  __init__: [\n    'keyboardMoveSelection'\n  ],\n  keyboardMoveSelection: [ 'type', KeyboardMoveSelection ]\n};\n","import {\n  isFunction\n} from 'min-dash';\n\nimport {\n  event as domEvent,\n  matches as domMatches\n} from 'min-dom';\n\nimport {\n  hasModifier,\n  isCmd,\n  isKey,\n  isShift\n} from './KeyboardUtil';\n\nvar KEYDOWN_EVENT = 'keyboard.keydown';\n\nvar DEFAULT_PRIORITY = 1000;\n\n\n/**\n * A keyboard abstraction that may be activated and\n * deactivated by users at will, consuming key events\n * and triggering diagram actions.\n *\n * For keys pressed down, keyboard fires `keyboard.keydown` event.\n * The event context contains one field which is `KeyboardEvent` event.\n *\n * The implementation fires the following key events that allow\n * other components to hook into key handling:\n *\n *  - keyboard.bind\n *  - keyboard.unbind\n *  - keyboard.init\n *  - keyboard.destroy\n *\n * All events contain one field which is node.\n *\n * A default binding for the keyboard may be specified via the\n * `keyboard.bindTo` configuration option.\n *\n * @param {Config} config\n * @param {EventBus} eventBus\n */\nexport default function Keyboard(config, eventBus) {\n  var self = this;\n\n  this._config = config || {};\n  this._eventBus = eventBus;\n\n  this._keyHandler = this._keyHandler.bind(this);\n\n  // properly clean dom registrations\n  eventBus.on('diagram.destroy', function() {\n    self._fire('destroy');\n\n    self.unbind();\n  });\n\n  eventBus.on('diagram.init', function() {\n    self._fire('init');\n  });\n\n  eventBus.on('attach', function() {\n    if (config && config.bindTo) {\n      self.bind(config.bindTo);\n    }\n  });\n\n  eventBus.on('detach', function() {\n    self.unbind();\n  });\n}\n\nKeyboard.$inject = [\n  'config.keyboard',\n  'eventBus'\n];\n\nKeyboard.prototype._keyHandler = function(event) {\n\n  var target = event.target,\n      eventBusResult;\n\n  if (isInput(target)) {\n    return;\n  }\n\n  var context = {\n    keyEvent: event\n  };\n\n  eventBusResult = this._eventBus.fire(KEYDOWN_EVENT, context);\n\n  if (eventBusResult) {\n    event.preventDefault();\n  }\n};\n\nKeyboard.prototype.bind = function(node) {\n\n  // make sure that the keyboard is only bound once to the DOM\n  this.unbind();\n\n  this._node = node;\n\n  // bind key events\n  domEvent.bind(node, 'keydown', this._keyHandler, true);\n\n  this._fire('bind');\n};\n\nKeyboard.prototype.getBinding = function() {\n  return this._node;\n};\n\nKeyboard.prototype.unbind = function() {\n  var node = this._node;\n\n  if (node) {\n    this._fire('unbind');\n\n    // unbind key events\n    domEvent.unbind(node, 'keydown', this._keyHandler, true);\n  }\n\n  this._node = null;\n};\n\nKeyboard.prototype._fire = function(event) {\n  this._eventBus.fire('keyboard.' + event, { node: this._node });\n};\n\n/**\n * Add a listener function that is notified with `KeyboardEvent` whenever\n * the keyboard is bound and the user presses a key. If no priority is\n * provided, the default value of 1000 is used.\n *\n * @param {Number} priority\n * @param {Function} listener\n */\nKeyboard.prototype.addListener = function(priority, listener) {\n  if (isFunction(priority)) {\n    listener = priority;\n    priority = DEFAULT_PRIORITY;\n  }\n\n  this._eventBus.on(KEYDOWN_EVENT, priority, listener);\n};\n\nKeyboard.prototype.hasModifier = hasModifier;\nKeyboard.prototype.isCmd = isCmd;\nKeyboard.prototype.isShift = isShift;\nKeyboard.prototype.isKey = isKey;\n\n\n\n// helpers ///////\n\nfunction isInput(target) {\n  return target && (domMatches(target, 'input, textarea') || target.contentEditable === 'true');\n}\n","import {\n  isCmd,\n  isKey,\n  isShift\n} from './KeyboardUtil';\n\nvar LOW_PRIORITY = 500;\n\n\n/**\n * Adds default keyboard bindings.\n *\n * This does not pull in any features will bind only actions that\n * have previously been registered against the editorActions component.\n *\n * @param {EventBus} eventBus\n * @param {Keyboard} keyboard\n */\nexport default function KeyboardBindings(eventBus, keyboard) {\n\n  var self = this;\n\n  eventBus.on('editorActions.init', LOW_PRIORITY, function(event) {\n\n    var editorActions = event.editorActions;\n\n    self.registerBindings(keyboard, editorActions);\n  });\n}\n\nKeyboardBindings.$inject = [\n  'eventBus',\n  'keyboard'\n];\n\n\n/**\n * Register available keyboard bindings.\n *\n * @param {Keyboard} keyboard\n * @param {EditorActions} editorActions\n */\nKeyboardBindings.prototype.registerBindings = function(keyboard, editorActions) {\n\n  /**\n   * Add keyboard binding if respective editor action\n   * is registered.\n   *\n   * @param {String} action name\n   * @param {Function} fn that implements the key binding\n   */\n  function addListener(action, fn) {\n\n    if (editorActions.isRegistered(action)) {\n      keyboard.addListener(fn);\n    }\n  }\n\n\n  // undo\n  // (CTRL|CMD) + Z\n  addListener('undo', function(context) {\n\n    var event = context.keyEvent;\n\n    if (isCmd(event) && !isShift(event) && isKey(['z', 'Z'], event)) {\n      editorActions.trigger('undo');\n\n      return true;\n    }\n  });\n\n  // redo\n  // CTRL + Y\n  // CMD + SHIFT + Z\n  addListener('redo', function(context) {\n\n    var event = context.keyEvent;\n\n    if (isCmd(event) && (isKey(['y', 'Y'], event) || (isKey(['z', 'Z'], event) && isShift(event)))) {\n      editorActions.trigger('redo');\n\n      return true;\n    }\n  });\n\n  // copy\n  // CTRL/CMD + C\n  addListener('copy', function(context) {\n\n    var event = context.keyEvent;\n\n    if (isCmd(event) && isKey(['c', 'C'], event)) {\n      editorActions.trigger('copy');\n\n      return true;\n    }\n  });\n\n  // paste\n  // CTRL/CMD + V\n  addListener('paste', function(context) {\n\n    var event = context.keyEvent;\n\n    if (isCmd(event) && isKey(['v', 'V'], event)) {\n      editorActions.trigger('paste');\n\n      return true;\n    }\n  });\n\n  // zoom in one step\n  // CTRL/CMD + +\n  addListener('stepZoom', function(context) {\n\n    var event = context.keyEvent;\n\n    if (isKey([ '+', 'Add' ], event) && isCmd(event)) {\n      editorActions.trigger('stepZoom', { value: 1 });\n\n      return true;\n    }\n  });\n\n  // zoom out one step\n  // CTRL + -\n  addListener('stepZoom', function(context) {\n\n    var event = context.keyEvent;\n\n    if (isKey([ '-', 'Subtract' ], event) && isCmd(event)) {\n      editorActions.trigger('stepZoom', { value: -1 });\n\n      return true;\n    }\n  });\n\n  // zoom to the default level\n  // CTRL + 0\n  addListener('zoom', function(context) {\n\n    var event = context.keyEvent;\n\n    if (isKey('0', event) && isCmd(event)) {\n      editorActions.trigger('zoom', { value: 1 });\n\n      return true;\n    }\n  });\n\n  // delete selected element\n  // DEL\n  addListener('removeSelection', function(context) {\n\n    var event = context.keyEvent;\n\n    if (isKey([ 'Delete', 'Del' ], event)) {\n      editorActions.trigger('removeSelection');\n\n      return true;\n    }\n  });\n};","import { isArray } from 'min-dash';\r\n\r\n/**\r\n * Returns true if event was triggered with any modifier\r\n * @param {KeyboardEvent} event\r\n */\r\nexport function hasModifier(event) {\r\n  return (event.ctrlKey || event.metaKey || event.shiftKey || event.altKey);\r\n}\r\n\r\n/**\r\n * @param {KeyboardEvent} event\r\n */\r\nexport function isCmd(event) {\r\n\r\n  // ensure we don't react to AltGr\r\n  // (mapped to CTRL + ALT)\r\n  if (event.altKey) {\r\n    return false;\r\n  }\r\n\r\n  return event.ctrlKey || event.metaKey;\r\n}\r\n\r\n/**\r\n * Checks if key pressed is one of provided keys.\r\n *\r\n * @param {String|String[]} keys\r\n * @param {KeyboardEvent} event\r\n */\r\nexport function isKey(keys, event) {\r\n  keys = isArray(keys) ? keys : [ keys ];\r\n\r\n  return keys.indexOf(event.key) > -1;\r\n}\r\n\r\n/**\r\n * @param {KeyboardEvent} event\r\n */\r\nexport function isShift(event) {\r\n  return event.shiftKey;\r\n}","import Keyboard from './Keyboard';\nimport KeyboardBindings from './KeyboardBindings';\n\nexport default {\n  __init__: [ 'keyboard', 'keyboardBindings' ],\n  keyboard: [ 'type', Keyboard ],\n  keyboardBindings: [ 'type', KeyboardBindings ]\n};\n","import {\n  forEach,\n  filter\n} from 'min-dash';\n\nimport inherits from 'inherits';\n\nvar LOW_PRIORITY = 250,\n    HIGH_PRIORITY = 1400;\n\nimport {\n  add as collectionAdd,\n  indexOf as collectionIdx\n} from '../../util/Collections';\n\nimport { saveClear } from '../../util/Removal';\n\nimport CommandInterceptor from '../../command/CommandInterceptor';\n\n\n/**\n * A handler that makes sure labels are properly moved with\n * their label targets.\n *\n * @param {didi.Injector} injector\n * @param {EventBus} eventBus\n * @param {Modeling} modeling\n */\nexport default function LabelSupport(injector, eventBus, modeling) {\n\n  CommandInterceptor.call(this, eventBus);\n\n  var movePreview = injector.get('movePreview', false);\n\n  // remove labels from the collection that are being\n  // moved with other elements anyway\n  eventBus.on('shape.move.start', HIGH_PRIORITY, function(e) {\n\n    var context = e.context,\n        shapes = context.shapes,\n        validatedShapes = context.validatedShapes;\n\n    context.shapes = removeLabels(shapes);\n    context.validatedShapes = removeLabels(validatedShapes);\n  });\n\n  // add labels to visual's group\n  movePreview && eventBus.on('shape.move.start', LOW_PRIORITY, function(e) {\n\n    var context = e.context,\n        shapes = context.shapes;\n\n    var labels = [];\n\n    forEach(shapes, function(element) {\n\n      forEach(element.labels, function(label) {\n\n        if (!label.hidden && context.shapes.indexOf(label) === -1) {\n          labels.push(label);\n        }\n\n        if (element.labelTarget) {\n          labels.push(element);\n        }\n      });\n    });\n\n    forEach(labels, function(label) {\n      movePreview.makeDraggable(context, label, true);\n    });\n\n  });\n\n  // add all labels to move closure\n  this.preExecuted('elements.move', HIGH_PRIORITY, function(e) {\n    var context = e.context,\n        closure = context.closure,\n        enclosedElements = closure.enclosedElements;\n\n    var enclosedLabels = [];\n\n    // find labels that are not part of\n    // move closure yet and add them\n    forEach(enclosedElements, function(element) {\n      forEach(element.labels, function(label) {\n\n        if (!enclosedElements[label.id]) {\n          enclosedLabels.push(label);\n        }\n      });\n    });\n\n    closure.addAll(enclosedLabels);\n  });\n\n\n  this.preExecute([\n    'connection.delete',\n    'shape.delete'\n  ], function(e) {\n\n    var context = e.context,\n        element = context.connection || context.shape;\n\n    saveClear(element.labels, function(label) {\n      modeling.removeShape(label, { nested: true });\n    });\n  });\n\n\n  this.execute('shape.delete', function(e) {\n\n    var context = e.context,\n        shape = context.shape,\n        labelTarget = shape.labelTarget;\n\n    // unset labelTarget\n    if (labelTarget) {\n      context.labelTargetIndex = collectionIdx(labelTarget.labels, shape);\n      context.labelTarget = labelTarget;\n\n      shape.labelTarget = null;\n    }\n  });\n\n  this.revert('shape.delete', function(e) {\n\n    var context = e.context,\n        shape = context.shape,\n        labelTarget = context.labelTarget,\n        labelTargetIndex = context.labelTargetIndex;\n\n    // restore labelTarget\n    if (labelTarget) {\n      collectionAdd(labelTarget.labels, shape, labelTargetIndex);\n\n      shape.labelTarget = labelTarget;\n    }\n  });\n\n}\n\ninherits(LabelSupport, CommandInterceptor);\n\nLabelSupport.$inject = [\n  'injector',\n  'eventBus',\n  'modeling'\n];\n\n\n/**\n * Return a filtered list of elements that do not\n * contain attached elements with hosts being part\n * of the selection.\n *\n * @param  {Array<djs.model.Base>} elements\n *\n * @return {Array<djs.model.Base>} filtered\n */\nfunction removeLabels(elements) {\n\n  return filter(elements, function(element) {\n\n    // filter out labels that are move together\n    // with their label targets\n    return elements.indexOf(element.labelTarget) === -1;\n  });\n}\n","import LabelSupport from './LabelSupport';\n\nexport default {\n  __init__: [ 'labelSupport'],\n  labelSupport: [ 'type', LabelSupport ]\n};\n","import { values } from 'min-dash';\n\nimport { getEnclosedElements } from '../../util/Elements';\n\nimport { hasSecondaryModifier } from '../../util/Mouse';\n\nimport {\n  append as svgAppend,\n  attr as svgAttr,\n  create as svgCreate,\n  remove as svgRemove\n} from 'tiny-svg';\n\nvar LASSO_TOOL_CURSOR = 'crosshair';\n\n\nexport default function LassoTool(\n    eventBus, canvas, dragging,\n    elementRegistry, selection, toolManager) {\n\n  this._selection = selection;\n  this._dragging = dragging;\n\n  var self = this;\n\n  // lasso visuals implementation\n\n  /**\n  * A helper that realizes the selection box visual\n  */\n  var visuals = {\n\n    create: function(context) {\n      var container = canvas.getDefaultLayer(),\n          frame;\n\n      frame = context.frame = svgCreate('rect');\n      svgAttr(frame, {\n        class: 'djs-lasso-overlay',\n        width:  1,\n        height: 1,\n        x: 0,\n        y: 0\n      });\n\n      svgAppend(container, frame);\n    },\n\n    update: function(context) {\n      var frame = context.frame,\n          bbox = context.bbox;\n\n      svgAttr(frame, {\n        x: bbox.x,\n        y: bbox.y,\n        width: bbox.width,\n        height: bbox.height\n      });\n    },\n\n    remove: function(context) {\n\n      if (context.frame) {\n        svgRemove(context.frame);\n      }\n    }\n  };\n\n  toolManager.registerTool('lasso', {\n    tool: 'lasso.selection',\n    dragging: 'lasso'\n  });\n\n  eventBus.on('lasso.selection.end', function(event) {\n    var target = event.originalEvent.target;\n\n    // only reactive on diagram click\n    // on some occasions, event.hover is not set and we have to check if the target is an svg\n    if (!event.hover && !(target instanceof SVGElement)) {\n      return;\n    }\n\n    eventBus.once('lasso.selection.ended', function() {\n      self.activateLasso(event.originalEvent, true);\n    });\n  });\n\n  // lasso interaction implementation\n\n  eventBus.on('lasso.end', function(event) {\n\n    var bbox = toBBox(event);\n\n    var elements = elementRegistry.filter(function(element) {\n      return element;\n    });\n\n    self.select(elements, bbox);\n  });\n\n  eventBus.on('lasso.start', function(event) {\n\n    var context = event.context;\n\n    context.bbox = toBBox(event);\n    visuals.create(context);\n  });\n\n  eventBus.on('lasso.move', function(event) {\n\n    var context = event.context;\n\n    context.bbox = toBBox(event);\n    visuals.update(context);\n  });\n\n  eventBus.on('lasso.cleanup', function(event) {\n\n    var context = event.context;\n\n    visuals.remove(context);\n  });\n\n\n  // event integration\n\n  eventBus.on('element.mousedown', 1500, function(event) {\n\n    if (hasSecondaryModifier(event)) {\n      self.activateLasso(event.originalEvent);\n\n      // we've handled the event\n      return true;\n    }\n  });\n}\n\nLassoTool.$inject = [\n  'eventBus',\n  'canvas',\n  'dragging',\n  'elementRegistry',\n  'selection',\n  'toolManager'\n];\n\n\nLassoTool.prototype.activateLasso = function(event, autoActivate) {\n\n  this._dragging.init(event, 'lasso', {\n    autoActivate: autoActivate,\n    cursor: LASSO_TOOL_CURSOR,\n    data: {\n      context: {}\n    }\n  });\n};\n\nLassoTool.prototype.activateSelection = function(event) {\n\n  this._dragging.init(event, 'lasso.selection', {\n    trapClick: false,\n    cursor: LASSO_TOOL_CURSOR,\n    data: {\n      context: {}\n    }\n  });\n};\n\nLassoTool.prototype.select = function(elements, bbox) {\n  var selectedElements = getEnclosedElements(elements, bbox);\n\n  this._selection.select(values(selectedElements));\n};\n\nLassoTool.prototype.toggle = function() {\n  if (this.isActive()) {\n    this._dragging.cancel();\n  } else {\n    this.activateSelection();\n  }\n};\n\nLassoTool.prototype.isActive = function() {\n  var context = this._dragging.context();\n\n  return context && /^lasso/.test(context.prefix);\n};\n\n\n\nfunction toBBox(event) {\n\n  var start = {\n\n    x: event.x - event.dx,\n    y: event.y - event.dy\n  };\n\n  var end = {\n    x: event.x,\n    y: event.y\n  };\n\n  var bbox;\n\n  if ((start.x <= end.x && start.y < end.y) ||\n      (start.x < end.x && start.y <= end.y)) {\n\n    bbox = {\n      x: start.x,\n      y: start.y,\n      width:  end.x - start.x,\n      height: end.y - start.y\n    };\n  } else if ((start.x >= end.x && start.y < end.y) ||\n             (start.x > end.x && start.y <= end.y)) {\n\n    bbox = {\n      x: end.x,\n      y: start.y,\n      width:  start.x - end.x,\n      height: end.y - start.y\n    };\n  } else if ((start.x <= end.x && start.y > end.y) ||\n             (start.x < end.x && start.y >= end.y)) {\n\n    bbox = {\n      x: start.x,\n      y: end.y,\n      width:  end.x - start.x,\n      height: start.y - end.y\n    };\n  } else if ((start.x >= end.x && start.y > end.y) ||\n             (start.x > end.x && start.y >= end.y)) {\n\n    bbox = {\n      x: end.x,\n      y: end.y,\n      width:  start.x - end.x,\n      height: start.y - end.y\n    };\n  } else {\n\n    bbox = {\n      x: end.x,\n      y: end.y,\n      width:  0,\n      height: 0\n    };\n  }\n  return bbox;\n}\n","import ToolManagerModule from '../tool-manager';\n\nimport LassoTool from './LassoTool';\n\nexport default {\n  __depends__: [\n    ToolManagerModule\n  ],\n  __init__: [ 'lassoTool' ],\n  lassoTool: [ 'type', LassoTool ]\n};\n","import { forEach } from 'min-dash';\n\nimport {\n  Base\n} from '../../model';\n\nimport AppendShapeHandler from './cmd/AppendShapeHandler';\nimport CreateShapeHandler from './cmd/CreateShapeHandler';\nimport DeleteShapeHandler from './cmd/DeleteShapeHandler';\nimport MoveShapeHandler from './cmd/MoveShapeHandler';\nimport ResizeShapeHandler from './cmd/ResizeShapeHandler';\nimport ReplaceShapeHandler from './cmd/ReplaceShapeHandler';\nimport ToggleShapeCollapseHandler from './cmd/ToggleShapeCollapseHandler';\nimport SpaceToolHandler from './cmd/SpaceToolHandler';\nimport CreateLabelHandler from './cmd/CreateLabelHandler';\nimport CreateConnectionHandler from './cmd/CreateConnectionHandler';\nimport DeleteConnectionHandler from './cmd/DeleteConnectionHandler';\nimport MoveConnectionHandler from './cmd/MoveConnectionHandler';\nimport LayoutConnectionHandler from './cmd/LayoutConnectionHandler';\nimport UpdateWaypointsHandler from './cmd/UpdateWaypointsHandler';\nimport ReconnectConnectionHandler from './cmd/ReconnectConnectionHandler';\nimport MoveElementsHandler from './cmd/MoveElementsHandler';\nimport DeleteElementsHandler from './cmd/DeleteElementsHandler';\nimport DistributeElementsHandler from './cmd/DistributeElementsHandler';\nimport AlignElementsHandler from './cmd/AlignElementsHandler';\nimport UpdateAttachmentHandler from './cmd/UpdateAttachmentHandler';\nimport PasteHandler from './cmd/PasteHandler';\n\n\n/**\n * The basic modeling entry point.\n *\n * @param {EventBus} eventBus\n * @param {ElementFactory} elementFactory\n * @param {CommandStack} commandStack\n */\nexport default function Modeling(eventBus, elementFactory, commandStack) {\n  this._eventBus = eventBus;\n  this._elementFactory = elementFactory;\n  this._commandStack = commandStack;\n\n  var self = this;\n\n  eventBus.on('diagram.init', function() {\n    // register modeling handlers\n    self.registerHandlers(commandStack);\n  });\n}\n\nModeling.$inject = [ 'eventBus', 'elementFactory', 'commandStack' ];\n\n\nModeling.prototype.getHandlers = function() {\n  return {\n    'shape.append': AppendShapeHandler,\n    'shape.create': CreateShapeHandler,\n    'shape.delete': DeleteShapeHandler,\n    'shape.move': MoveShapeHandler,\n    'shape.resize': ResizeShapeHandler,\n    'shape.replace': ReplaceShapeHandler,\n    'shape.toggleCollapse': ToggleShapeCollapseHandler,\n\n    'spaceTool': SpaceToolHandler,\n\n    'label.create': CreateLabelHandler,\n\n    'connection.create': CreateConnectionHandler,\n    'connection.delete': DeleteConnectionHandler,\n    'connection.move': MoveConnectionHandler,\n    'connection.layout': LayoutConnectionHandler,\n\n    'connection.updateWaypoints': UpdateWaypointsHandler,\n\n    'connection.reconnectStart': ReconnectConnectionHandler,\n    'connection.reconnectEnd': ReconnectConnectionHandler,\n\n    'elements.move': MoveElementsHandler,\n    'elements.delete': DeleteElementsHandler,\n\n    'elements.distribute': DistributeElementsHandler,\n    'elements.align': AlignElementsHandler,\n\n    'element.updateAttachment': UpdateAttachmentHandler,\n\n    'elements.paste': PasteHandler\n  };\n};\n\n/**\n * Register handlers with the command stack\n *\n * @param {CommandStack} commandStack\n */\nModeling.prototype.registerHandlers = function(commandStack) {\n  forEach(this.getHandlers(), function(handler, id) {\n    commandStack.registerHandler(id, handler);\n  });\n};\n\n\n// modeling helpers //////////////////////\n\nModeling.prototype.moveShape = function(shape, delta, newParent, newParentIndex, hints) {\n\n  if (typeof newParentIndex === 'object') {\n    hints = newParentIndex;\n    newParentIndex = null;\n  }\n\n  var context = {\n    shape: shape,\n    delta:  delta,\n    newParent: newParent,\n    newParentIndex: newParentIndex,\n    hints: hints || {}\n  };\n\n  this._commandStack.execute('shape.move', context);\n};\n\n\n/**\n * Update the attachment of the given shape.\n *\n * @param {djs.mode.Base} shape\n * @param {djs.model.Base} [newHost]\n */\nModeling.prototype.updateAttachment = function(shape, newHost) {\n  var context = {\n    shape: shape,\n    newHost: newHost\n  };\n\n  this._commandStack.execute('element.updateAttachment', context);\n};\n\n\n/**\n * Move a number of shapes to a new target, either setting it as\n * the new parent or attaching it.\n *\n * @param {Array<djs.mode.Base>} shapes\n * @param {Point} delta\n * @param {djs.model.Base} [target]\n * @param {Object} [hints]\n * @param {Boolean} [hints.attach=false]\n */\nModeling.prototype.moveElements = function(shapes, delta, target, hints) {\n\n  hints = hints || {};\n\n  var attach = hints.attach;\n\n  var newParent = target,\n      newHost;\n\n  if (attach === true) {\n    newHost = target;\n    newParent = target.parent;\n  } else\n\n  if (attach === false) {\n    newHost = null;\n  }\n\n  var context = {\n    shapes: shapes,\n    delta: delta,\n    newParent: newParent,\n    newHost: newHost,\n    hints: hints\n  };\n\n  this._commandStack.execute('elements.move', context);\n};\n\n\nModeling.prototype.moveConnection = function(connection, delta, newParent, newParentIndex, hints) {\n\n  if (typeof newParentIndex === 'object') {\n    hints = newParentIndex;\n    newParentIndex = undefined;\n  }\n\n  var context = {\n    connection: connection,\n    delta: delta,\n    newParent: newParent,\n    newParentIndex: newParentIndex,\n    hints: hints || {}\n  };\n\n  this._commandStack.execute('connection.move', context);\n};\n\n\nModeling.prototype.layoutConnection = function(connection, hints) {\n  var context = {\n    connection: connection,\n    hints: hints || {}\n  };\n\n  this._commandStack.execute('connection.layout', context);\n};\n\n\n/**\n * Create connection.\n *\n * @param {djs.model.Base} source\n * @param {djs.model.Base} target\n * @param {Number} [targetIndex]\n * @param {Object|djs.model.Connection} connection\n * @param {djs.model.Base} parent\n * @param {Object} hints\n *\n * @return {djs.model.Connection} the created connection.\n */\nModeling.prototype.createConnection = function(source, target, parentIndex, connection, parent, hints) {\n\n  if (typeof parentIndex === 'object') {\n    hints = parent;\n    parent = connection;\n    connection = parentIndex;\n    parentIndex = undefined;\n  }\n\n  connection = this._create('connection', connection);\n\n  var context = {\n    source: source,\n    target: target,\n    parent: parent,\n    parentIndex: parentIndex,\n    connection: connection,\n    hints: hints\n  };\n\n  this._commandStack.execute('connection.create', context);\n\n  return context.connection;\n};\n\n\n/**\n * Create a shape at the specified position.\n *\n * @param {djs.model.Shape|Object} shape\n * @param {Point} position\n * @param {djs.model.Shape|djs.model.Root} target\n * @param {Number} [parentIndex] position in parents children list\n * @param {Object} [hints]\n * @param {Boolean} [hints.attach] whether to attach to target or become a child\n *\n * @return {djs.model.Shape} the created shape\n */\nModeling.prototype.createShape = function(shape, position, target, parentIndex, hints) {\n\n  if (typeof parentIndex !== 'number') {\n    hints = parentIndex;\n    parentIndex = undefined;\n  }\n\n  hints = hints || {};\n\n  var attach = hints.attach,\n      parent,\n      host;\n\n  shape = this._create('shape', shape);\n\n  if (attach) {\n    parent = target.parent;\n    host = target;\n  } else {\n    parent = target;\n  }\n\n  var context = {\n    position: position,\n    shape: shape,\n    parent: parent,\n    parentIndex: parentIndex,\n    host: host,\n    hints: hints\n  };\n\n  this._commandStack.execute('shape.create', context);\n\n  return context.shape;\n};\n\n\nModeling.prototype.createLabel = function(labelTarget, position, label, parent) {\n\n  label = this._create('label', label);\n\n  var context = {\n    labelTarget: labelTarget,\n    position: position,\n    parent: parent || labelTarget.parent,\n    shape: label\n  };\n\n  this._commandStack.execute('label.create', context);\n\n  return context.shape;\n};\n\n\n/**\n * Append shape to given source, drawing a connection\n * between source and the newly created shape.\n *\n * @param {djs.model.Shape} source\n * @param {djs.model.Shape|Object} shape\n * @param {Point} position\n * @param {djs.model.Shape} target\n * @param {Object} [hints]\n * @param {Boolean} [hints.attach]\n * @param {djs.model.Connection|Object} [hints.connection]\n * @param {djs.model.Base} [hints.connectionParent]\n *\n * @return {djs.model.Shape} the newly created shape\n */\nModeling.prototype.appendShape = function(source, shape, position, target, hints) {\n\n  hints = hints || {};\n\n  shape = this._create('shape', shape);\n\n  var context = {\n    source: source,\n    position: position,\n    target: target,\n    shape: shape,\n    connection: hints.connection,\n    connectionParent: hints.connectionParent,\n    attach: hints.attach\n  };\n\n  this._commandStack.execute('shape.append', context);\n\n  return context.shape;\n};\n\n\nModeling.prototype.removeElements = function(elements) {\n  var context = {\n    elements: elements\n  };\n\n  this._commandStack.execute('elements.delete', context);\n};\n\n\nModeling.prototype.distributeElements = function(groups, axis, dimension) {\n  var context = {\n    groups: groups,\n    axis: axis,\n    dimension: dimension\n  };\n\n  this._commandStack.execute('elements.distribute', context);\n};\n\n\nModeling.prototype.removeShape = function(shape, hints) {\n  var context = {\n    shape: shape,\n    hints: hints || {}\n  };\n\n  this._commandStack.execute('shape.delete', context);\n};\n\n\nModeling.prototype.removeConnection = function(connection, hints) {\n  var context = {\n    connection: connection,\n    hints: hints || {}\n  };\n\n  this._commandStack.execute('connection.delete', context);\n};\n\nModeling.prototype.replaceShape = function(oldShape, newShape, hints) {\n  var context = {\n    oldShape: oldShape,\n    newData: newShape,\n    hints: hints || {}\n  };\n\n  this._commandStack.execute('shape.replace', context);\n\n  return context.newShape;\n};\n\nModeling.prototype.pasteElements = function(tree, topParent, position) {\n  var context = {\n    tree: tree,\n    topParent: topParent,\n    position: position\n  };\n\n  this._commandStack.execute('elements.paste', context);\n};\n\nModeling.prototype.alignElements = function(elements, alignment) {\n  var context = {\n    elements: elements,\n    alignment: alignment\n  };\n\n  this._commandStack.execute('elements.align', context);\n};\n\nModeling.prototype.resizeShape = function(shape, newBounds, minBounds) {\n  var context = {\n    shape: shape,\n    newBounds: newBounds,\n    minBounds: minBounds\n  };\n\n  this._commandStack.execute('shape.resize', context);\n};\n\nModeling.prototype.createSpace = function(movingShapes, resizingShapes, delta, direction) {\n  var context = {\n    movingShapes: movingShapes,\n    resizingShapes: resizingShapes,\n    delta: delta,\n    direction: direction\n  };\n\n  this._commandStack.execute('spaceTool', context);\n};\n\nModeling.prototype.updateWaypoints = function(connection, newWaypoints, hints) {\n  var context = {\n    connection: connection,\n    newWaypoints: newWaypoints,\n    hints: hints || {}\n  };\n\n  this._commandStack.execute('connection.updateWaypoints', context);\n};\n\nModeling.prototype.reconnectStart = function(connection, newSource, dockingOrPoints) {\n  var context = {\n    connection: connection,\n    newSource: newSource,\n    dockingOrPoints: dockingOrPoints\n  };\n\n  this._commandStack.execute('connection.reconnectStart', context);\n};\n\nModeling.prototype.reconnectEnd = function(connection, newTarget, dockingOrPoints) {\n  var context = {\n    connection: connection,\n    newTarget: newTarget,\n    dockingOrPoints: dockingOrPoints\n  };\n\n  this._commandStack.execute('connection.reconnectEnd', context);\n};\n\nModeling.prototype.connect = function(source, target, attrs, hints) {\n  return this.createConnection(source, target, attrs || {}, source.parent, hints);\n};\n\nModeling.prototype._create = function(type, attrs) {\n  if (attrs instanceof Base) {\n    return attrs;\n  } else {\n    return this._elementFactory.create(type, attrs);\n  }\n};\n\nModeling.prototype.toggleCollapse = function(shape, hints) {\n  var context = {\n    shape: shape,\n    hints: hints || {}\n  };\n\n  this._commandStack.execute('shape.toggleCollapse', context);\n};\n","import { forEach } from 'min-dash';\n\n/**\n * A handler that align elements in a certain way.\n *\n */\nexport default function AlignElements(modeling, canvas) {\n  this._modeling = modeling;\n  this._canvas = canvas;\n}\n\nAlignElements.$inject = [ 'modeling', 'canvas' ];\n\n\nAlignElements.prototype.preExecute = function(context) {\n  var modeling = this._modeling;\n\n  var elements = context.elements,\n      alignment = context.alignment;\n\n\n  forEach(elements, function(element) {\n    var delta = {\n      x: 0,\n      y: 0\n    };\n\n    if (alignment.left) {\n      delta.x = alignment.left - element.x;\n\n    } else if (alignment.right) {\n      delta.x = (alignment.right - element.width) - element.x;\n\n    } else if (alignment.center) {\n      delta.x = (alignment.center - Math.round(element.width / 2)) - element.x;\n\n    } else if (alignment.top) {\n      delta.y = alignment.top - element.y;\n\n    } else if (alignment.bottom) {\n      delta.y = (alignment.bottom - element.height) - element.y;\n\n    } else if (alignment.middle) {\n      delta.y = (alignment.middle - Math.round(element.height / 2)) - element.y;\n    }\n\n    modeling.moveElements([ element ], delta, element.parent);\n  });\n};\n\nAlignElements.prototype.postExecute = function(context) {\n\n};\n","import { some } from 'min-dash';\n\n\n/**\n * A handler that implements reversible appending of shapes\n * to a source shape.\n *\n * @param {canvas} Canvas\n * @param {elementFactory} ElementFactory\n * @param {modeling} Modeling\n */\nexport default function AppendShapeHandler(modeling) {\n  this._modeling = modeling;\n}\n\nAppendShapeHandler.$inject = [ 'modeling' ];\n\n\n// api //////////////////////\n\n\n/**\n * Creates a new shape\n *\n * @param {Object} context\n * @param {ElementDescriptor} context.shape the new shape\n * @param {ElementDescriptor} context.source the source object\n * @param {ElementDescriptor} context.parent the parent object\n * @param {Point} context.position position of the new element\n */\nAppendShapeHandler.prototype.preExecute = function(context) {\n\n  var source = context.source;\n\n  if (!source) {\n    throw new Error('source required');\n  }\n\n  var target = context.target || source.parent,\n      shape = context.shape;\n\n  shape = context.shape =\n    this._modeling.createShape(\n      shape,\n      context.position,\n      target, { attach: context.attach });\n\n  context.shape = shape;\n};\n\nAppendShapeHandler.prototype.postExecute = function(context) {\n  var parent = context.connectionParent || context.shape.parent;\n\n  if (!existsConnection(context.source, context.shape)) {\n\n    // create connection\n    this._modeling.connect(context.source, context.shape, context.connection, parent);\n  }\n};\n\n\nfunction existsConnection(source, target) {\n  return some(source.outgoing, function(c) {\n    return c.target === target;\n  });\n}","export default function CreateConnectionHandler(canvas, layouter) {\n  this._canvas = canvas;\n  this._layouter = layouter;\n}\n\nCreateConnectionHandler.$inject = [ 'canvas', 'layouter' ];\n\n\n// api //////////////////////\n\n\n/**\n * Appends a shape to a target shape\n *\n * @param {Object} context\n * @param {djs.element.Base} context.source the source object\n * @param {djs.element.Base} context.target the parent object\n * @param {Point} context.position position of the new element\n */\nCreateConnectionHandler.prototype.execute = function(context) {\n\n  var connection = context.connection,\n      source = context.source,\n      target = context.target,\n      parent = context.parent,\n      parentIndex = context.parentIndex,\n      hints = context.hints;\n\n  if (!source || !target) {\n    throw new Error('source and target required');\n  }\n\n  if (!parent) {\n    throw new Error('parent required');\n  }\n\n  connection.source = source;\n  connection.target = target;\n\n  if (!connection.waypoints) {\n    connection.waypoints = this._layouter.layoutConnection(connection, hints);\n  }\n\n  // add connection\n  this._canvas.addConnection(connection, parent, parentIndex);\n\n  return connection;\n};\n\nCreateConnectionHandler.prototype.revert = function(context) {\n  var connection = context.connection;\n\n  this._canvas.removeConnection(connection);\n\n  connection.source = null;\n  connection.target = null;\n};","import inherits from 'inherits';\n\nimport CreateShapeHandler from './CreateShapeHandler';\n\n\n/**\n * A handler that attaches a label to a given target shape.\n *\n * @param {Canvas} canvas\n */\nexport default function CreateLabelHandler(canvas) {\n  CreateShapeHandler.call(this, canvas);\n}\n\ninherits(CreateLabelHandler, CreateShapeHandler);\n\nCreateLabelHandler.$inject = [ 'canvas' ];\n\n\n// api //////////////////////\n\n\nvar originalExecute = CreateShapeHandler.prototype.execute;\n\n/**\n * Appends a label to a target shape.\n *\n * @method CreateLabelHandler#execute\n *\n * @param {Object} context\n * @param {ElementDescriptor} context.target the element the label is attached to\n * @param {ElementDescriptor} context.parent the parent object\n * @param {Point} context.position position of the new element\n */\nCreateLabelHandler.prototype.execute = function(context) {\n\n  var label = context.shape;\n\n  ensureValidDimensions(label);\n\n  label.labelTarget = context.labelTarget;\n\n  return originalExecute.call(this, context);\n};\n\nvar originalRevert = CreateShapeHandler.prototype.revert;\n\n/**\n * Undo append by removing the shape\n */\nCreateLabelHandler.prototype.revert = function(context) {\n  context.shape.labelTarget = null;\n\n  return originalRevert.call(this, context);\n};\n\n\n// helpers //////////////////////\n\nfunction ensureValidDimensions(label) {\n  // make sure a label has valid { width, height } dimensions\n  [ 'width', 'height' ].forEach(function(prop) {\n    if (typeof label[prop] === 'undefined') {\n      label[prop] = 0;\n    }\n  });\n}","import { assign } from 'min-dash';\n\nvar round = Math.round;\n\n\n/**\n * A handler that implements reversible addition of shapes.\n *\n * @param {canvas} Canvas\n */\nexport default function CreateShapeHandler(canvas) {\n  this._canvas = canvas;\n}\n\nCreateShapeHandler.$inject = [ 'canvas' ];\n\n\n// api //////////////////////\n\n\n/**\n * Appends a shape to a target shape\n *\n * @param {Object} context\n * @param {djs.model.Base} context.parent the parent object\n * @param {Point} context.position position of the new element\n */\nCreateShapeHandler.prototype.execute = function(context) {\n\n  var shape = context.shape,\n      positionOrBounds = context.position,\n      parent = context.parent,\n      parentIndex = context.parentIndex;\n\n  if (!parent) {\n    throw new Error('parent required');\n  }\n\n  if (!positionOrBounds) {\n    throw new Error('position required');\n  }\n\n  // (1) add at event center position _or_ at given bounds\n  if (positionOrBounds.width !== undefined) {\n    assign(shape, positionOrBounds);\n  } else {\n    assign(shape, {\n      x: positionOrBounds.x - round(shape.width / 2),\n      y: positionOrBounds.y - round(shape.height / 2)\n    });\n  }\n\n  // (2) add to canvas\n  this._canvas.addShape(shape, parent, parentIndex);\n\n  return shape;\n};\n\n\n/**\n * Undo append by removing the shape\n */\nCreateShapeHandler.prototype.revert = function(context) {\n\n  // (3) remove form canvas\n  this._canvas.removeShape(context.shape);\n};","import {\n  add as collectionAdd,\n  indexOf as collectionIdx\n} from '../../../util/Collections';\n\n\n/**\n * A handler that implements reversible deletion of Connections.\n */\nexport default function DeleteConnectionHandler(canvas, modeling) {\n  this._canvas = canvas;\n  this._modeling = modeling;\n}\n\nDeleteConnectionHandler.$inject = [\n  'canvas',\n  'modeling'\n];\n\n\nDeleteConnectionHandler.prototype.execute = function(context) {\n\n  var connection = context.connection,\n      parent = connection.parent;\n\n  context.parent = parent;\n\n  // remember containment\n  context.parentIndex = collectionIdx(parent.children, connection);\n\n  context.source = connection.source;\n  context.target = connection.target;\n\n  this._canvas.removeConnection(connection);\n\n  connection.source = null;\n  connection.target = null;\n\n  return connection;\n};\n\n/**\n * Command revert implementation.\n */\nDeleteConnectionHandler.prototype.revert = function(context) {\n\n  var connection = context.connection,\n      parent = context.parent,\n      parentIndex = context.parentIndex;\n\n  connection.source = context.source;\n  connection.target = context.target;\n\n  // restore containment\n  collectionAdd(parent.children, connection, parentIndex);\n\n  this._canvas.addConnection(connection, parent);\n\n  return connection;\n};\n","import { forEach } from 'min-dash';\n\n\nexport default function DeleteElementsHandler(modeling, elementRegistry) {\n  this._modeling = modeling;\n  this._elementRegistry = elementRegistry;\n}\n\nDeleteElementsHandler.$inject = [\n  'modeling',\n  'elementRegistry'\n];\n\n\nDeleteElementsHandler.prototype.postExecute = function(context) {\n\n  var modeling = this._modeling,\n      elementRegistry = this._elementRegistry,\n      elements = context.elements;\n\n  forEach(elements, function(element) {\n\n    // element may have been removed with previous\n    // remove operations already (e.g. in case of nesting)\n    if (!elementRegistry.get(element.id)) {\n      return;\n    }\n\n    if (element.waypoints) {\n      modeling.removeConnection(element);\n    } else {\n      modeling.removeShape(element);\n    }\n  });\n};","import {\n  add as collectionAdd,\n  indexOf as collectionIdx\n} from '../../../util/Collections';\n\nimport { saveClear } from '../../../util/Removal';\n\n\n/**\n * A handler that implements reversible deletion of shapes.\n *\n */\nexport default function DeleteShapeHandler(canvas, modeling) {\n  this._canvas = canvas;\n  this._modeling = modeling;\n}\n\nDeleteShapeHandler.$inject = [ 'canvas', 'modeling' ];\n\n\n/**\n * - Remove connections\n * - Remove all direct children\n */\nDeleteShapeHandler.prototype.preExecute = function(context) {\n\n  var modeling = this._modeling;\n\n  var shape = context.shape;\n\n  // remove connections\n  saveClear(shape.incoming, function(connection) {\n    // To make sure that the connection isn't removed twice\n    // For example if a container is removed\n    modeling.removeConnection(connection, { nested: true });\n  });\n\n  saveClear(shape.outgoing, function(connection) {\n    modeling.removeConnection(connection, { nested: true });\n  });\n\n  // remove child shapes and connections\n  saveClear(shape.children, function(child) {\n    if (isConnection(child)) {\n      modeling.removeConnection(child, { nested: true });\n    } else {\n      modeling.removeShape(child, { nested: true });\n    }\n  });\n};\n\n/**\n * Remove shape and remember the parent\n */\nDeleteShapeHandler.prototype.execute = function(context) {\n  var canvas = this._canvas;\n\n  var shape = context.shape,\n      oldParent = shape.parent;\n\n  context.oldParent = oldParent;\n\n  // remove containment\n  context.oldParentIndex = collectionIdx(oldParent.children, shape);\n\n  // remove shape\n  canvas.removeShape(shape);\n\n  return shape;\n};\n\n\n/**\n * Command revert implementation\n */\nDeleteShapeHandler.prototype.revert = function(context) {\n\n  var canvas = this._canvas;\n\n  var shape = context.shape,\n      oldParent = context.oldParent,\n      oldParentIndex = context.oldParentIndex;\n\n  // restore containment\n  collectionAdd(oldParent.children, shape, oldParentIndex);\n\n  canvas.addShape(shape, oldParent);\n\n  return shape;\n};\n\nfunction isConnection(element) {\n  return element.waypoints;\n}\n","import {\n  forEach,\n  sortBy\n} from 'min-dash';\n\n\n/**\n * A handler that distributes elements evenly.\n */\nexport default function DistributeElements(modeling) {\n  this._modeling = modeling;\n}\n\nDistributeElements.$inject = [ 'modeling' ];\n\nvar OFF_AXIS = {\n  x: 'y',\n  y: 'x'\n};\n\nDistributeElements.prototype.preExecute = function(context) {\n  var modeling = this._modeling;\n\n  var groups = context.groups,\n      axis = context.axis,\n      dimension = context.dimension;\n\n  function updateRange(group, element) {\n    group.range.min = Math.min(element[axis], group.range.min);\n    group.range.max = Math.max(element[axis] + element[dimension], group.range.max);\n  }\n\n  function center(element) {\n    return element[axis] + element[dimension] / 2;\n  }\n\n  function lastIdx(arr) {\n    return arr.length - 1;\n  }\n\n  function rangeDiff(range) {\n    return range.max - range.min;\n  }\n\n  function centerElement(refCenter, element) {\n    var delta = { y: 0 };\n\n    delta[axis] = refCenter - center(element);\n\n    if (delta[axis]) {\n\n      delta[OFF_AXIS[axis]] = 0;\n\n      modeling.moveElements([ element ], delta, element.parent);\n    }\n  }\n\n  var firstGroup = groups[0],\n      lastGroupIdx = lastIdx(groups),\n      lastGroup = groups[ lastGroupIdx ];\n\n  var margin,\n      spaceInBetween,\n      groupsSize = 0; // the size of each range\n\n  forEach(groups, function(group, idx) {\n    var sortedElements,\n        refElem,\n        refCenter;\n\n    if (group.elements.length < 2) {\n      if (idx && idx !== groups.length - 1) {\n        updateRange(group, group.elements[0]);\n\n        groupsSize += rangeDiff(group.range);\n      }\n      return;\n    }\n\n    sortedElements = sortBy(group.elements, axis);\n\n    refElem = sortedElements[0];\n\n    if (idx === lastGroupIdx) {\n      refElem = sortedElements[lastIdx(sortedElements)];\n    }\n\n    refCenter = center(refElem);\n\n    // wanna update the ranges after the shapes have been centered\n    group.range = null;\n\n    forEach(sortedElements, function(element) {\n\n      centerElement(refCenter, element);\n\n      if (group.range === null) {\n        group.range = {\n          min: element[axis],\n          max: element[axis] + element[dimension]\n        };\n\n        return;\n      }\n\n      // update group's range after centering the range elements\n      updateRange(group, element);\n    });\n\n    if (idx && idx !== groups.length - 1) {\n      groupsSize += rangeDiff(group.range);\n    }\n  });\n\n  spaceInBetween = Math.abs(lastGroup.range.min - firstGroup.range.max);\n\n  margin = Math.round((spaceInBetween - groupsSize) / (groups.length - 1));\n\n  if (margin < groups.length - 1) {\n    return;\n  }\n\n  forEach(groups, function(group, groupIdx) {\n    var delta = {},\n        prevGroup;\n\n    if (group === firstGroup || group === lastGroup) {\n      return;\n    }\n\n    prevGroup = groups[groupIdx - 1];\n\n    group.range.max = 0;\n\n    forEach(group.elements, function(element, idx) {\n      delta[OFF_AXIS[axis]] = 0;\n      delta[axis] = (prevGroup.range.max - element[axis]) + margin;\n\n      if (group.range.min !== element[axis]) {\n        delta[axis] += element[axis] - group.range.min;\n      }\n\n      if (delta[axis]) {\n        modeling.moveElements([ element ], delta, element.parent);\n      }\n\n      group.range.max = Math.max(element[axis] + element[dimension], idx ? group.range.max : 0);\n    });\n  });\n};\n\nDistributeElements.prototype.postExecute = function(context) {\n\n};\n","import { assign } from 'min-dash';\n\n\n/**\n * A handler that implements reversible moving of shapes.\n */\nexport default function LayoutConnectionHandler(layouter, canvas) {\n  this._layouter = layouter;\n  this._canvas = canvas;\n}\n\nLayoutConnectionHandler.$inject = [ 'layouter', 'canvas' ];\n\nLayoutConnectionHandler.prototype.execute = function(context) {\n\n  var connection = context.connection;\n\n  var oldWaypoints = connection.waypoints;\n\n  assign(context, {\n    oldWaypoints: oldWaypoints\n  });\n\n  connection.waypoints = this._layouter.layoutConnection(connection, context.hints);\n\n  return connection;\n};\n\nLayoutConnectionHandler.prototype.revert = function(context) {\n\n  var connection = context.connection;\n\n  connection.waypoints = context.oldWaypoints;\n\n  return connection;\n};\n","import { forEach } from 'min-dash';\n\n\nimport {\n  add as collectionAdd,\n  remove as collectionRemove\n} from '../../../util/Collections';\n\n\n/**\n * A handler that implements reversible moving of connections.\n *\n * The handler differs from the layout connection handler in a sense\n * that it preserves the connection layout.\n */\nexport default function MoveConnectionHandler() { }\n\n\nMoveConnectionHandler.prototype.execute = function(context) {\n\n  var connection = context.connection,\n      delta = context.delta;\n\n  var newParent = context.newParent || connection.parent,\n      newParentIndex = context.newParentIndex,\n      oldParent = connection.parent;\n\n  // save old parent in context\n  context.oldParent = oldParent;\n  context.oldParentIndex = collectionRemove(oldParent.children, connection);\n\n  // add to new parent at position\n  collectionAdd(newParent.children, connection, newParentIndex);\n\n  // update parent\n  connection.parent = newParent;\n\n  // update waypoint positions\n  forEach(connection.waypoints, function(p) {\n    p.x += delta.x;\n    p.y += delta.y;\n\n    if (p.original) {\n      p.original.x += delta.x;\n      p.original.y += delta.y;\n    }\n  });\n\n  return connection;\n};\n\nMoveConnectionHandler.prototype.revert = function(context) {\n\n  var connection = context.connection,\n      newParent = connection.parent,\n      oldParent = context.oldParent,\n      oldParentIndex = context.oldParentIndex,\n      delta = context.delta;\n\n  // remove from newParent\n  collectionRemove(newParent.children, connection);\n\n  // restore previous location in old parent\n  collectionAdd(oldParent.children, connection, oldParentIndex);\n\n  // restore parent\n  connection.parent = oldParent;\n\n  // revert to old waypoint positions\n  forEach(connection.waypoints, function(p) {\n    p.x -= delta.x;\n    p.y -= delta.y;\n\n    if (p.original) {\n      p.original.x -= delta.x;\n      p.original.y -= delta.y;\n    }\n  });\n\n  return connection;\n};","import MoveHelper from './helper/MoveHelper';\n\n\n/**\n * A handler that implements reversible moving of shapes.\n */\nexport default function MoveElementsHandler(modeling) {\n  this._helper = new MoveHelper(modeling);\n}\n\nMoveElementsHandler.$inject = [ 'modeling' ];\n\nMoveElementsHandler.prototype.preExecute = function(context) {\n  context.closure = this._helper.getClosure(context.shapes);\n};\n\nMoveElementsHandler.prototype.postExecute = function(context) {\n\n  var hints = context.hints,\n      primaryShape;\n\n  if (hints && hints.primaryShape) {\n    primaryShape = hints.primaryShape;\n    hints.oldParent = primaryShape.parent;\n  }\n\n  this._helper.moveClosure(\n    context.closure,\n    context.delta,\n    context.newParent,\n    context.newHost,\n    primaryShape\n  );\n};","import {\n  assign,\n  forEach,\n  pick\n} from 'min-dash';\n\nimport MoveHelper from './helper/MoveHelper';\n\nimport {\n  add as collectionAdd,\n  remove as collectionRemove\n} from '../../../util/Collections';\n\nimport {\n  getMovedSourceAnchor,\n  getMovedTargetAnchor\n} from './helper/AnchorsHelper';\n\n\n/**\n * A handler that implements reversible moving of shapes.\n */\nexport default function MoveShapeHandler(modeling) {\n  this._modeling = modeling;\n\n  this._helper = new MoveHelper(modeling);\n}\n\nMoveShapeHandler.$inject = [ 'modeling' ];\n\n\nMoveShapeHandler.prototype.execute = function(context) {\n\n  var shape = context.shape,\n      delta = context.delta,\n      newParent = context.newParent || shape.parent,\n      newParentIndex = context.newParentIndex,\n      oldParent = shape.parent;\n\n  context.oldBounds = pick(shape, [ 'x', 'y', 'width', 'height']);\n\n  // save old parent in context\n  context.oldParent = oldParent;\n  context.oldParentIndex = collectionRemove(oldParent.children, shape);\n\n  // add to new parent at position\n  collectionAdd(newParent.children, shape, newParentIndex);\n\n  // update shape parent + position\n  assign(shape, {\n    parent: newParent,\n    x: shape.x + delta.x,\n    y: shape.y + delta.y\n  });\n\n  return shape;\n};\n\nMoveShapeHandler.prototype.postExecute = function(context) {\n\n  var shape = context.shape,\n      delta = context.delta,\n      hints = context.hints;\n\n  var modeling = this._modeling;\n\n  if (hints.layout !== false) {\n\n    forEach(shape.incoming, function(c) {\n      modeling.layoutConnection(c, {\n        connectionEnd: getMovedTargetAnchor(c, shape, delta)\n      });\n    });\n\n    forEach(shape.outgoing, function(c) {\n      modeling.layoutConnection(c, {\n        connectionStart: getMovedSourceAnchor(c, shape, delta)\n      });\n    });\n  }\n\n  if (hints.recurse !== false) {\n    this.moveChildren(context);\n  }\n};\n\nMoveShapeHandler.prototype.revert = function(context) {\n\n  var shape = context.shape,\n      oldParent = context.oldParent,\n      oldParentIndex = context.oldParentIndex,\n      delta = context.delta;\n\n  // restore previous location in old parent\n  collectionAdd(oldParent.children, shape, oldParentIndex);\n\n  // revert to old position and parent\n  assign(shape, {\n    parent: oldParent,\n    x: shape.x - delta.x,\n    y: shape.y - delta.y\n  });\n\n  return shape;\n};\n\nMoveShapeHandler.prototype.moveChildren = function(context) {\n\n  var delta = context.delta,\n      shape = context.shape;\n\n  this._helper.moveRecursive(shape.children, delta, null);\n};\n\nMoveShapeHandler.prototype.getNewParent = function(context) {\n  return context.newParent || context.shape.parent;\n};\n","import {\n  forEach,\n  map,\n  sortBy,\n  assign,\n} from 'min-dash';\n\nfunction removeProperties(element, properties) {\n  forEach(properties, function(prop) {\n    if (element[prop]) {\n      delete element[prop];\n    }\n  });\n}\n\n/**\n * A handler that implements pasting of elements onto the diagram.\n *\n * @param {eventBus} EventBus\n * @param {canvas} Canvas\n * @param {selection} Selection\n * @param {elementFactory} ElementFactory\n * @param {modeling} Modeling\n * @param {rules} Rules\n */\nexport default function PasteHandler(\n    eventBus, canvas, selection,\n    elementFactory, modeling, rules) {\n\n  this._eventBus = eventBus;\n  this._canvas = canvas;\n  this._selection = selection;\n  this._elementFactory = elementFactory;\n  this._modeling = modeling;\n  this._rules = rules;\n}\n\n\nPasteHandler.$inject = [\n  'eventBus',\n  'canvas',\n  'selection',\n  'elementFactory',\n  'modeling',\n  'rules'\n];\n\n\n// api //////////////////////\n\n/**\n * Creates a new shape\n *\n * @param {Object} context\n * @param {Object} context.tree the new shape\n * @param {Element} context.topParent the paste target\n */\nPasteHandler.prototype.preExecute = function(context) {\n  var eventBus = this._eventBus,\n      self = this;\n\n  var tree = context.tree,\n      topParent = context.topParent,\n      position = context.position;\n\n  tree.createdElements = {};\n\n  tree.labels = [];\n\n  forEach(tree, function(elements, depthStr) {\n    var depth = parseInt(depthStr, 10);\n\n    if (isNaN(depth)) {\n      return;\n    }\n\n    // set the parent on the top level elements\n    if (!depth) {\n      elements = map(elements, function(descriptor) {\n        descriptor.parent = topParent;\n\n        return descriptor;\n      });\n    }\n\n    // Order by priority for element creation\n    elements = sortBy(elements, 'priority');\n\n    forEach(elements, function(descriptor) {\n      var id = descriptor.id,\n          parent = descriptor.parent,\n          hints = {},\n          newPosition;\n\n      var element = assign({}, descriptor);\n\n      if (depth) {\n        element.parent = self._getCreatedElement(parent, tree);\n      }\n\n      // this happens when shapes have not been created due to rules\n      if (!parent) {\n        return;\n      }\n\n      eventBus.fire('element.paste', {\n        createdElements: tree.createdElements,\n        descriptor: element\n      });\n\n      // in case the parent changed during 'element.paste'\n      parent = element.parent;\n\n      if (element.waypoints) {\n        element = self._createConnection(element, parent, position, tree);\n\n        if (element) {\n          tree.createdElements[id] = {\n            element: element,\n            descriptor: descriptor\n          };\n        }\n\n        return;\n      }\n\n\n      // supply not-root information as hint\n      if (element.parent !== topParent) {\n        hints.root = false;\n      }\n\n      // set host\n      if (element.host) {\n        hints.attach = true;\n\n        parent = self._getCreatedElement(element.host, tree);\n      }\n\n      // handle labels\n      if (element.labelTarget) {\n        return tree.labels.push(element);\n      }\n\n      newPosition = {\n        x: Math.round(position.x + element.delta.x + (element.width / 2)),\n        y: Math.round(position.y + element.delta.y + (element.height / 2))\n      };\n\n      removeProperties(element, [\n        'id',\n        'parent',\n        'delta',\n        'host',\n        'priority'\n      ]);\n\n      element = self._createShape(element, parent, newPosition, hints);\n\n      if (element) {\n        tree.createdElements[id] = {\n          element: element,\n          descriptor: descriptor\n        };\n      }\n    });\n  });\n};\n\n// move label's to their relative position\nPasteHandler.prototype.postExecute = function(context) {\n  var modeling = this._modeling,\n      selection = this._selection,\n      self = this;\n\n  var tree = context.tree,\n      labels = tree.labels,\n      topLevelElements = [];\n\n  forEach(labels, function(labelDescriptor) {\n    var labelTarget = self._getCreatedElement(labelDescriptor.labelTarget, tree),\n        labels, labelTargetPos, newPosition;\n\n    if (!labelTarget) {\n      return;\n    }\n\n    labels = labelTarget.labels;\n\n    if (!labels || !labels.length) {\n      return;\n    }\n\n    labelTargetPos = {\n      x: labelTarget.x,\n      y: labelTarget.y\n    };\n\n    if (labelTarget.waypoints) {\n      labelTargetPos = labelTarget.waypoints[0];\n    }\n\n    forEach(labels, function(label) {\n      newPosition = {\n        x: Math.round((labelTargetPos.x - label.x) + labelDescriptor.delta.x),\n        y: Math.round((labelTargetPos.y - label.y) + labelDescriptor.delta.y)\n      };\n\n      modeling.moveShape(label, newPosition, labelTarget.parent);\n    });\n  });\n\n  forEach(tree[0], function(descriptor) {\n    var id = descriptor.id,\n        toplevel = tree.createdElements[id];\n\n    if (toplevel) {\n      topLevelElements.push(toplevel.element);\n    }\n  });\n\n  selection.select(topLevelElements);\n};\n\n\nPasteHandler.prototype._createConnection = function(element, parent, parentCenter, tree) {\n  var modeling = this._modeling,\n      rules = this._rules;\n\n  var connection, source, target, canPaste;\n\n  element.waypoints = map(element.waypoints, function(waypoint, idx) {\n    return {\n      x: Math.round(parentCenter.x + element.delta[idx].x),\n      y: Math.round(parentCenter.y + element.delta[idx].y)\n    };\n  });\n\n  source = this._getCreatedElement(element.source, tree);\n  target = this._getCreatedElement(element.target, tree);\n\n  if (!source || !target) {\n    return null;\n  }\n\n  canPaste = rules.allowed('element.paste', {\n    source: source,\n    target: target\n  });\n\n  if (!canPaste) {\n    return null;\n  }\n\n  removeProperties(element, [\n    'id',\n    'parent',\n    'delta',\n    'source',\n    'target',\n    'width',\n    'height',\n    'priority'\n  ]);\n\n  connection = modeling.createConnection(source, target, element, parent);\n\n  return connection;\n};\n\n\nPasteHandler.prototype._createShape = function(element, parent, position, isAttach, hints) {\n  var modeling = this._modeling,\n      elementFactory = this._elementFactory,\n      rules = this._rules;\n\n  var canPaste = rules.allowed('element.paste', {\n    element: element,\n    position: position,\n    parent: parent\n  });\n\n  if (!canPaste) {\n    return null;\n  }\n\n  var shape = elementFactory.createShape(element);\n\n  modeling.createShape(shape, position, parent, isAttach, hints);\n\n  return shape;\n};\n\n\nPasteHandler.prototype._getCreatedElement = function(id, tree) {\n  return tree.createdElements[id] && tree.createdElements[id].element;\n};\n","import { isArray } from 'min-dash';\n\n\n/**\n * Reconnect connection handler\n */\nexport default function ReconnectConnectionHandler() { }\n\nReconnectConnectionHandler.$inject = [ ];\n\nReconnectConnectionHandler.prototype.execute = function(context) {\n\n  var newSource = context.newSource,\n      newTarget = context.newTarget,\n      connection = context.connection,\n      dockingOrPoints = context.dockingOrPoints,\n      oldWaypoints = connection.waypoints,\n      newWaypoints;\n\n  if (!newSource && !newTarget) {\n    throw new Error('newSource or newTarget are required');\n  }\n\n  if (newSource && newTarget) {\n    throw new Error('must specify either newSource or newTarget');\n  }\n\n  context.oldWaypoints = oldWaypoints;\n\n  if (isArray(dockingOrPoints)) {\n    newWaypoints = dockingOrPoints;\n  } else {\n    newWaypoints = oldWaypoints.slice();\n\n    newWaypoints.splice(newSource ? 0 : -1, 1, dockingOrPoints);\n  }\n\n  if (newSource) {\n    context.oldSource = connection.source;\n    connection.source = newSource;\n  }\n\n  if (newTarget) {\n    context.oldTarget = connection.target;\n    connection.target = newTarget;\n  }\n\n  connection.waypoints = newWaypoints;\n\n  return connection;\n};\n\nReconnectConnectionHandler.prototype.revert = function(context) {\n\n  var newSource = context.newSource,\n      newTarget = context.newTarget,\n      connection = context.connection;\n\n  if (newSource) {\n    connection.source = context.oldSource;\n  }\n\n  if (newTarget) {\n    connection.target = context.oldTarget;\n  }\n\n  connection.waypoints = context.oldWaypoints;\n\n  return connection;\n};","import { forEach } from 'min-dash';\n\n\n/**\n * A handler that implements reversible replacing of shapes.\n * Internally the old shape will be removed and the new shape will be added.\n *\n *\n * @class\n * @constructor\n *\n * @param {canvas} Canvas\n */\nexport default function ReplaceShapeHandler(modeling, rules) {\n  this._modeling = modeling;\n  this._rules = rules;\n}\n\nReplaceShapeHandler.$inject = [ 'modeling', 'rules' ];\n\n\n// api //////////////////////\n\n\n/**\n * Replaces a shape with an replacement Element.\n *\n * The newData object should contain type, x, y.\n *\n * If possible also the incoming/outgoing connection\n * will be restored.\n *\n * @param {Object} context\n */\nReplaceShapeHandler.prototype.preExecute = function(context) {\n\n  var self = this,\n      modeling = this._modeling,\n      rules = this._rules;\n\n  var oldShape = context.oldShape,\n      newData = context.newData,\n      hints = context.hints,\n      newShape;\n\n  function canReconnect(type, source, target, connection) {\n    return rules.allowed(type, {\n      source: source,\n      target: target,\n      connection: connection\n    });\n  }\n\n\n  // (1) place a new shape at the given position\n\n  var position = {\n    x: newData.x,\n    y: newData.y\n  };\n\n  newShape = context.newShape =\n    context.newShape ||\n    self.createShape(newData, position, oldShape.parent, hints);\n\n\n  // (2) update the host\n\n  if (oldShape.host) {\n    modeling.updateAttachment(newShape, oldShape.host);\n  }\n\n\n  // (3) adopt all children from the old shape\n\n  var children;\n\n  if (hints.moveChildren !== false) {\n    children = oldShape.children.slice();\n\n    modeling.moveElements(children, { x: 0, y: 0 }, newShape);\n  }\n\n  // (4) reconnect connections to the new shape (where allowed)\n\n  var incoming = oldShape.incoming.slice(),\n      outgoing = oldShape.outgoing.slice();\n\n  forEach(incoming, function(connection) {\n    var waypoints = connection.waypoints,\n        docking = waypoints[waypoints.length - 1],\n        source = connection.source,\n        allowed = canReconnect('connection.reconnectEnd', source, newShape, connection);\n\n    if (allowed) {\n      self.reconnectEnd(connection, newShape, docking);\n    }\n  });\n\n  forEach(outgoing, function(connection) {\n    var waypoints = connection.waypoints,\n        docking = waypoints[0],\n        target = connection.target,\n        allowed = canReconnect('connection.reconnectStart', newShape, target, connection);\n\n    if (allowed) {\n      self.reconnectStart(connection, newShape, docking);\n    }\n\n  });\n};\n\n\nReplaceShapeHandler.prototype.postExecute = function(context) {\n  var modeling = this._modeling;\n\n  var oldShape = context.oldShape,\n      newShape = context.newShape;\n\n  // if an element gets resized on replace, layout the connection again\n  forEach(newShape.incoming, function(c) {\n    modeling.layoutConnection(c, { endChanged: true });\n  });\n\n  forEach(newShape.outgoing, function(c) {\n    modeling.layoutConnection(c, { startChanged: true });\n  });\n\n  modeling.removeShape(oldShape);\n};\n\n\nReplaceShapeHandler.prototype.execute = function(context) {};\n\nReplaceShapeHandler.prototype.revert = function(context) {};\n\n\nReplaceShapeHandler.prototype.createShape = function(shape, position, target, hints) {\n  var modeling = this._modeling;\n  return modeling.createShape(shape, position, target, hints);\n};\n\n\nReplaceShapeHandler.prototype.reconnectStart = function(connection, newSource, dockingPoint) {\n  var modeling = this._modeling;\n  modeling.reconnectStart(connection, newSource, dockingPoint);\n};\n\n\nReplaceShapeHandler.prototype.reconnectEnd = function(connection, newTarget, dockingPoint) {\n  var modeling = this._modeling;\n  modeling.reconnectEnd(connection, newTarget, dockingPoint);\n};\n","import {\n  assign,\n  forEach\n} from 'min-dash';\n\nimport {\n  getResizedSourceAnchor,\n  getResizedTargetAnchor\n} from './helper/AnchorsHelper';\n\n\n/**\n * A handler that implements reversible resizing of shapes.\n *\n * @param {Modeling} modeling\n */\nexport default function ResizeShapeHandler(modeling) {\n  this._modeling = modeling;\n}\n\nResizeShapeHandler.$inject = [ 'modeling' ];\n\n/**\n * {\n *   shape: {....}\n *   newBounds: {\n *     width:  20,\n *     height: 40,\n *     x:       5,\n *     y:      10\n *   }\n *\n * }\n */\nResizeShapeHandler.prototype.execute = function(context) {\n  var shape = context.shape,\n      newBounds = context.newBounds,\n      minBounds = context.minBounds;\n\n  if (newBounds.x === undefined || newBounds.y === undefined ||\n      newBounds.width === undefined || newBounds.height === undefined) {\n    throw new Error('newBounds must have {x, y, width, height} properties');\n  }\n\n  if (minBounds && (newBounds.width < minBounds.width\n    || newBounds.height < minBounds.height)) {\n    throw new Error('width and height cannot be less than minimum height and width');\n  } else if (!minBounds\n    && newBounds.width < 10 || newBounds.height < 10) {\n    throw new Error('width and height cannot be less than 10px');\n  }\n\n  // save old bbox in context\n  context.oldBounds = {\n    width:  shape.width,\n    height: shape.height,\n    x:      shape.x,\n    y:      shape.y\n  };\n\n  // update shape\n  assign(shape, {\n    width:  newBounds.width,\n    height: newBounds.height,\n    x:      newBounds.x,\n    y:      newBounds.y\n  });\n\n  return shape;\n};\n\nResizeShapeHandler.prototype.postExecute = function(context) {\n\n  var shape = context.shape,\n      oldBounds = context.oldBounds;\n\n  var modeling = this._modeling;\n\n  forEach(shape.incoming, function(c) {\n    modeling.layoutConnection(c, {\n      connectionEnd: getResizedTargetAnchor(c, shape, oldBounds)\n    });\n  });\n\n  forEach(shape.outgoing, function(c) {\n    modeling.layoutConnection(c, {\n      connectionStart: getResizedSourceAnchor(c, shape, oldBounds)\n    });\n  });\n\n};\n\nResizeShapeHandler.prototype.revert = function(context) {\n\n  var shape = context.shape,\n      oldBounds = context.oldBounds;\n\n  // restore previous bbox\n  assign(shape, {\n    width:  oldBounds.width,\n    height: oldBounds.height,\n    x:      oldBounds.x,\n    y:      oldBounds.y\n  });\n\n  return shape;\n};\n","import { forEach } from 'min-dash';\n\nimport {\n  resizeBounds\n} from '../../space-tool/SpaceUtil';\n\n\n/**\n * A handler that implements reversible creating and removing of space.\n *\n * It executes in two phases:\n *\n *  (1) resize all affected resizeShapes\n *  (2) move all affected moveElements\n */\nexport default function SpaceToolHandler(modeling) {\n  this._modeling = modeling;\n}\n\nSpaceToolHandler.$inject = [ 'modeling' ];\n\n\nSpaceToolHandler.prototype.preExecute = function(context) {\n\n  // resize\n  var modeling = this._modeling,\n      resizingShapes = context.resizingShapes,\n      delta = context.delta,\n      direction = context.direction;\n\n  forEach(resizingShapes, function(shape) {\n    var newBounds = resizeBounds(shape, direction, delta);\n\n    modeling.resizeShape(shape, newBounds);\n  });\n};\n\nSpaceToolHandler.prototype.postExecute = function(context) {\n  // move\n  var modeling = this._modeling,\n      movingShapes = context.movingShapes,\n      delta = context.delta;\n\n  modeling.moveElements(movingShapes, delta, undefined, { autoResize: false, attach: false });\n};\n\nSpaceToolHandler.prototype.execute = function(context) {};\nSpaceToolHandler.prototype.revert = function(context) {};\n","/**\n * A handler that toggles the collapsed state of an element\n * and the visibility of all its children.\n *\n * @param {Modeling} modeling\n */\nexport default function ToggleShapeCollapseHandler(modeling) {\n  this._modeling = modeling;\n}\n\nToggleShapeCollapseHandler.$inject = [ 'modeling' ];\n\n\nToggleShapeCollapseHandler.prototype.execute = function(context) {\n\n  var shape = context.shape,\n      children = shape.children;\n\n  // remember previous visibility of children\n  context.oldChildrenVisibility = getElementsVisibility(children);\n\n  // toggle state\n  shape.collapsed = !shape.collapsed;\n\n  // hide/show children\n  setHidden(children, shape.collapsed);\n\n  return [shape].concat(children);\n};\n\n\nToggleShapeCollapseHandler.prototype.revert = function(context) {\n\n  var shape = context.shape,\n      oldChildrenVisibility = context.oldChildrenVisibility;\n\n  var children = shape.children;\n\n  // set old visability of children\n  restoreVisibility(children, oldChildrenVisibility);\n\n  // retoggle state\n  shape.collapsed = !shape.collapsed;\n\n  return [shape].concat(children);\n};\n\n\n// helpers //////////////////////\n\n/**\n * Return a map { elementId -> hiddenState}.\n *\n * @param {Array<djs.model.Shape>} elements\n *\n * @return {Object}\n */\nfunction getElementsVisibility(elements) {\n\n  var result = {};\n\n  elements.forEach(function(e) {\n    result[e.id] = e.hidden;\n  });\n\n  return result;\n}\n\n\nfunction setHidden(elements, newHidden) {\n  elements.forEach(function(element) {\n    element.hidden = newHidden;\n  });\n}\n\nfunction restoreVisibility(elements, lastState) {\n  elements.forEach(function(e) {\n    e.hidden = lastState[e.id];\n  });\n}\n","import {\n  add as collectionAdd,\n  remove as collectionRemove\n} from '../../../util/Collections';\n\n/**\n * A handler that implements reversible attaching/detaching of shapes.\n */\nexport default function UpdateAttachmentHandler(modeling) {\n  this._modeling = modeling;\n}\n\nUpdateAttachmentHandler.$inject = [ 'modeling' ];\n\n\nUpdateAttachmentHandler.prototype.execute = function(context) {\n  var shape = context.shape,\n      newHost = context.newHost,\n      oldHost = shape.host;\n\n  // (0) detach from old host\n  context.oldHost = oldHost;\n  context.attacherIdx = removeAttacher(oldHost, shape);\n\n  // (1) attach to new host\n  addAttacher(newHost, shape);\n\n  // (2) update host\n  shape.host = newHost;\n\n  return shape;\n};\n\nUpdateAttachmentHandler.prototype.revert = function(context) {\n  var shape = context.shape,\n      newHost = context.newHost,\n      oldHost = context.oldHost,\n      attacherIdx = context.attacherIdx;\n\n  // (2) update host\n  shape.host = oldHost;\n\n  // (1) attach to new host\n  removeAttacher(newHost, shape);\n\n  // (0) detach from old host\n  addAttacher(oldHost, shape, attacherIdx);\n\n  return shape;\n};\n\n\nfunction removeAttacher(host, attacher) {\n  // remove attacher from host\n  return collectionRemove(host && host.attachers, attacher);\n}\n\nfunction addAttacher(host, attacher, idx) {\n\n  if (!host) {\n    return;\n  }\n\n  var attachers = host.attachers;\n\n  if (!attachers) {\n    host.attachers = attachers = [];\n  }\n\n  collectionAdd(attachers, attacher, idx);\n}\n","export default function UpdateWaypointsHandler() { }\n\nUpdateWaypointsHandler.prototype.execute = function(context) {\n\n  var connection = context.connection,\n      newWaypoints = context.newWaypoints;\n\n  context.oldWaypoints = connection.waypoints;\n\n  connection.waypoints = newWaypoints;\n\n  return connection;\n};\n\nUpdateWaypointsHandler.prototype.revert = function(context) {\n\n  var connection = context.connection,\n      oldWaypoints = context.oldWaypoints;\n\n  connection.waypoints = oldWaypoints;\n\n  return connection;\n};","import {\n  getNewAttachPoint\n} from '../../../../util/AttachUtil';\n\n\nexport function getResizedSourceAnchor(connection, shape, oldBounds) {\n\n  var waypoints = safeGetWaypoints(connection),\n      oldAnchor = waypoints[0];\n\n  return getNewAttachPoint(oldAnchor.original || oldAnchor, oldBounds, shape);\n}\n\n\nexport function getResizedTargetAnchor(connection, shape, oldBounds) {\n\n  var waypoints = safeGetWaypoints(connection),\n      oldAnchor = waypoints[waypoints.length - 1];\n\n  return getNewAttachPoint(oldAnchor.original || oldAnchor, oldBounds, shape);\n}\n\n\nexport function getMovedSourceAnchor(connection, source, moveDelta) {\n  return getResizedSourceAnchor(connection, source, substractPosition(source, moveDelta));\n}\n\n\nexport function getMovedTargetAnchor(connection, target, moveDelta) {\n  return getResizedTargetAnchor(connection, target, substractPosition(target, moveDelta));\n}\n\n\n// helpers //////////////////////\n\nfunction substractPosition(bounds, delta) {\n  return {\n    x: bounds.x - delta.x,\n    y: bounds.y - delta.y,\n    width: bounds.width,\n    height: bounds.height\n  };\n}\n\n\n/**\n * Return waypoints of given connection; throw if non exists (should not happen!!).\n *\n * @param {Connection} connection\n *\n * @return {Array<Point>}\n */\nfunction safeGetWaypoints(connection) {\n\n  var waypoints = connection.waypoints;\n\n  if (!waypoints.length) {\n    throw new Error('connection#' + connection.id + ': no waypoints');\n  }\n\n  return waypoints;\n}\n","import {\n  assign\n} from 'min-dash';\n\nimport {\n  getClosure\n} from '../../../../util/Elements';\n\n\nexport default function MoveClosure() {\n\n  this.allShapes = {};\n  this.allConnections = {};\n\n  this.enclosedElements = {};\n  this.enclosedConnections = {};\n\n  this.topLevel = {};\n}\n\n\nMoveClosure.prototype.add = function(element, isTopLevel) {\n  return this.addAll([ element ], isTopLevel);\n};\n\n\nMoveClosure.prototype.addAll = function(elements, isTopLevel) {\n\n  var newClosure = getClosure(elements, !!isTopLevel, this);\n\n  assign(this, newClosure);\n\n  return this;\n};","import {\n  forEach\n} from 'min-dash';\n\nimport {\n  getMovedSourceAnchor,\n  getMovedTargetAnchor\n} from './AnchorsHelper';\n\nimport MoveClosure from './MoveClosure';\n\n\n/**\n * A helper that is able to carry out serialized move\n * operations on multiple elements.\n *\n * @param {Modeling} modeling\n */\nexport default function MoveHelper(modeling) {\n  this._modeling = modeling;\n}\n\n/**\n * Move the specified elements and all children by the given delta.\n *\n * This moves all enclosed connections, too and layouts all affected\n * external connections.\n *\n * @param  {Array<djs.model.Base>} elements\n * @param  {Point} delta\n * @param  {djs.model.Base} newParent applied to the first level of shapes\n *\n * @return {Array<djs.model.Base>} list of touched elements\n */\nMoveHelper.prototype.moveRecursive = function(elements, delta, newParent) {\n  if (!elements) {\n    return [];\n  } else {\n    return this.moveClosure(this.getClosure(elements), delta, newParent);\n  }\n};\n\n/**\n * Move the given closure of elmements.\n *\n * @param {Object} closure\n * @param {Point} delta\n * @param {djs.model.Base} [newParent]\n * @param {djs.model.Base} [newHost]\n */\nMoveHelper.prototype.moveClosure = function(closure, delta, newParent, newHost, primaryShape) {\n  var modeling = this._modeling;\n\n  var allShapes = closure.allShapes,\n      allConnections = closure.allConnections,\n      enclosedConnections = closure.enclosedConnections,\n      topLevel = closure.topLevel,\n      keepParent = false;\n\n  if (primaryShape && primaryShape.parent === newParent) {\n    keepParent = true;\n  }\n\n  // move all shapes\n  forEach(allShapes, function(shape) {\n\n    // move the element according to the given delta\n    modeling.moveShape(shape, delta, topLevel[shape.id] && !keepParent && newParent, {\n      recurse: false,\n      layout: false\n    });\n  });\n\n  // move all child connections / layout external connections\n  forEach(allConnections, function(c) {\n\n    var sourceMoved = !!allShapes[c.source.id],\n        targetMoved = !!allShapes[c.target.id];\n\n    if (enclosedConnections[c.id] && sourceMoved && targetMoved) {\n      modeling.moveConnection(c, delta, topLevel[c.id] && !keepParent && newParent);\n    } else {\n      modeling.layoutConnection(c, {\n        connectionStart: sourceMoved && getMovedSourceAnchor(c, c.source, delta),\n        connectionEnd: targetMoved && getMovedTargetAnchor(c, c.target, delta)\n      });\n    }\n  });\n};\n\n/**\n * Returns the closure for the selected elements\n *\n * @param  {Array<djs.model.Base>} elements\n * @return {MoveClosure} closure\n */\nMoveHelper.prototype.getClosure = function(elements) {\n  return new MoveClosure().addAll(elements, true);\n};","import { bind } from 'min-dash';\n\n\nexport default function MouseTracking(eventBus, canvas) {\n  this._eventBus = eventBus;\n  this._canvas = canvas;\n\n  this._init();\n}\n\nMouseTracking.$inject = [\n  'eventBus',\n  'canvas'\n];\n\n\nMouseTracking.prototype.getHoverContext = function() {\n  var viewbox = this._canvas.viewbox();\n\n  return {\n    element: this._hoverElement,\n    point: {\n      x: viewbox.x + Math.round(this._mouseX / viewbox.scale),\n      y: viewbox.y + Math.round(this._mouseY / viewbox.scale)\n    }\n  };\n};\n\nMouseTracking.prototype._init = function() {\n  var eventBus = this._eventBus,\n      canvas = this._canvas;\n\n  var container = canvas.getContainer();\n\n  this._setMousePosition = bind(this._setMousePosition, this);\n\n  container.addEventListener('mousemove', this._setMousePosition);\n\n  eventBus.on('diagram.destroy', function() {\n    container.removeEventListener('mousemove', this._setMousePosition);\n  }, this);\n\n  eventBus.on('element.hover', this._setHoverElement, this);\n};\n\n\nMouseTracking.prototype._setHoverElement = function(event) {\n  this._hoverElement = event.element;\n};\n\n\nMouseTracking.prototype._setMousePosition = function(event) {\n  this._mouseX = event.layerX;\n  this._mouseY = event.layerY;\n};\n","import MouseTracking from './MouseTracking';\n\nexport default {\n  __init__: [ 'mouseTracking' ],\n  mouseTracking: [ 'type', MouseTracking ]\n};\n","import {\n  assign,\n  filter,\n  groupBy\n} from 'min-dash';\n\nvar LOW_PRIORITY = 500,\n    MEDIUM_PRIORITY = 1250,\n    HIGH_PRIORITY = 1500;\n\nimport { getOriginal as getOriginalEvent } from '../../util/Event';\n\nvar round = Math.round;\n\nfunction mid(element) {\n  return {\n    x: element.x + round(element.width / 2),\n    y: element.y + round(element.height / 2)\n  };\n}\n\n/**\n * A plugin that makes shapes draggable / droppable.\n *\n * @param {EventBus} eventBus\n * @param {Dragging} dragging\n * @param {Modeling} modeling\n * @param {Selection} selection\n * @param {Rules} rules\n */\nexport default function MoveEvents(\n    eventBus, dragging, modeling,\n    selection, rules) {\n\n  // rules\n\n  function canMove(shapes, delta, position, target) {\n\n    return rules.allowed('elements.move', {\n      shapes: shapes,\n      delta: delta,\n      position: position,\n      target: target\n    });\n  }\n\n\n  // move events\n\n  // assign a high priority to this handler to setup the environment\n  // others may hook up later, e.g. at default priority and modify\n  // the move environment.\n  //\n  // This sets up the context with\n  //\n  // * shape: the primary shape being moved\n  // * shapes: a list of shapes to be moved\n  // * validatedShapes: a list of shapes that are being checked\n  //                    against the rules before and during move\n  //\n  eventBus.on('shape.move.start', HIGH_PRIORITY, function(event) {\n\n    var context = event.context,\n        shape = event.shape,\n        shapes = selection.get().slice();\n\n    // move only single shape if the dragged element\n    // is not part of the current selection\n    if (shapes.indexOf(shape) === -1) {\n      shapes = [ shape ];\n    }\n\n    // ensure we remove nested elements in the collection\n    // and add attachers for a proper dragger\n    shapes = removeNested(shapes);\n\n    // attach shapes to drag context\n    assign(context, {\n      shapes: shapes,\n      validatedShapes: shapes,\n      shape: shape\n    });\n  });\n\n\n  // assign a high priority to this handler to setup the environment\n  // others may hook up later, e.g. at default priority and modify\n  // the move environment\n  //\n  eventBus.on('shape.move.start', MEDIUM_PRIORITY, function(event) {\n\n    var context = event.context,\n        validatedShapes = context.validatedShapes,\n        canExecute;\n\n    canExecute = context.canExecute = canMove(validatedShapes);\n\n    // check if we can move the elements\n    if (!canExecute) {\n      return false;\n    }\n  });\n\n  // assign a low priority to this handler\n  // to let others modify the move event before we update\n  // the context\n  //\n  eventBus.on('shape.move.move', LOW_PRIORITY, function(event) {\n\n    var context = event.context,\n        validatedShapes = context.validatedShapes,\n        hover = event.hover,\n        delta = { x: event.dx, y: event.dy },\n        position = { x: event.x, y: event.y },\n        canExecute;\n\n    // check if we can move the elements\n    canExecute = canMove(validatedShapes, delta, position, hover);\n\n    context.delta = delta;\n    context.canExecute = canExecute;\n\n    // simply ignore move over\n    if (canExecute === null) {\n      context.target = null;\n\n      return;\n    }\n\n    context.target = hover;\n  });\n\n  eventBus.on('shape.move.end', function(event) {\n\n    var context = event.context;\n\n    var delta = context.delta,\n        canExecute = context.canExecute,\n        isAttach = canExecute === 'attach',\n        shapes = context.shapes;\n\n    if (!canExecute) {\n      return false;\n    }\n\n    // ensure we have actual pixel values deltas\n    // (important when zoom level was > 1 during move)\n    delta.x = round(delta.x);\n    delta.y = round(delta.y);\n\n    modeling.moveElements(shapes, delta, context.target, {\n      primaryShape: context.shape,\n      attach: isAttach\n    });\n  });\n\n\n  // move activation\n\n  eventBus.on('element.mousedown', function(event) {\n\n    var originalEvent = getOriginalEvent(event);\n\n    if (!originalEvent) {\n      throw new Error('must supply DOM mousedown event');\n    }\n\n    return start(originalEvent, event.element);\n  });\n\n\n  function start(event, element, activate) {\n\n    // do not move connections or the root element\n    if (element.waypoints || !element.parent) {\n      return;\n    }\n\n    var referencePoint = mid(element);\n\n    dragging.init(event, referencePoint, 'shape.move', {\n      cursor: 'grabbing',\n      autoActivate: activate,\n      data: {\n        shape: element,\n        context: {}\n      }\n    });\n\n    // we've handled the event\n    return true;\n  }\n\n  // API\n\n  this.start = start;\n}\n\nMoveEvents.$inject = [\n  'eventBus',\n  'dragging',\n  'modeling',\n  'selection',\n  'rules'\n];\n\n\n/**\n * Return a filtered list of elements that do not contain\n * those nested into others.\n *\n * @param  {Array<djs.model.Base>} elements\n *\n * @return {Array<djs.model.Base>} filtered\n */\nfunction removeNested(elements) {\n\n  var ids = groupBy(elements, 'id');\n\n  return filter(elements, function(element) {\n    while ((element = element.parent)) {\n\n      // parent in selection\n      if (ids[element.id]) {\n        return false;\n      }\n    }\n\n    return true;\n  });\n}\n","import {\n  flatten,\n  forEach,\n  filter,\n  find,\n  groupBy,\n  map,\n  matchPattern,\n  size\n} from 'min-dash';\n\nimport {\n  selfAndAllChildren\n} from '../../util/Elements';\n\nimport {\n  append as svgAppend,\n  attr as svgAttr,\n  clear as svgClear,\n  create as svgCreate\n} from 'tiny-svg';\n\nimport { translate } from '../../util/SvgTransformUtil';\n\nvar LOW_PRIORITY = 499;\n\nvar MARKER_DRAGGING = 'djs-dragging',\n    MARKER_OK = 'drop-ok',\n    MARKER_NOT_OK = 'drop-not-ok',\n    MARKER_NEW_PARENT = 'new-parent',\n    MARKER_ATTACH = 'attach-ok';\n\n\n/**\n * Provides previews for moving shapes when moving.\n *\n * @param {EventBus} eventBus\n * @param {ElementRegistry} elementRegistry\n * @param {Canvas} canvas\n * @param {Styles} styles\n */\nexport default function MovePreview(\n    eventBus, elementRegistry, canvas,\n    styles, previewSupport) {\n\n  function getVisualDragShapes(shapes) {\n    var elements = getAllDraggedElements(shapes);\n\n    var filteredElements = removeEdges(elements);\n\n    return filteredElements;\n  }\n\n  function getAllDraggedElements(shapes) {\n    var allShapes = selfAndAllChildren(shapes, true);\n\n    var allConnections = map(allShapes, function(shape) {\n      return (shape.incoming || []).concat(shape.outgoing || []);\n    });\n\n    return flatten(allShapes.concat(allConnections));\n  }\n\n  /**\n   * Sets drop marker on an element.\n   */\n  function setMarker(element, marker) {\n\n    [ MARKER_ATTACH, MARKER_OK, MARKER_NOT_OK, MARKER_NEW_PARENT ].forEach(function(m) {\n\n      if (m === marker) {\n        canvas.addMarker(element, m);\n      } else {\n        canvas.removeMarker(element, m);\n      }\n    });\n  }\n\n  /**\n   * Make an element draggable.\n   *\n   * @param {Object} context\n   * @param {djs.model.Base} element\n   * @param {Boolean} addMarker\n   */\n  function makeDraggable(context, element, addMarker) {\n\n    previewSupport.addDragger(element, context.dragGroup);\n\n    if (addMarker) {\n      canvas.addMarker(element, MARKER_DRAGGING);\n    }\n\n    if (context.allDraggedElements) {\n      context.allDraggedElements.push(element);\n    } else {\n      context.allDraggedElements = [ element ];\n    }\n  }\n\n  // assign a low priority to this handler\n  // to let others modify the move context before\n  // we draw things\n  eventBus.on('shape.move.start', LOW_PRIORITY, function(event) {\n\n    var context = event.context,\n        dragShapes = context.shapes,\n        allDraggedElements = context.allDraggedElements;\n\n    var visuallyDraggedShapes = getVisualDragShapes(dragShapes);\n\n    if (!context.dragGroup) {\n      var dragGroup = svgCreate('g');\n      svgAttr(dragGroup, styles.cls('djs-drag-group', [ 'no-events' ]));\n\n      var defaultLayer = canvas.getDefaultLayer();\n\n      svgAppend(defaultLayer, dragGroup);\n\n      context.dragGroup = dragGroup;\n    }\n\n    // add previews\n    visuallyDraggedShapes.forEach(function(shape) {\n      previewSupport.addDragger(shape, context.dragGroup);\n    });\n\n    // cache all dragged elements / gfx\n    // so that we can quickly undo their state changes later\n    if (!allDraggedElements) {\n      allDraggedElements = getAllDraggedElements(dragShapes);\n    } else {\n      allDraggedElements = flatten([\n        allDraggedElements,\n        getAllDraggedElements(dragShapes)\n      ]);\n    }\n\n    // add dragging marker\n    forEach(allDraggedElements, function(e) {\n      canvas.addMarker(e, MARKER_DRAGGING);\n    });\n\n    context.allDraggedElements = allDraggedElements;\n\n    // determine, if any of the dragged elements have different parents\n    context.differentParents = haveDifferentParents(dragShapes);\n  });\n\n  // update previews\n  eventBus.on('shape.move.move', LOW_PRIORITY, function(event) {\n\n    var context = event.context,\n        dragGroup = context.dragGroup,\n        target = context.target,\n        parent = context.shape.parent,\n        canExecute = context.canExecute;\n\n    if (target) {\n      if (canExecute === 'attach') {\n        setMarker(target, MARKER_ATTACH);\n      } else if (context.canExecute && target && target.id !== parent.id) {\n        setMarker(target, MARKER_NEW_PARENT);\n      } else {\n        setMarker(target, context.canExecute ? MARKER_OK : MARKER_NOT_OK);\n      }\n    }\n\n    translate(dragGroup, event.dx, event.dy);\n  });\n\n  eventBus.on([ 'shape.move.out', 'shape.move.cleanup' ], function(event) {\n    var context = event.context,\n        target = context.target;\n\n    if (target) {\n      setMarker(target, null);\n    }\n  });\n\n  // remove previews\n  eventBus.on('shape.move.cleanup', function(event) {\n\n    var context = event.context,\n        allDraggedElements = context.allDraggedElements,\n        dragGroup = context.dragGroup;\n\n\n    // remove dragging marker\n    forEach(allDraggedElements, function(e) {\n      canvas.removeMarker(e, MARKER_DRAGGING);\n    });\n\n    if (dragGroup) {\n      svgClear(dragGroup);\n    }\n  });\n\n\n  // API //////////////////////\n\n  /**\n   * Make an element draggable.\n   *\n   * @param {Object} context\n   * @param {djs.model.Base} element\n   * @param {Boolean} addMarker\n   */\n  this.makeDraggable = makeDraggable;\n}\n\nMovePreview.$inject = [\n  'eventBus',\n  'elementRegistry',\n  'canvas',\n  'styles',\n  'previewSupport'\n];\n\n\n// helpers //////////////////////\n\n/**\n * returns elements minus all connections\n * where source or target is not elements\n */\nfunction removeEdges(elements) {\n\n  var filteredElements = filter(elements, function(element) {\n\n    if (!isConnection(element)) {\n      return true;\n    } else {\n\n      return (\n        find(elements, matchPattern({ id: element.source.id })) &&\n        find(elements, matchPattern({ id: element.target.id }))\n      );\n    }\n  });\n\n  return filteredElements;\n}\n\nfunction haveDifferentParents(elements) {\n  return size(groupBy(elements, function(e) { return e.parent && e.parent.id; })) !== 1;\n}\n\n/**\n * Checks if an element is a connection.\n */\nfunction isConnection(element) {\n  return element.waypoints;\n}\n","import InteractionEventsModule from '../interaction-events';\nimport SelectionModule from '../selection';\nimport OutlineModule from '../outline';\nimport RulesModule from '../rules';\nimport DraggingModule from '../dragging';\nimport PreviewSupportModule from '../preview-support';\n\nimport Move from './Move';\nimport MovePreview from './MovePreview';\n\nexport default {\n  __depends__: [\n    InteractionEventsModule,\n    SelectionModule,\n    OutlineModule,\n    RulesModule,\n    DraggingModule,\n    PreviewSupportModule\n  ],\n  __init__: [\n    'move',\n    'movePreview'\n  ],\n  move: [ 'type', Move ],\n  movePreview: [ 'type', MovePreview ]\n};\n","import inherits from 'inherits';\n\nimport CommandInterceptor from '../../command/CommandInterceptor';\n\n\n/**\n * An abstract provider that allows modelers to implement a custom\n * ordering of diagram elements on the canvas.\n *\n * It makes sure that the order is always preserved during element\n * creation and move operations.\n *\n * In order to use this behavior, inherit from it and override\n * the method {@link OrderingProvider#getOrdering}.\n *\n * @example\n *\n * ```javascript\n * function CustomOrderingProvider(eventBus) {\n *   OrderingProvider.call(this, eventBus);\n *\n *   this.getOrdering = function(element, newParent) {\n *     // always insert elements at the front\n *     // when moving\n *     return {\n *       index: 0,\n *       parent: newParent\n *     };\n *   };\n * }\n * ```\n *\n * @param {EventBus} eventBus\n */\nexport default function OrderingProvider(eventBus) {\n\n  CommandInterceptor.call(this, eventBus);\n\n\n  var self = this;\n\n  this.preExecute([ 'shape.create', 'connection.create' ], function(event) {\n\n    var context = event.context,\n        element = context.shape || context.connection,\n        parent = context.parent;\n\n    var ordering = self.getOrdering(element, parent);\n\n    if (ordering) {\n\n      if (ordering.parent !== undefined) {\n        context.parent = ordering.parent;\n      }\n\n      context.parentIndex = ordering.index;\n    }\n  });\n\n  this.preExecute([ 'shape.move', 'connection.move' ], function(event) {\n\n    var context = event.context,\n        element = context.shape || context.connection,\n        parent = context.newParent || element.parent;\n\n    var ordering = self.getOrdering(element, parent);\n\n    if (ordering) {\n\n      if (ordering.parent !== undefined) {\n        context.newParent = ordering.parent;\n      }\n\n      context.newParentIndex = ordering.index;\n    }\n  });\n}\n\n/**\n * Return a custom ordering of the element, both in terms\n * of parent element and index in the new parent.\n *\n * Implementors of this method must return an object with\n * `parent` _and_ `index` in it.\n *\n * @param {djs.model.Base} element\n * @param {djs.model.Shape} newParent\n *\n * @return {Object} ordering descriptor\n */\nOrderingProvider.prototype.getOrdering = function(element, newParent) {\n  return null;\n};\n\ninherits(OrderingProvider, CommandInterceptor);","import { getBBox } from '../../util/Elements';\n\nvar LOW_PRIORITY = 500;\n\nimport {\n  append as svgAppend,\n  attr as svgAttr,\n  create as svgCreate\n} from 'tiny-svg';\n\nimport {\n  query as domQuery\n} from 'min-dom';\n\nimport {\n  assign\n} from 'min-dash';\n\n\n/**\n * @class\n *\n * A plugin that adds an outline to shapes and connections that may be activated and styled\n * via CSS classes.\n *\n * @param {EventBus} eventBus\n * @param {Styles} styles\n * @param {ElementRegistry} elementRegistry\n */\nexport default function Outline(eventBus, styles, elementRegistry) {\n\n  this.offset = 6;\n\n  var OUTLINE_STYLE = styles.cls('djs-outline', [ 'no-fill' ]);\n\n  var self = this;\n\n  function createOutline(gfx, bounds) {\n    var outline = svgCreate('rect');\n\n    svgAttr(outline, assign({\n      x: 10,\n      y: 10,\n      width: 100,\n      height: 100\n    }, OUTLINE_STYLE));\n\n    svgAppend(gfx, outline);\n\n    return outline;\n  }\n\n  // A low priortity is necessary, because outlines of labels have to be updated\n  // after the label bounds have been updated in the renderer.\n  eventBus.on([ 'shape.added', 'shape.changed' ], LOW_PRIORITY, function(event) {\n    var element = event.element,\n        gfx = event.gfx;\n\n    var outline = domQuery('.djs-outline', gfx);\n\n    if (!outline) {\n      outline = createOutline(gfx, element);\n    }\n\n    self.updateShapeOutline(outline, element);\n  });\n\n  eventBus.on([ 'connection.added', 'connection.changed' ], function(event) {\n    var element = event.element,\n        gfx = event.gfx;\n\n    var outline = domQuery('.djs-outline', gfx);\n\n    if (!outline) {\n      outline = createOutline(gfx, element);\n    }\n\n    self.updateConnectionOutline(outline, element);\n  });\n}\n\n\n/**\n * Updates the outline of a shape respecting the dimension of the\n * element and an outline offset.\n *\n * @param  {SVGElement} outline\n * @param  {djs.model.Base} element\n */\nOutline.prototype.updateShapeOutline = function(outline, element) {\n\n  svgAttr(outline, {\n    x: -this.offset,\n    y: -this.offset,\n    width: element.width + this.offset * 2,\n    height: element.height + this.offset * 2\n  });\n\n};\n\n\n/**\n * Updates the outline of a connection respecting the bounding box of\n * the connection and an outline offset.\n *\n * @param  {SVGElement} outline\n * @param  {djs.model.Base} element\n */\nOutline.prototype.updateConnectionOutline = function(outline, connection) {\n\n  var bbox = getBBox(connection);\n\n  svgAttr(outline, {\n    x: bbox.x - this.offset,\n    y: bbox.y - this.offset,\n    width: bbox.width + this.offset * 2,\n    height: bbox.height + this.offset * 2\n  });\n\n};\n\n\nOutline.$inject = ['eventBus', 'styles', 'elementRegistry'];","import Outline from './Outline';\n\nexport default {\n  __init__: [ 'outline' ],\n  outline: [ 'type', Outline ]\n};","import {\n  isArray,\n  isString,\n  isObject,\n  assign,\n  forEach,\n  find,\n  filter,\n  matchPattern,\n  isDefined\n} from 'min-dash';\n\nimport {\n  domify,\n  classes as domClasses,\n  attr as domAttr,\n  remove as domRemove,\n  clear as domClear\n} from 'min-dom';\n\nimport {\n  getBBox\n} from '../../util/Elements';\n\nimport Ids from '../../util/IdGenerator';\n\n// document wide unique overlay ids\nvar ids = new Ids('ov');\n\nvar LOW_PRIORITY = 500;\n\n\n/**\n * A service that allows users to attach overlays to diagram elements.\n *\n * The overlay service will take care of overlay positioning during updates.\n *\n * @example\n *\n * // add a pink badge on the top left of the shape\n * overlays.add(someShape, {\n *   position: {\n *     top: -5,\n *     left: -5\n *   },\n *   html: '<div style=\"width: 10px; background: fuchsia; color: white;\">0</div>'\n * });\n *\n * // or add via shape id\n *\n * overlays.add('some-element-id', {\n *   position: {\n *     top: -5,\n *     left: -5\n *   }\n *   html: '<div style=\"width: 10px; background: fuchsia; color: white;\">0</div>'\n * });\n *\n * // or add with optional type\n *\n * overlays.add(someShape, 'badge', {\n *   position: {\n *     top: -5,\n *     left: -5\n *   }\n *   html: '<div style=\"width: 10px; background: fuchsia; color: white;\">0</div>'\n * });\n *\n *\n * // remove an overlay\n *\n * var id = overlays.add(...);\n * overlays.remove(id);\n *\n *\n * You may configure overlay defaults during tool by providing a `config` module\n * with `overlays.defaults` as an entry:\n *\n * {\n *   overlays: {\n *     defaults: {\n *       show: {\n *         minZoom: 0.7,\n *         maxZoom: 5.0\n *       },\n *       scale: {\n *         min: 1\n *       }\n *     }\n * }\n *\n * @param {Object} config\n * @param {EventBus} eventBus\n * @param {Canvas} canvas\n * @param {ElementRegistry} elementRegistry\n */\nexport default function Overlays(config, eventBus, canvas, elementRegistry) {\n\n  this._eventBus = eventBus;\n  this._canvas = canvas;\n  this._elementRegistry = elementRegistry;\n\n  this._ids = ids;\n\n  this._overlayDefaults = assign({\n    // no show constraints\n    show: null,\n\n    // always scale\n    scale: true\n  }, config && config.defaults);\n\n  /**\n   * Mapping overlayId -> overlay\n   */\n  this._overlays = {};\n\n  /**\n   * Mapping elementId -> overlay container\n   */\n  this._overlayContainers = [];\n\n  // root html element for all overlays\n  this._overlayRoot = createRoot(canvas.getContainer());\n\n  this._init();\n}\n\n\nOverlays.$inject = [\n  'config.overlays',\n  'eventBus',\n  'canvas',\n  'elementRegistry'\n];\n\n\n/**\n * Returns the overlay with the specified id or a list of overlays\n * for an element with a given type.\n *\n * @example\n *\n * // return the single overlay with the given id\n * overlays.get('some-id');\n *\n * // return all overlays for the shape\n * overlays.get({ element: someShape });\n *\n * // return all overlays on shape with type 'badge'\n * overlays.get({ element: someShape, type: 'badge' });\n *\n * // shape can also be specified as id\n * overlays.get({ element: 'element-id', type: 'badge' });\n *\n *\n * @param {Object} search\n * @param {String} [search.id]\n * @param {String|djs.model.Base} [search.element]\n * @param {String} [search.type]\n *\n * @return {Object|Array<Object>} the overlay(s)\n */\nOverlays.prototype.get = function(search) {\n\n  if (isString(search)) {\n    search = { id: search };\n  }\n\n  if (isString(search.element)) {\n    search.element = this._elementRegistry.get(search.element);\n  }\n\n  if (search.element) {\n    var container = this._getOverlayContainer(search.element, true);\n\n    // return a list of overlays when searching by element (+type)\n    if (container) {\n      return search.type ? filter(container.overlays, matchPattern({ type: search.type })) : container.overlays.slice();\n    } else {\n      return [];\n    }\n  } else\n  if (search.type) {\n    return filter(this._overlays, matchPattern({ type: search.type }));\n  } else {\n    // return single element when searching by id\n    return search.id ? this._overlays[search.id] : null;\n  }\n};\n\n/**\n * Adds a HTML overlay to an element.\n *\n * @param {String|djs.model.Base}   element   attach overlay to this shape\n * @param {String}                  [type]    optional type to assign to the overlay\n * @param {Object}                  overlay   the overlay configuration\n *\n * @param {String|DOMElement}       overlay.html                 html element to use as an overlay\n * @param {Object}                  [overlay.show]               show configuration\n * @param {Number}                  [overlay.show.minZoom]       minimal zoom level to show the overlay\n * @param {Number}                  [overlay.show.maxZoom]       maximum zoom level to show the overlay\n * @param {Object}                  overlay.position             where to attach the overlay\n * @param {Number}                  [overlay.position.left]      relative to element bbox left attachment\n * @param {Number}                  [overlay.position.top]       relative to element bbox top attachment\n * @param {Number}                  [overlay.position.bottom]    relative to element bbox bottom attachment\n * @param {Number}                  [overlay.position.right]     relative to element bbox right attachment\n * @param {Boolean|Object}          [overlay.scale=true]         false to preserve the same size regardless of\n *                                                               diagram zoom\n * @param {Number}                  [overlay.scale.min]\n * @param {Number}                  [overlay.scale.max]\n *\n * @return {String}                 id that may be used to reference the overlay for update or removal\n */\nOverlays.prototype.add = function(element, type, overlay) {\n\n  if (isObject(type)) {\n    overlay = type;\n    type = null;\n  }\n\n  if (!element.id) {\n    element = this._elementRegistry.get(element);\n  }\n\n  if (!overlay.position) {\n    throw new Error('must specifiy overlay position');\n  }\n\n  if (!overlay.html) {\n    throw new Error('must specifiy overlay html');\n  }\n\n  if (!element) {\n    throw new Error('invalid element specified');\n  }\n\n  var id = this._ids.next();\n\n  overlay = assign({}, this._overlayDefaults, overlay, {\n    id: id,\n    type: type,\n    element: element,\n    html: overlay.html\n  });\n\n  this._addOverlay(overlay);\n\n  return id;\n};\n\n\n/**\n * Remove an overlay with the given id or all overlays matching the given filter.\n *\n * @see Overlays#get for filter options.\n *\n * @param {String} [id]\n * @param {Object} [filter]\n */\nOverlays.prototype.remove = function(filter) {\n\n  var overlays = this.get(filter) || [];\n\n  if (!isArray(overlays)) {\n    overlays = [ overlays ];\n  }\n\n  var self = this;\n\n  forEach(overlays, function(overlay) {\n\n    var container = self._getOverlayContainer(overlay.element, true);\n\n    if (overlay) {\n      domRemove(overlay.html);\n      domRemove(overlay.htmlContainer);\n\n      delete overlay.htmlContainer;\n      delete overlay.element;\n\n      delete self._overlays[overlay.id];\n    }\n\n    if (container) {\n      var idx = container.overlays.indexOf(overlay);\n      if (idx !== -1) {\n        container.overlays.splice(idx, 1);\n      }\n    }\n  });\n\n};\n\n\nOverlays.prototype.show = function() {\n  setVisible(this._overlayRoot);\n};\n\n\nOverlays.prototype.hide = function() {\n  setVisible(this._overlayRoot, false);\n};\n\nOverlays.prototype.clear = function() {\n  this._overlays = {};\n\n  this._overlayContainers = [];\n\n  domClear(this._overlayRoot);\n};\n\nOverlays.prototype._updateOverlayContainer = function(container) {\n  var element = container.element,\n      html = container.html;\n\n  // update container left,top according to the elements x,y coordinates\n  // this ensures we can attach child elements relative to this container\n\n  var x = element.x,\n      y = element.y;\n\n  if (element.waypoints) {\n    var bbox = getBBox(element);\n    x = bbox.x;\n    y = bbox.y;\n  }\n\n  setPosition(html, x, y);\n\n  domAttr(container.html, 'data-container-id', element.id);\n};\n\n\nOverlays.prototype._updateOverlay = function(overlay) {\n\n  var position = overlay.position,\n      htmlContainer = overlay.htmlContainer,\n      element = overlay.element;\n\n  // update overlay html relative to shape because\n  // it is already positioned on the element\n\n  // update relative\n  var left = position.left,\n      top = position.top;\n\n  if (position.right !== undefined) {\n\n    var width;\n\n    if (element.waypoints) {\n      width = getBBox(element).width;\n    } else {\n      width = element.width;\n    }\n\n    left = position.right * -1 + width;\n  }\n\n  if (position.bottom !== undefined) {\n\n    var height;\n\n    if (element.waypoints) {\n      height = getBBox(element).height;\n    } else {\n      height = element.height;\n    }\n\n    top = position.bottom * -1 + height;\n  }\n\n  setPosition(htmlContainer, left || 0, top || 0);\n};\n\n\nOverlays.prototype._createOverlayContainer = function(element) {\n  var html = domify('<div class=\"djs-overlays\" style=\"position: absolute\" />');\n\n  this._overlayRoot.appendChild(html);\n\n  var container = {\n    html: html,\n    element: element,\n    overlays: []\n  };\n\n  this._updateOverlayContainer(container);\n\n  this._overlayContainers.push(container);\n\n  return container;\n};\n\n\nOverlays.prototype._updateRoot = function(viewbox) {\n  var scale = viewbox.scale || 1;\n\n  var matrix = 'matrix(' +\n  [\n    scale,\n    0,\n    0,\n    scale,\n    -1 * viewbox.x * scale,\n    -1 * viewbox.y * scale\n  ].join(',') +\n  ')';\n\n  setTransform(this._overlayRoot, matrix);\n};\n\n\nOverlays.prototype._getOverlayContainer = function(element, raw) {\n  var container = find(this._overlayContainers, function(c) {\n    return c.element === element;\n  });\n\n\n  if (!container && !raw) {\n    return this._createOverlayContainer(element);\n  }\n\n  return container;\n};\n\n\nOverlays.prototype._addOverlay = function(overlay) {\n\n  var id = overlay.id,\n      element = overlay.element,\n      html = overlay.html,\n      htmlContainer,\n      overlayContainer;\n\n  // unwrap jquery (for those who need it)\n  if (html.get && html.constructor.prototype.jquery) {\n    html = html.get(0);\n  }\n\n  // create proper html elements from\n  // overlay HTML strings\n  if (isString(html)) {\n    html = domify(html);\n  }\n\n  overlayContainer = this._getOverlayContainer(element);\n\n  htmlContainer = domify('<div class=\"djs-overlay\" data-overlay-id=\"' + id + '\" style=\"position: absolute\">');\n\n  htmlContainer.appendChild(html);\n\n  if (overlay.type) {\n    domClasses(htmlContainer).add('djs-overlay-' + overlay.type);\n  }\n\n  overlay.htmlContainer = htmlContainer;\n\n  overlayContainer.overlays.push(overlay);\n  overlayContainer.html.appendChild(htmlContainer);\n\n  this._overlays[id] = overlay;\n\n  this._updateOverlay(overlay);\n  this._updateOverlayVisibilty(overlay, this._canvas.viewbox());\n};\n\n\nOverlays.prototype._updateOverlayVisibilty = function(overlay, viewbox) {\n  var show = overlay.show,\n      minZoom = show && show.minZoom,\n      maxZoom = show && show.maxZoom,\n      htmlContainer = overlay.htmlContainer,\n      visible = true;\n\n  if (show) {\n    if (\n      (isDefined(minZoom) && minZoom > viewbox.scale) ||\n      (isDefined(maxZoom) && maxZoom < viewbox.scale)\n    ) {\n      visible = false;\n    }\n\n    setVisible(htmlContainer, visible);\n  }\n\n  this._updateOverlayScale(overlay, viewbox);\n};\n\n\nOverlays.prototype._updateOverlayScale = function(overlay, viewbox) {\n  var shouldScale = overlay.scale,\n      minScale,\n      maxScale,\n      htmlContainer = overlay.htmlContainer;\n\n  var scale, transform = '';\n\n  if (shouldScale !== true) {\n\n    if (shouldScale === false) {\n      minScale = 1;\n      maxScale = 1;\n    } else {\n      minScale = shouldScale.min;\n      maxScale = shouldScale.max;\n    }\n\n    if (isDefined(minScale) && viewbox.scale < minScale) {\n      scale = (1 / viewbox.scale || 1) * minScale;\n    }\n\n    if (isDefined(maxScale) && viewbox.scale > maxScale) {\n      scale = (1 / viewbox.scale || 1) * maxScale;\n    }\n  }\n\n  if (isDefined(scale)) {\n    transform = 'scale(' + scale + ',' + scale + ')';\n  }\n\n  setTransform(htmlContainer, transform);\n};\n\n\nOverlays.prototype._updateOverlaysVisibilty = function(viewbox) {\n\n  var self = this;\n\n  forEach(this._overlays, function(overlay) {\n    self._updateOverlayVisibilty(overlay, viewbox);\n  });\n};\n\n\nOverlays.prototype._init = function() {\n\n  var eventBus = this._eventBus;\n\n  var self = this;\n\n\n  // scroll/zoom integration\n\n  function updateViewbox(viewbox) {\n    self._updateRoot(viewbox);\n    self._updateOverlaysVisibilty(viewbox);\n\n    self.show();\n  }\n\n  eventBus.on('canvas.viewbox.changing', function(event) {\n    self.hide();\n  });\n\n  eventBus.on('canvas.viewbox.changed', function(event) {\n    updateViewbox(event.viewbox);\n  });\n\n\n  // remove integration\n\n  eventBus.on([ 'shape.remove', 'connection.remove' ], function(e) {\n    var element = e.element;\n    var overlays = self.get({ element: element });\n\n    forEach(overlays, function(o) {\n      self.remove(o.id);\n    });\n\n    var container = self._getOverlayContainer(element);\n\n    if (container) {\n      domRemove(container.html);\n      var i = self._overlayContainers.indexOf(container);\n      if (i !== -1) {\n        self._overlayContainers.splice(i, 1);\n      }\n    }\n  });\n\n\n  // move integration\n\n  eventBus.on('element.changed', LOW_PRIORITY, function(e) {\n    var element = e.element;\n\n    var container = self._getOverlayContainer(element, true);\n\n    if (container) {\n      forEach(container.overlays, function(overlay) {\n        self._updateOverlay(overlay);\n      });\n\n      self._updateOverlayContainer(container);\n    }\n  });\n\n\n  // marker integration, simply add them on the overlays as classes, too.\n\n  eventBus.on('element.marker.update', function(e) {\n    var container = self._getOverlayContainer(e.element, true);\n    if (container) {\n      domClasses(container.html)[e.add ? 'add' : 'remove'](e.marker);\n    }\n  });\n\n\n  // clear overlays with diagram\n\n  eventBus.on('diagram.clear', this.clear, this);\n};\n\n\n\n// helpers /////////////////////////////\n\nfunction createRoot(parentNode) {\n  var root = domify(\n    '<div class=\"djs-overlay-container\" style=\"position: absolute; width: 0; height: 0;\" />'\n  );\n\n  parentNode.insertBefore(root, parentNode.firstChild);\n\n  return root;\n}\n\nfunction setPosition(el, x, y) {\n  assign(el.style, { left: x + 'px', top: y + 'px' });\n}\n\nfunction setVisible(el, visible) {\n  el.style.display = visible === false ? 'none' : '';\n}\n\nfunction setTransform(el, transform) {\n\n  el.style['transform-origin'] = 'top left';\n\n  [ '', '-ms-', '-webkit-' ].forEach(function(prefix) {\n    el.style[prefix + 'transform'] = transform;\n  });\n}","import Overlays from './Overlays';\n\nexport default {\n  __init__: [ 'overlays' ],\n  overlays: [ 'type', Overlays ]\n};","import {\n  isFunction,\n  isArray,\n  forEach\n} from 'min-dash';\n\nimport {\n  domify,\n  query as domQuery,\n  attr as domAttr,\n  clear as domClear,\n  classes as domClasses,\n  matches as domMatches,\n  delegate as domDelegate,\n  event as domEvent\n} from 'min-dom';\n\n\nvar TOGGLE_SELECTOR = '.djs-palette-toggle',\n    ENTRY_SELECTOR = '.entry',\n    ELEMENT_SELECTOR = TOGGLE_SELECTOR + ', ' + ENTRY_SELECTOR;\n\nvar PALETTE_OPEN_CLS = 'open',\n    PALETTE_TWO_COLUMN_CLS = 'two-column';\n\n\n/**\n * A palette containing modeling elements.\n */\nexport default function Palette(eventBus, canvas) {\n\n  this._eventBus = eventBus;\n  this._canvas = canvas;\n\n  this._providers = [];\n\n  var self = this;\n\n  eventBus.on('tool-manager.update', function(event) {\n    var tool = event.tool;\n\n    self.updateToolHighlight(tool);\n  });\n\n  eventBus.on('i18n.changed', function() {\n    self._update();\n  });\n\n  eventBus.on('diagram.init', function() {\n\n    self._diagramInitialized = true;\n\n    // initialize + update once diagram is ready\n    if (self._providers.length) {\n      self._init();\n\n      self._update();\n    }\n  });\n}\n\nPalette.$inject = [ 'eventBus', 'canvas' ];\n\n\n/**\n * Register a provider with the palette\n *\n * @param  {PaletteProvider} provider\n */\nPalette.prototype.registerProvider = function(provider) {\n  this._providers.push(provider);\n\n  // postpone init / update until diagram is initialized\n  if (!this._diagramInitialized) {\n    return;\n  }\n\n  if (!this._container) {\n    this._init();\n  }\n\n  this._update();\n};\n\n\n/**\n * Returns the palette entries for a given element\n *\n * @return {Array<PaletteEntryDescriptor>} list of entries\n */\nPalette.prototype.getEntries = function() {\n\n  var entries = {};\n\n  // loop through all providers and their entries.\n  // group entries by id so that overriding an entry is possible\n  forEach(this._providers, function(provider) {\n    var e = provider.getPaletteEntries();\n\n    forEach(e, function(entry, id) {\n      entries[id] = entry;\n    });\n  });\n\n  return entries;\n};\n\n\n/**\n * Initialize\n */\nPalette.prototype._init = function() {\n  var canvas = this._canvas,\n      eventBus = this._eventBus;\n\n  var parent = canvas.getContainer(),\n      container = this._container = domify(Palette.HTML_MARKUP),\n      self = this;\n\n  parent.appendChild(container);\n\n  domDelegate.bind(container, ELEMENT_SELECTOR, 'click', function(event) {\n\n    var target = event.delegateTarget;\n\n    if (domMatches(target, TOGGLE_SELECTOR)) {\n      return self.toggle();\n    }\n\n    self.trigger('click', event);\n  });\n\n  // prevent drag propagation\n  domEvent.bind(container, 'mousedown', function(event) {\n    event.stopPropagation();\n  });\n\n  // prevent drag propagation\n  domDelegate.bind(container, ENTRY_SELECTOR, 'dragstart', function(event) {\n    self.trigger('dragstart', event);\n  });\n\n  eventBus.on('canvas.resized', this._layoutChanged, this);\n\n  eventBus.fire('palette.create', {\n    container: container\n  });\n};\n\n/**\n * Update palette state.\n *\n * @param  {Object} [state] { open, twoColumn }\n */\nPalette.prototype._toggleState = function(state) {\n\n  state = state || {};\n\n  var parent = this._getParentContainer(),\n      container = this._container;\n\n  var eventBus = this._eventBus;\n\n  var twoColumn;\n\n  var cls = domClasses(container);\n\n  if ('twoColumn' in state) {\n    twoColumn = state.twoColumn;\n  } else {\n    twoColumn = this._needsCollapse(parent.clientHeight, this._entries || {});\n  }\n\n  // always update two column\n  cls.toggle(PALETTE_TWO_COLUMN_CLS, twoColumn);\n\n  if ('open' in state) {\n    cls.toggle(PALETTE_OPEN_CLS, state.open);\n  }\n\n  eventBus.fire('palette.changed', {\n    twoColumn: twoColumn,\n    open: this.isOpen()\n  });\n};\n\nPalette.prototype._update = function() {\n\n  var entriesContainer = domQuery('.djs-palette-entries', this._container),\n      entries = this._entries = this.getEntries();\n\n  domClear(entriesContainer);\n\n  forEach(entries, function(entry, id) {\n\n    var grouping = entry.group || 'default';\n\n    var container = domQuery('[data-group=' + grouping + ']', entriesContainer);\n    if (!container) {\n      container = domify('<div class=\"group\" data-group=\"' + grouping + '\"></div>');\n      entriesContainer.appendChild(container);\n    }\n\n    var html = entry.html || (\n      entry.separator ?\n        '<hr class=\"separator\" />' :\n        '<div class=\"entry\" draggable=\"true\"></div>');\n\n\n    var control = domify(html);\n    container.appendChild(control);\n\n    if (!entry.separator) {\n      domAttr(control, 'data-action', id);\n\n      if (entry.title) {\n        domAttr(control, 'title', entry.title);\n      }\n\n      if (entry.className) {\n        addClasses(control, entry.className);\n      }\n\n      if (entry.imageUrl) {\n        control.appendChild(domify('<img src=\"' + entry.imageUrl + '\">'));\n      }\n    }\n  });\n\n  // open after update\n  this.open();\n};\n\n\n/**\n * Trigger an action available on the palette\n *\n * @param  {String} action\n * @param  {Event} event\n */\nPalette.prototype.trigger = function(action, event, autoActivate) {\n  var entries = this._entries,\n      entry,\n      handler,\n      originalEvent,\n      button = event.delegateTarget || event.target;\n\n  if (!button) {\n    return event.preventDefault();\n  }\n\n  entry = entries[domAttr(button, 'data-action')];\n\n  // when user clicks on the palette and not on an action\n  if (!entry) {\n    return;\n  }\n\n  handler = entry.action;\n\n  originalEvent = event.originalEvent || event;\n\n  // simple action (via callback function)\n  if (isFunction(handler)) {\n    if (action === 'click') {\n      handler(originalEvent, autoActivate);\n    }\n  } else {\n    if (handler[action]) {\n      handler[action](originalEvent, autoActivate);\n    }\n  }\n\n  // silence other actions\n  event.preventDefault();\n};\n\nPalette.prototype._layoutChanged = function() {\n  this._toggleState({});\n};\n\n/**\n * Do we need to collapse to two columns?\n *\n * @param {Number} availableHeight\n * @param {Object} entries\n *\n * @return {Boolean}\n */\nPalette.prototype._needsCollapse = function(availableHeight, entries) {\n\n  // top margin + bottom toggle + bottom margin\n  // implementors must override this method if they\n  // change the palette styles\n  var margin = 20 + 10 + 20;\n\n  var entriesHeight = Object.keys(entries).length * 46;\n\n  return availableHeight < entriesHeight + margin;\n};\n\n/**\n * Close the palette\n */\nPalette.prototype.close = function() {\n\n  this._toggleState({\n    open: false,\n    twoColumn: false\n  });\n};\n\n\n/**\n * Open the palette\n */\nPalette.prototype.open = function() {\n  this._toggleState({ open: true });\n};\n\n\nPalette.prototype.toggle = function(open) {\n  if (this.isOpen()) {\n    this.close();\n  } else {\n    this.open();\n  }\n};\n\nPalette.prototype.isActiveTool = function(tool) {\n  return tool && this._activeTool === tool;\n};\n\nPalette.prototype.updateToolHighlight = function(name) {\n  var entriesContainer,\n      toolsContainer;\n\n  if (!this._toolsContainer) {\n    entriesContainer = domQuery('.djs-palette-entries', this._container);\n\n    this._toolsContainer = domQuery('[data-group=tools]', entriesContainer);\n  }\n\n  toolsContainer = this._toolsContainer;\n\n  forEach(toolsContainer.children, function(tool) {\n    var actionName = tool.getAttribute('data-action');\n\n    if (!actionName) {\n      return;\n    }\n\n    var toolClasses = domClasses(tool);\n\n    actionName = actionName.replace('-tool', '');\n\n    if (toolClasses.contains('entry') && actionName === name) {\n      toolClasses.add('highlighted-entry');\n    } else {\n      toolClasses.remove('highlighted-entry');\n    }\n  });\n};\n\n\n/**\n * Return true if the palette is opened.\n *\n * @example\n *\n * palette.open();\n *\n * if (palette.isOpen()) {\n *   // yes, we are open\n * }\n *\n * @return {boolean} true if palette is opened\n */\nPalette.prototype.isOpen = function() {\n  return domClasses(this._container).has(PALETTE_OPEN_CLS);\n};\n\n/**\n * Get container the palette lives in.\n *\n * @return {Element}\n */\nPalette.prototype._getParentContainer = function() {\n  return this._canvas.getContainer();\n};\n\n\n/* markup definition */\n\nPalette.HTML_MARKUP =\n  '<div class=\"djs-palette\">' +\n    '<div class=\"djs-palette-entries\"></div>' +\n    '<div class=\"djs-palette-toggle\"></div>' +\n  '</div>';\n\n\n// helpers //////////////////////\n\nfunction addClasses(element, classNames) {\n\n  var classes = domClasses(element);\n\n  var actualClassNames = isArray(classNames) ? classNames : classNames.split(/\\s+/g);\n  actualClassNames.forEach(function(cls) {\n    classes.add(cls);\n  });\n}\n","import Palette from './Palette';\n\nexport default {\n  __init__: [ 'palette' ],\n  palette: [ 'type', Palette ]\n};\n","import {\n  forEach,\n  assign,\n  find,\n  matchPattern,\n  isDefined\n} from 'min-dash';\n\nimport {\n  delegate as domDelegate,\n  domify as domify,\n  classes as domClasses,\n  attr as domAttr,\n  remove as domRemove\n} from 'min-dom';\n\nvar DATA_REF = 'data-id';\n\n\n/**\n * A popup menu that can be used to display a list of actions anywhere in the canvas.\n *\n * @param {Object} config\n * @param {Boolean|Object} [config.scale={ min: 1.0, max: 1.5 }]\n * @param {Number} [config.scale.min]\n * @param {Number} [config.scale.max]\n * @param {EventBus} eventBus\n * @param {Canvas} canvas\n *\n * @class\n * @constructor\n */\nexport default function PopupMenu(config, eventBus, canvas) {\n\n  var scale = isDefined(config && config.scale) ? config.scale : {\n    min: 1,\n    max: 1.5\n  };\n\n  this._config = {\n    scale: scale\n  };\n\n  this._eventBus = eventBus;\n  this._canvas = canvas;\n  this._providers = {};\n  this._current = {};\n}\n\nPopupMenu.$inject = [\n  'config.popupMenu',\n  'eventBus',\n  'canvas'\n];\n\n/**\n * Registers a popup menu provider\n *\n * @param  {String} id\n * @param  {Object} provider\n *\n * @example\n *\n * popupMenu.registerProvider('myMenuID', {\n *   getEntries: function(element) {\n *     return [\n *       {\n *         id: 'entry-1',\n *         label: 'My Entry',\n *         action: 'alert(\"I have been clicked!\")'\n *       }\n *     ];\n *   }\n * });\n */\nPopupMenu.prototype.registerProvider = function(id, provider) {\n  this._providers[id] = provider;\n};\n\n\n/**\n * Determine if the popup menu has entries.\n *\n * @return {Boolean} true if empty\n */\nPopupMenu.prototype.isEmpty = function(element, providerId) {\n  if (!element) {\n    throw new Error('element parameter is missing');\n  }\n\n  if (!providerId) {\n    throw new Error('providerId parameter is missing');\n  }\n\n  var provider = this._providers[providerId];\n\n  var entries = provider.getEntries(element),\n      headerEntries = provider.getHeaderEntries && provider.getHeaderEntries(element);\n\n  var hasEntries = entries.length > 0,\n      hasHeaderEntries = headerEntries && headerEntries.length > 0;\n\n  return !hasEntries && !hasHeaderEntries;\n};\n\n\n/**\n * Create entries and open popup menu at given position\n *\n * @param  {Object} element\n * @param  {String} id provider id\n * @param  {Object} position\n *\n * @return {Object} popup menu instance\n */\nPopupMenu.prototype.open = function(element, id, position) {\n\n  var provider = this._providers[id];\n\n  if (!element) {\n    throw new Error('Element is missing');\n  }\n\n  if (!provider) {\n    throw new Error('Provider is not registered: ' + id);\n  }\n\n  if (!position) {\n    throw new Error('the position argument is missing');\n  }\n\n  if (this.isOpen()) {\n    this.close();\n  }\n\n  this._emit('open');\n\n  var current = this._current = {\n    provider: provider,\n    className: id,\n    element: element,\n    position: position\n  };\n\n  if (provider.getHeaderEntries) {\n    current.headerEntries = provider.getHeaderEntries(element);\n  }\n\n  current.entries = provider.getEntries(element);\n\n  current.container = this._createContainer();\n\n  var headerEntries = current.headerEntries || [],\n      entries = current.entries || [];\n\n  if (headerEntries.length) {\n    current.container.appendChild(\n      this._createEntries(current.headerEntries, 'djs-popup-header')\n    );\n  }\n\n  if (entries.length) {\n    current.container.appendChild(\n      this._createEntries(current.entries, 'djs-popup-body')\n    );\n  }\n\n  var canvas = this._canvas,\n      parent = canvas.getContainer();\n\n  this._attachContainer(current.container, parent, position.cursor);\n};\n\n\n/**\n * Removes the popup menu and unbinds the event handlers.\n */\nPopupMenu.prototype.close = function() {\n\n  if (!this.isOpen()) {\n    return;\n  }\n\n  this._emit('close');\n\n  this._unbindHandlers();\n  domRemove(this._current.container);\n  this._current.container = null;\n};\n\n\n/**\n * Determine if an open popup menu exist.\n *\n * @return {Boolean} true if open\n */\nPopupMenu.prototype.isOpen = function() {\n  return !!this._current.container;\n};\n\n\n/**\n * Trigger an action associated with an entry.\n *\n * @param {Object} event\n *\n * @return the result of the action callback, if any\n */\nPopupMenu.prototype.trigger = function(event) {\n\n  // silence other actions\n  event.preventDefault();\n\n  var element = event.delegateTarget || event.target,\n      entryId = domAttr(element, DATA_REF);\n\n  var entry = this._getEntry(entryId);\n\n  if (entry.action) {\n    return entry.action.call(null, event, entry);\n  }\n};\n\n/**\n * Gets an entry instance (either entry or headerEntry) by id.\n *\n * @param  {String} entryId\n *\n * @return {Object} entry instance\n */\nPopupMenu.prototype._getEntry = function(entryId) {\n\n  var search = matchPattern({ id: entryId });\n\n  var entry = find(this._current.entries, search) || find(this._current.headerEntries, search);\n\n  if (!entry) {\n    throw new Error('entry not found');\n  }\n\n  return entry;\n};\n\nPopupMenu.prototype._emit = function(eventName) {\n  this._eventBus.fire('popupMenu.' + eventName);\n};\n\n/**\n * Creates the popup menu container.\n *\n * @return {Object} a DOM container\n */\nPopupMenu.prototype._createContainer = function() {\n  var container = domify('<div class=\"djs-popup\">'),\n      position = this._current.position,\n      className = this._current.className;\n\n  assign(container.style, {\n    position: 'absolute',\n    left: position.x + 'px',\n    top: position.y + 'px',\n    visibility: 'hidden'\n  });\n\n  domClasses(container).add(className);\n\n  return container;\n};\n\n\n/**\n * Attaches the container to the DOM and binds the event handlers.\n *\n * @param {Object} container\n * @param {Object} parent\n */\nPopupMenu.prototype._attachContainer = function(container, parent, cursor) {\n  var self = this;\n\n  // Event handler\n  domDelegate.bind(container, '.entry' ,'click', function(event) {\n    self.trigger(event);\n  });\n\n  this._updateScale(container);\n\n  // Attach to DOM\n  parent.appendChild(container);\n\n  if (cursor) {\n    this._assureIsInbounds(container, cursor);\n  }\n\n  // Add Handler\n  this._bindHandlers();\n};\n\n\n/**\n * Updates popup style.transform with respect to the config and zoom level.\n *\n * @method _updateScale\n *\n * @param {Object} container\n */\nPopupMenu.prototype._updateScale = function(container) {\n  var zoom = this._canvas.zoom();\n\n  var scaleConfig = this._config.scale,\n      minScale,\n      maxScale,\n      scale = zoom;\n\n  if (scaleConfig !== true) {\n\n    if (scaleConfig === false) {\n      minScale = 1;\n      maxScale = 1;\n    } else {\n      minScale = scaleConfig.min;\n      maxScale = scaleConfig.max;\n    }\n\n    if (isDefined(minScale) && zoom < minScale) {\n      scale = minScale;\n    }\n\n    if (isDefined(maxScale) && zoom > maxScale) {\n      scale = maxScale;\n    }\n\n  }\n\n  setTransform(container, 'scale(' + scale + ')');\n};\n\n\n/**\n * Make sure that the menu is always fully shown\n *\n * @method function\n *\n * @param  {Object} container\n * @param  {Position} cursor {x, y}\n */\nPopupMenu.prototype._assureIsInbounds = function(container, cursor) {\n  var canvas = this._canvas,\n      clientRect = canvas._container.getBoundingClientRect();\n\n  var containerX = container.offsetLeft,\n      containerY = container.offsetTop,\n      containerWidth = container.scrollWidth,\n      containerHeight = container.scrollHeight,\n      overAxis = {},\n      left, top;\n\n  var cursorPosition = {\n    x: cursor.x - clientRect.left,\n    y: cursor.y - clientRect.top\n  };\n\n  if (containerX + containerWidth > clientRect.width) {\n    overAxis.x = true;\n  }\n\n  if (containerY + containerHeight > clientRect.height) {\n    overAxis.y = true;\n  }\n\n  if (overAxis.x && overAxis.y) {\n    left = cursorPosition.x - containerWidth + 'px';\n    top = cursorPosition.y - containerHeight + 'px';\n  } else if (overAxis.x) {\n    left = cursorPosition.x - containerWidth + 'px';\n    top = cursorPosition.y + 'px';\n  } else if (overAxis.y && cursorPosition.y < containerHeight) {\n    left = cursorPosition.x + 'px';\n    top = 10 + 'px';\n  } else if (overAxis.y) {\n    left = cursorPosition.x + 'px';\n    top = cursorPosition.y - containerHeight + 'px';\n  }\n\n  assign(container.style, { left: left, top: top }, { visibility: 'visible', 'z-index': 1000 });\n};\n\n\n/**\n * Creates a list of entries and returns them as a DOM container.\n *\n * @param {Array<Object>} entries an array of entry objects\n * @param {String} className the class name of the entry container\n *\n * @return {Object} a DOM container\n */\nPopupMenu.prototype._createEntries = function(entries, className) {\n\n  var entriesContainer = domify('<div>'),\n      self = this;\n\n  domClasses(entriesContainer).add(className);\n\n  forEach(entries, function(entry) {\n    var entryContainer = self._createEntry(entry, entriesContainer);\n    entriesContainer.appendChild(entryContainer);\n  });\n\n  return entriesContainer;\n};\n\n\n/**\n * Creates a single entry and returns it as a DOM container.\n *\n * @param  {Object} entry\n *\n * @return {Object} a DOM container\n */\nPopupMenu.prototype._createEntry = function(entry) {\n\n  if (!entry.id) {\n    throw new Error ('every entry must have the id property set');\n  }\n\n  var entryContainer = domify('<div>'),\n      entryClasses = domClasses(entryContainer);\n\n  entryClasses.add('entry');\n\n  if (entry.className) {\n    entry.className.split(' ').forEach(function(className) {\n      entryClasses.add(className);\n    });\n  }\n\n  domAttr(entryContainer, DATA_REF, entry.id);\n\n  if (entry.label) {\n    var label = domify('<span>');\n    label.textContent = entry.label;\n    entryContainer.appendChild(label);\n  }\n\n  if (entry.imageUrl) {\n    entryContainer.appendChild(domify('<img src=\"' + entry.imageUrl + '\" />'));\n  }\n\n  if (entry.active === true) {\n    entryClasses.add('active');\n  }\n\n  if (entry.disabled === true) {\n    entryClasses.add('disabled');\n  }\n\n  if (entry.title) {\n    entryContainer.title = entry.title;\n  }\n\n  return entryContainer;\n};\n\n\n/**\n * Binds the `close` method to 'contextPad.close' & 'canvas.viewbox.changed'.\n */\nPopupMenu.prototype._bindHandlers = function() {\n\n  var eventBus = this._eventBus,\n      self = this;\n\n  function close() {\n    self.close();\n  }\n\n  eventBus.once('contextPad.close', close);\n  eventBus.once('canvas.viewbox.changing', close);\n  eventBus.once('commandStack.changed', close);\n};\n\n\n/**\n * Unbinds the `close` method to 'contextPad.close' & 'canvas.viewbox.changing'.\n */\nPopupMenu.prototype._unbindHandlers = function() {\n\n  var eventBus = this._eventBus,\n      self = this;\n\n  function close() {\n    self.close();\n  }\n\n  eventBus.off('contextPad.close', close);\n  eventBus.off('canvas.viewbox.changed', close);\n  eventBus.off('commandStack.changed', close);\n};\n\n\n\n// helpers /////////////////////////////\n\nfunction setTransform(element, transform) {\n  element.style['transform-origin'] = 'top left';\n\n  [ '', '-ms-', '-webkit-' ].forEach(function(prefix) {\n    element.style[prefix + 'transform'] = transform;\n  });\n}","import PopupMenu from './PopupMenu';\n\nexport default {\n  __init__: [ 'popupMenu' ],\n  popupMenu: [ 'type', PopupMenu ]\n};\n","import {\r\n  forEach\r\n} from 'min-dash';\r\n\r\nimport {\r\n  append as svgAppend,\r\n  attr as svgAttr,\r\n  clone as svgClone,\r\n  create as svgCreate\r\n} from 'tiny-svg';\r\n\r\n\r\n/**\r\n * Adds support for previews of moving/resizing elements.\r\n */\r\nexport default function PreviewSupport(elementRegistry, canvas, styles) {\r\n  this._elementRegistry = elementRegistry;\r\n  this._canvas = canvas;\r\n  this._styles = styles;\r\n}\r\n\r\nPreviewSupport.$inject = [\r\n  'elementRegistry',\r\n  'canvas',\r\n  'styles'\r\n];\r\n\r\n\r\n/**\r\n * Returns graphics of an element.\r\n *\r\n * @param {djs.model.Base} element\r\n *\r\n * @return {SVGElement}\r\n */\r\nPreviewSupport.prototype.getGfx = function(element) {\r\n  return this._elementRegistry.getGraphics(element);\r\n};\r\n\r\n/**\r\n * Adds a move preview of a given shape to a given svg group.\r\n *\r\n * @param {djs.model.Base} element\r\n * @param {SVGElement} group\r\n *\r\n * @return {SVGElement} dragger\r\n */\r\nPreviewSupport.prototype.addDragger = function(shape, group) {\r\n  var gfx = this.getGfx(shape);\r\n\r\n  // clone is not included in tsvg for some reason\r\n  var dragger = svgClone(gfx);\r\n  var bbox = gfx.getBoundingClientRect();\r\n\r\n  // remove markers from connections\r\n  if (isConnection(shape)) {\r\n    removeMarkers(dragger);\r\n  }\r\n\r\n  svgAttr(dragger, this._styles.cls('djs-dragger', [], {\r\n    x: bbox.top,\r\n    y: bbox.left\r\n  }));\r\n\r\n  svgAppend(group, dragger);\r\n\r\n  return dragger;\r\n};\r\n\r\n/**\r\n * Adds a resize preview of a given shape to a given svg group.\r\n *\r\n * @param {djs.model.Base} element\r\n * @param {SVGElement} group\r\n *\r\n * @return {SVGElement} frame\r\n */\r\nPreviewSupport.prototype.addFrame = function(shape, group) {\r\n\r\n  var frame = svgCreate('rect', {\r\n    class: 'djs-resize-overlay',\r\n    width:  shape.width,\r\n    height: shape.height,\r\n    x: shape.x,\r\n    y: shape.y\r\n  });\r\n\r\n  svgAppend(group, frame);\r\n\r\n  return frame;\r\n};\r\n\r\n\r\n// helpers //////////////////////\r\n\r\n/**\r\n * Removes all svg marker references from an SVG.\r\n *\r\n * @param {SVGElement} gfx\r\n */\r\nfunction removeMarkers(gfx) {\r\n\r\n  if (gfx.children) {\r\n\r\n    forEach(gfx.children, function(child) {\r\n\r\n      // recursion\r\n      removeMarkers(child);\r\n\r\n    });\r\n\r\n  }\r\n\r\n  gfx.style.markerStart = '';\r\n  gfx.style.markerEnd = '';\r\n\r\n}\r\n\r\n/**\r\n * Checks if an element is a connection.\r\n */\r\nfunction isConnection(element) {\r\n  return element.waypoints;\r\n}\r\n","import PreviewSupport from './PreviewSupport';\n\nexport default {\n  __init__: [ 'previewSupport' ],\n  previewSupport: [ 'type', PreviewSupport ]\n};\n","var round = Math.round;\n\n/**\n * Service that allow replacing of elements.\n */\nexport default function Replace(modeling) {\n\n  this._modeling = modeling;\n}\n\nReplace.$inject = [ 'modeling' ];\n\n/**\n * @param {Element} oldElement - Element to be replaced\n * @param {Object}  newElementData - Containing information about the new Element, for example height, width, type.\n * @param {Object}  options - Custom options that will be attached to the context. It can be used to inject data\n *                            that is needed in the command chain. For example it could be used in\n *                            eventbus.on('commandStack.shape.replace.postExecute') to change shape attributes after\n *                            shape creation.\n */\nReplace.prototype.replaceElement = function(oldElement, newElementData, options) {\n\n  var modeling = this._modeling;\n\n  var newElement = null;\n\n  if (oldElement.waypoints) {\n    // TODO\n    // modeling.replaceConnection\n  } else {\n    // set center of element for modeling API\n    // if no new width / height is given use old elements size\n    newElementData.x = round(oldElement.x + (newElementData.width || oldElement.width) / 2);\n    newElementData.y = round(oldElement.y + (newElementData.height || oldElement.height) / 2);\n\n    newElement = modeling.replaceShape(oldElement, newElementData, options);\n  }\n\n  return newElement;\n};\n","import Replace from './Replace';\n\nexport default {\n  __init__: [ 'replace' ],\n  replace: [ 'type', Replace ]\n};","import {\n  pick,\n  assign\n} from 'min-dash';\n\nimport {\n  resizeBounds,\n  ensureConstraints,\n  computeChildrenBBox,\n  getMinResizeBounds\n} from './ResizeUtil';\n\nimport {\n  asTRBL,\n  roundBounds\n} from '../../layout/LayoutUtil';\n\nvar DEFAULT_MIN_WIDTH = 10;\n\n\n/**\n * A component that provides resizing of shapes on the canvas.\n *\n * The following components are part of shape resize:\n *\n *  * adding resize handles,\n *  * creating a visual during resize\n *  * checking resize rules\n *  * committing a change once finished\n *\n *\n * ## Customizing\n *\n * It's possible to customize the resizing behaviour by intercepting 'resize.start'\n * and providing the following parameters through the 'context':\n *\n *   * minDimensions ({ width, height }): minimum shape dimensions\n *\n *   * childrenBoxPadding ({ left, top, bottom, right } || number):\n *     gap between the minimum bounding box and the container\n *\n * f.ex:\n *\n * ```javascript\n * eventBus.on('resize.start', 1500, function(event) {\n *   var context = event.context,\n *\n *  context.minDimensions = { width: 140, height: 120 };\n *\n *  // Passing general padding\n *  context.childrenBoxPadding = 30;\n *\n *  // Passing padding to a specific side\n *  context.childrenBoxPadding.left = 20;\n * });\n * ```\n */\nexport default function Resize(eventBus, rules, modeling, dragging) {\n\n  this._dragging = dragging;\n  this._rules = rules;\n\n  var self = this;\n\n\n  /**\n   * Handle resize move by specified delta.\n   *\n   * @param {Object} context\n   * @param {Point delta\n   */\n  function handleMove(context, delta) {\n\n    var shape = context.shape,\n        direction = context.direction,\n        resizeConstraints = context.resizeConstraints,\n        newBounds;\n\n    context.delta = delta;\n\n    newBounds = resizeBounds(shape, direction, delta);\n\n    // ensure constraints during resize\n    context.newBounds = ensureConstraints(newBounds, resizeConstraints);\n\n    // update + cache executable state\n    context.canExecute = self.canResize(context);\n  }\n\n  /**\n   * Handle resize start.\n   *\n   * @param  {Object} context\n   */\n  function handleStart(context) {\n\n    var resizeConstraints = context.resizeConstraints,\n        // evaluate minBounds for backwards compatibility\n        minBounds = context.minBounds;\n\n    if (resizeConstraints !== undefined) {\n      return;\n    }\n\n    if (minBounds === undefined) {\n      minBounds = self.computeMinResizeBox(context);\n    }\n\n    context.resizeConstraints = {\n      min: asTRBL(minBounds)\n    };\n  }\n\n  /**\n   * Handle resize end.\n   *\n   * @param  {Object} context\n   */\n  function handleEnd(context) {\n    var shape = context.shape,\n        canExecute = context.canExecute,\n        newBounds = context.newBounds;\n\n    if (canExecute) {\n      // ensure we have actual pixel values for new bounds\n      // (important when zoom level was > 1 during move)\n      newBounds = roundBounds(newBounds);\n\n      // perform the actual resize\n      modeling.resizeShape(shape, newBounds);\n    }\n  }\n\n\n  eventBus.on('resize.start', function(event) {\n    handleStart(event.context);\n  });\n\n  eventBus.on('resize.move', function(event) {\n    var delta = {\n      x: event.dx,\n      y: event.dy\n    };\n\n    handleMove(event.context, delta);\n  });\n\n  eventBus.on('resize.end', function(event) {\n    handleEnd(event.context);\n  });\n\n}\n\n\nResize.prototype.canResize = function(context) {\n  var rules = this._rules;\n\n  var ctx = pick(context, [ 'newBounds', 'shape', 'delta', 'direction' ]);\n\n  return rules.allowed('shape.resize', ctx);\n};\n\n/**\n * Activate a resize operation.\n *\n * You may specify additional contextual information and must specify a\n * resize direction during activation of the resize event.\n *\n * @param {MouseEvent} event\n * @param {djs.model.Shape} shape\n * @param {Object|String} contextOrDirection\n */\nResize.prototype.activate = function(event, shape, contextOrDirection) {\n  var dragging = this._dragging,\n      context,\n      direction;\n\n  if (typeof contextOrDirection === 'string') {\n    contextOrDirection = {\n      direction: contextOrDirection\n    };\n  }\n\n  context = assign({ shape: shape }, contextOrDirection);\n\n  direction = context.direction;\n\n  if (!direction) {\n    throw new Error('must provide a direction (nw|se|ne|sw)');\n  }\n\n  dragging.init(event, 'resize', {\n    autoActivate: true,\n    cursor: 'resize-' + (/nw|se/.test(direction) ? 'nwse' : 'nesw'),\n    data: {\n      shape: shape,\n      context: context\n    }\n  });\n};\n\nResize.prototype.computeMinResizeBox = function(context) {\n  var shape = context.shape,\n      direction = context.direction,\n      minDimensions,\n      childrenBounds;\n\n  minDimensions = context.minDimensions || {\n    width: DEFAULT_MIN_WIDTH,\n    height: DEFAULT_MIN_WIDTH\n  };\n\n  // get children bounds\n  childrenBounds = computeChildrenBBox(shape, context.childrenBoxPadding);\n\n  // get correct minimum bounds from given resize direction\n  // basically ensures that the minBounds is max(childrenBounds, minDimensions)\n  return getMinResizeBounds(direction, shape, minDimensions, childrenBounds);\n};\n\n\nResize.$inject = [\n  'eventBus',\n  'rules',\n  'modeling',\n  'dragging'\n];","import {\n  bind,\n  forEach\n} from 'min-dash';\n\nvar HANDLE_OFFSET = -2,\n    HANDLE_SIZE = 5,\n    HANDLE_HIT_SIZE = 20;\n\nvar CLS_RESIZER = 'djs-resizer';\n\nimport {\n  append as svgAppend,\n  attr as svgAttr,\n  classes as svgClasses,\n  clear as svgClear,\n  create as svgCreate\n} from 'tiny-svg';\n\nimport {\n  event as domEvent\n} from 'min-dom';\n\nimport {\n  isPrimaryButton\n} from '../../util/Mouse';\n\nimport {\n  asTRBL\n} from '../../layout/LayoutUtil';\n\nimport {\n  transform\n} from '../../util/SvgTransformUtil';\n\n\n/**\n * This component is responsible for adding resize handles.\n *\n * @param {EventBus} eventBus\n * @param {Canvas} canvas\n * @param {Selection} selection\n * @param {Resize} resize\n */\nexport default function ResizeHandles(eventBus, canvas, selection, resize) {\n\n  this._resize = resize;\n  this._canvas = canvas;\n\n  var self = this;\n\n  eventBus.on('selection.changed', function(e) {\n    var newSelection = e.newSelection;\n\n    // remove old selection markers\n    self.removeResizers();\n\n    // add new selection markers ONLY if single selection\n    if (newSelection.length === 1) {\n      forEach(newSelection, bind(self.addResizer, self));\n    }\n  });\n\n  eventBus.on('shape.changed', function(e) {\n    var shape = e.element;\n\n    if (selection.isSelected(shape)) {\n      self.removeResizers();\n\n      self.addResizer(shape);\n    }\n  });\n}\n\n\nResizeHandles.prototype.makeDraggable = function(element, gfx, direction) {\n  var resize = this._resize;\n\n  function startResize(event) {\n    // only trigger on left mouse button\n    if (isPrimaryButton(event)) {\n      resize.activate(event, element, direction);\n    }\n  }\n\n  domEvent.bind(gfx, 'mousedown', startResize);\n  domEvent.bind(gfx, 'touchstart', startResize);\n};\n\n\nResizeHandles.prototype._createResizer = function(element, x, y, rotation, direction) {\n  var resizersParent = this._getResizersParent();\n\n  var group = svgCreate('g');\n  svgClasses(group).add(CLS_RESIZER);\n  svgClasses(group).add(CLS_RESIZER + '-' + element.id);\n  svgClasses(group).add(CLS_RESIZER + '-' + direction);\n\n  svgAppend(resizersParent, group);\n\n  var origin = -HANDLE_SIZE + HANDLE_OFFSET;\n\n  // Create four drag indicators on the outline\n  var visual = svgCreate('rect');\n  svgAttr(visual, {\n    x: origin,\n    y: origin,\n    width: HANDLE_SIZE,\n    height: HANDLE_SIZE\n  });\n  svgClasses(visual).add(CLS_RESIZER + '-visual');\n\n  svgAppend(group, visual);\n\n  var hit = svgCreate('rect');\n  svgAttr(hit, {\n    x: origin,\n    y: origin,\n    width: HANDLE_HIT_SIZE,\n    height: HANDLE_HIT_SIZE\n  });\n  svgClasses(hit).add(CLS_RESIZER + '-hit');\n\n  svgAppend(group, hit);\n\n  transform(group, x, y, rotation);\n\n  return group;\n};\n\nResizeHandles.prototype.createResizer = function(element, direction) {\n  var resizer;\n\n  var trbl = asTRBL(element);\n\n  if (direction === 'nw') {\n    resizer = this._createResizer(element, trbl.left, trbl.top, 0, direction);\n  } else if (direction === 'ne') {\n    resizer = this._createResizer(element, trbl.right, trbl.top, 90, direction);\n  } else if (direction === 'se') {\n    resizer = this._createResizer(element, trbl.right, trbl.bottom, 180, direction);\n  } else {\n    resizer = this._createResizer(element, trbl.left, trbl.bottom, 270, direction);\n  }\n\n  this.makeDraggable(element, resizer, direction);\n};\n\n// resize handles implementation ///////////////////////////////\n\n/**\n * Add resizers for a given element.\n *\n * @param {djs.model.Shape} shape\n */\nResizeHandles.prototype.addResizer = function(shape) {\n  var resize = this._resize;\n\n  if (!resize.canResize({ shape: shape })) {\n    return;\n  }\n\n  this.createResizer(shape, 'nw');\n  this.createResizer(shape, 'ne');\n  this.createResizer(shape, 'se');\n  this.createResizer(shape, 'sw');\n};\n\n/**\n * Remove all resizers\n */\nResizeHandles.prototype.removeResizers = function() {\n  var resizersParent = this._getResizersParent();\n\n  svgClear(resizersParent);\n};\n\nResizeHandles.prototype._getResizersParent = function() {\n  return this._canvas.getLayer('resizers');\n};\n\nResizeHandles.$inject = [\n  'eventBus',\n  'canvas',\n  'selection',\n  'resize'\n];\n","var MARKER_RESIZING = 'djs-resizing',\n    MARKER_RESIZE_NOT_OK = 'resize-not-ok';\n\nvar LOW_PRIORITY = 500;\n\nimport {\n  attr as svgAttr,\n  remove as svgRemove,\n  classes as svgClasses\n} from 'tiny-svg';\n\n\n/**\n * Provides previews for resizing shapes when resizing.\n *\n * @param {EventBus} eventBus\n * @param {Canvas} canvas\n * @param {PreviewSupport} previewSupport\n */\nexport default function ResizePreview(eventBus, canvas, previewSupport) {\n\n  /**\n   * Update resizer frame.\n   *\n   * @param {Object} context\n   */\n  function updateFrame(context) {\n\n    var shape = context.shape,\n        bounds = context.newBounds,\n        frame = context.frame;\n\n    if (!frame) {\n      frame = context.frame = previewSupport.addFrame(shape, canvas.getDefaultLayer());\n\n      canvas.addMarker(shape, MARKER_RESIZING);\n    }\n\n    if (bounds.width > 5) {\n      svgAttr(frame, { x: bounds.x, width: bounds.width });\n    }\n\n    if (bounds.height > 5) {\n      svgAttr(frame, { y: bounds.y, height: bounds.height });\n    }\n\n    if (context.canExecute) {\n      svgClasses(frame).remove(MARKER_RESIZE_NOT_OK);\n    } else {\n      svgClasses(frame).add(MARKER_RESIZE_NOT_OK);\n    }\n  }\n\n  /**\n   * Remove resizer frame.\n   *\n   * @param {Object} context\n   */\n  function removeFrame(context) {\n    var shape = context.shape,\n        frame = context.frame;\n\n    if (frame) {\n      svgRemove(context.frame);\n    }\n\n    canvas.removeMarker(shape, MARKER_RESIZING);\n  }\n\n  // add and update previews\n  eventBus.on('resize.move', LOW_PRIORITY, function(event) {\n    updateFrame(event.context);\n  });\n\n  // remove previews\n  eventBus.on('resize.cleanup', function(event) {\n    removeFrame(event.context);\n  });\n\n}\n\nResizePreview.$inject = [\n  'eventBus',\n  'canvas',\n  'previewSupport'\n];","import {\n  filter,\n  isNumber\n} from 'min-dash';\n\nvar max = Math.max,\n    min = Math.min;\n\nvar DEFAULT_CHILD_BOX_PADDING = 20;\n\nimport {\n  getBBox\n} from '../../util/Elements';\n\nimport {\n  asTRBL,\n  asBounds\n} from '../../layout/LayoutUtil';\n\n\n/**\n * Substract a TRBL from another\n *\n * @param  {TRBL} trblA\n * @param  {TRBL} trblB\n *\n * @return {TRBL}\n */\nexport function substractTRBL(trblA, trblB) {\n  return {\n    top: trblA.top - trblB.top,\n    right: trblA.right - trblB.right,\n    bottom: trblA.bottom - trblB.bottom,\n    left: trblA.left - trblB.left\n  };\n}\n\n/**\n * Resize the given bounds by the specified delta from a given anchor point.\n *\n * @param {Bounds} bounds the bounding box that should be resized\n * @param {String} direction in which the element is resized (nw, ne, se, sw)\n * @param {Point} delta of the resize operation\n *\n * @return {Bounds} resized bounding box\n */\nexport function resizeBounds(bounds, direction, delta) {\n\n  var dx = delta.x,\n      dy = delta.y;\n\n  switch (direction) {\n\n  case 'nw':\n    return {\n      x: bounds.x + dx,\n      y: bounds.y + dy,\n      width: bounds.width - dx,\n      height: bounds.height - dy\n    };\n\n  case 'sw':\n    return {\n      x: bounds.x + dx,\n      y: bounds.y,\n      width: bounds.width - dx,\n      height: bounds.height + dy\n    };\n\n  case 'ne':\n    return {\n      x: bounds.x,\n      y: bounds.y + dy,\n      width: bounds.width + dx,\n      height: bounds.height - dy\n    };\n\n  case 'se':\n    return {\n      x: bounds.x,\n      y: bounds.y,\n      width: bounds.width + dx,\n      height: bounds.height + dy\n    };\n\n  default:\n    throw new Error('unrecognized direction: ' + direction);\n  }\n}\n\n\n/**\n * Resize the given bounds by applying the passed\n * { top, right, bottom, left } delta.\n *\n * @param {Bounds} bounds\n * @param {TRBL} trblResize\n *\n * @return {Bounds}\n */\nexport function resizeTRBL(bounds, resize) {\n  return {\n    x: bounds.x + (resize.left || 0),\n    y: bounds.y + (resize.top || 0),\n    width: bounds.width - (resize.left || 0) + (resize.right || 0),\n    height: bounds.height - (resize.top || 0) + (resize.bottom || 0)\n  };\n}\n\n\nexport function reattachPoint(bounds, newBounds, point) {\n\n  var sx = bounds.width / newBounds.width,\n      sy = bounds.height / newBounds.height;\n\n  return {\n    x: Math.round((newBounds.x + newBounds.width / 2)) - Math.floor(((bounds.x + bounds.width / 2) - point.x) / sx),\n    y: Math.round((newBounds.y + newBounds.height / 2)) - Math.floor(((bounds.y + bounds.height / 2) - point.y) / sy)\n  };\n}\n\n\nfunction applyConstraints(attr, trbl, resizeConstraints) {\n\n  var value = trbl[attr],\n      minValue = resizeConstraints.min && resizeConstraints.min[attr],\n      maxValue = resizeConstraints.max && resizeConstraints.max[attr];\n\n  if (isNumber(minValue)) {\n    value = (/top|left/.test(attr) ? min : max)(value, minValue);\n  }\n\n  if (isNumber(maxValue)) {\n    value = (/top|left/.test(attr) ? max : min)(value, maxValue);\n  }\n\n  return value;\n}\n\nexport function ensureConstraints(currentBounds, resizeConstraints) {\n\n  if (!resizeConstraints) {\n    return currentBounds;\n  }\n\n  var currentTrbl = asTRBL(currentBounds);\n\n  return asBounds({\n    top: applyConstraints('top', currentTrbl, resizeConstraints),\n    right: applyConstraints('right', currentTrbl, resizeConstraints),\n    bottom: applyConstraints('bottom', currentTrbl, resizeConstraints),\n    left: applyConstraints('left', currentTrbl, resizeConstraints)\n  });\n}\n\n\nexport function getMinResizeBounds(direction, currentBounds, minDimensions, childrenBounds) {\n\n  var currentBox = asTRBL(currentBounds);\n\n  var minBox = {\n    top: /n/.test(direction) ? currentBox.bottom - minDimensions.height : currentBox.top,\n    left: /w/.test(direction) ? currentBox.right - minDimensions.width : currentBox.left,\n    bottom: /s/.test(direction) ? currentBox.top + minDimensions.height : currentBox.bottom,\n    right: /e/.test(direction) ? currentBox.left + minDimensions.width : currentBox.right\n  };\n\n  var childrenBox = childrenBounds ? asTRBL(childrenBounds) : minBox;\n\n  var combinedBox = {\n    top: min(minBox.top, childrenBox.top),\n    left: min(minBox.left, childrenBox.left),\n    bottom: max(minBox.bottom, childrenBox.bottom),\n    right: max(minBox.right, childrenBox.right)\n  };\n\n  return asBounds(combinedBox);\n}\n\nfunction asPadding(mayBePadding, defaultValue) {\n  if (typeof mayBePadding !== 'undefined') {\n    return mayBePadding;\n  } else {\n    return DEFAULT_CHILD_BOX_PADDING;\n  }\n}\n\nexport function addPadding(bbox, padding) {\n  var left, right, top, bottom;\n\n  if (typeof padding === 'object') {\n    left = asPadding(padding.left);\n    right = asPadding(padding.right);\n    top = asPadding(padding.top);\n    bottom = asPadding(padding.bottom);\n  } else {\n    left = right = top = bottom = asPadding(padding);\n  }\n\n  return {\n    x: bbox.x - left,\n    y: bbox.y - top,\n    width: bbox.width + left + right,\n    height: bbox.height + top + bottom\n  };\n}\n\n\n/**\n * Is the given element part of the resize\n * targets min boundary box?\n *\n * This is the default implementation which excludes\n * connections and labels.\n *\n * @param {djs.model.Base} element\n */\nfunction isBBoxChild(element) {\n\n  // exclude connections\n  if (element.waypoints) {\n    return false;\n  }\n\n  // exclude labels\n  if (element.type === 'label') {\n    return false;\n  }\n\n  return true;\n}\n\n/**\n * Return children bounding computed from a shapes children\n * or a list of prefiltered children.\n *\n * @param  {djs.model.Shape|Array<djs.model.Shape>} shapeOrChildren\n * @param  {Number|Object} padding\n *\n * @return {Bounds}\n */\nexport function computeChildrenBBox(shapeOrChildren, padding) {\n\n  var elements;\n\n  // compute based on shape\n  if (shapeOrChildren.length === undefined) {\n    // grab all the children that are part of the\n    // parents children box\n    elements = filter(shapeOrChildren.children, isBBoxChild);\n\n  } else {\n    elements = shapeOrChildren;\n  }\n\n  if (elements.length) {\n    return addPadding(getBBox(elements), padding);\n  }\n}\n","import RulesModule from '../rules';\nimport DraggingModule from '../dragging';\nimport PreviewSupportModule from '../preview-support';\n\nimport Resize from './Resize';\nimport ResizePreview from './ResizePreview';\nimport ResizeHandles from './ResizeHandles';\n\nexport default {\n  __depends__: [\n    RulesModule,\n    DraggingModule,\n    PreviewSupportModule\n  ],\n  __init__: [\n    'resize',\n    'resizePreview',\n    'resizeHandles'\n  ],\n  resize: [ 'type', Resize ],\n  resizePreview: [ 'type', ResizePreview ],\n  resizeHandles: [ 'type', ResizeHandles ]\n};\n","import inherits from 'inherits';\n\nimport CommandInterceptor from '../../command/CommandInterceptor';\n\n/**\n * A basic provider that may be extended to implement modeling rules.\n *\n * Extensions should implement the init method to actually add their custom\n * modeling checks. Checks may be added via the #addRule(action, fn) method.\n *\n * @param {EventBus} eventBus\n */\nexport default function RuleProvider(eventBus) {\n  CommandInterceptor.call(this, eventBus);\n\n  this.init();\n}\n\nRuleProvider.$inject = [ 'eventBus' ];\n\ninherits(RuleProvider, CommandInterceptor);\n\n\n/**\n * Adds a modeling rule for the given action, implemented through\n * a callback function.\n *\n * The function will receive the modeling specific action context\n * to perform its check. It must return `false` to disallow the\n * action from happening or `true` to allow the action.\n *\n * A rule provider may pass over the evaluation to lower priority\n * rules by returning return nothing (or <code>undefined</code>).\n *\n * @example\n *\n * ResizableRules.prototype.init = function() {\n *\n *   \\/**\n *    * Return `true`, `false` or nothing to denote\n *    * _allowed_, _not allowed_ and _continue evaluating_.\n *    *\\/\n *   this.addRule('shape.resize', function(context) {\n *\n *     var shape = context.shape;\n *\n *     if (!context.newBounds) {\n *       // check general resizability\n *       if (!shape.resizable) {\n *         return false;\n *       }\n *\n *       // not returning anything (read: undefined)\n *       // will continue the evaluation of other rules\n *       // (with lower priority)\n *       return;\n *     } else {\n *       // element must have minimum size of 10*10 points\n *       return context.newBounds.width > 10 && context.newBounds.height > 10;\n *     }\n *   });\n * };\n *\n * @param {String|Array<String>} actions the identifier for the modeling action to check\n * @param {Number} [priority] the priority at which this rule is being applied\n * @param {Function} fn the callback function that performs the actual check\n */\nRuleProvider.prototype.addRule = function(actions, priority, fn) {\n\n  var self = this;\n\n  if (typeof actions === 'string') {\n    actions = [ actions ];\n  }\n\n  actions.forEach(function(action) {\n\n    self.canExecute(action, priority, function(context, action, event) {\n      return fn(context);\n    }, true);\n  });\n};\n\n/**\n * Implement this method to add new rules during provider initialization.\n */\nRuleProvider.prototype.init = function() {};","/**\n * A service that provides rules for certain diagram actions.\n *\n * The default implementation will hook into the {@link CommandStack}\n * to perform the actual rule evaluation. Make sure to provide the\n * `commandStack` service with this module if you plan to use it.\n *\n * Together with this implementation you may use the {@link RuleProvider}\n * to implement your own rule checkers.\n *\n * This module is ment to be easily replaced, thus the tiny foot print.\n *\n * @param {Injector} injector\n */\nexport default function Rules(injector) {\n  this._commandStack = injector.get('commandStack', false);\n}\n\nRules.$inject = [ 'injector' ];\n\n\n/**\n * Returns whether or not a given modeling action can be executed\n * in the specified context.\n *\n * This implementation will respond with allow unless anyone\n * objects.\n *\n * @param {String} action the action to be checked\n * @param {Object} [context] the context to check the action in\n *\n * @return {Boolean} returns true, false or null depending on whether the\n *                   operation is allowed, not allowed or should be ignored.\n */\nRules.prototype.allowed = function(action, context) {\n  var allowed = true;\n\n  var commandStack = this._commandStack;\n\n  if (commandStack) {\n    allowed = commandStack.canExecute(action, context);\n  }\n\n  // map undefined to true, i.e. no rules\n  return allowed === undefined ? true : allowed;\n};","import Rules from './Rules';\n\nexport default {\n  __init__: [ 'rules' ],\n  rules: [ 'type', Rules ]\n};\n","import {\n  clear as domClear,\n  delegate as domDelegate,\n  query as domQuery,\n  classes as domClasses,\n  attr as domAttr,\n  domify as domify\n} from 'min-dom';\n\nimport {\n  getBBox as getBoundingBox\n} from '../../util/Elements';\n\n\n/**\n * Provides searching infrastructure\n */\nexport default function SearchPad(canvas, eventBus, overlays, selection) {\n  this._open = false;\n  this._results = [];\n  this._eventMaps = [];\n\n  this._canvas = canvas;\n  this._eventBus = eventBus;\n  this._overlays = overlays;\n  this._selection = selection;\n\n  // setup elements\n  this._container = domify(SearchPad.BOX_HTML);\n  this._searchInput = domQuery(SearchPad.INPUT_SELECTOR, this._container);\n  this._resultsContainer = domQuery(SearchPad.RESULTS_CONTAINER_SELECTOR, this._container);\n\n  // attach search pad\n  this._canvas.getContainer().appendChild(this._container);\n\n  // cleanup on destroy\n  eventBus.on([ 'canvas.destroy', 'diagram.destroy' ], this.close, this);\n}\n\n\nSearchPad.$inject = [\n  'canvas',\n  'eventBus',\n  'overlays',\n  'selection'\n];\n\n\n/**\n * Binds and keeps track of all event listereners\n */\nSearchPad.prototype._bindEvents = function() {\n  var self = this;\n\n  function listen(el, selector, type, fn) {\n    self._eventMaps.push({\n      el: el,\n      type: type,\n      listener: domDelegate.bind(el, selector, type, fn)\n    });\n  }\n\n  // close search on clicking anywhere outside\n  listen(document, 'html', 'click', function(e) {\n    self.close();\n  }, true);\n\n  // stop event from propagating and closing search\n  // focus on input\n  listen(this._container, SearchPad.INPUT_SELECTOR, 'click', function(e) {\n    e.stopPropagation();\n    e.delegateTarget.focus();\n  });\n\n  // preselect result on hover\n  listen(this._container, SearchPad.RESULT_SELECTOR, 'mouseover', function(e) {\n    e.stopPropagation();\n    self._scrollToNode(e.delegateTarget);\n    self._preselect(e.delegateTarget);\n  });\n\n  // selects desired result on mouse click\n  listen(this._container, SearchPad.RESULT_SELECTOR, 'click', function(e) {\n    e.stopPropagation();\n    self._select(e.delegateTarget);\n  });\n\n  // prevent cursor in input from going left and right when using up/down to\n  // navigate results\n  listen(this._container, SearchPad.INPUT_SELECTOR, 'keydown', function(e) {\n    // up\n    if (e.keyCode === 38) {\n      e.preventDefault();\n    }\n\n    // down\n    if (e.keyCode === 40) {\n      e.preventDefault();\n    }\n  });\n\n  // handle keyboard input\n  listen(this._container, SearchPad.INPUT_SELECTOR, 'keyup', function(e) {\n    // escape\n    if (e.keyCode === 27) {\n      return self.close();\n    }\n\n    // enter\n    if (e.keyCode === 13) {\n      var selected = self._getCurrentResult();\n\n      return selected ? self._select(selected) : self.close();\n    }\n\n    // up\n    if (e.keyCode === 38) {\n      return self._scrollToDirection(true);\n    }\n\n    // down\n    if (e.keyCode === 40) {\n      return self._scrollToDirection();\n    }\n\n    // left && right\n    // do not search while navigating text input\n    if (e.keyCode === 37 || e.keyCode === 39) {\n      return;\n    }\n\n    // anything else\n    self._search(e.delegateTarget.value);\n  });\n};\n\n\n/**\n * Unbinds all previously established listeners\n */\nSearchPad.prototype._unbindEvents = function() {\n  this._eventMaps.forEach(function(m) {\n    domDelegate.unbind(m.el, m.type, m.listener);\n  });\n};\n\n\n/**\n * Performs a search for the given pattern.\n *\n * @param  {String} pattern\n */\nSearchPad.prototype._search = function(pattern) {\n  var self = this;\n\n  this._clearResults();\n\n  // do not search on empty query\n  if (!pattern || pattern === '') {\n    return;\n  }\n\n  var searchResults = this._searchProvider.find(pattern);\n\n  if (!searchResults.length) {\n    return;\n  }\n\n  // append new results\n  searchResults.forEach(function(result) {\n    var id = result.element.id;\n    var node = self._createResultNode(result, id);\n    self._results[id] = {\n      element: result.element,\n      node: node\n    };\n  });\n\n  // preselect first result\n  var node = domQuery(SearchPad.RESULT_SELECTOR, this._resultsContainer);\n  this._scrollToNode(node);\n  this._preselect(node);\n};\n\n\n/**\n * Navigate to the previous/next result. Defaults to next result.\n * @param  {Boolean} previous\n */\nSearchPad.prototype._scrollToDirection = function(previous) {\n  var selected = this._getCurrentResult();\n  if (!selected) {\n    return;\n  }\n\n  var node = previous ? selected.previousElementSibling : selected.nextElementSibling;\n  if (node) {\n    this._scrollToNode(node);\n    this._preselect(node);\n  }\n};\n\n\n/**\n * Scroll to the node if it is not visible.\n *\n * @param  {Element} node\n */\nSearchPad.prototype._scrollToNode = function(node) {\n  if (!node || node === this._getCurrentResult()) {\n    return;\n  }\n\n  var nodeOffset = node.offsetTop;\n  var containerScroll = this._resultsContainer.scrollTop;\n\n  var bottomScroll = nodeOffset - this._resultsContainer.clientHeight + node.clientHeight;\n\n  if (nodeOffset < containerScroll) {\n    this._resultsContainer.scrollTop = nodeOffset;\n  } else if (containerScroll < bottomScroll) {\n    this._resultsContainer.scrollTop = bottomScroll;\n  }\n};\n\n\n/**\n * Clears all results data.\n */\nSearchPad.prototype._clearResults = function() {\n  domClear(this._resultsContainer);\n\n  this._results = [];\n\n  this._resetOverlay();\n\n  this._eventBus.fire('searchPad.cleared');\n};\n\n\n/**\n * Get currently selected result.\n *\n * @return {Element}\n */\nSearchPad.prototype._getCurrentResult = function() {\n  return domQuery(SearchPad.RESULT_SELECTED_SELECTOR, this._resultsContainer);\n};\n\n\n/**\n * Create result DOM element within results container\n * that corresponds to a search result.\n *\n * 'result' : one of the elements returned by SearchProvider\n * 'id' : id attribute value to assign to the new DOM node\n * return : created DOM element\n *\n * @param  {SearchResult} result\n * @param  {String} id\n * @return {Element}\n */\nSearchPad.prototype._createResultNode = function(result, id) {\n  var node = domify(SearchPad.RESULT_HTML);\n\n  // create only if available\n  if (result.primaryTokens.length > 0) {\n    createInnerTextNode(node, result.primaryTokens, SearchPad.RESULT_PRIMARY_HTML);\n  }\n\n  // secondary tokens (represent element ID) are allways available\n  createInnerTextNode(node, result.secondaryTokens, SearchPad.RESULT_SECONDARY_HTML);\n\n  domAttr(node, SearchPad.RESULT_ID_ATTRIBUTE, id);\n\n  this._resultsContainer.appendChild(node);\n\n  return node;\n};\n\n\n/**\n * Register search element provider.\n *\n * SearchProvider.find - provides search function over own elements\n *  (pattern) => [{ text: <String>, element: <Element>}, ...]\n *\n * @param  {SearchProvider} provider\n */\nSearchPad.prototype.registerProvider = function(provider) {\n  this._searchProvider = provider;\n};\n\n\n/**\n * Open search pad.\n */\nSearchPad.prototype.open = function() {\n  if (!this._searchProvider) {\n    throw new Error('no search provider registered');\n  }\n\n  if (this.isOpen()) {\n    return;\n  }\n\n  this._bindEvents();\n\n  this._open = true;\n\n  domClasses(this._container).add('open');\n\n  this._searchInput.focus();\n\n  this._eventBus.fire('searchPad.opened');\n};\n\n\n/**\n * Close search pad.\n */\nSearchPad.prototype.close = function() {\n  if (!this.isOpen()) {\n    return;\n  }\n\n  this._unbindEvents();\n\n  this._open = false;\n\n  domClasses(this._container).remove('open');\n\n  this._clearResults();\n\n  this._searchInput.value = '';\n  this._searchInput.blur();\n\n  this._resetOverlay();\n\n  this._eventBus.fire('searchPad.closed');\n};\n\n\n/**\n * Toggles search pad on/off.\n */\nSearchPad.prototype.toggle = function() {\n  this.isOpen() ? this.close() : this.open();\n};\n\n\n/**\n * Report state of search pad.\n */\nSearchPad.prototype.isOpen = function() {\n  return this._open;\n};\n\n\n/**\n * Preselect result entry.\n *\n * @param  {Element} element\n */\nSearchPad.prototype._preselect = function(node) {\n  var selectedNode = this._getCurrentResult();\n\n  // already selected\n  if (node === selectedNode) {\n    return;\n  }\n\n  // removing preselection from current node\n  if (selectedNode) {\n    domClasses(selectedNode).remove(SearchPad.RESULT_SELECTED_CLASS);\n  }\n\n  var id = domAttr(node, SearchPad.RESULT_ID_ATTRIBUTE);\n  var element = this._results[id].element;\n\n  domClasses(node).add(SearchPad.RESULT_SELECTED_CLASS);\n\n  this._resetOverlay(element);\n\n  this._centerViewbox(element);\n\n  this._selection.select(element);\n\n  this._eventBus.fire('searchPad.preselected', element);\n};\n\n\n/**\n * Select result node.\n *\n * @param  {Element} element\n */\nSearchPad.prototype._select = function(node) {\n  var id = domAttr(node, SearchPad.RESULT_ID_ATTRIBUTE);\n  var element = this._results[id].element;\n\n  this.close();\n\n  this._resetOverlay();\n\n  this._centerViewbox(element);\n\n  this._selection.select(element);\n\n  this._eventBus.fire('searchPad.selected', element);\n};\n\n\n/**\n * Center viewbox on the element middle point.\n *\n * @param  {Element} element\n */\nSearchPad.prototype._centerViewbox = function(element) {\n  var viewbox = this._canvas.viewbox();\n\n  var box = getBoundingBox(element);\n\n  var newViewbox = {\n    x: (box.x + box.width/2) - viewbox.outer.width/2,\n    y: (box.y + box.height/2) - viewbox.outer.height/2,\n    width: viewbox.outer.width,\n    height: viewbox.outer.height\n  };\n\n  this._canvas.viewbox(newViewbox);\n\n  this._canvas.zoom(viewbox.scale);\n};\n\n\n/**\n * Reset overlay removes and, optionally, set\n * overlay to a new element.\n *\n * @param  {Element} element\n */\nSearchPad.prototype._resetOverlay = function(element) {\n  if (this._overlayId) {\n    this._overlays.remove(this._overlayId);\n  }\n\n  if (element) {\n    var box = getBoundingBox(element);\n    var overlay = constructOverlay(box);\n    this._overlayId = this._overlays.add(element, overlay);\n  }\n};\n\n\n/**\n * Construct overlay object for the given bounding box.\n *\n * @param  {BoundingBox} box\n * @return {Object}\n */\nfunction constructOverlay(box) {\n\n  var offset = 6;\n  var w = box.width + offset * 2;\n  var h = box.height + offset * 2;\n\n  var styles = [\n    'width: '+ w +'px',\n    'height: '+ h + 'px'\n  ].join('; ');\n\n  return {\n    position: {\n      bottom: h - offset,\n      right: w - offset\n    },\n    show: true,\n    html: '<div style=\"' + styles + '\" class=\"' + SearchPad.OVERLAY_CLASS + '\"></div>'\n  };\n}\n\n\n/**\n * Creates and appends child node from result tokens and HTML template.\n *\n * @param  {Element} node\n * @param  {Array<Object>} tokens\n * @param  {String} template\n */\nfunction createInnerTextNode(parentNode, tokens, template) {\n  var text = createHtmlText(tokens);\n  var childNode = domify(template);\n  childNode.innerHTML = text;\n  parentNode.appendChild(childNode);\n}\n\n/**\n * Create internal HTML markup from result tokens.\n * Caters for highlighting pattern matched tokens.\n *\n * @param  {Array<Object>} tokens\n * @return {String}\n */\nfunction createHtmlText(tokens) {\n  var htmlText = '';\n\n  tokens.forEach(function(t) {\n    if (t.matched) {\n      htmlText += '<strong class=\"' + SearchPad.RESULT_HIGHLIGHT_CLASS + '\">' + t.matched + '</strong>';\n    } else {\n      htmlText += t.normal;\n    }\n  });\n\n  return htmlText !== '' ? htmlText : null;\n}\n\n\n/**\n * CONSTANTS\n */\nSearchPad.CONTAINER_SELECTOR = '.djs-search-container';\nSearchPad.INPUT_SELECTOR = '.djs-search-input input';\nSearchPad.RESULTS_CONTAINER_SELECTOR = '.djs-search-results';\nSearchPad.RESULT_SELECTOR = '.djs-search-result';\nSearchPad.RESULT_SELECTED_CLASS = 'djs-search-result-selected';\nSearchPad.RESULT_SELECTED_SELECTOR = '.' + SearchPad.RESULT_SELECTED_CLASS;\nSearchPad.RESULT_ID_ATTRIBUTE = 'data-result-id';\nSearchPad.RESULT_HIGHLIGHT_CLASS = 'djs-search-highlight';\nSearchPad.OVERLAY_CLASS = 'djs-search-overlay';\n\nSearchPad.BOX_HTML =\n  '<div class=\"djs-search-container djs-draggable djs-scrollable\">' +\n    '<div class=\"djs-search-input\">' +\n      '<input type=\"text\"/>' +\n    '</div>' +\n    '<div class=\"djs-search-results\"></div>' +\n  '</div>';\n\nSearchPad.RESULT_HTML =\n  '<div class=\"djs-search-result\"></div>';\n\nSearchPad.RESULT_PRIMARY_HTML =\n  '<div class=\"djs-search-result-primary\"></div>';\n\nSearchPad.RESULT_SECONDARY_HTML =\n  '<p class=\"djs-search-result-secondary\"></p>';\n","import OverlaysModule from '../overlays';\nimport SelectionModule from '../selection';\n\nimport SearchPad from './SearchPad';\n\nexport default {\n  __depends__: [\n    OverlaysModule,\n    SelectionModule\n  ],\n  searchPad: [ 'type', SearchPad ]\n};\n","import {\n  isArray,\n  forEach\n} from 'min-dash';\n\n\n/**\n * A service that offers the current selection in a diagram.\n * Offers the api to control the selection, too.\n *\n * @class\n *\n * @param {EventBus} eventBus the event bus\n */\nexport default function Selection(eventBus) {\n\n  this._eventBus = eventBus;\n\n  this._selectedElements = [];\n\n  var self = this;\n\n  eventBus.on([ 'shape.remove', 'connection.remove' ], function(e) {\n    var element = e.element;\n    self.deselect(element);\n  });\n\n  eventBus.on([ 'diagram.clear' ], function(e) {\n    self.select(null);\n  });\n}\n\nSelection.$inject = [ 'eventBus' ];\n\n\nSelection.prototype.deselect = function(element) {\n  var selectedElements = this._selectedElements;\n\n  var idx = selectedElements.indexOf(element);\n\n  if (idx !== -1) {\n    var oldSelection = selectedElements.slice();\n\n    selectedElements.splice(idx, 1);\n\n    this._eventBus.fire('selection.changed', { oldSelection: oldSelection, newSelection: selectedElements });\n  }\n};\n\n\nSelection.prototype.get = function() {\n  return this._selectedElements;\n};\n\nSelection.prototype.isSelected = function(element) {\n  return this._selectedElements.indexOf(element) !== -1;\n};\n\n\n/**\n * This method selects one or more elements on the diagram.\n *\n * By passing an additional add parameter you can decide whether or not the element(s)\n * should be added to the already existing selection or not.\n *\n * @method Selection#select\n *\n * @param  {Object|Object[]} elements element or array of elements to be selected\n * @param  {boolean} [add] whether the element(s) should be appended to the current selection, defaults to false\n */\nSelection.prototype.select = function(elements, add) {\n  var selectedElements = this._selectedElements,\n      oldSelection = selectedElements.slice();\n\n  if (!isArray(elements)) {\n    elements = elements ? [ elements ] : [];\n  }\n\n  // selection may be cleared by passing an empty array or null\n  // to the method\n  if (add) {\n    forEach(elements, function(element) {\n      if (selectedElements.indexOf(element) !== -1) {\n        // already selected\n        return;\n      } else {\n        selectedElements.push(element);\n      }\n    });\n  } else {\n    this._selectedElements = selectedElements = elements.slice();\n  }\n\n  this._eventBus.fire('selection.changed', { oldSelection: oldSelection, newSelection: selectedElements });\n};\n","import {\n  hasPrimaryModifier\n} from '../../util/Mouse';\n\nimport {\n  find\n} from 'min-dash';\n\n\nexport default function SelectionBehavior(\n    eventBus, selection, canvas,\n    elementRegistry) {\n\n  eventBus.on('create.end', 500, function(e) {\n\n    // select the created shape after a\n    // successful create operation\n    if (e.context.canExecute) {\n      selection.select(e.context.shape);\n    }\n  });\n\n  eventBus.on('connect.end', 500, function(e) {\n\n    // select the connect end target\n    // after a connect operation\n    if (e.context.canExecute && e.context.target) {\n      selection.select(e.context.target);\n    }\n  });\n\n  eventBus.on('shape.move.end', 500, function(e) {\n    var previousSelection = e.previousSelection || [];\n\n    var shape = elementRegistry.get(e.context.shape.id);\n\n    // make sure at least the main moved element is being\n    // selected after a move operation\n    var inSelection = find(previousSelection, function(selectedShape) {\n      return shape.id === selectedShape.id;\n    });\n\n    if (!inSelection) {\n      selection.select(shape);\n    }\n  });\n\n  // Shift + click selection\n  eventBus.on('element.click', function(event) {\n\n    var element = event.element;\n\n    // do not select the root element\n    // or connections\n    if (element === canvas.getRootElement()) {\n      element = null;\n    }\n\n    var isSelected = selection.isSelected(element),\n        isMultiSelect = selection.get().length > 1;\n\n    // mouse-event: SELECTION_KEY\n    var add = hasPrimaryModifier(event);\n\n    // select OR deselect element in multi selection\n    if (isSelected && isMultiSelect) {\n      if (add) {\n        return selection.deselect(element);\n      } else {\n        return selection.select(element);\n      }\n    } else\n    if (!isSelected) {\n      selection.select(element, add);\n    } else {\n      selection.deselect(element);\n    }\n  });\n}\n\nSelectionBehavior.$inject = [\n  'eventBus',\n  'selection',\n  'canvas',\n  'elementRegistry'\n];\n","import {\n  forEach\n} from 'min-dash';\n\nvar MARKER_HOVER = 'hover',\n    MARKER_SELECTED = 'selected';\n\n\n/**\n * A plugin that adds a visible selection UI to shapes and connections\n * by appending the <code>hover</code> and <code>selected</code> classes to them.\n *\n * @class\n *\n * Makes elements selectable, too.\n *\n * @param {EventBus} events\n * @param {SelectionService} selection\n * @param {Canvas} canvas\n */\nexport default function SelectionVisuals(events, canvas, selection, styles) {\n\n  this._multiSelectionBox = null;\n\n  function addMarker(e, cls) {\n    canvas.addMarker(e, cls);\n  }\n\n  function removeMarker(e, cls) {\n    canvas.removeMarker(e, cls);\n  }\n\n  events.on('element.hover', function(event) {\n    addMarker(event.element, MARKER_HOVER);\n  });\n\n  events.on('element.out', function(event) {\n    removeMarker(event.element, MARKER_HOVER);\n  });\n\n  events.on('selection.changed', function(event) {\n\n    function deselect(s) {\n      removeMarker(s, MARKER_SELECTED);\n    }\n\n    function select(s) {\n      addMarker(s, MARKER_SELECTED);\n    }\n\n    var oldSelection = event.oldSelection,\n        newSelection = event.newSelection;\n\n    forEach(oldSelection, function(e) {\n      if (newSelection.indexOf(e) === -1) {\n        deselect(e);\n      }\n    });\n\n    forEach(newSelection, function(e) {\n      if (oldSelection.indexOf(e) === -1) {\n        select(e);\n      }\n    });\n  });\n}\n\nSelectionVisuals.$inject = [\n  'eventBus',\n  'canvas',\n  'selection',\n  'styles'\n];","import InteractionEventsModule from '../interaction-events';\nimport OutlineModule from '../outline';\n\nimport Selection from './Selection';\nimport SelectionVisuals from './SelectionVisuals';\nimport SelectionBehavior from './SelectionBehavior';\n\n\nexport default {\n  __init__: [ 'selectionVisuals', 'selectionBehavior' ],\n  __depends__: [\n    InteractionEventsModule,\n    OutlineModule\n  ],\n  selection: [ 'type', Selection ],\n  selectionVisuals: [ 'type', SelectionVisuals ],\n  selectionBehavior: [ 'type', SelectionBehavior ]\n};\n","import {\n  forEach\n} from 'min-dash';\n\nimport {\n  snapTo\n} from './SnapUtil';\n\n\n/**\n * A snap context, containing the (possibly incomplete)\n * mappings of drop targets (to identify the snapping)\n * to computed snap points.\n */\nexport default function SnapContext() {\n\n  /**\n   * Map<String, SnapPoints> mapping drop targets to\n   * a list of possible snappings.\n   *\n   * @type {Object}\n   */\n  this._targets = {};\n\n  /**\n   * Map<String, Point> initial positioning of element\n   * regarding various snap directions.\n   *\n   * @type {Object}\n   */\n  this._snapOrigins = {};\n\n  /**\n   * List of snap locations\n   *\n   * @type {Array<String>}\n   */\n  this._snapLocations = [];\n\n  /**\n   * Map<String, Array<Point>> of default snapping locations\n   *\n   * @type {Object}\n   */\n  this._defaultSnaps = {};\n}\n\n\nSnapContext.prototype.getSnapOrigin = function(snapLocation) {\n  return this._snapOrigins[snapLocation];\n};\n\n\nSnapContext.prototype.setSnapOrigin = function(snapLocation, initialValue) {\n  this._snapOrigins[snapLocation] = initialValue;\n\n  if (this._snapLocations.indexOf(snapLocation) === -1) {\n    this._snapLocations.push(snapLocation);\n  }\n};\n\n\nSnapContext.prototype.addDefaultSnap = function(type, point) {\n\n  var snapValues = this._defaultSnaps[type];\n\n  if (!snapValues) {\n    snapValues = this._defaultSnaps[type] = [];\n  }\n\n  snapValues.push(point);\n};\n\n/**\n * Return a number of initialized snaps, i.e. snap locations such as\n * top-left, mid, bottom-right and so forth.\n *\n * @return {Array<String>} snapLocations\n */\nSnapContext.prototype.getSnapLocations = function() {\n  return this._snapLocations;\n};\n\n/**\n * Set the snap locations for this context.\n *\n * The order of locations determines precedence.\n *\n * @param {Array<String>} snapLocations\n */\nSnapContext.prototype.setSnapLocations = function(snapLocations) {\n  this._snapLocations = snapLocations;\n};\n\n/**\n * Get snap points for a given target\n *\n * @param {Element|String} target\n */\nSnapContext.prototype.pointsForTarget = function(target) {\n\n  var targetId = target.id || target;\n\n  var snapPoints = this._targets[targetId];\n\n  if (!snapPoints) {\n    snapPoints = this._targets[targetId] = new SnapPoints();\n    snapPoints.initDefaults(this._defaultSnaps);\n  }\n\n  return snapPoints;\n};\n\n\n/**\n * Creates the snap points and initializes them with the\n * given default values.\n *\n * @param {Object<String, Array<Point>>} [defaultPoints]\n */\nfunction SnapPoints(defaultSnaps) {\n\n  /**\n   * Map<String, Map<(x|y), Array<Number>>> mapping snap locations,\n   * i.e. top-left, bottom-right, center to actual snap values.\n   *\n   * @type {Object}\n   */\n  this._snapValues = {};\n}\n\nSnapPoints.prototype.add = function(snapLocation, point) {\n\n  var snapValues = this._snapValues[snapLocation];\n\n  if (!snapValues) {\n    snapValues = this._snapValues[snapLocation] = { x: [], y: [] };\n  }\n\n  if (snapValues.x.indexOf(point.x) === -1) {\n    snapValues.x.push(point.x);\n  }\n\n  if (snapValues.y.indexOf(point.y) === -1) {\n    snapValues.y.push(point.y);\n  }\n};\n\n\nSnapPoints.prototype.snap = function(point, snapLocation, axis, tolerance) {\n  var snappingValues = this._snapValues[snapLocation];\n\n  return snappingValues && snapTo(point[axis], snappingValues[axis], tolerance);\n};\n\n/**\n * Initialize a number of default snapping points.\n *\n * @param  {Object} defaultSnaps\n */\nSnapPoints.prototype.initDefaults = function(defaultSnaps) {\n\n  var self = this;\n\n  forEach(defaultSnaps || {}, function(snapPoints, snapLocation) {\n    forEach(snapPoints, function(point) {\n      self.add(snapLocation, point);\n    });\n  });\n};","var abs = Math.abs,\n    round = Math.round;\n\n\n/**\n * Snap value to a collection of reference values.\n *\n * @param  {Number} value\n * @param  {Array<Number>} values\n * @param  {Number} [tolerance=10]\n *\n * @return {Number} the value we snapped to or null, if none snapped\n */\nexport function snapTo(value, values, tolerance) {\n  tolerance = tolerance === undefined ? 10 : tolerance;\n\n  var idx, snapValue;\n\n  for (idx = 0; idx < values.length; idx++) {\n    snapValue = values[idx];\n\n    if (abs(snapValue - value) <= tolerance) {\n      return snapValue;\n    }\n  }\n}\n\n\nexport function topLeft(bounds) {\n  return {\n    x: bounds.x,\n    y: bounds.y\n  };\n}\n\n\nexport function mid(bounds, defaultValue) {\n\n  if (!bounds || isNaN(bounds.x) || isNaN(bounds.y)) {\n    return defaultValue;\n  }\n\n  return {\n    x: round(bounds.x + bounds.width / 2),\n    y: round(bounds.y + bounds.height / 2)\n  };\n}\n\n\nexport function bottomRight(bounds) {\n  return {\n    x: bounds.x + bounds.width,\n    y: bounds.y + bounds.height\n  };\n}\n\n\n/**\n * Retrieve the snap state of the given event.\n *\n * @param  {Event} event\n * @param  {String} axis\n *\n * @return {Boolean} the snapped state\n *\n */\nexport function isSnapped(event, axis) {\n  var snapped = event.snapped;\n\n  if (!snapped) {\n    return false;\n  }\n\n  if (typeof axis === 'string') {\n    return snapped[axis];\n  }\n\n  return snapped.x && snapped.y;\n}\n\n\n/**\n * Set the given event as snapped.\n *\n * This method may change the x and/or y position of the shape\n * from the given event!\n *\n * @param {Event} event\n * @param {String} axis\n * @param {Number|Boolean} value\n *\n * @return {Number} old value\n */\nexport function setSnapped(event, axis, value) {\n  if (typeof axis !== 'string') {\n    throw new Error('axis must be in [x, y]');\n  }\n\n  if (typeof value !== 'number' && value !== false) {\n    throw new Error('value must be Number or false');\n  }\n\n  var delta,\n      previousValue = event[axis];\n\n  var snapped = event.snapped = (event.snapped || {});\n\n\n  if (value === false) {\n    snapped[axis] = false;\n  } else {\n    snapped[axis] = true;\n\n    delta = value - previousValue;\n\n    event[axis] += delta;\n    event['d' + axis] += delta;\n  }\n\n  return previousValue;\n}","import {\n  filter,\n  forEach,\n  debounce,\n  bind\n} from 'min-dash';\n\nimport SnapContext from './SnapContext';\n\nimport {\n  mid,\n  isSnapped,\n  setSnapped\n} from './SnapUtil';\n\nvar HIGHER_PRIORITY = 1250;\n\nimport {\n  append as svgAppend,\n  attr as svgAttr,\n  classes as svgClasses,\n  create as svgCreate\n} from 'tiny-svg';\n\n\n/**\n * A general purpose snapping component for diagram elements.\n *\n * @param {EventBus} eventBus\n * @param {Canvas} canvas\n */\nexport default function Snapping(eventBus, canvas) {\n\n  this._canvas = canvas;\n\n  var self = this;\n\n  eventBus.on([ 'shape.move.start', 'create.start' ], function(event) {\n    self.initSnap(event);\n  });\n\n  eventBus.on([ 'shape.move.move', 'shape.move.end', 'create.move', 'create.end' ], HIGHER_PRIORITY, function(event) {\n\n    if (event.originalEvent && event.originalEvent.ctrlKey) {\n      return;\n    }\n\n    if (isSnapped(event)) {\n      return;\n    }\n\n    self.snap(event);\n  });\n\n  eventBus.on([ 'shape.move.cleanup', 'create.cleanup' ], function(event) {\n    self.hide();\n  });\n\n  // delay hide by 1000 seconds since last match\n  this._asyncHide = debounce(bind(this.hide, this), 1000);\n}\n\nSnapping.$inject = [ 'eventBus', 'canvas' ];\n\n\nSnapping.prototype.initSnap = function(event) {\n\n  var context = event.context,\n      shape = context.shape,\n      snapContext = context.snapContext;\n\n  if (!snapContext) {\n    snapContext = context.snapContext = new SnapContext();\n  }\n\n  var snapMid = mid(shape, event);\n\n  snapContext.setSnapOrigin('mid', {\n    x: snapMid.x - event.x,\n    y: snapMid.y - event.y\n  });\n\n  return snapContext;\n};\n\n\nSnapping.prototype.snap = function(event) {\n\n  var context = event.context,\n      snapContext = context.snapContext,\n      shape = context.shape,\n      target = context.target,\n      snapLocations = snapContext.getSnapLocations();\n\n  if (!target) {\n    return;\n  }\n\n  var snapPoints = snapContext.pointsForTarget(target);\n\n  if (!snapPoints.initialized) {\n    this.addTargetSnaps(snapPoints, shape, target);\n\n    snapPoints.initialized = true;\n  }\n\n\n  var snapping = {\n    x: isSnapped(event, 'x'),\n    y: isSnapped(event, 'y')\n  };\n\n\n  forEach(snapLocations, function(location) {\n\n    var snapOrigin = snapContext.getSnapOrigin(location);\n\n    var snapCurrent = {\n      x: event.x + snapOrigin.x,\n      y: event.y + snapOrigin.y\n    };\n\n    // snap on both axis, if not snapped already\n    forEach([ 'x', 'y' ], function(axis) {\n      var locationSnapping;\n\n      if (!snapping[axis]) {\n        locationSnapping = snapPoints.snap(snapCurrent, location, axis, 7);\n\n        if (locationSnapping !== undefined) {\n          snapping[axis] = {\n            value: locationSnapping,\n            originValue: locationSnapping - snapOrigin[axis]\n          };\n        }\n      }\n    });\n\n    // no more need to snap, drop out of interation\n    if (snapping.x && snapping.y) {\n      return false;\n    }\n  });\n\n\n  // show snap visuals\n\n  this.showSnapLine('vertical', snapping.x && snapping.x.value);\n  this.showSnapLine('horizontal', snapping.y && snapping.y.value);\n\n\n  // adjust event { x, y, dx, dy } and mark as snapping\n  forEach([ 'x', 'y' ], function(axis) {\n\n    var axisSnapping = snapping[axis];\n\n    if (typeof axisSnapping === 'object') {\n      // set as snapped and adjust the x and/or y position of the event\n      setSnapped(event, axis, axisSnapping.originValue);\n    }\n  });\n};\n\n\nSnapping.prototype._createLine = function(orientation) {\n\n  var root = this._canvas.getLayer('snap');\n\n  // var line = root.path('M0,0 L0,0').addClass('djs-snap-line');\n\n  var line = svgCreate('path');\n  svgAttr(line, { d: 'M0,0 L0,0' });\n  svgClasses(line).add('djs-snap-line');\n\n  svgAppend(root, line);\n\n  return {\n    update: function(position) {\n\n      if (typeof position !== 'number') {\n        svgAttr(line, { display: 'none' });\n      } else {\n        if (orientation === 'horizontal') {\n          svgAttr(line, {\n            d: 'M-100000,' + position + ' L+100000,' + position,\n            display: ''\n          });\n        } else {\n          svgAttr(line, {\n            d: 'M ' + position + ',-100000 L ' + position + ', +100000',\n            display: ''\n          });\n        }\n      }\n    }\n  };\n};\n\n\nSnapping.prototype._createSnapLines = function() {\n\n  this._snapLines = {\n    horizontal: this._createLine('horizontal'),\n    vertical: this._createLine('vertical')\n  };\n};\n\nSnapping.prototype.showSnapLine = function(orientation, position) {\n\n  var line = this.getSnapLine(orientation);\n\n  if (line) {\n    line.update(position);\n  }\n\n  this._asyncHide();\n};\n\nSnapping.prototype.getSnapLine = function(orientation) {\n  if (!this._snapLines) {\n    this._createSnapLines();\n  }\n\n  return this._snapLines[orientation];\n};\n\nSnapping.prototype.hide = function() {\n  forEach(this._snapLines, function(l) {\n    l.update();\n  });\n};\n\nSnapping.prototype.addTargetSnaps = function(snapPoints, shape, target) {\n\n  var siblings = this.getSiblings(shape, target);\n\n  forEach(siblings, function(s) {\n    snapPoints.add('mid', mid(s));\n  });\n\n};\n\nSnapping.prototype.getSiblings = function(element, target) {\n\n  // snap to all siblings that are not hidden, labels, attached to element or element itself\n  return target && filter(target.children, function(e) {\n    return !e.hidden && !e.labelTarget && e.host !== element && e !== element;\n  });\n};\n","import {\n  getDirection\n} from './SpaceUtil';\n\nimport {\n  set as cursorSet\n} from '../../util/Cursor';\n\nimport {\n  hasPrimaryModifier\n} from '../../util/Mouse';\n\nvar abs = Math.abs,\n    round = Math.round;\n\nvar HIGH_PRIORITY = 1500,\n    SPACE_TOOL_CURSOR = 'crosshair';\n\nvar AXIS_TO_DIMENSION = { x: 'width', y: 'height' },\n    AXIS_INVERTED = { x: 'y', y: 'x' };\n\nimport {\n  selfAndAllChildren as getAllChildren\n} from '../../util/Elements';\n\nimport {\n  assign,\n  forEach\n} from 'min-dash';\n\n\n/**\n * A tool that allows users to create and remove space in a diagram.\n *\n * The tool needs to be activated manually via {@link SpaceTool#activate(MouseEvent)}.\n */\nexport default function SpaceTool(\n    eventBus, dragging, canvas,\n    modeling, rules, toolManager) {\n\n  this._canvas = canvas;\n  this._dragging = dragging;\n  this._modeling = modeling;\n  this._rules = rules;\n  this._toolManager = toolManager;\n\n  var self = this;\n\n  toolManager.registerTool('space', {\n    tool: 'spaceTool.selection',\n    dragging: 'spaceTool'\n  });\n\n  eventBus.on('spaceTool.selection.end', function(event) {\n    var target = event.originalEvent.target;\n\n    // only reactive on diagram click\n    // on some occasions, event.hover is not set and we have to check if the target is an svg\n    if (!event.hover && !(target instanceof SVGElement)) {\n      return;\n    }\n\n    eventBus.once('spaceTool.selection.ended', function() {\n      self.activateMakeSpace(event.originalEvent);\n    });\n  });\n\n\n  eventBus.on('spaceTool.move', HIGH_PRIORITY , function(event) {\n\n    var context = event.context;\n\n    if (!context.initialized) {\n      context.initialized = self.initializeMakeSpace(event, context);\n    }\n  });\n\n\n  eventBus.on('spaceTool.end', function(event) {\n\n    var context = event.context,\n        axis = context.axis,\n        direction = context.direction,\n        movingShapes = context.movingShapes,\n        resizingShapes = context.resizingShapes;\n\n    // skip if create space has not been initialized yet\n    if (!context.initialized) {\n      return;\n    }\n\n    var delta = { x: round(event.dx), y: round(event.dy) };\n    delta[ AXIS_INVERTED[ axis ] ] = 0;\n\n    var insideBounds = true;\n\n    // check if the space tool cursor is inside of bounds of\n    // any of the shapes that would be resized.\n    forEach(resizingShapes, function(shape) {\n\n      if ((direction === 'w' && event.x > shape.x + shape.width) ||\n          (direction === 'e' && event.x < shape.x) ||\n          (direction === 'n' && event.y > shape.y + shape.height) ||\n          (direction === 's' && event.y < shape.y)) {\n\n        insideBounds = false;\n        return;\n      }\n    });\n\n    if (insideBounds) {\n      // make space only if the cursor is inside bounds\n      self.makeSpace(movingShapes, resizingShapes, delta, direction);\n    }\n\n    eventBus.once('spaceTool.ended', function(event) {\n      // reactivate space tool after usage\n      self.activateSelection(event.originalEvent, true, true);\n    });\n\n  });\n}\n\nSpaceTool.$inject = [\n  'eventBus',\n  'dragging',\n  'canvas',\n  'modeling',\n  'rules',\n  'toolManager'\n];\n\n\n/**\n * Activate space tool selection\n *\n * @param  {MouseEvent} event\n * @param  {Boolean} autoActivate\n */\nSpaceTool.prototype.activateSelection = function(event, autoActivate, reactivate) {\n  this._dragging.init(event, 'spaceTool.selection', {\n    trapClick: false,\n    cursor: SPACE_TOOL_CURSOR,\n    autoActivate: autoActivate,\n    data: {\n      context: {\n        reactivate: reactivate\n      }\n    }\n  });\n};\n\n/**\n * Activate make space\n *\n * @param  {MouseEvent} event\n */\nSpaceTool.prototype.activateMakeSpace = function(event) {\n  this._dragging.init(event, 'spaceTool', {\n    autoActivate: true,\n    cursor: SPACE_TOOL_CURSOR,\n    data: {\n      context: {}\n    }\n  });\n};\n\n/**\n * Actually make space on the diagram\n *\n * @param  {Array<djs.model.Shape>} movingShapes\n * @param  {Array<djs.model.Shape>} resizingShapes\n * @param  {Point} delta\n * @param  {String} direction\n */\nSpaceTool.prototype.makeSpace = function(movingShapes, resizingShapes, delta, direction) {\n  return this._modeling.createSpace(movingShapes, resizingShapes, delta, direction);\n};\n\n/**\n * Initialize make space and return true if that was successful.\n *\n * @param {Event} event\n * @param {Object} context\n *\n * @return {Boolean} true, if successful\n */\nSpaceTool.prototype.initializeMakeSpace = function(event, context) {\n\n  var axis = abs(event.dx) > abs(event.dy) ? 'x' : 'y',\n      offset = event['d' + axis],\n      // start point of create space operation\n      spacePos = event[axis] - offset;\n\n  if (abs(offset) < 5) {\n    return false;\n  }\n\n  // invert the offset in order to remove space when moving left\n  if (offset < 0) {\n    offset *= -1;\n  }\n\n  // inverts the offset to choose the shapes\n  // on the opposite side of the resizer if\n  // a key modifier is pressed\n  if (hasPrimaryModifier(event)) {\n    offset *= -1;\n  }\n\n  var rootShape = this._canvas.getRootElement();\n\n  var allShapes = getAllChildren(rootShape, true);\n\n  var adjustments = this.calculateAdjustments(allShapes, axis, offset, spacePos);\n\n  // store data in context\n  assign(context, adjustments, {\n    axis: axis,\n    direction: getDirection(axis, offset)\n  });\n\n  cursorSet('resize-' + (axis === 'x' ? 'ew' : 'ns'));\n\n  return true;\n};\n\n/**\n * Calculate adjustments needed when making space\n *\n * @param  {Array<djs.model.Shape>} elements\n * @param  {String} axis\n * @param  {Number} offset\n * @param  {Number} spacePos\n *\n * @return {Object}\n */\nSpaceTool.prototype.calculateAdjustments = function(elements, axis, offset, spacePos) {\n\n  var movingShapes = [],\n      resizingShapes = [];\n\n  var rules = this._rules;\n\n  // collect all elements that need to be moved _AND_\n  // resized given on the initial create space position\n  elements.forEach(function(shape) {\n\n    var shapeStart = shape[axis],\n        shapeEnd = shapeStart + shape[AXIS_TO_DIMENSION[axis]];\n\n    // checking if it's root\n    if (!shape.parent) {\n      return;\n    }\n\n    // checking if it's a shape\n    if (shape.waypoints) {\n      return;\n    }\n\n    // shape after spacePos\n    if (offset > 0 && shapeStart > spacePos) {\n      return movingShapes.push(shape);\n    }\n\n    // shape before spacePos\n    if (offset < 0 && shapeEnd < spacePos) {\n      return movingShapes.push(shape);\n    }\n\n    // shape on top of spacePos, resize only if allowed\n    if (shapeStart < spacePos &&\n        shapeEnd > spacePos &&\n        rules.allowed('shape.resize', { shape: shape })) {\n\n      return resizingShapes.push(shape);\n    }\n  });\n\n  return {\n    movingShapes: movingShapes,\n    resizingShapes: resizingShapes\n  };\n};\n\nSpaceTool.prototype.toggle = function() {\n  if (this.isActive()) {\n    this._dragging.cancel();\n  } else {\n    this.activateSelection();\n  }\n};\n\nSpaceTool.prototype.isActive = function() {\n  var context = this._dragging.context();\n\n  return context && /^spaceTool/.test(context.prefix);\n};\n","import {\n  forEach\n} from 'min-dash';\n\nvar MARKER_DRAGGING = 'djs-dragging',\n    MARKER_RESIZING = 'djs-resizing';\n\nvar LOW_PRIORITY = 250;\n\nimport {\n  append as svgAppend,\n  attr as svgAttr,\n  classes as svgClasses,\n  create as svgCreate,\n  remove as svgRemove\n} from 'tiny-svg';\n\nimport {\n  translate\n} from '../../util/SvgTransformUtil';\n\n\n/**\n * Provides previews for selecting/moving/resizing shapes when creating/removing space.\n *\n * @param {EventBus} eventBus\n * @param {ElementRegistry} elementRegistry\n * @param {Canvas} canvas\n * @param {Styles} styles\n */\nexport default function SpaceToolPreview(\n    eventBus, elementRegistry, canvas,\n    styles, previewSupport) {\n\n  function addPreviewGfx(collection, dragGroup) {\n    forEach(collection, function(element) {\n      previewSupport.addDragger(element, dragGroup);\n\n      canvas.addMarker(element, MARKER_DRAGGING);\n    });\n  }\n\n  // add crosshair\n  eventBus.on('spaceTool.selection.start', function(event) {\n    var space = canvas.getLayer('space'),\n        context = event.context;\n\n    var orientation = {\n      x: 'M 0,-10000 L 0,10000',\n      y: 'M -10000,0 L 10000,0'\n    };\n\n    var crosshairGroup = svgCreate('g');\n    svgAttr(crosshairGroup, styles.cls('djs-crosshair-group', [ 'no-events' ]));\n\n    svgAppend(space, crosshairGroup);\n\n    // horizontal path\n    var pathX = svgCreate('path');\n    svgAttr(pathX, 'd', orientation.x);\n    svgClasses(pathX).add('djs-crosshair');\n\n    svgAppend(crosshairGroup, pathX);\n\n    // vertical path\n    var pathY = svgCreate('path');\n    svgAttr(pathY, 'd', orientation.y);\n    svgClasses(pathY).add('djs-crosshair');\n\n    svgAppend(crosshairGroup, pathY);\n\n    context.crosshairGroup = crosshairGroup;\n  });\n\n  // update crosshair\n  eventBus.on('spaceTool.selection.move', function(event) {\n    var crosshairGroup = event.context.crosshairGroup;\n\n    translate(crosshairGroup, event.x, event.y);\n  });\n\n  // remove crosshair\n  eventBus.on('spaceTool.selection.cleanup', function(event) {\n    var context = event.context,\n        crosshairGroup = context.crosshairGroup;\n\n    if (crosshairGroup) {\n      svgRemove(crosshairGroup);\n    }\n  });\n\n  // add and update move/resize previews\n  eventBus.on('spaceTool.move', LOW_PRIORITY, function(event) {\n\n    var context = event.context,\n        line = context.line,\n        axis = context.axis,\n        movingShapes = context.movingShapes,\n        resizingShapes = context.resizingShapes;\n\n    if (!context.initialized) {\n      return;\n    }\n\n    if (!context.dragGroup) {\n      var spaceLayer = canvas.getLayer('space');\n\n      line = svgCreate('path');\n      svgAttr(line, 'd', 'M0,0 L0,0');\n      svgClasses(line).add('djs-crosshair');\n\n      svgAppend(spaceLayer, line);\n\n      context.line = line;\n\n      var dragGroup = svgCreate('g');\n      svgAttr(dragGroup, styles.cls('djs-drag-group', [ 'no-events' ]));\n\n      svgAppend(canvas.getDefaultLayer(), dragGroup);\n\n      // shapes\n      addPreviewGfx(movingShapes, dragGroup);\n\n      // connections\n      var movingConnections = context.movingConnections = elementRegistry.filter(function(element) {\n        var sourceIsMoving = false;\n\n        forEach(movingShapes, function(shape) {\n          forEach(shape.outgoing, function(connection) {\n            if (element === connection) {\n              sourceIsMoving = true;\n            }\n          });\n        });\n\n        var targetIsMoving = false;\n\n        forEach(movingShapes, function(shape) {\n          forEach(shape.incoming, function(connection) {\n            if (element === connection) {\n              targetIsMoving = true;\n            }\n          });\n        });\n\n        var sourceIsResizing = false;\n\n        forEach(resizingShapes, function(shape) {\n          forEach(shape.outgoing, function(connection) {\n            if (element === connection) {\n              sourceIsResizing = true;\n            }\n          });\n        });\n\n        var targetIsResizing = false;\n\n        forEach(resizingShapes, function(shape) {\n          forEach(shape.incoming, function(connection) {\n            if (element === connection) {\n              targetIsResizing = true;\n            }\n          });\n        });\n\n        return isConnection(element)\n          && (sourceIsMoving || sourceIsResizing)\n          && (targetIsMoving || targetIsResizing);\n      });\n\n\n      addPreviewGfx(movingConnections, dragGroup);\n\n      context.dragGroup = dragGroup;\n    }\n\n    if (!context.frameGroup) {\n      var frameGroup = svgCreate('g');\n      svgAttr(frameGroup, styles.cls('djs-frame-group', [ 'no-events' ]));\n\n      svgAppend(canvas.getDefaultLayer(), frameGroup);\n\n      var frames = [];\n\n      forEach(resizingShapes, function(shape) {\n        var frame = previewSupport.addFrame(shape, frameGroup);\n\n        frames.push({\n          element: frame,\n          initialWidth: frame.getBBox().width,\n          initialHeight: frame.getBBox().height\n        });\n\n        canvas.addMarker(shape, MARKER_RESIZING);\n      });\n\n      context.frameGroup = frameGroup;\n      context.frames = frames;\n    }\n\n    var orientation = {\n      x: 'M' + event.x + ', -10000 L' + event.x + ', 10000',\n      y: 'M -10000, ' + event.y + ' L 10000, ' + event.y\n    };\n\n    svgAttr(line, { path: orientation[ axis ], display: '' });\n\n    var opposite = { x: 'y', y: 'x' };\n    var delta = { x: event.dx, y: event.dy };\n    delta[ opposite[ context.axis ] ] = 0;\n\n    // update move previews\n    translate(context.dragGroup, delta.x, delta.y);\n\n    // update resize previews\n    forEach(context.frames, function(frame) {\n      if (frame.initialWidth + delta.x > 5) {\n        svgAttr(frame.element, { width: frame.initialWidth + delta.x });\n      }\n\n      if (frame.initialHeight + delta.y > 5) {\n        svgAttr(frame.element, { height: frame.initialHeight + delta.y });\n      }\n    });\n\n  });\n\n  // remove move/resize previews\n  eventBus.on('spaceTool.cleanup', function(event) {\n\n    var context = event.context,\n        movingShapes = context.movingShapes,\n        movingConnections = context.movingConnections,\n        resizingShapes = context.resizingShapes,\n        line = context.line,\n        dragGroup = context.dragGroup,\n        frameGroup = context.frameGroup;\n\n    // moving shapes\n    forEach(movingShapes, function(shape) {\n      canvas.removeMarker(shape, MARKER_DRAGGING);\n    });\n\n    // moving connections\n    forEach(movingConnections, function(connection) {\n      canvas.removeMarker(connection, MARKER_DRAGGING);\n    });\n\n    if (dragGroup) {\n      svgRemove(line);\n      svgRemove(dragGroup);\n    }\n\n    forEach(resizingShapes, function(shape) {\n      canvas.removeMarker(shape, MARKER_RESIZING);\n    });\n\n    if (frameGroup) {\n      svgRemove(frameGroup);\n    }\n  });\n}\n\nSpaceToolPreview.$inject = [\n  'eventBus',\n  'elementRegistry',\n  'canvas',\n  'styles',\n  'previewSupport'\n];\n\n\n// helpers //////////////////////\n\n/**\n * Checks if an element is a connection.\n */\nfunction isConnection(element) {\n  return element.waypoints;\n}\n","/**\n * Get Resize direction given axis + offset\n *\n * @param {String} axis (x|y)\n * @param {Number} offset\n *\n * @return {String} (e|w|n|s)\n */\nexport function getDirection(axis, offset) {\n\n  if (axis === 'x') {\n    if (offset > 0) {\n      return 'e';\n    }\n\n    if (offset < 0) {\n      return 'w';\n    }\n  }\n\n  if (axis === 'y') {\n    if (offset > 0) {\n      return 's';\n    }\n\n    if (offset < 0) {\n      return 'n';\n    }\n  }\n\n  return null;\n}\n\n\n/**\n * Resize the given bounds by the specified delta from a given anchor point.\n *\n * @param {Bounds} bounds the bounding box that should be resized\n * @param {String} direction in which the element is resized (n, s, e, w)\n * @param {Point} delta of the resize operation\n *\n * @return {Bounds} resized bounding box\n */\nexport function resizeBounds(bounds, direction, delta) {\n\n  var dx = delta.x,\n      dy = delta.y;\n\n  switch (direction) {\n\n  case 'n':\n    return {\n      x: bounds.x,\n      y: bounds.y + dy,\n      width: bounds.width,\n      height: bounds.height - dy\n    };\n\n  case 's':\n    return {\n      x: bounds.x,\n      y: bounds.y,\n      width: bounds.width,\n      height: bounds.height + dy\n    };\n\n  case 'w':\n    return {\n      x: bounds.x + dx,\n      y: bounds.y,\n      width: bounds.width - dx,\n      height: bounds.height\n    };\n\n  case 'e':\n    return {\n      x: bounds.x,\n      y: bounds.y,\n      width: bounds.width + dx,\n      height: bounds.height\n    };\n\n  default:\n    throw new Error('unrecognized direction: ' + direction);\n  }\n}","import DraggingModule from '../dragging';\nimport RulesModule from '../rules';\nimport ToolManagerModule from '../tool-manager';\nimport PreviewSupportModule from '../preview-support';\n\nimport SpaceTool from './SpaceTool';\nimport SpaceToolPreview from './SpaceToolPreview';\n\nexport default {\n  __init__: ['spaceToolPreview'],\n  __depends__: [\n    DraggingModule,\n    RulesModule,\n    ToolManagerModule,\n    PreviewSupportModule\n  ],\n  spaceTool: ['type', SpaceTool ],\n  spaceToolPreview: ['type', SpaceToolPreview ]\n};\n","import {\n  forEach\n} from 'min-dash';\n\nimport {\n  closest as domClosest\n} from 'min-dom';\n\nvar LOW_PRIORITY = 250;\n\n/**\n * The tool manager acts as middle-man between the available tool's and the Palette,\n * it takes care of making sure that the correct active state is set.\n *\n * @param  {Object}    eventBus\n * @param  {Object}    dragging\n */\nexport default function ToolManager(eventBus, dragging) {\n  this._eventBus = eventBus;\n  this._dragging = dragging;\n\n  this._tools = [];\n  this._active = null;\n}\n\nToolManager.$inject = [ 'eventBus', 'dragging' ];\n\nToolManager.prototype.registerTool = function(name, events) {\n  var tools = this._tools;\n\n  if (!events) {\n    throw new Error('A tool has to be registered with it\\'s \"events\"');\n  }\n\n  tools.push(name);\n\n  this.bindEvents(name, events);\n};\n\nToolManager.prototype.isActive = function(tool) {\n  return tool && this._active === tool;\n};\n\nToolManager.prototype.length = function(tool) {\n  return this._tools.length;\n};\n\nToolManager.prototype.setActive = function(tool) {\n  var eventBus = this._eventBus;\n\n  if (this._active !== tool) {\n    this._active = tool;\n\n    eventBus.fire('tool-manager.update', { tool: tool });\n  }\n};\n\nToolManager.prototype.bindEvents = function(name, events) {\n  var eventBus = this._eventBus,\n      dragging = this._dragging;\n\n  var eventsToRegister = [];\n\n  eventBus.on(events.tool + '.init', function(event) {\n    var context = event.context;\n\n    // Active tools that want to reactivate themselves must do this explicitly\n    if (!context.reactivate && this.isActive(name)) {\n      this.setActive(null);\n\n      dragging.cancel();\n      return;\n    }\n\n    this.setActive(name);\n\n  }, this);\n\n  // Todo[ricardo]: add test cases\n  forEach(events, function(event) {\n    eventsToRegister.push(event + '.ended');\n    eventsToRegister.push(event + '.canceled');\n  });\n\n  eventBus.on(eventsToRegister, LOW_PRIORITY, function(event) {\n    var originalEvent = event.originalEvent;\n\n    // We defer the de-activation of the tool to the .activate phase,\n    // so we're able to check if we want to toggle off the current\n    // active tool or switch to a new one\n    if (!this._active) {\n      return;\n    }\n\n    if (originalEvent && domClosest(originalEvent.target, '.group[data-group=\"tools\"]')) {\n      return;\n    }\n\n    this.setActive(null);\n  }, this);\n};\n","import DraggingModule from '../dragging';\n\nimport ToolManager from './ToolManager';\n\nexport default {\n  __depends__: [\n    DraggingModule\n  ],\n  __init__: [ 'toolManager' ],\n  toolManager: [ 'type', ToolManager ]\n};\n","import {\n  isString,\n  assign,\n  forEach\n} from 'min-dash';\n\nimport {\n  domify,\n  attr as domAttr,\n  classes as domClasses,\n  remove as domRemove,\n  delegate as domDelegate\n} from 'min-dom';\n\nimport Ids from '../../util/IdGenerator';\n\n// document wide unique tooltip ids\nvar ids = new Ids('tt');\n\n\nfunction createRoot(parentNode) {\n  var root = domify(\n    '<div class=\"djs-tooltip-container\" style=\"position: absolute; width: 0; height: 0;\" />'\n  );\n\n  parentNode.insertBefore(root, parentNode.firstChild);\n\n  return root;\n}\n\n\nfunction setPosition(el, x, y) {\n  assign(el.style, { left: x + 'px', top: y + 'px' });\n}\n\nfunction setVisible(el, visible) {\n  el.style.display = visible === false ? 'none' : '';\n}\n\n\nvar tooltipClass = 'djs-tooltip',\n    tooltipSelector = '.' + tooltipClass;\n\n/**\n * A service that allows users to render tool tips on the diagram.\n *\n * The tooltip service will take care of updating the tooltip positioning\n * during navigation + zooming.\n *\n * @example\n *\n * ```javascript\n *\n * // add a pink badge on the top left of the shape\n * tooltips.add({\n *   position: {\n *     x: 50,\n *     y: 100\n *   },\n *   html: '<div style=\"width: 10px; background: fuchsia; color: white;\">0</div>'\n * });\n *\n * // or with optional life span\n * tooltips.add({\n *   position: {\n *     top: -5,\n *     left: -5\n *   },\n *   html: '<div style=\"width: 10px; background: fuchsia; color: white;\">0</div>',\n *   ttl: 2000\n * });\n *\n * // remove a tool tip\n * var id = tooltips.add(...);\n * tooltips.remove(id);\n * ```\n *\n * @param {EventBus} eventBus\n * @param {Canvas} canvas\n */\nexport default function Tooltips(eventBus, canvas) {\n\n  this._eventBus = eventBus;\n  this._canvas = canvas;\n\n  this._ids = ids;\n\n  this._tooltipDefaults = {\n    show: {\n      minZoom: 0.7,\n      maxZoom: 5.0\n    }\n  };\n\n  /**\n   * Mapping tooltipId -> tooltip\n   */\n  this._tooltips = {};\n\n  // root html element for all tooltips\n  this._tooltipRoot = createRoot(canvas.getContainer());\n\n\n  var self = this;\n\n  domDelegate.bind(this._tooltipRoot, tooltipSelector, 'mousedown', function(event) {\n    event.stopPropagation();\n  });\n\n  domDelegate.bind(this._tooltipRoot, tooltipSelector, 'mouseover', function(event) {\n    self.trigger('mouseover', event);\n  });\n\n  domDelegate.bind(this._tooltipRoot, tooltipSelector, 'mouseout', function(event) {\n    self.trigger('mouseout', event);\n  });\n\n  this._init();\n}\n\n\nTooltips.$inject = [ 'eventBus', 'canvas' ];\n\n\n/**\n * Adds a HTML tooltip to the diagram\n *\n * @param {Object}               tooltip   the tooltip configuration\n *\n * @param {String|DOMElement}    tooltip.html                 html element to use as an tooltip\n * @param {Object}               [tooltip.show]               show configuration\n * @param {Number}               [tooltip.show.minZoom]       minimal zoom level to show the tooltip\n * @param {Number}               [tooltip.show.maxZoom]       maximum zoom level to show the tooltip\n * @param {Object}               tooltip.position             where to attach the tooltip\n * @param {Number}               [tooltip.position.left]      relative to element bbox left attachment\n * @param {Number}               [tooltip.position.top]       relative to element bbox top attachment\n * @param {Number}               [tooltip.position.bottom]    relative to element bbox bottom attachment\n * @param {Number}               [tooltip.position.right]     relative to element bbox right attachment\n * @param {Number}               [tooltip.timeout=-1]\n *\n * @return {String}              id that may be used to reference the tooltip for update or removal\n */\nTooltips.prototype.add = function(tooltip) {\n\n  if (!tooltip.position) {\n    throw new Error('must specifiy tooltip position');\n  }\n\n  if (!tooltip.html) {\n    throw new Error('must specifiy tooltip html');\n  }\n\n  var id = this._ids.next();\n\n  tooltip = assign({}, this._tooltipDefaults, tooltip, {\n    id: id\n  });\n\n  this._addTooltip(tooltip);\n\n  if (tooltip.timeout) {\n    this.setTimeout(tooltip);\n  }\n\n  return id;\n};\n\nTooltips.prototype.trigger = function(action, event) {\n\n  var node = event.delegateTarget || event.target;\n\n  var tooltip = this.get(domAttr(node, 'data-tooltip-id'));\n\n  if (!tooltip) {\n    return;\n  }\n\n  if (action === 'mouseover' && tooltip.timeout) {\n    this.clearTimeout(tooltip);\n  }\n\n  if (action === 'mouseout' && tooltip.timeout) {\n    // cut timeout after mouse out\n    tooltip.timeout = 1000;\n\n    this.setTimeout(tooltip);\n  }\n};\n\n/**\n * Get a tooltip with the given id\n *\n * @param {String} id\n */\nTooltips.prototype.get = function(id) {\n\n  if (typeof id !== 'string') {\n    id = id.id;\n  }\n\n  return this._tooltips[id];\n};\n\nTooltips.prototype.clearTimeout = function(tooltip) {\n\n  tooltip = this.get(tooltip);\n\n  if (!tooltip) {\n    return;\n  }\n\n  var removeTimer = tooltip.removeTimer;\n\n  if (removeTimer) {\n    clearTimeout(removeTimer);\n    tooltip.removeTimer = null;\n  }\n};\n\nTooltips.prototype.setTimeout = function(tooltip) {\n\n  tooltip = this.get(tooltip);\n\n  if (!tooltip) {\n    return;\n  }\n\n  this.clearTimeout(tooltip);\n\n  var self = this;\n\n  tooltip.removeTimer = setTimeout(function() {\n    self.remove(tooltip);\n  }, tooltip.timeout);\n};\n\n/**\n * Remove an tooltip with the given id\n *\n * @param {String} id\n */\nTooltips.prototype.remove = function(id) {\n\n  var tooltip = this.get(id);\n\n  if (tooltip) {\n    domRemove(tooltip.html);\n    domRemove(tooltip.htmlContainer);\n\n    delete tooltip.htmlContainer;\n\n    delete this._tooltips[tooltip.id];\n  }\n};\n\n\nTooltips.prototype.show = function() {\n  setVisible(this._tooltipRoot);\n};\n\n\nTooltips.prototype.hide = function() {\n  setVisible(this._tooltipRoot, false);\n};\n\n\nTooltips.prototype._updateRoot = function(viewbox) {\n  var a = viewbox.scale || 1;\n  var d = viewbox.scale || 1;\n\n  var matrix = 'matrix(' + a + ',0,0,' + d + ',' + (-1 * viewbox.x * a) + ',' + (-1 * viewbox.y * d) + ')';\n\n  this._tooltipRoot.style.transform = matrix;\n  this._tooltipRoot.style['-ms-transform'] = matrix;\n};\n\n\nTooltips.prototype._addTooltip = function(tooltip) {\n\n  var id = tooltip.id,\n      html = tooltip.html,\n      htmlContainer,\n      tooltipRoot = this._tooltipRoot;\n\n  // unwrap jquery (for those who need it)\n  if (html.get && html.constructor.prototype.jquery) {\n    html = html.get(0);\n  }\n\n  // create proper html elements from\n  // tooltip HTML strings\n  if (isString(html)) {\n    html = domify(html);\n  }\n\n  htmlContainer = domify('<div data-tooltip-id=\"' + id + '\" class=\"' + tooltipClass + '\" style=\"position: absolute\">');\n\n  htmlContainer.appendChild(html);\n\n  if (tooltip.type) {\n    domClasses(htmlContainer).add('djs-tooltip-' + tooltip.type);\n  }\n\n  if (tooltip.className) {\n    domClasses(htmlContainer).add(tooltip.className);\n  }\n\n  tooltip.htmlContainer = htmlContainer;\n\n  tooltipRoot.appendChild(htmlContainer);\n\n  this._tooltips[id] = tooltip;\n\n  this._updateTooltip(tooltip);\n};\n\n\nTooltips.prototype._updateTooltip = function(tooltip) {\n\n  var position = tooltip.position,\n      htmlContainer = tooltip.htmlContainer;\n\n  // update overlay html based on tooltip x, y\n\n  setPosition(htmlContainer, position.x, position.y);\n};\n\n\nTooltips.prototype._updateTooltipVisibilty = function(viewbox) {\n\n  forEach(this._tooltips, function(tooltip) {\n    var show = tooltip.show,\n        htmlContainer = tooltip.htmlContainer,\n        visible = true;\n\n    if (show) {\n      if (show.minZoom > viewbox.scale ||\n          show.maxZoom < viewbox.scale) {\n        visible = false;\n      }\n\n      setVisible(htmlContainer, visible);\n    }\n  });\n};\n\nTooltips.prototype._init = function() {\n\n  var self = this;\n\n  // scroll/zoom integration\n\n  function updateViewbox(viewbox) {\n    self._updateRoot(viewbox);\n    self._updateTooltipVisibilty(viewbox);\n\n    self.show();\n  }\n\n  this._eventBus.on('canvas.viewbox.changing', function(event) {\n    self.hide();\n  });\n\n  this._eventBus.on('canvas.viewbox.changed', function(event) {\n    updateViewbox(event.viewbox);\n  });\n};\n","import Tooltips from './Tooltips';\n\nexport default {\n  __init__: [ 'tooltips' ],\n  tooltips: [ 'type', Tooltips ]\n};","import {\n  append as svgAppend,\n  attr as svgAttr,\n  create as svgCreate\n} from 'tiny-svg';\n\n\nexport default function TouchFix(canvas, eventBus) {\n\n  var self = this;\n\n  eventBus.on('canvas.init', function(e) {\n    self.addBBoxMarker(e.svg);\n  });\n}\n\nTouchFix.$inject = [ 'canvas', 'eventBus' ];\n\n\n/**\n * Safari mobile (iOS 7) does not fire touchstart event in <SVG> element\n * if there is no shape between 0,0 and viewport elements origin.\n *\n * So touchstart event is only fired when the <g class=\"viewport\"> element was hit.\n * Putting an element over and below the 'viewport' fixes that behavior.\n */\nTouchFix.prototype.addBBoxMarker = function(svg) {\n\n  var markerStyle = {\n    fill: 'none',\n    class: 'outer-bound-marker'\n  };\n\n  var rect1 = svgCreate('rect');\n  svgAttr(rect1, {\n    x: -10000,\n    y: 10000,\n    width: 10,\n    height: 10\n  });\n  svgAttr(rect1, markerStyle);\n\n  svgAppend(svg, rect1);\n\n  var rect2 = svgCreate('rect');\n  svgAttr(rect2, {\n    x: 10000,\n    y: 10000,\n    width: 10,\n    height: 10\n  });\n  svgAttr(rect2, markerStyle);\n\n  svgAppend(svg, rect2);\n};\n","import {\n  forEach\n} from 'min-dash';\n\nimport {\n  event as domEvent,\n  closest as domClosest\n} from 'min-dom';\n\nimport Hammer from 'hammerjs';\n\nimport {\n  toPoint\n} from '../../util/Event';\n\nvar MIN_ZOOM = 0.2,\n    MAX_ZOOM = 4;\n\nvar mouseEvents = [\n  'mousedown',\n  'mouseup',\n  'mouseover',\n  'mouseout',\n  'click',\n  'dblclick'\n];\n\nfunction log() {\n  // console.log.apply(console, arguments);\n}\n\nfunction get(service, injector) {\n  return injector.get(service, false);\n}\n\nfunction stopEvent(event) {\n\n  event.preventDefault();\n  event.stopPropagation();\n\n  if (typeof event.stopImmediatePropagation === 'function') {\n    event.stopImmediatePropagation();\n  }\n}\n\n\nfunction createTouchRecognizer(node) {\n\n  function stopMouse(event) {\n\n    forEach(mouseEvents, function(e) {\n      domEvent.bind(node, e, stopEvent, true);\n    });\n  }\n\n  function allowMouse(event) {\n    setTimeout(function() {\n      forEach(mouseEvents, function(e) {\n        domEvent.unbind(node, e, stopEvent, true);\n      });\n    }, 500);\n  }\n\n  domEvent.bind(node, 'touchstart', stopMouse, true);\n  domEvent.bind(node, 'touchend', allowMouse, true);\n  domEvent.bind(node, 'touchcancel', allowMouse, true);\n\n  // A touch event recognizer that handles\n  // touch events only (we know, we can already handle\n  // mouse events out of the box)\n\n  var recognizer = new Hammer.Manager(node, {\n    inputClass: Hammer.TouchInput,\n    recognizers: []\n  });\n\n\n  var tap = new Hammer.Tap();\n  var pan = new Hammer.Pan({ threshold: 10 });\n  var press = new Hammer.Press();\n  var pinch = new Hammer.Pinch();\n\n  var doubleTap = new Hammer.Tap({ event: 'doubletap', taps: 2 });\n\n  pinch.requireFailure(pan);\n  pinch.requireFailure(press);\n\n  recognizer.add([ pan, press, pinch, doubleTap, tap ]);\n\n  recognizer.reset = function(force) {\n    var recognizers = this.recognizers,\n        session = this.session;\n\n    if (session.stopped) {\n      return;\n    }\n\n    log('recognizer', 'stop');\n\n    recognizer.stop(force);\n\n    setTimeout(function() {\n      var i, r;\n\n      log('recognizer', 'reset');\n      for (i = 0; (r = recognizers[i]); i++) {\n        r.reset();\n        r.state = 8; // FAILED STATE\n      }\n\n      session.curRecognizer = null;\n    }, 0);\n  };\n\n  recognizer.on('hammer.input', function(event) {\n    if (event.srcEvent.defaultPrevented) {\n      recognizer.reset(true);\n    }\n  });\n\n  return recognizer;\n}\n\n/**\n * A plugin that provides touch events for elements.\n *\n * @param {EventBus} eventBus\n * @param {InteractionEvents} interactionEvents\n */\nexport default function TouchInteractionEvents(\n    injector, canvas, eventBus,\n    elementRegistry, interactionEvents) {\n\n  // optional integrations\n  var dragging = get('dragging', injector),\n      move = get('move', injector),\n      contextPad = get('contextPad', injector),\n      palette = get('palette', injector);\n\n  // the touch recognizer\n  var recognizer;\n\n  function handler(type) {\n\n    return function(event) {\n      log('element', type, event);\n\n      interactionEvents.fire(type, event);\n    };\n  }\n\n  function getGfx(target) {\n    var node = domClosest(target, 'svg, .djs-element', true);\n    return node;\n  }\n\n  function initEvents(svg) {\n\n    // touch recognizer\n    recognizer = createTouchRecognizer(svg);\n\n    recognizer.on('doubletap', handler('element.dblclick'));\n\n    recognizer.on('tap', handler('element.click'));\n\n    function startGrabCanvas(event) {\n\n      log('canvas', 'grab start');\n\n      var lx = 0, ly = 0;\n\n      function update(e) {\n\n        var dx = e.deltaX - lx,\n            dy = e.deltaY - ly;\n\n        canvas.scroll({ dx: dx, dy: dy });\n\n        lx = e.deltaX;\n        ly = e.deltaY;\n      }\n\n      function end(e) {\n        recognizer.off('panmove', update);\n        recognizer.off('panend', end);\n        recognizer.off('pancancel', end);\n\n        log('canvas', 'grab end');\n      }\n\n      recognizer.on('panmove', update);\n      recognizer.on('panend', end);\n      recognizer.on('pancancel', end);\n    }\n\n    function startGrab(event) {\n\n      var gfx = getGfx(event.target),\n          element = gfx && elementRegistry.get(gfx);\n\n      // recognizer\n      if (move && canvas.getRootElement() !== element) {\n        log('element', 'move start', element, event, true);\n        return move.start(event, element, true);\n      } else {\n        startGrabCanvas(event);\n      }\n    }\n\n    function startZoom(e) {\n\n      log('canvas', 'zoom start');\n\n      var zoom = canvas.zoom(),\n          mid = e.center;\n\n      function update(e) {\n\n        var ratio = 1 - (1 - e.scale) / 1.50,\n            newZoom = Math.max(MIN_ZOOM, Math.min(MAX_ZOOM, ratio * zoom));\n\n        canvas.zoom(newZoom, mid);\n\n        stopEvent(e);\n      }\n\n      function end(e) {\n        recognizer.off('pinchmove', update);\n        recognizer.off('pinchend', end);\n        recognizer.off('pinchcancel', end);\n\n        recognizer.reset(true);\n\n        log('canvas', 'zoom end');\n      }\n\n      recognizer.on('pinchmove', update);\n      recognizer.on('pinchend', end);\n      recognizer.on('pinchcancel', end);\n    }\n\n    recognizer.on('panstart', startGrab);\n    recognizer.on('press', startGrab);\n\n    recognizer.on('pinchstart', startZoom);\n  }\n\n  if (dragging) {\n\n    // simulate hover during dragging\n    eventBus.on('drag.move', function(event) {\n\n      var originalEvent = event.originalEvent;\n\n      if (!originalEvent || originalEvent instanceof MouseEvent) {\n        return;\n      }\n\n      var position = toPoint(originalEvent);\n\n      // this gets really expensive ...\n      var node = document.elementFromPoint(position.x, position.y),\n          gfx = getGfx(node),\n          element = gfx && elementRegistry.get(gfx);\n\n      if (element !== event.hover) {\n        if (event.hover) {\n          dragging.out(event);\n        }\n\n        if (element) {\n          dragging.hover({ element: element, gfx: gfx });\n\n          event.hover = element;\n          event.hoverGfx = gfx;\n        }\n      }\n    });\n  }\n\n  if (contextPad) {\n\n    eventBus.on('contextPad.create', function(event) {\n      var node = event.pad.html;\n\n      // touch recognizer\n      var padRecognizer = createTouchRecognizer(node);\n\n      padRecognizer.on('panstart', function(event) {\n        log('context-pad', 'panstart', event);\n        contextPad.trigger('dragstart', event, true);\n      });\n\n      padRecognizer.on('press', function(event) {\n        log('context-pad', 'press', event);\n        contextPad.trigger('dragstart', event, true);\n      });\n\n      padRecognizer.on('tap', function(event) {\n        log('context-pad', 'tap', event);\n        contextPad.trigger('click', event);\n      });\n    });\n  }\n\n  if (palette) {\n    eventBus.on('palette.create', function(event) {\n      var node = event.container;\n\n      // touch recognizer\n      var padRecognizer = createTouchRecognizer(node);\n\n      padRecognizer.on('panstart', function(event) {\n        log('palette', 'panstart', event);\n        palette.trigger('dragstart', event, true);\n      });\n\n      padRecognizer.on('press', function(event) {\n        log('palette', 'press', event);\n        palette.trigger('dragstart', event, true);\n      });\n\n      padRecognizer.on('tap', function(event) {\n        log('palette', 'tap', event);\n        palette.trigger('click', event);\n      });\n    });\n  }\n\n  eventBus.on('canvas.init', function(event) {\n    initEvents(event.svg);\n  });\n}\n\n\nTouchInteractionEvents.$inject = [\n  'injector',\n  'canvas',\n  'eventBus',\n  'elementRegistry',\n  'interactionEvents',\n  'touchFix'\n];\n","import InteractionEventsModule from '../interaction-events';\n\nimport TouchInteractionEvents from './TouchInteractionEvents';\nimport TouchFix from './TouchFix';\n\nexport default {\n  __depends__: [ InteractionEventsModule ],\n  __init__: [ 'touchInteractionEvents' ],\n  touchInteractionEvents: [ 'type', TouchInteractionEvents ],\n  touchFix: [ 'type', TouchFix ]\n};","import translate from './translate';\n\nexport default {\n  translate: [ 'value', translate ]\n};","/**\n * A simple translation stub to be used for multi-language support\n * in diagrams. Can be easily replaced with a more sophisticated\n * solution.\n *\n * @example\n *\n * // use it inside any diagram component by injecting `translate`.\n *\n * function MyService(translate) {\n *   alert(translate('HELLO {you}', { you: 'You!' }));\n * }\n *\n * @param {String} template to interpolate\n * @param {Object} [replacements] a map with substitutes\n *\n * @return {String} the translated string\n */\nexport default function translate(template, replacements) {\n\n  replacements = replacements || {};\n\n  return template.replace(/{([^}]+)}/g, function(_, key) {\n    return replacements[key] || '{' + key + '}';\n  });\n}","import {\n  getMid\n} from './LayoutUtil';\n\n\n/**\n * A base connection layouter implementation\n * that layouts the connection by directly connecting\n * mid(source) + mid(target).\n */\nexport default function BaseLayouter() {}\n\n\n/**\n * Return the new layouted waypoints for the given connection.\n *\n * The connection passed is still unchanged; you may figure out about\n * the new connection start / end via the layout hints provided.\n *\n * @param {djs.model.Connection} connection\n * @param {Object} [hints]\n * @param {Point} [hints.connectionStart]\n * @param {Point} [hints.connectionEnd]\n *\n * @return {Array<Point>} the layouted connection waypoints\n */\nBaseLayouter.prototype.layoutConnection = function(connection, hints) {\n\n  hints = hints || {};\n\n  return [\n    hints.connectionStart || getMid(connection.source),\n    hints.connectionEnd || getMid(connection.target)\n  ];\n};\n","import {\n  assign\n} from 'min-dash';\n\nimport {\n  getElementLineIntersection\n} from './LayoutUtil';\n\n\nfunction dockingToPoint(docking) {\n  // use the dockings actual point and\n  // retain the original docking\n  return assign({ original: docking.point.original || docking.point }, docking.actual);\n}\n\n\n/**\n * A {@link ConnectionDocking} that crops connection waypoints based on\n * the path(s) of the connection source and target.\n *\n * @param {djs.core.ElementRegistry} elementRegistry\n */\nexport default function CroppingConnectionDocking(elementRegistry, graphicsFactory) {\n  this._elementRegistry = elementRegistry;\n  this._graphicsFactory = graphicsFactory;\n}\n\nCroppingConnectionDocking.$inject = [ 'elementRegistry', 'graphicsFactory' ];\n\n\n/**\n * @inheritDoc ConnectionDocking#getCroppedWaypoints\n */\nCroppingConnectionDocking.prototype.getCroppedWaypoints = function(connection, source, target) {\n\n  source = source || connection.source;\n  target = target || connection.target;\n\n  var sourceDocking = this.getDockingPoint(connection, source, true),\n      targetDocking = this.getDockingPoint(connection, target);\n\n  var croppedWaypoints = connection.waypoints.slice(sourceDocking.idx + 1, targetDocking.idx);\n\n  croppedWaypoints.unshift(dockingToPoint(sourceDocking));\n  croppedWaypoints.push(dockingToPoint(targetDocking));\n\n  return croppedWaypoints;\n};\n\n/**\n * Return the connection docking point on the specified shape\n *\n * @inheritDoc ConnectionDocking#getDockingPoint\n */\nCroppingConnectionDocking.prototype.getDockingPoint = function(connection, shape, dockStart) {\n\n  var waypoints = connection.waypoints,\n      dockingIdx,\n      dockingPoint,\n      croppedPoint;\n\n  dockingIdx = dockStart ? 0 : waypoints.length - 1;\n  dockingPoint = waypoints[dockingIdx];\n\n  croppedPoint = this._getIntersection(shape, connection, dockStart);\n\n  return {\n    point: dockingPoint,\n    actual: croppedPoint || dockingPoint,\n    idx: dockingIdx\n  };\n};\n\n\n// helpers //////////////////////\n\nCroppingConnectionDocking.prototype._getIntersection = function(shape, connection, takeFirst) {\n\n  var shapePath = this._getShapePath(shape),\n      connectionPath = this._getConnectionPath(connection);\n\n  return getElementLineIntersection(shapePath, connectionPath, takeFirst);\n};\n\nCroppingConnectionDocking.prototype._getConnectionPath = function(connection) {\n  return this._graphicsFactory.getConnectionPath(connection);\n};\n\nCroppingConnectionDocking.prototype._getShapePath = function(shape) {\n  return this._graphicsFactory.getShapePath(shape);\n};\n\nCroppingConnectionDocking.prototype._getGfx = function(element) {\n  return this._elementRegistry.getGraphics(element);\n};\n","import {\n  isObject,\n  sortBy\n} from 'min-dash';\n\nimport {\n  pointDistance\n} from '../util/Geometry';\n\nimport intersectPaths from 'path-intersection';\n\n\nexport function roundBounds(bounds) {\n  return {\n    x: Math.round(bounds.x),\n    y: Math.round(bounds.y),\n    width: Math.round(bounds.width),\n    height: Math.round(bounds.height)\n  };\n}\n\n\nexport function roundPoint(point) {\n\n  return {\n    x: Math.round(point.x),\n    y: Math.round(point.y)\n  };\n}\n\n\n/**\n * Convert the given bounds to a { top, left, bottom, right } descriptor.\n *\n * @param {Bounds|Point} bounds\n *\n * @return {Object}\n */\nexport function asTRBL(bounds) {\n  return {\n    top: bounds.y,\n    right: bounds.x + (bounds.width || 0),\n    bottom: bounds.y + (bounds.height || 0),\n    left: bounds.x\n  };\n}\n\n\n/**\n * Convert a { top, left, bottom, right } to an objects bounds.\n *\n * @param {Object} trbl\n *\n * @return {Bounds}\n */\nexport function asBounds(trbl) {\n  return {\n    x: trbl.left,\n    y: trbl.top,\n    width: trbl.right - trbl.left,\n    height: trbl.bottom - trbl.top\n  };\n}\n\n\n/**\n * Get the mid of the given bounds or point.\n *\n * @param {Bounds|Point} bounds\n *\n * @return {Point}\n */\nexport function getMid(bounds) {\n  return roundPoint({\n    x: bounds.x + (bounds.width || 0) / 2,\n    y: bounds.y + (bounds.height || 0) / 2\n  });\n}\n\n\n// orientation utils //////////////////////\n\n/**\n * Get orientation of the given rectangle with respect to\n * the reference rectangle.\n *\n * A padding (positive or negative) may be passed to influence\n * horizontal / vertical orientation and intersection.\n *\n * @param {Bounds} rect\n * @param {Bounds} reference\n * @param {Point|Number} padding\n *\n * @return {String} the orientation; one of top, top-left, left, ..., bottom, right or intersect.\n */\nexport function getOrientation(rect, reference, padding) {\n\n  padding = padding || 0;\n\n  // make sure we can use an object, too\n  // for individual { x, y } padding\n  if (!isObject(padding)) {\n    padding = { x: padding, y: padding };\n  }\n\n\n  var rectOrientation = asTRBL(rect),\n      referenceOrientation = asTRBL(reference);\n\n  var top = rectOrientation.bottom + padding.y <= referenceOrientation.top,\n      right = rectOrientation.left - padding.x >= referenceOrientation.right,\n      bottom = rectOrientation.top - padding.y >= referenceOrientation.bottom,\n      left = rectOrientation.right + padding.x <= referenceOrientation.left;\n\n  var vertical = top ? 'top' : (bottom ? 'bottom' : null),\n      horizontal = left ? 'left' : (right ? 'right' : null);\n\n  if (horizontal && vertical) {\n    return vertical + '-' + horizontal;\n  } else {\n    return horizontal || vertical || 'intersect';\n  }\n}\n\n\n// intersection utils //////////////////////\n\n/**\n * Get intersection between an element and a line path.\n *\n * @param {PathDef} elementPath\n * @param {PathDef} linePath\n * @param {Boolean} cropStart crop from start or end\n *\n * @return {Point}\n */\nexport function getElementLineIntersection(elementPath, linePath, cropStart) {\n\n  var intersections = getIntersections(elementPath, linePath);\n\n  // recognize intersections\n  // only one -> choose\n  // two close together -> choose first\n  // two or more distinct -> pull out appropriate one\n  // none -> ok (fallback to point itself)\n  if (intersections.length === 1) {\n    return roundPoint(intersections[0]);\n  } else if (intersections.length === 2 && pointDistance(intersections[0], intersections[1]) < 1) {\n    return roundPoint(intersections[0]);\n  } else if (intersections.length > 1) {\n\n    // sort by intersections based on connection segment +\n    // distance from start\n    intersections = sortBy(intersections, function(i) {\n      var distance = Math.floor(i.t2 * 100) || 1;\n\n      distance = 100 - distance;\n\n      distance = (distance < 10 ? '0' : '') + distance;\n\n      // create a sort string that makes sure we sort\n      // line segment ASC + line segment position DESC (for cropStart)\n      // line segment ASC + line segment position ASC (for cropEnd)\n      return i.segment2 + '#' + distance;\n    });\n\n    return roundPoint(intersections[cropStart ? 0 : intersections.length - 1]);\n  }\n\n  return null;\n}\n\n\nexport function getIntersections(a, b) {\n  return intersectPaths(a, b);\n}","import {\n  isArray,\n  find,\n  without,\n  assign\n} from 'min-dash';\n\nimport {\n  getOrientation,\n  getMid\n} from './LayoutUtil';\n\nimport {\n  pointInRect,\n  pointDistance,\n  pointsAligned,\n  pointsOnLine\n} from '../util/Geometry';\n\nvar MIN_SEGMENT_LENGTH = 20,\n    POINT_ORIENTATION_PADDING = 5;\n\nvar round = Math.round;\n\nvar INTERSECTION_THRESHOLD = 20,\n    ORIENTATION_THRESHOLD = {\n      'h:h': 20,\n      'v:v': 20,\n      'h:v': -10,\n      'v:h': -10\n    };\n\nfunction needsTurn(orientation, startDirection) {\n  return !{\n    t: /top/,\n    r: /right/,\n    b: /bottom/,\n    l: /left/,\n    h: /./,\n    v: /./\n  }[startDirection].test(orientation);\n}\n\nfunction canLayoutStraight(direction, targetOrientation) {\n  return {\n    t: /top/,\n    r: /right/,\n    b: /bottom/,\n    l: /left/,\n    h: /left|right/,\n    v: /top|bottom/\n  }[direction].test(targetOrientation);\n}\n\nfunction getSegmentBendpoints(a, b, directions) {\n  var orientation = getOrientation(b, a, POINT_ORIENTATION_PADDING);\n\n  var startDirection = directions.split(':')[0];\n\n  var xmid = round((b.x - a.x) / 2 + a.x),\n      ymid = round((b.y - a.y) / 2 + a.y);\n\n  var segmentEnd, segmentDirections;\n\n  var layoutStraight = canLayoutStraight(startDirection, orientation),\n      layoutHorizontal = /h|r|l/.test(startDirection),\n      layoutTurn = false;\n\n  var turnNextDirections = false;\n\n  if (layoutStraight) {\n    segmentEnd = layoutHorizontal ? { x: xmid, y: a.y } : { x: a.x, y: ymid };\n\n    segmentDirections = layoutHorizontal ? 'h:h' : 'v:v';\n  } else {\n    layoutTurn = needsTurn(orientation, startDirection);\n\n    segmentDirections = layoutHorizontal ? 'h:v' : 'v:h';\n\n    if (layoutTurn) {\n\n      if (layoutHorizontal) {\n        turnNextDirections = ymid === a.y;\n\n        segmentEnd = {\n          x: a.x + MIN_SEGMENT_LENGTH * (/l/.test(startDirection) ? -1 : 1),\n          y: turnNextDirections ? ymid + MIN_SEGMENT_LENGTH : ymid\n        };\n      } else {\n        turnNextDirections = xmid === a.x;\n\n        segmentEnd = {\n          x: turnNextDirections ? xmid + MIN_SEGMENT_LENGTH : xmid,\n          y: a.y + MIN_SEGMENT_LENGTH * (/t/.test(startDirection) ? -1 : 1)\n        };\n      }\n\n    } else {\n      segmentEnd = {\n        x: xmid,\n        y: ymid\n      };\n    }\n  }\n\n  return {\n    waypoints: getBendpoints(a, segmentEnd, segmentDirections).concat(segmentEnd),\n    directions:  segmentDirections,\n    turnNextDirections: turnNextDirections\n  };\n}\n\nfunction getStartSegment(a, b, directions) {\n  return getSegmentBendpoints(a, b, directions);\n}\n\nfunction getEndSegment(a, b, directions) {\n  var invertedSegment = getSegmentBendpoints(b, a, invertDirections(directions));\n\n  return {\n    waypoints: invertedSegment.waypoints.slice().reverse(),\n    directions: invertDirections(invertedSegment.directions),\n    turnNextDirections: invertedSegment.turnNextDirections\n  };\n}\n\nfunction getMidSegment(startSegment, endSegment) {\n\n  var startDirection = startSegment.directions.split(':')[1],\n      endDirection = endSegment.directions.split(':')[0];\n\n  if (startSegment.turnNextDirections) {\n    startDirection = startDirection == 'h' ? 'v' : 'h';\n  }\n\n  if (endSegment.turnNextDirections) {\n    endDirection = endDirection == 'h' ? 'v' : 'h';\n  }\n\n  var directions = startDirection + ':' + endDirection;\n\n  var bendpoints = getBendpoints(\n    startSegment.waypoints[startSegment.waypoints.length - 1],\n    endSegment.waypoints[0],\n    directions\n  );\n\n  return {\n    waypoints: bendpoints,\n    directions: directions\n  };\n}\n\nfunction invertDirections(directions) {\n  return directions.split(':').reverse().join(':');\n}\n\n/**\n * Handle simple layouts with maximum two bendpoints.\n */\nfunction getSimpleBendpoints(a, b, directions) {\n\n  var xmid = round((b.x - a.x) / 2 + a.x),\n      ymid = round((b.y - a.y) / 2 + a.y);\n\n  // one point, right or left from a\n  if (directions === 'h:v') {\n    return [ { x: b.x, y: a.y } ];\n  }\n\n  // one point, above or below a\n  if (directions === 'v:h') {\n    return [ { x: a.x, y: b.y } ];\n  }\n\n  // vertical segment between a and b\n  if (directions === 'h:h') {\n    return [\n      { x: xmid, y: a.y },\n      { x: xmid, y: b.y }\n    ];\n  }\n\n  // horizontal segment between a and b\n  if (directions === 'v:v') {\n    return [\n      { x: a.x, y: ymid },\n      { x: b.x, y: ymid }\n    ];\n  }\n\n  throw new Error('invalid directions: can only handle varians of [hv]:[hv]');\n}\n\n\n/**\n * Returns the mid points for a manhattan connection between two points.\n *\n * @example h:h (horizontal:horizontal)\n *\n * [a]----[x]\n *         |\n *        [x]----[b]\n *\n * @example h:v (horizontal:vertical)\n *\n * [a]----[x]\n *         |\n *        [b]\n *\n * @example h:r (horizontal:right)\n *\n * [a]----[x]\n *         |\n *    [b]-[x]\n *\n * @param  {Point} a\n * @param  {Point} b\n * @param  {String} directions\n *\n * @return {Array<Point>}\n */\nfunction getBendpoints(a, b, directions) {\n  directions = directions || 'h:h';\n\n  if (!isValidDirections(directions)) {\n    throw new Error(\n      'unknown directions: <' + directions + '>: ' +\n      'must be specified as <start>:<end> ' +\n      'with start/end in { h,v,t,r,b,l }'\n    );\n  }\n\n  // compute explicit directions, involving trbl dockings\n  // using a three segmented layouting algorithm\n  if (isExplicitDirections(directions)) {\n    var startSegment = getStartSegment(a, b, directions),\n        endSegment = getEndSegment(a, b, directions),\n        midSegment = getMidSegment(startSegment, endSegment);\n\n    return [].concat(\n      startSegment.waypoints,\n      midSegment.waypoints,\n      endSegment.waypoints\n    );\n  }\n\n  // handle simple [hv]:[hv] cases that can be easily computed\n  return getSimpleBendpoints(a, b, directions);\n}\n\n/**\n * Create a connection between the two points according\n * to the manhattan layout (only horizontal and vertical) edges.\n *\n * @param {Point} a\n * @param {Point} b\n *\n * @param {String} [directions='h:h'] specifies manhattan directions for each point as {adirection}:{bdirection}.\n                   A directionfor a point is either `h` (horizontal) or `v` (vertical)\n *\n * @return {Array<Point>}\n */\nexport function connectPoints(a, b, directions) {\n\n  var points = getBendpoints(a, b, directions);\n\n  points.unshift(a);\n  points.push(b);\n\n  return withoutRedundantPoints(points);\n}\n\n\n/**\n * Connect two rectangles using a manhattan layouted connection.\n *\n * @param {Bounds} source source rectangle\n * @param {Bounds} target target rectangle\n * @param {Point} [start] source docking\n * @param {Point} [end] target docking\n *\n * @param {Object} [hints]\n * @param {String} [hints.preserveDocking=source] preserve docking on selected side\n * @param {Array<String>} [hints.preferredLayouts]\n * @param {Point|Boolean} [hints.connectionStart] whether the start changed\n * @param {Point|Boolean} [hints.connectionEnd] whether the end changed\n *\n * @return {Array<Point>} connection points\n */\nexport function connectRectangles(source, target, start, end, hints) {\n\n  var preferredLayouts = hints && hints.preferredLayouts || [];\n\n  var preferredLayout = without(preferredLayouts, 'straight')[0] || 'h:h';\n\n  var threshold = ORIENTATION_THRESHOLD[preferredLayout] || 0;\n\n  var orientation = getOrientation(source, target, threshold);\n\n  var directions = getDirections(orientation, preferredLayout);\n\n  start = start || getMid(source);\n  end = end || getMid(target);\n\n  var directionSplit = directions.split(':');\n\n  // compute actual docking points for start / end\n  // this ensures we properly layout only parts of the\n  // connection that lies in between the two rectangles\n  var startDocking = getDockingPoint(start, source, directionSplit[0], invertOrientation(orientation)),\n      endDocking = getDockingPoint(end, target, directionSplit[1], orientation);\n\n  return connectPoints(startDocking, endDocking, directions);\n}\n\n\n/**\n * Repair the connection between two rectangles, of which one has been updated.\n *\n * @param {Bounds} source\n * @param {Bounds} target\n * @param {Point} [start]\n * @param {Point} [end]\n * @param {Array<Point>} waypoints\n * @param {Object} [hints]\n * @param {Array<String>} [hints.preferredLayouts] list of preferred layouts\n * @param {Boolean} [hints.connectionStart]\n * @param {Boolean} [hints.connectionEnd]\n *\n * @return {Array<Point>} repaired waypoints\n */\nexport function repairConnection(source, target, start, end, waypoints, hints) {\n\n  if (isArray(start)) {\n    waypoints = start;\n    hints = end;\n\n    start = getMid(source);\n    end = getMid(target);\n  }\n\n  hints = assign({ preferredLayouts: [] }, hints);\n  waypoints = waypoints || [];\n\n  var preferredLayouts = hints.preferredLayouts,\n      preferStraight = preferredLayouts.indexOf('straight') !== -1,\n      repairedWaypoints;\n\n  // just layout non-existing or simple connections\n  // attempt to render straight lines, if required\n\n  if (preferStraight) {\n    // attempt to layout a straight line\n    repairedWaypoints = layoutStraight(source, target, start, end, hints);\n  }\n\n  if (!repairedWaypoints) {\n    // check if we layout from start or end\n    if (hints.connectionEnd) {\n      repairedWaypoints = _repairConnectionSide(target, source, end, waypoints.slice().reverse());\n      repairedWaypoints = repairedWaypoints && repairedWaypoints.reverse();\n    } else\n    if (hints.connectionStart) {\n      repairedWaypoints = _repairConnectionSide(source, target, start, waypoints);\n    } else\n    // or whether nothing seems to have changed\n    if (waypoints && waypoints.length) {\n      repairedWaypoints = waypoints;\n    }\n  }\n\n  // simply reconnect if nothing else worked\n  if (!repairedWaypoints) {\n    repairedWaypoints = connectRectangles(source, target, start, end, hints);\n  }\n\n  return repairedWaypoints;\n}\n\n\nfunction inRange(a, start, end) {\n  return a >= start && a <= end;\n}\n\nfunction isInRange(axis, a, b) {\n  var size = {\n    x: 'width',\n    y: 'height'\n  };\n\n  return inRange(a[axis], b[axis], b[axis] + b[size[axis]]);\n}\n\n/**\n * Layout a straight connection\n *\n * @param {Bounds} source\n * @param {Bounds} target\n * @param {Point} start\n * @param {Point} end\n * @param {Object} [hints]\n *\n * @return {Array<Point>} waypoints if straight layout worked\n */\nexport function layoutStraight(source, target, start, end, hints) {\n  var axis = {},\n      primaryAxis,\n      orientation;\n\n  orientation = getOrientation(source, target);\n\n  // only layout a straight connection if shapes are\n  // horizontally or vertically aligned\n  if (!/^(top|bottom|left|right)$/.test(orientation)) {\n    return null;\n  }\n\n  if (/top|bottom/.test(orientation)) {\n    primaryAxis = 'x';\n  }\n\n  if (/left|right/.test(orientation)) {\n    primaryAxis = 'y';\n  }\n\n  if (hints.preserveDocking === 'target') {\n\n    if (!isInRange(primaryAxis, end, source)) {\n      return null;\n    }\n\n    axis[primaryAxis] = end[primaryAxis];\n\n    return [\n      {\n        x: axis.x !== undefined ? axis.x : start.x,\n        y: axis.y !== undefined ? axis.y : start.y,\n        original: {\n          x: axis.x !== undefined ? axis.x : start.x,\n          y: axis.y !== undefined ? axis.y : start.y\n        }\n      },\n      {\n        x: end.x,\n        y: end.y\n      }\n    ];\n\n  } else {\n\n    if (!isInRange(primaryAxis, start, target)) {\n      return null;\n    }\n\n    axis[primaryAxis] = start[primaryAxis];\n\n    return [\n      {\n        x: start.x,\n        y: start.y\n      },\n      {\n        x: axis.x !== undefined ? axis.x : end.x,\n        y: axis.y !== undefined ? axis.y : end.y,\n        original: {\n          x: axis.x !== undefined ? axis.x : end.x,\n          y: axis.y !== undefined ? axis.y : end.y\n        }\n      }\n    ];\n  }\n\n}\n\n\n/**\n * Repair a connection from one side that moved.\n *\n * @param {Bounds} moved\n * @param {Bounds} other\n * @param {Point} newDocking\n * @param {Array<Point>} points originalPoints from moved to other\n *\n * @return {Array<Point>} the repaired points between the two rectangles\n */\nexport function _repairConnectionSide(moved, other, newDocking, points) {\n\n  function needsRelayout(moved, other, points) {\n\n    if (points.length < 3) {\n      return true;\n    }\n\n    if (points.length > 4) {\n      return false;\n    }\n\n    // relayout if two points overlap\n    // this is most likely due to\n    return !!find(points, function(p, idx) {\n      var q = points[idx - 1];\n\n      return q && pointDistance(p, q) < 3;\n    });\n  }\n\n  function repairBendpoint(candidate, oldPeer, newPeer) {\n\n    var alignment = pointsAligned(oldPeer, candidate);\n\n    switch (alignment) {\n    case 'v':\n      // repair vertical alignment\n      return { x: candidate.x, y: newPeer.y };\n    case 'h':\n      // repair horizontal alignment\n      return { x: newPeer.x, y: candidate.y };\n    }\n\n    return { x: candidate.x, y: candidate. y };\n  }\n\n  function removeOverlapping(points, a, b) {\n    var i;\n\n    for (i = points.length - 2; i !== 0; i--) {\n\n      // intersects (?) break, remove all bendpoints up to this one and relayout\n      if (pointInRect(points[i], a, INTERSECTION_THRESHOLD) ||\n          pointInRect(points[i], b, INTERSECTION_THRESHOLD)) {\n\n        // return sliced old connection\n        return points.slice(i);\n      }\n    }\n\n    return points;\n  }\n\n\n  // (0) only repair what has layoutable bendpoints\n\n  // (1) if only one bendpoint and on shape moved onto other shapes axis\n  //     (horizontally / vertically), relayout\n\n  if (needsRelayout(moved, other, points)) {\n    return null;\n  }\n\n  var oldDocking = points[0],\n      newPoints = points.slice(),\n      slicedPoints;\n\n  // (2) repair only last line segment and only if it was layouted before\n\n  newPoints[0] = newDocking;\n  newPoints[1] = repairBendpoint(newPoints[1], oldDocking, newDocking);\n\n\n  // (3) if shape intersects with any bendpoint after repair,\n  //     remove all segments up to this bendpoint and repair from there\n\n  slicedPoints = removeOverlapping(newPoints, moved, other);\n\n  if (slicedPoints !== newPoints) {\n    return _repairConnectionSide(moved, other, newDocking, slicedPoints);\n  }\n\n  return newPoints;\n}\n\n\n/**\n * Returns the manhattan directions connecting two rectangles\n * with the given orientation.\n *\n * Will always return the default layout, if it is specific\n * regarding sides already (trbl).\n *\n * @example\n *\n * getDirections('top'); // -> 'v:v'\n * getDirections('intersect'); // -> 't:t'\n *\n * getDirections('top-right', 'v:h'); // -> 'v:h'\n * getDirections('top-right', 'h:h'); // -> 'h:h'\n *\n *\n * @param {String} orientation\n * @param {String} defaultLayout\n *\n * @return {String}\n */\nfunction getDirections(orientation, defaultLayout) {\n\n  // don't override specific trbl directions\n  if (isExplicitDirections(defaultLayout)) {\n    return defaultLayout;\n  }\n\n  switch (orientation) {\n  case 'intersect':\n    return 't:t';\n\n  case 'top':\n  case 'bottom':\n    return 'v:v';\n\n  case 'left':\n  case 'right':\n    return 'h:h';\n\n  // 'top-left'\n  // 'top-right'\n  // 'bottom-left'\n  // 'bottom-right'\n  default:\n    return defaultLayout;\n  }\n}\n\nfunction isValidDirections(directions) {\n  return directions && /^h|v|t|r|b|l:h|v|t|r|b|l$/.test(directions);\n}\n\nfunction isExplicitDirections(directions) {\n  return directions && /t|r|b|l/.test(directions);\n}\n\nfunction invertOrientation(orientation) {\n  return {\n    'top': 'bottom',\n    'bottom': 'top',\n    'left': 'right',\n    'right': 'left',\n    'top-left': 'bottom-right',\n    'bottom-right': 'top-left',\n    'top-right': 'bottom-left',\n    'bottom-left': 'top-right',\n  }[orientation];\n}\n\nfunction getDockingPoint(point, rectangle, dockingDirection, targetOrientation) {\n\n  // ensure we end up with a specific docking direction\n  // based on the targetOrientation, if <h|v> is being passed\n\n  if (dockingDirection === 'h') {\n    dockingDirection = /left/.test(targetOrientation) ? 'l' : 'r';\n  }\n\n  if (dockingDirection === 'v') {\n    dockingDirection = /top/.test(targetOrientation) ? 't' : 'b';\n  }\n\n  if (dockingDirection === 't') {\n    return { original: point, x: point.x, y: rectangle.y };\n  }\n\n  if (dockingDirection === 'r') {\n    return { original: point, x: rectangle.x + rectangle.width, y: point.y };\n  }\n\n  if (dockingDirection === 'b') {\n    return { original: point, x: point.x, y: rectangle.y + rectangle.height };\n  }\n\n  if (dockingDirection === 'l') {\n    return { original: point, x: rectangle.x, y: point.y };\n  }\n\n  throw new Error('unexpected dockingDirection: <' + dockingDirection + '>');\n}\n\n\n/**\n * Return list of waypoints with redundant ones filtered out.\n *\n * @example\n *\n * Original points:\n *\n *   [x] ----- [x] ------ [x]\n *                         |\n *                        [x] ----- [x] - [x]\n *\n * Filtered:\n *\n *   [x] ---------------- [x]\n *                         |\n *                        [x] ----------- [x]\n *\n * @param  {Array<Point>} waypoints\n *\n * @return {Array<Point>}\n */\nexport function withoutRedundantPoints(waypoints) {\n  return waypoints.reduce(function(points, p, idx) {\n\n    var previous = points[points.length - 1],\n        next = waypoints[idx + 1];\n\n    if (!pointsOnLine(previous, next, p, 0)) {\n      points.push(p);\n    }\n\n    return points;\n  }, []);\n}","import { assign } from 'min-dash';\nimport inherits from 'inherits';\n\nimport Refs from 'object-refs';\n\nvar parentRefs = new Refs({ name: 'children', enumerable: true, collection: true }, { name: 'parent' }),\n    labelRefs = new Refs({ name: 'labels', enumerable: true, collection: true }, { name: 'labelTarget' }),\n    attacherRefs = new Refs({ name: 'attachers', collection: true }, { name: 'host' }),\n    outgoingRefs = new Refs({ name: 'outgoing', collection: true }, { name: 'source' }),\n    incomingRefs = new Refs({ name: 'incoming', collection: true }, { name: 'target' });\n\n/**\n * @namespace djs.model\n */\n\n/**\n * @memberOf djs.model\n */\n\n/**\n * The basic graphical representation\n *\n * @class\n *\n * @abstract\n */\nexport function Base() {\n\n  /**\n   * The object that backs up the shape\n   *\n   * @name Base#businessObject\n   * @type Object\n   */\n  Object.defineProperty(this, 'businessObject', {\n    writable: true\n  });\n\n\n  /**\n   * Single label support, will mapped to multi label array\n   *\n   * @name Base#label\n   * @type Object\n   */\n  Object.defineProperty(this, 'label', {\n    get: function() {\n      return this.labels[0];\n    },\n    set: function(newLabel) {\n\n      var label = this.label,\n          labels = this.labels;\n\n      if (!newLabel && label) {\n        labels.remove(label);\n      } else {\n        labels.add(newLabel, 0);\n      }\n    }\n  });\n\n  /**\n   * The parent shape\n   *\n   * @name Base#parent\n   * @type Shape\n   */\n  parentRefs.bind(this, 'parent');\n\n  /**\n   * The list of labels\n   *\n   * @name Base#labels\n   * @type Label\n   */\n  labelRefs.bind(this, 'labels');\n\n  /**\n   * The list of outgoing connections\n   *\n   * @name Base#outgoing\n   * @type Array<Connection>\n   */\n  outgoingRefs.bind(this, 'outgoing');\n\n  /**\n   * The list of incoming connections\n   *\n   * @name Base#incoming\n   * @type Array<Connection>\n   */\n  incomingRefs.bind(this, 'incoming');\n}\n\n\n/**\n * A graphical object\n *\n * @class\n * @constructor\n *\n * @extends Base\n */\nexport function Shape() {\n  Base.call(this);\n\n  /**\n   * The list of children\n   *\n   * @name Shape#children\n   * @type Array<Base>\n   */\n  parentRefs.bind(this, 'children');\n\n  /**\n   * @name Shape#host\n   * @type Shape\n   */\n  attacherRefs.bind(this, 'host');\n\n  /**\n   * @name Shape#attachers\n   * @type Shape\n   */\n  attacherRefs.bind(this, 'attachers');\n}\n\ninherits(Shape, Base);\n\n\n/**\n * A root graphical object\n *\n * @class\n * @constructor\n *\n * @extends Shape\n */\nexport function Root() {\n  Shape.call(this);\n}\n\ninherits(Root, Shape);\n\n\n/**\n * A label for an element\n *\n * @class\n * @constructor\n *\n * @extends Shape\n */\nexport function Label() {\n  Shape.call(this);\n\n  /**\n   * The labeled element\n   *\n   * @name Label#labelTarget\n   * @type Base\n   */\n  labelRefs.bind(this, 'labelTarget');\n}\n\ninherits(Label, Shape);\n\n\n/**\n * A connection between two elements\n *\n * @class\n * @constructor\n *\n * @extends Base\n */\nexport function Connection() {\n  Base.call(this);\n\n  /**\n   * The element this connection originates from\n   *\n   * @name Connection#source\n   * @type Base\n   */\n  outgoingRefs.bind(this, 'source');\n\n  /**\n   * The element this connection points to\n   *\n   * @name Connection#target\n   * @type Base\n   */\n  incomingRefs.bind(this, 'target');\n}\n\ninherits(Connection, Base);\n\n\nvar types = {\n  connection: Connection,\n  shape: Shape,\n  label: Label,\n  root: Root\n};\n\n/**\n * Creates a new model element of the specified type\n *\n * @method create\n *\n * @example\n *\n * var shape1 = Model.create('shape', { x: 10, y: 10, width: 100, height: 100 });\n * var shape2 = Model.create('shape', { x: 210, y: 210, width: 100, height: 100 });\n *\n * var connection = Model.create('connection', { waypoints: [ { x: 110, y: 55 }, {x: 210, y: 55 } ] });\n *\n * @param  {String} type lower-cased model name\n * @param  {Object} attrs attributes to initialize the new model instance with\n *\n * @return {Base} the new model instance\n */\nexport function create(type, attrs) {\n  var Type = types[type];\n  if (!Type) {\n    throw new Error('unknown type: <' + type + '>');\n  }\n  return assign(new Type(), attrs);\n}","import { assign } from 'min-dash';\n\n\nvar DEFAULT_CONFIG = {\n  moveSpeed: 50,\n  moveSpeedAccelerated: 200\n};\n\n\n/**\n * A feature that allows users to move the canvas using the keyboard.\n *\n * @param {Object} config\n * @param {Number} [config.moveSpeed=50]\n * @param {Number} [config.moveSpeedAccelerated=200]\n * @param {Keyboard} keyboard\n * @param {Canvas} canvas\n */\nexport default function KeyboardMove(\n    config,\n    keyboard,\n    canvas\n) {\n\n  var self = this;\n\n  this._config = assign({}, DEFAULT_CONFIG, config || {});\n\n  keyboard.addListener(arrowsListener);\n\n\n  function arrowsListener(context) {\n\n    var event = context.keyEvent,\n        config = self._config;\n\n    if (!keyboard.isCmd(event)) {\n      return;\n    }\n\n    if (keyboard.isKey([\n      'ArrowLeft', 'Left',\n      'ArrowUp', 'Up',\n      'ArrowDown', 'Down',\n      'ArrowRight', 'Right'\n    ], event)) {\n\n      var speed = (\n        keyboard.isShift(event) ?\n          config.moveSpeedAccelerated :\n          config.moveSpeed\n      );\n\n      var direction;\n\n      switch (event.key) {\n      case 'ArrowLeft':\n      case 'Left':\n        direction = 'left';\n        break;\n      case 'ArrowUp':\n      case 'Up':\n        direction = 'up';\n        break;\n      case 'ArrowRight':\n      case 'Right':\n        direction = 'right';\n        break;\n      case 'ArrowDown':\n      case 'Down':\n        direction = 'down';\n        break;\n      }\n\n      self.moveCanvas({\n        speed: speed,\n        direction: direction\n      });\n\n      return true;\n    }\n  }\n\n  this.moveCanvas = function(opts) {\n\n    var dx = 0,\n        dy = 0,\n        speed = opts.speed;\n\n    var actualSpeed = speed / Math.min(Math.sqrt(canvas.viewbox().scale), 1);\n\n    switch (opts.direction) {\n    case 'left': // Left\n      dx = actualSpeed;\n      break;\n    case 'up': // Up\n      dy = actualSpeed;\n      break;\n    case 'right': // Right\n      dx = -actualSpeed;\n      break;\n    case 'down': // Down\n      dy = -actualSpeed;\n      break;\n    }\n\n    canvas.scroll({\n      dx: dx,\n      dy: dy\n    });\n  };\n\n}\n\n\nKeyboardMove.$inject = [\n  'config.keyboardMove',\n  'keyboard',\n  'canvas'\n];\n","import KeyboardModule from '../../features/keyboard';\n\nimport KeyboardMove from './KeyboardMove';\n\n\nexport default {\n  __depends__: [\n    KeyboardModule\n  ],\n  __init__: [ 'keyboardMove' ],\n  keyboardMove: [ 'type', KeyboardMove ]\n};","import {\n  set as cursorSet,\n  unset as cursorUnset\n} from '../../util/Cursor';\n\nimport {\n  install as installClickTrap\n} from '../../util/ClickTrap';\n\nimport {\n  delta as deltaPos\n} from '../../util/PositionUtil';\n\nimport {\n  event as domEvent,\n  closest as domClosest\n} from 'min-dom';\n\nimport {\n  toPoint\n} from '../../util/Event';\n\n\nvar THRESHOLD = 15;\n\n\n/**\n * Move the canvas via mouse.\n *\n * @param {EventBus} eventBus\n * @param {Canvas} canvas\n */\nexport default function MoveCanvas(eventBus, canvas) {\n\n  var context;\n\n\n  // listen for move on element mouse down;\n  // allow others to hook into the event before us though\n  // (dragging / element moving will do this)\n  eventBus.on('element.mousedown', 500, function(e) {\n    return handleStart(e.originalEvent);\n  });\n\n\n  function handleMove(event) {\n\n    var start = context.start,\n        position = toPoint(event),\n        delta = deltaPos(position, start);\n\n    if (!context.dragging && length(delta) > THRESHOLD) {\n      context.dragging = true;\n\n      installClickTrap(eventBus);\n\n      cursorSet('grab');\n    }\n\n    if (context.dragging) {\n\n      var lastPosition = context.last || context.start;\n\n      delta = deltaPos(position, lastPosition);\n\n      canvas.scroll({\n        dx: delta.x,\n        dy: delta.y\n      });\n\n      context.last = position;\n    }\n\n    // prevent select\n    event.preventDefault();\n  }\n\n\n  function handleEnd(event) {\n    domEvent.unbind(document, 'mousemove', handleMove);\n    domEvent.unbind(document, 'mouseup', handleEnd);\n\n    context = null;\n\n    cursorUnset();\n  }\n\n  function handleStart(event) {\n    // event is already handled by '.djs-draggable'\n    if (domClosest(event.target, '.djs-draggable')) {\n      return;\n    }\n\n\n    // reject non-left left mouse button or modifier key\n    if (event.button || event.ctrlKey || event.shiftKey || event.altKey) {\n      return;\n    }\n\n    context = {\n      start: toPoint(event)\n    };\n\n    domEvent.bind(document, 'mousemove', handleMove);\n    domEvent.bind(document, 'mouseup', handleEnd);\n\n    // we've handled the event\n    return true;\n  }\n}\n\n\nMoveCanvas.$inject = [\n  'eventBus',\n  'canvas'\n];\n\n\n\n// helpers ///////\n\nfunction length(point) {\n  return Math.sqrt(Math.pow(point.x, 2) + Math.pow(point.y, 2));\n}\n","import MoveCanvas from './MoveCanvas';\n\nexport default {\n  __init__: [ 'moveCanvas' ],\n  moveCanvas: [ 'type', MoveCanvas ]\n};","import TouchModule from '../../features/touch';\n\nexport default {\n  __depends__: [\n    TouchModule\n  ]\n};","import {\n  event as domEvent,\n  closest as domClosest\n} from 'min-dom';\n\nimport {\n  getStepSize,\n  cap\n} from './ZoomUtil';\n\nimport {\n  log10\n} from '../../util/Math';\n\nimport {\n  bind\n} from 'min-dash';\n\nvar sign = Math.sign || function(n) {\n  return n >= 0 ? 1 : -1;\n};\n\nvar RANGE = { min: 0.2, max: 4 },\n    NUM_STEPS = 10;\n\nvar DELTA_THRESHOLD = 0.1;\n\nvar DEFAULT_SCALE = 0.75;\n\n/**\n * An implementation of zooming and scrolling within the\n * {@link Canvas} via the mouse wheel.\n *\n * Mouse wheel zooming / scrolling may be disabled using\n * the {@link toggle(enabled)} method.\n *\n * @param {Object} [config]\n * @param {Boolean} [config.enabled=true] default enabled state\n * @param {Number} [config.scale=.75] scroll sensivity\n * @param {EventBus} eventBus\n * @param {Canvas} canvas\n */\nexport default function ZoomScroll(config, eventBus, canvas) {\n\n  config = config || {};\n\n  this._enabled = false;\n\n  this._canvas = canvas;\n  this._container = canvas._container;\n\n  this._handleWheel = bind(this._handleWheel, this);\n\n  this._totalDelta = 0;\n  this._scale = config.scale || DEFAULT_SCALE;\n\n  var self = this;\n\n  eventBus.on('canvas.init', function(e) {\n    self._init(config.enabled !== false);\n  });\n}\n\nZoomScroll.$inject = [\n  'config.zoomScroll',\n  'eventBus',\n  'canvas'\n];\n\nZoomScroll.prototype.scroll = function scroll(delta) {\n  this._canvas.scroll(delta);\n};\n\n\nZoomScroll.prototype.reset = function reset() {\n  this._canvas.zoom('fit-viewport');\n};\n\n/**\n * Zoom depending on delta.\n *\n * @param {number} delta - Zoom delta.\n * @param {Object} position - Zoom position.\n */\nZoomScroll.prototype.zoom = function zoom(delta, position) {\n\n  // zoom with half the step size of stepZoom\n  var stepSize = getStepSize(RANGE, NUM_STEPS * 2);\n\n  // add until threshold reached\n  this._totalDelta += delta;\n\n  if (Math.abs(this._totalDelta) > DELTA_THRESHOLD) {\n    this._zoom(delta, position, stepSize);\n\n    // reset\n    this._totalDelta = 0;\n  }\n};\n\n\nZoomScroll.prototype._handleWheel = function handleWheel(event) {\n  // event is already handled by '.djs-scrollable'\n  if (domClosest(event.target, '.djs-scrollable', true)) {\n    return;\n  }\n\n  var element = this._container;\n\n  event.preventDefault();\n\n  // pinch to zoom is mapped to wheel + ctrlKey = true\n  // in modern browsers (!)\n\n  var isZoom = event.ctrlKey;\n\n  var isHorizontalScroll = event.shiftKey;\n\n  var factor = -1 * this._scale,\n      delta;\n\n  if (isZoom) {\n    factor *= event.deltaMode === 0 ? 0.020 : 0.32;\n  } else {\n    factor *= event.deltaMode === 0 ? 1.0 : 16.0;\n  }\n\n  if (isZoom) {\n    var elementRect = element.getBoundingClientRect();\n\n    var offset = {\n      x: event.clientX - elementRect.left,\n      y: event.clientY - elementRect.top\n    };\n\n    delta = (\n      Math.sqrt(\n        Math.pow(event.deltaY, 2) +\n        Math.pow(event.deltaX, 2)\n      ) * sign(event.deltaY) * factor\n    );\n\n    // zoom in relative to diagram {x,y} coordinates\n    this.zoom(delta, offset);\n  } else {\n\n    if (isHorizontalScroll) {\n      delta = {\n        dx: factor * event.deltaY,\n        dy: 0\n      };\n    } else {\n      delta = {\n        dx: factor * event.deltaX,\n        dy: factor * event.deltaY\n      };\n    }\n\n    this.scroll(delta);\n  }\n};\n\n/**\n * Zoom with fixed step size.\n *\n * @param {number} delta - Zoom delta (1 for zooming in, -1 for out).\n * @param {Object} position - Zoom position.\n */\nZoomScroll.prototype.stepZoom = function stepZoom(delta, position) {\n\n  var stepSize = getStepSize(RANGE, NUM_STEPS);\n\n  this._zoom(delta, position, stepSize);\n};\n\n\n/**\n * Zoom in/out given a step size.\n *\n * @param {number} delta - Zoom delta. Can be positive or negative.\n * @param {Object} position - Zoom position.\n * @param {number} stepSize - Step size.\n */\nZoomScroll.prototype._zoom = function(delta, position, stepSize) {\n  var canvas = this._canvas;\n\n  var direction = delta > 0 ? 1 : -1;\n\n  var currentLinearZoomLevel = log10(canvas.zoom());\n\n  // snap to a proximate zoom step\n  var newLinearZoomLevel = Math.round(currentLinearZoomLevel / stepSize) * stepSize;\n\n  // increase or decrease one zoom step in the given direction\n  newLinearZoomLevel += stepSize * direction;\n\n  // calculate the absolute logarithmic zoom level based on the linear zoom level\n  // (e.g. 2 for an absolute x2 zoom)\n  var newLogZoomLevel = Math.pow(10, newLinearZoomLevel);\n\n  canvas.zoom(cap(RANGE, newLogZoomLevel), position);\n};\n\n\n/**\n * Toggle the zoom scroll ability via mouse wheel.\n *\n * @param  {Boolean} [newEnabled] new enabled state\n */\nZoomScroll.prototype.toggle = function toggle(newEnabled) {\n\n  var element = this._container;\n  var handleWheel = this._handleWheel;\n\n  var oldEnabled = this._enabled;\n\n  if (typeof newEnabled === 'undefined') {\n    newEnabled = !oldEnabled;\n  }\n\n  // only react on actual changes\n  if (oldEnabled !== newEnabled) {\n\n    // add or remove wheel listener based on\n    // changed enabled state\n    domEvent[newEnabled ? 'bind' : 'unbind'](element, 'wheel', handleWheel, false);\n  }\n\n  this._enabled = newEnabled;\n\n  return newEnabled;\n};\n\n\nZoomScroll.prototype._init = function(newEnabled) {\n  this.toggle(newEnabled);\n};\n","import {\n  log10\n} from '../../util/Math';\n\n/**\n * Get step size for given range and number of steps.\n *\n * @param {Object} range - Range.\n * @param {number} range.min - Range minimum.\n * @param {number} range.max - Range maximum.\n */\nexport function getStepSize(range, steps) {\n\n  var minLinearRange = log10(range.min),\n      maxLinearRange = log10(range.max);\n\n  var absoluteLinearRange = Math.abs(minLinearRange) + Math.abs(maxLinearRange);\n\n  return absoluteLinearRange / steps;\n}\n\nexport function cap(range, scale) {\n  return Math.max(range.min, Math.min(range.max, scale));\n}\n","import ZoomScroll from './ZoomScroll';\n\nexport default {\n  __init__: [ 'zoomScroll' ],\n  zoomScroll: [ 'type', ZoomScroll ]\n};","import {\n  roundPoint\n} from '../layout/LayoutUtil';\n\nimport {\n  center,\n  delta\n} from './PositionUtil';\n\n\n/**\n * Calculates the absolute point relative to the new element's position\n *\n * @param {point} point [absolute]\n * @param {bounds} oldBounds\n * @param {bounds} newBounds\n *\n * @return {point} point [absolute]\n */\nexport function getNewAttachPoint(point, oldBounds, newBounds) {\n  var oldCenter = center(oldBounds),\n      newCenter = center(newBounds),\n      oldDelta = delta(point, oldCenter);\n\n  var newDelta = {\n    x: oldDelta.x * (newBounds.width / oldBounds.width),\n    y: oldDelta.y * (newBounds.height / oldBounds.height)\n  };\n\n  return roundPoint({\n    x: newCenter.x + newDelta.x,\n    y: newCenter.y + newDelta.y\n  });\n}\n\n\n/**\n * Calculates the shape's delta relative to a new position\n * of a certain element's bounds\n *\n * @param {djs.model.Shape} point [absolute]\n * @param {bounds} oldBounds\n * @param {bounds} newBounds\n *\n * @return {delta} delta\n */\nexport function getNewAttachShapeDelta(shape, oldBounds, newBounds) {\n  var shapeCenter = center(shape),\n      oldCenter = center(oldBounds),\n      newCenter = center(newBounds),\n      shapeDelta = delta(shape, shapeCenter),\n      oldCenterDelta = delta(shapeCenter, oldCenter);\n\n  var newCenterDelta = {\n    x: oldCenterDelta.x * (newBounds.width / oldBounds.width),\n    y: oldCenterDelta.y * (newBounds.height / oldBounds.height)\n  };\n\n  var newShapeCenter = {\n    x: newCenter.x + newCenterDelta.x,\n    y: newCenter.y + newCenterDelta.y\n  };\n\n  return roundPoint({\n    x: newShapeCenter.x + shapeDelta.x - shape.x,\n    y: newShapeCenter.y + shapeDelta.y - shape.y\n  });\n}","var TRAP_PRIORITY = 5000;\n\n/**\n * Installs a click trap that prevents a ghost click following a dragging operation.\n *\n * @return {Function} a function to immediately remove the installed trap.\n */\nexport function install(eventBus, eventName) {\n\n  eventName = eventName || 'element.click';\n\n  function trap() {\n    return false;\n  }\n\n  eventBus.once(eventName, TRAP_PRIORITY, trap);\n\n  return function() {\n    eventBus.off(eventName, trap);\n  };\n}","/**\n * Failsafe remove an element from a collection\n *\n * @param  {Array<Object>} [collection]\n * @param  {Object} [element]\n *\n * @return {Number} the previous index of the element\n */\nexport function remove(collection, element) {\n\n  if (!collection || !element) {\n    return -1;\n  }\n\n  var idx = collection.indexOf(element);\n\n  if (idx !== -1) {\n    collection.splice(idx, 1);\n  }\n\n  return idx;\n}\n\n/**\n * Fail save add an element to the given connection, ensuring\n * it does not yet exist.\n *\n * @param {Array<Object>} collection\n * @param {Object} element\n * @param {Number} idx\n */\nexport function add(collection, element, idx) {\n\n  if (!collection || !element) {\n    return;\n  }\n\n  if (typeof idx !== 'number') {\n    idx = -1;\n  }\n\n  var currentIdx = collection.indexOf(element);\n\n  if (currentIdx !== -1) {\n\n    if (currentIdx === idx) {\n      // nothing to do, position has not changed\n      return;\n    } else {\n\n      if (idx !== -1) {\n        // remove from current position\n        collection.splice(currentIdx, 1);\n      } else {\n        // already exists in collection\n        return;\n      }\n    }\n  }\n\n  if (idx !== -1) {\n    // insert at specified position\n    collection.splice(idx, 0, element);\n  } else {\n    // push to end\n    collection.push(element);\n  }\n}\n\n\n/**\n * Fail save get the index of an element in a collection.\n *\n * @param {Array<Object>} collection\n * @param {Object} element\n *\n * @return {Number} the index or -1 if collection or element do\n *                  not exist or the element is not contained.\n */\nexport function indexOf(collection, element) {\n\n  if (!collection || !element) {\n    return -1;\n  }\n\n  return collection.indexOf(element);\n}\n","import {\n  forEach\n} from 'min-dash';\n\n\nexport function getTopLevel(elements) {\n  var topLevel = {},\n      parents = [],\n      result = [],\n      clearedParents = [];\n\n  forEach(elements, function(element) {\n    var parent = element.parent;\n\n    if (!topLevel[parent.id]) {\n      topLevel[parent.id] = [];\n    }\n\n    if (parents.indexOf(parent.id) === -1) {\n      parents.push(parent.id);\n    }\n\n    topLevel[parent.id].push(element);\n  });\n\n  forEach(parents, function(parent) {\n    forEach(topLevel[parent], function(element) {\n      if (topLevel[element.id]) {\n        clearedParents.push(element.id);\n      }\n    });\n  });\n\n  forEach(parents, function(parent) {\n    var idx = clearedParents.indexOf(parent);\n\n    if (idx === -1) {\n      result = result.concat(topLevel[parent]);\n    }\n  });\n\n  return result;\n}","import {\n  classes as domClasses\n} from 'min-dom';\n\nvar CURSOR_CLS_PATTERN = /^djs-cursor-.*$/;\n\n\nexport function set(mode) {\n  var classes = domClasses(document.body);\n\n  classes.removeMatching(CURSOR_CLS_PATTERN);\n\n  if (mode) {\n    classes.add('djs-cursor-' + mode);\n  }\n}\n\nexport function unset() {\n  set(null);\n}\n\nexport function has(mode) {\n  var classes = domClasses(document.body);\n\n  return classes.has('djs-cursor-' + mode);\n}\n","import {\n  assign,\n  isArray,\n  isNumber,\n  isObject,\n  isUndefined,\n  groupBy,\n  forEach\n} from 'min-dash';\n\n\n/**\n * Adds an element to a collection and returns true if the\n * element was added.\n *\n * @param {Array<Object>} elements\n * @param {Object} e\n * @param {Boolean} unique\n */\nexport function add(elements, e, unique) {\n  var canAdd = !unique || elements.indexOf(e) === -1;\n\n  if (canAdd) {\n    elements.push(e);\n  }\n\n  return canAdd;\n}\n\n\n/**\n * Iterate over each element in a collection, calling the iterator function `fn`\n * with (element, index, recursionDepth).\n *\n * Recurse into all elements that are returned by `fn`.\n *\n * @param  {Object|Array<Object>} elements\n * @param  {Function} fn iterator function called with (element, index, recursionDepth)\n * @param  {Number} [depth] maximum recursion depth\n */\nexport function eachElement(elements, fn, depth) {\n\n  depth = depth || 0;\n\n  if (!isArray(elements)) {\n    elements = [ elements ];\n  }\n\n  forEach(elements, function(s, i) {\n    var filter = fn(s, i, depth);\n\n    if (isArray(filter) && filter.length) {\n      eachElement(filter, fn, depth + 1);\n    }\n  });\n}\n\n\n/**\n * Collects self + child elements up to a given depth from a list of elements.\n *\n * @param  {djs.model.Base|Array<djs.model.Base>} elements the elements to select the children from\n * @param  {Boolean} unique whether to return a unique result set (no duplicates)\n * @param  {Number} maxDepth the depth to search through or -1 for infinite\n *\n * @return {Array<djs.model.Base>} found elements\n */\nexport function selfAndChildren(elements, unique, maxDepth) {\n  var result = [],\n      processedChildren = [];\n\n  eachElement(elements, function(element, i, depth) {\n    add(result, element, unique);\n\n    var children = element.children;\n\n    // max traversal depth not reached yet\n    if (maxDepth === -1 || depth < maxDepth) {\n\n      // children exist && children not yet processed\n      if (children && add(processedChildren, children, unique)) {\n        return children;\n      }\n    }\n  });\n\n  return result;\n}\n\n/**\n * Return self + direct children for a number of elements\n *\n * @param  {Array<djs.model.Base>} elements to query\n * @param  {Boolean} allowDuplicates to allow duplicates in the result set\n *\n * @return {Array<djs.model.Base>} the collected elements\n */\nexport function selfAndDirectChildren(elements, allowDuplicates) {\n  return selfAndChildren(elements, !allowDuplicates, 1);\n}\n\n\n/**\n * Return self + ALL children for a number of elements\n *\n * @param  {Array<djs.model.Base>} elements to query\n * @param  {Boolean} allowDuplicates to allow duplicates in the result set\n *\n * @return {Array<djs.model.Base>} the collected elements\n */\nexport function selfAndAllChildren(elements, allowDuplicates) {\n  return selfAndChildren(elements, !allowDuplicates, -1);\n}\n\n\n/**\n * Gets the the closure for all selected elements,\n * their enclosed children and connections.\n *\n * @param {Array<djs.model.Base>} elements\n * @param {Boolean} [isTopLevel=true]\n * @param {Object} [existingClosure]\n *\n * @return {Object} newClosure\n */\nexport function getClosure(elements, isTopLevel, closure) {\n\n  if (isUndefined(isTopLevel)) {\n    isTopLevel = true;\n  }\n\n  if (isObject(isTopLevel)) {\n    closure = isTopLevel;\n    isTopLevel = true;\n  }\n\n\n  closure = closure || {};\n\n  var allShapes = copyObject(closure.allShapes),\n      allConnections = copyObject(closure.allConnections),\n      enclosedElements = copyObject(closure.enclosedElements),\n      enclosedConnections = copyObject(closure.enclosedConnections);\n\n  var topLevel = copyObject(\n    closure.topLevel,\n    isTopLevel && groupBy(elements, function(e) { return e.id; })\n  );\n\n\n  function handleConnection(c) {\n    if (topLevel[c.source.id] && topLevel[c.target.id]) {\n      topLevel[c.id] = [ c ];\n    }\n\n    // not enclosed as a child, but maybe logically\n    // (connecting two moved elements?)\n    if (allShapes[c.source.id] && allShapes[c.target.id]) {\n      enclosedConnections[c.id] = enclosedElements[c.id] = c;\n    }\n\n    allConnections[c.id] = c;\n  }\n\n  function handleElement(element) {\n\n    enclosedElements[element.id] = element;\n\n    if (element.waypoints) {\n      // remember connection\n      enclosedConnections[element.id] = allConnections[element.id] = element;\n    } else {\n      // remember shape\n      allShapes[element.id] = element;\n\n      // remember all connections\n      forEach(element.incoming, handleConnection);\n\n      forEach(element.outgoing, handleConnection);\n\n      // recurse into children\n      return element.children;\n    }\n  }\n\n  eachElement(elements, handleElement);\n\n  return {\n    allShapes: allShapes,\n    allConnections: allConnections,\n    topLevel: topLevel,\n    enclosedConnections: enclosedConnections,\n    enclosedElements: enclosedElements\n  };\n}\n\n/**\n * Returns the surrounding bbox for all elements in\n * the array or the element primitive.\n *\n * @param {Array<djs.model.Shape>|djs.model.Shape} elements\n * @param {Boolean} stopRecursion\n */\nexport function getBBox(elements, stopRecursion) {\n\n  stopRecursion = !!stopRecursion;\n  if (!isArray(elements)) {\n    elements = [elements];\n  }\n\n  var minX,\n      minY,\n      maxX,\n      maxY;\n\n  forEach(elements, function(element) {\n\n    // If element is a connection the bbox must be computed first\n    var bbox = element;\n    if (element.waypoints && !stopRecursion) {\n      bbox = getBBox(element.waypoints, true);\n    }\n\n    var x = bbox.x,\n        y = bbox.y,\n        height = bbox.height || 0,\n        width = bbox.width || 0;\n\n    if (x < minX || minX === undefined) {\n      minX = x;\n    }\n    if (y < minY || minY === undefined) {\n      minY = y;\n    }\n\n    if ((x + width) > maxX || maxX === undefined) {\n      maxX = x + width;\n    }\n    if ((y + height) > maxY || maxY === undefined) {\n      maxY = y + height;\n    }\n  });\n\n  return {\n    x: minX,\n    y: minY,\n    height: maxY - minY,\n    width: maxX - minX\n  };\n}\n\n\n/**\n * Returns all elements that are enclosed from the bounding box.\n *\n *   * If bbox.(width|height) is not specified the method returns\n *     all elements with element.x/y > bbox.x/y\n *   * If only bbox.x or bbox.y is specified, method return all elements with\n *     e.x > bbox.x or e.y > bbox.y\n *\n * @param {Array<djs.model.Shape>} elements List of Elements to search through\n * @param {djs.model.Shape} bbox the enclosing bbox.\n *\n * @return {Array<djs.model.Shape>} enclosed elements\n */\nexport function getEnclosedElements(elements, bbox) {\n\n  var filteredElements = {};\n\n  forEach(elements, function(element) {\n\n    var e = element;\n\n    if (e.waypoints) {\n      e = getBBox(e);\n    }\n\n    if (!isNumber(bbox.y) && (e.x > bbox.x)) {\n      filteredElements[element.id] = element;\n    }\n    if (!isNumber(bbox.x) && (e.y > bbox.y)) {\n      filteredElements[element.id] = element;\n    }\n    if (e.x > bbox.x && e.y > bbox.y) {\n      if (isNumber(bbox.width) && isNumber(bbox.height) &&\n          e.width + e.x < bbox.width + bbox.x &&\n          e.height + e.y < bbox.height + bbox.y) {\n\n        filteredElements[element.id] = element;\n      } else if (!isNumber(bbox.width) || !isNumber(bbox.height)) {\n        filteredElements[element.id] = element;\n      }\n    }\n  });\n\n  return filteredElements;\n}\n\n\nexport function getType(element) {\n\n  if ('waypoints' in element) {\n    return 'connection';\n  }\n\n  if ('x' in element) {\n    return 'shape';\n  }\n\n  return 'root';\n}\n\n\n// helpers ///////////////////////////////\n\nfunction copyObject(src1, src2) {\n  return assign({}, src1 || {}, src2 || {});\n}","function __stopPropagation(event) {\n  if (!event || typeof event.stopPropagation !== 'function') {\n    return;\n  }\n\n  event.stopPropagation();\n}\n\n\nexport function getOriginal(event) {\n  return event.originalEvent || event.srcEvent;\n}\n\n\nexport function stopPropagation(event, immediate) {\n  __stopPropagation(event, immediate);\n  __stopPropagation(getOriginal(event), immediate);\n}\n\n\nexport function toPoint(event) {\n\n  if (event.pointers && event.pointers.length) {\n    event = event.pointers[0];\n  }\n\n  if (event.touches && event.touches.length) {\n    event = event.touches[0];\n  }\n\n  return event ? {\n    x: event.clientX,\n    y: event.clientY\n  } : null;\n}","/**\n * Computes the distance between two points\n *\n * @param  {Point}  p\n * @param  {Point}  q\n *\n * @return {Number}  distance\n */\nexport function pointDistance(a, b) {\n  if (!a || !b) {\n    return -1;\n  }\n\n  return Math.sqrt(\n    Math.pow(a.x - b.x, 2) +\n    Math.pow(a.y - b.y, 2)\n  );\n}\n\n\n/**\n * Returns true if the point r is on the line between p and q\n *\n * @param  {Point}  p\n * @param  {Point}  q\n * @param  {Point}  r\n * @param  {Number} [accuracy=5] accuracy for points on line check (lower is better)\n *\n * @return {Boolean}\n */\nexport function pointsOnLine(p, q, r, accuracy) {\n\n  if (typeof accuracy === 'undefined') {\n    accuracy = 5;\n  }\n\n  if (!p || !q || !r) {\n    return false;\n  }\n\n  var val = (q.x - p.x) * (r.y - p.y) - (q.y - p.y) * (r.x - p.x),\n      dist = pointDistance(p, q);\n\n  // @see http://stackoverflow.com/a/907491/412190\n  return Math.abs(val / dist) <= accuracy;\n}\n\n\nvar ALIGNED_THRESHOLD = 2;\n\n/**\n * Returns whether two points are in a horizontal or vertical line.\n *\n * @param {Point} a\n * @param {Point} b\n *\n * @return {String|Boolean} returns false if the points are not\n *                          aligned or 'h|v' if they are aligned\n *                          horizontally / vertically.\n */\nexport function pointsAligned(a, b) {\n  if (Math.abs(a.x - b.x) <= ALIGNED_THRESHOLD) {\n    return 'h';\n  }\n\n  if (Math.abs(a.y - b.y) <= ALIGNED_THRESHOLD) {\n    return 'v';\n  }\n\n  return false;\n}\n\n\n/**\n * Returns true if the point p is inside the rectangle rect\n *\n * @param  {Point}  p\n * @param  {Rect}   rect\n * @param  {Number} tolerance\n *\n * @return {Boolean}\n */\nexport function pointInRect(p, rect, tolerance) {\n  tolerance = tolerance || 0;\n\n  return p.x > rect.x - tolerance &&\n         p.y > rect.y - tolerance &&\n         p.x < rect.x + rect.width + tolerance &&\n         p.y < rect.y + rect.height + tolerance;\n}\n\n/**\n * Returns a point in the middle of points p and q\n *\n * @param  {Point}  p\n * @param  {Point}  q\n *\n * @return {Point} middle point\n */\nexport function getMidPoint(p, q) {\n  return {\n    x: Math.round(p.x + ((q.x - p.x) / 2.0)),\n    y: Math.round(p.y + ((q.y - p.y) / 2.0))\n  };\n}\n","import {\n  query as domQuery\n} from 'min-dom';\n\n/**\n * SVGs for elements are generated by the {@link GraphicsFactory}.\n *\n * This utility gives quick access to the important semantic\n * parts of an element.\n */\n\n/**\n * Returns the visual part of a diagram element\n *\n * @param {Snap<SVGElement>} gfx\n *\n * @return {Snap<SVGElement>}\n */\nexport function getVisual(gfx) {\n  return domQuery('.djs-visual', gfx);\n}\n\n/**\n * Returns the children for a given diagram element.\n *\n * @param {Snap<SVGElement>} gfx\n * @return {Snap<SVGElement>}\n */\nexport function getChildren(gfx) {\n  return gfx.parentNode.childNodes[1];\n}","/**\n * Util that provides unique IDs.\n *\n * @class djs.util.IdGenerator\n * @constructor\n * @memberOf djs.util\n *\n * The ids can be customized via a given prefix and contain a random value to avoid collisions.\n *\n * @param {String} prefix a prefix to prepend to generated ids (for better readability)\n */\nexport default function IdGenerator(prefix) {\n\n  this._counter = 0;\n  this._prefix = (prefix ? prefix + '-' : '') + Math.floor(Math.random() * 1000000000) + '-';\n}\n\n/**\n * Returns a next unique ID.\n *\n * @method djs.util.IdGenerator#next\n *\n * @returns {String} the id\n */\nIdGenerator.prototype.next = function() {\n  return this._prefix + (++this._counter);\n};\n","import {\n  pointDistance\n} from './Geometry';\n\nimport intersectPaths from 'path-intersection';\n\nvar round = Math.round,\n    max = Math.max;\n\n\nfunction circlePath(center, r) {\n  var x = center.x,\n      y = center.y;\n\n  return [\n    ['M', x, y],\n    ['m', 0, -r],\n    ['a', r, r, 0, 1, 1, 0, 2 * r],\n    ['a', r, r, 0, 1, 1, 0, -2 * r],\n    ['z']\n  ];\n}\n\nfunction linePath(points) {\n  var segments = [];\n\n  points.forEach(function(p, idx) {\n    segments.push([ idx === 0 ? 'M' : 'L', p.x, p.y ]);\n  });\n\n  return segments;\n}\n\n\nvar INTERSECTION_THRESHOLD = 10;\n\nfunction getBendpointIntersection(waypoints, reference) {\n\n  var i, w;\n\n  for (i = 0; (w = waypoints[i]); i++) {\n\n    if (pointDistance(w, reference) <= INTERSECTION_THRESHOLD) {\n      return {\n        point: waypoints[i],\n        bendpoint: true,\n        index: i\n      };\n    }\n  }\n\n  return null;\n}\n\nfunction getPathIntersection(waypoints, reference) {\n\n  var intersections = intersectPaths(circlePath(reference, INTERSECTION_THRESHOLD), linePath(waypoints));\n\n  var a = intersections[0],\n      b = intersections[intersections.length - 1],\n      idx;\n\n  if (!a) {\n    // no intersection\n    return null;\n  }\n\n  if (a !== b) {\n\n    if (a.segment2 !== b.segment2) {\n      // we use the bendpoint in between both segments\n      // as the intersection point\n\n      idx = max(a.segment2, b.segment2) - 1;\n\n      return {\n        point: waypoints[idx],\n        bendpoint: true,\n        index: idx\n      };\n    }\n\n    return {\n      point: {\n        x: (round(a.x + b.x) / 2),\n        y: (round(a.y + b.y) / 2)\n      },\n      index: a.segment2\n    };\n  }\n\n  return {\n    point: {\n      x: round(a.x),\n      y: round(a.y)\n    },\n    index: a.segment2\n  };\n}\n\n/**\n * Returns the closest point on the connection towards a given reference point.\n *\n * @param  {Array<Point>} waypoints\n * @param  {Point} reference\n *\n * @return {Object} intersection data (segment, point)\n */\nexport function getApproxIntersection(waypoints, reference) {\n  return getBendpointIntersection(waypoints, reference) || getPathIntersection(waypoints, reference);\n}\n","/**\n * Get the logarithm of x with base 10\n * @param  {Integer} value\n */\nexport function log10(x) {\n  return Math.log(x) / Math.log(10);\n}\n\nexport { delta as substract } from './PositionUtil';\n","import {\n  getOriginal as getOriginalEvent\n} from './Event';\n\nimport {\n  isMac\n} from './Platform';\n\nexport {\n  isMac\n} from './Platform';\n\n\nexport function isPrimaryButton(event) {\n  // button === 0 -> left áka primary mouse button\n  return !(getOriginalEvent(event) || event).button;\n}\n\nexport function hasPrimaryModifier(event) {\n  var originalEvent = getOriginalEvent(event) || event;\n\n  if (!isPrimaryButton(event)) {\n    return false;\n  }\n\n  // Use alt as primary modifier key for mac OS\n  if (isMac()) {\n    return originalEvent.metaKey;\n  } else {\n    return originalEvent.ctrlKey;\n  }\n}\n\n\nexport function hasSecondaryModifier(event) {\n  var originalEvent = getOriginalEvent(event) || event;\n\n  return isPrimaryButton(event) && originalEvent.shiftKey;\n}","export function isMac() {\n  return (/mac/i).test(navigator.platform);\n}","export function center(bounds) {\n  return {\n    x: bounds.x + (bounds.width / 2),\n    y: bounds.y + (bounds.height / 2)\n  };\n}\n\n\nexport function delta(a, b) {\n  return {\n    x: a.x - b.x,\n    y: a.y - b.y\n  };\n}","/**\n * Remove from the beginning of a collection until it is empty.\n *\n * This is a null-safe operation that ensures elements\n * are being removed from the given collection until the\n * collection is empty.\n *\n * The implementation deals with the fact that a remove operation\n * may touch, i.e. remove multiple elements in the collection\n * at a time.\n *\n * @param {Array<Object>} [collection]\n * @param {Function} removeFn\n *\n * @return {Array<Object>} the cleared collection\n */\nexport function saveClear(collection, removeFn) {\n\n  if (typeof removeFn !== 'function') {\n    throw new Error('removeFn iterator must be a function');\n  }\n\n  if (!collection) {\n    return;\n  }\n\n  var e;\n\n  while ((e = collection[0])) {\n    removeFn(e);\n  }\n\n  return collection;\n}\n","import {\n  attr as svgAttr,\n  create as svgCreate\n} from 'tiny-svg';\n\n\nexport function componentsToPath(elements) {\n  return elements.join(',').replace(/,?([A-z]),?/g, '$1');\n}\n\nexport function toSVGPoints(points) {\n  var result = '';\n\n  for (var i = 0, p; (p = points[i]); i++) {\n    result += p.x + ',' + p.y + ' ';\n  }\n\n  return result;\n}\n\nexport function createLine(points, attrs) {\n\n  var line = svgCreate('polyline');\n  svgAttr(line, { points: toSVGPoints(points) });\n\n  if (attrs) {\n    svgAttr(line, attrs);\n  }\n\n  return line;\n}\n\nexport function updateLine(gfx, points) {\n  svgAttr(gfx, { points: toSVGPoints(points) });\n\n  return gfx;\n}\n","import {\r\n  transform as svgTransform,\r\n  createTransform\r\n} from 'tiny-svg';\r\n\r\n\r\n/**\r\n * @param {<SVGElement>} element\r\n * @param {Number} x\r\n * @param {Number} y\r\n * @param {Number} angle\r\n * @param {Number} amount\r\n */\r\nexport function transform(gfx, x, y, angle, amount) {\r\n  var translate = createTransform();\r\n  translate.setTranslate(x, y);\r\n\r\n  var rotate = createTransform();\r\n  rotate.setRotate(angle, 0, 0);\r\n\r\n  var scale = createTransform();\r\n  scale.setScale(amount || 1, amount || 1);\r\n\r\n  svgTransform(gfx, [ translate, rotate, scale ]);\r\n}\r\n\r\n\r\n/**\r\n * @param {SVGElement} element\r\n * @param {Number} x\r\n * @param {Number} y\r\n */\r\nexport function translate(gfx, x, y) {\r\n  var translate = createTransform();\r\n  translate.setTranslate(x, y);\r\n\r\n  svgTransform(gfx, translate);\r\n}\r\n\r\n\r\n/**\r\n * @param {SVGElement} element\r\n * @param {Number} angle\r\n */\r\nexport function rotate(gfx, angle) {\r\n  var rotate = createTransform();\r\n  rotate.setRotate(angle, 0, 0);\r\n\r\n  svgTransform(gfx, rotate);\r\n}\r\n\r\n\r\n/**\r\n * @param {SVGElement} element\r\n * @param {Number} amount\r\n */\r\nexport function scale(gfx, amount) {\r\n  var scale = createTransform();\r\n  scale.setScale(amount, amount);\r\n\r\n  svgTransform(gfx, scale);\r\n}","import {\n  isObject,\n  assign,\n  forEach,\n  reduce\n} from 'min-dash';\n\nimport {\n  append as svgAppend,\n  attr as svgAttr,\n  create as svgCreate,\n  remove as svgRemove\n} from 'tiny-svg';\n\nvar DEFAULT_BOX_PADDING = 0;\n\nvar DEFAULT_LABEL_SIZE = {\n  width: 150,\n  height: 50\n};\n\n\nfunction parseAlign(align) {\n\n  var parts = align.split('-');\n\n  return {\n    horizontal: parts[0] || 'center',\n    vertical: parts[1] || 'top'\n  };\n}\n\nfunction parsePadding(padding) {\n\n  if (isObject(padding)) {\n    return assign({ top: 0, left: 0, right: 0, bottom: 0 }, padding);\n  } else {\n    return {\n      top: padding,\n      left: padding,\n      right: padding,\n      bottom: padding\n    };\n  }\n}\n\nfunction getTextBBox(text, fakeText) {\n\n  fakeText.textContent = text;\n\n  var textBBox;\n\n  try {\n    var bbox,\n        emptyLine = text === '';\n\n    // add dummy text, when line is empty to\n    // determine correct height\n    fakeText.textContent = emptyLine ? 'dummy' : text;\n\n    textBBox = fakeText.getBBox();\n\n    // take text rendering related horizontal\n    // padding into account\n    bbox = {\n      width: textBBox.width + textBBox.x * 2,\n      height: textBBox.height\n    };\n\n    if (emptyLine) {\n      // correct width\n      bbox.width = 0;\n    }\n\n    return bbox;\n  } catch (e) {\n    return { width: 0, height: 0 };\n  }\n}\n\n\n/**\n * Layout the next line and return the layouted element.\n *\n * Alters the lines passed.\n *\n * @param  {Array<String>} lines\n * @return {Object} the line descriptor, an object { width, height, text }\n */\nfunction layoutNext(lines, maxWidth, fakeText) {\n\n  var originalLine = lines.shift(),\n      fitLine = originalLine;\n\n  var textBBox;\n\n  for (;;) {\n    textBBox = getTextBBox(fitLine, fakeText);\n\n    textBBox.width = fitLine ? textBBox.width : 0;\n\n    // try to fit\n    if (fitLine === ' ' || fitLine === '' || textBBox.width < Math.round(maxWidth) || fitLine.length < 2) {\n      return fit(lines, fitLine, originalLine, textBBox);\n    }\n\n    fitLine = shortenLine(fitLine, textBBox.width, maxWidth);\n  }\n}\n\nfunction fit(lines, fitLine, originalLine, textBBox) {\n  if (fitLine.length < originalLine.length) {\n    var remainder = originalLine.slice(fitLine.length).trim();\n\n    lines.unshift(remainder);\n  }\n\n  return {\n    width: textBBox.width,\n    height: textBBox.height,\n    text: fitLine\n  };\n}\n\n\n/**\n * Shortens a line based on spacing and hyphens.\n * Returns the shortened result on success.\n *\n * @param  {String} line\n * @param  {Number} maxLength the maximum characters of the string\n * @return {String} the shortened string\n */\nfunction semanticShorten(line, maxLength) {\n  var parts = line.split(/(\\s|-)/g),\n      part,\n      shortenedParts = [],\n      length = 0;\n\n  // try to shorten via spaces + hyphens\n  if (parts.length > 1) {\n    while ((part = parts.shift())) {\n      if (part.length + length < maxLength) {\n        shortenedParts.push(part);\n        length += part.length;\n      } else {\n        // remove previous part, too if hyphen does not fit anymore\n        if (part === '-') {\n          shortenedParts.pop();\n        }\n\n        break;\n      }\n    }\n  }\n\n  return shortenedParts.join('');\n}\n\n\nfunction shortenLine(line, width, maxWidth) {\n  var length = Math.max(line.length * (maxWidth / width), 1);\n\n  // try to shorten semantically (i.e. based on spaces and hyphens)\n  var shortenedLine = semanticShorten(line, length);\n\n  if (!shortenedLine) {\n\n    // force shorten by cutting the long word\n    shortenedLine = line.slice(0, Math.max(Math.round(length - 1), 1));\n  }\n\n  return shortenedLine;\n}\n\n\nfunction getHelperSvg() {\n  var helperSvg = document.getElementById('helper-svg');\n\n  if (!helperSvg) {\n    helperSvg = svgCreate('svg');\n\n    svgAttr(helperSvg, {\n      id: 'helper-svg',\n      width: 0,\n      height: 0,\n      style: 'visibility: hidden; position: fixed'\n    });\n\n    document.body.appendChild(helperSvg);\n  }\n\n  return helperSvg;\n}\n\n\n/**\n * Creates a new label utility\n *\n * @param {Object} config\n * @param {Dimensions} config.size\n * @param {Number} config.padding\n * @param {Object} config.style\n * @param {String} config.align\n */\nexport default function Text(config) {\n\n  this._config = assign({}, {\n    size: DEFAULT_LABEL_SIZE,\n    padding: DEFAULT_BOX_PADDING,\n    style: {},\n    align: 'center-top'\n  }, config || {});\n}\n\n/**\n * Returns the layouted text as an SVG element.\n *\n * @param {String} text\n * @param {Object} options\n *\n * @return {SVGElement}\n */\nText.prototype.createText = function(text, options) {\n  return this.layoutText(text, options).element;\n};\n\n/**\n * Returns a labels layouted dimensions.\n *\n * @param {String} text to layout\n * @param {Object} options\n *\n * @return {Dimensions}\n */\nText.prototype.getDimensions = function(text, options) {\n  return this.layoutText(text, options).dimensions;\n};\n\n/**\n * Creates and returns a label and its bounding box.\n *\n * @method Text#createText\n *\n * @param {String} text the text to render on the label\n * @param {Object} options\n * @param {String} options.align how to align in the bounding box.\n *                               Any of { 'center-middle', 'center-top' },\n *                               defaults to 'center-top'.\n * @param {String} options.style style to be applied to the text\n * @param {boolean} options.fitBox indicates if box will be recalculated to\n *                                 fit text\n *\n * @return {Object} { element, dimensions }\n */\nText.prototype.layoutText = function(text, options) {\n  var box = assign({}, this._config.size, options.box),\n      style = assign({}, this._config.style, options.style),\n      align = parseAlign(options.align || this._config.align),\n      padding = parsePadding(options.padding !== undefined ? options.padding : this._config.padding),\n      fitBox = options.fitBox || false;\n\n  var lineHeight = getLineHeight(style);\n\n  var lines = text.split(/\\r?\\n/g),\n      layouted = [];\n\n  var maxWidth = box.width - padding.left - padding.right;\n\n  // ensure correct rendering by attaching helper text node to invisible SVG\n  var helperText = svgCreate('text');\n  svgAttr(helperText, { x: 0, y: 0 });\n  svgAttr(helperText, style);\n\n  var helperSvg = getHelperSvg();\n\n  svgAppend(helperSvg, helperText);\n\n  while (lines.length) {\n    layouted.push(layoutNext(lines, maxWidth, helperText));\n  }\n\n  if (align.vertical === 'middle') {\n    padding.top = padding.bottom = 0;\n  }\n\n  var totalHeight = reduce(layouted, function(sum, line, idx) {\n    return sum + (lineHeight || line.height);\n  }, 0) + padding.top + padding.bottom;\n\n  var maxLineWidth = reduce(layouted, function(sum, line, idx) {\n    return line.width > sum ? line.width : sum;\n  }, 0);\n\n  // the y position of the next line\n  var y = padding.top;\n\n  if (align.vertical === 'middle') {\n    y += (box.height - totalHeight) / 2;\n  }\n\n  // magic number initial offset\n  y -= (lineHeight || layouted[0].height) / 4;\n\n\n  var textElement = svgCreate('text');\n\n  svgAttr(textElement, style);\n\n  // layout each line taking into account that parent\n  // shape might resize to fit text size\n  forEach(layouted, function(line) {\n\n    var x;\n\n    y += (lineHeight || line.height);\n\n    switch (align.horizontal) {\n    case 'left':\n      x = padding.left;\n      break;\n\n    case 'right':\n      x = ((fitBox ? maxLineWidth : maxWidth)\n        - padding.right - line.width);\n      break;\n\n    default:\n      // aka center\n      x = Math.max((((fitBox ? maxLineWidth : maxWidth)\n        - line.width) / 2 + padding.left), 0);\n    }\n\n    var tspan = svgCreate('tspan');\n    svgAttr(tspan, { x: x, y: y });\n\n    tspan.textContent = line.text;\n\n    svgAppend(textElement, tspan);\n  });\n\n  svgRemove(helperText);\n\n  var dimensions = {\n    width: maxLineWidth,\n    height: totalHeight\n  };\n\n  return {\n    dimensions: dimensions,\n    element: textElement\n  };\n};\n\n\nfunction getLineHeight(style) {\n  if ('fontSize' in style && 'lineHeight' in style) {\n    return style.lineHeight * parseInt(style.fontSize, 10);\n  }\n}","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar CLASS_PATTERN = /^class /;\n\nfunction isClass(fn) {\n  return CLASS_PATTERN.test(fn.toString());\n}\n\nfunction isArray(obj) {\n  return Object.prototype.toString.call(obj) === '[object Array]';\n}\n\nfunction annotate() {\n  var args = Array.prototype.slice.call(arguments);\n\n  if (args.length === 1 && isArray(args[0])) {\n    args = args[0];\n  }\n\n  var fn = args.pop();\n\n  fn.$inject = args;\n\n  return fn;\n}\n\n// Current limitations:\n// - can't put into \"function arg\" comments\n// function /* (no parenthesis like this) */ (){}\n// function abc( /* xx (no parenthesis like this) */ a, b) {}\n//\n// Just put the comment before function or inside:\n// /* (((this is fine))) */ function(a, b) {}\n// function abc(a) { /* (((this is fine))) */}\n//\n// - can't reliably auto-annotate constructor; we'll match the\n// first constructor(...) pattern found which may be the one\n// of a nested class, too.\n\nvar CONSTRUCTOR_ARGS = /constructor\\s*[^(]*\\(\\s*([^)]*)\\)/m;\nvar FN_ARGS = /^function\\s*[^(]*\\(\\s*([^)]*)\\)/m;\nvar FN_ARG = /\\/\\*([^*]*)\\*\\//m;\n\nfunction parse(fn) {\n\n  if (typeof fn !== 'function') {\n    throw new Error('Cannot annotate \"' + fn + '\". Expected a function!');\n  }\n\n  var match = fn.toString().match(isClass(fn) ? CONSTRUCTOR_ARGS : FN_ARGS);\n\n  // may parse class without constructor\n  if (!match) {\n    return [];\n  }\n\n  return match[1] && match[1].split(',').map(function (arg) {\n    match = arg.match(FN_ARG);\n    return match ? match[1].trim() : arg.trim();\n  }) || [];\n}\n\nfunction Module() {\n  var providers = [];\n\n  this.factory = function (name, factory) {\n    providers.push([name, 'factory', factory]);\n    return this;\n  };\n\n  this.value = function (name, value) {\n    providers.push([name, 'value', value]);\n    return this;\n  };\n\n  this.type = function (name, type) {\n    providers.push([name, 'type', type]);\n    return this;\n  };\n\n  this.forEach = function (iterator) {\n    providers.forEach(iterator);\n  };\n}\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nfunction _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }\n\nfunction Injector(modules, parent) {\n  parent = parent || {\n    get: function get(name, strict) {\n      currentlyResolving.push(name);\n\n      if (strict === false) {\n        return null;\n      } else {\n        throw error('No provider for \"' + name + '\"!');\n      }\n    }\n  };\n\n  var currentlyResolving = [];\n  var providers = this._providers = Object.create(parent._providers || null);\n  var instances = this._instances = Object.create(null);\n\n  var self = instances.injector = this;\n\n  var error = function error(msg) {\n    var stack = currentlyResolving.join(' -> ');\n    currentlyResolving.length = 0;\n    return new Error(stack ? msg + ' (Resolving: ' + stack + ')' : msg);\n  };\n\n  /**\n   * Return a named service.\n   *\n   * @param {String} name\n   * @param {Boolean} [strict=true] if false, resolve missing services to null\n   *\n   * @return {Object}\n   */\n  var get = function get(name, strict) {\n    if (!providers[name] && name.indexOf('.') !== -1) {\n      var parts = name.split('.');\n      var pivot = get(parts.shift());\n\n      while (parts.length) {\n        pivot = pivot[parts.shift()];\n      }\n\n      return pivot;\n    }\n\n    if (hasProp(instances, name)) {\n      return instances[name];\n    }\n\n    if (hasProp(providers, name)) {\n      if (currentlyResolving.indexOf(name) !== -1) {\n        currentlyResolving.push(name);\n        throw error('Cannot resolve circular dependency!');\n      }\n\n      currentlyResolving.push(name);\n      instances[name] = providers[name][0](providers[name][1]);\n      currentlyResolving.pop();\n\n      return instances[name];\n    }\n\n    return parent.get(name, strict);\n  };\n\n  var fnDef = function fnDef(fn) {\n    var locals = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    if (typeof fn !== 'function') {\n      if (isArray(fn)) {\n        fn = annotate(fn.slice());\n      } else {\n        throw new Error('Cannot invoke \"' + fn + '\". Expected a function!');\n      }\n    }\n\n    var inject = fn.$inject || parse(fn);\n    var dependencies = inject.map(function (dep) {\n      if (hasProp(locals, dep)) {\n        return locals[dep];\n      } else {\n        return get(dep);\n      }\n    });\n\n    return {\n      fn: fn,\n      dependencies: dependencies\n    };\n  };\n\n  var instantiate = function instantiate(Type) {\n    var _fnDef = fnDef(Type),\n        dependencies = _fnDef.dependencies,\n        fn = _fnDef.fn;\n\n    return new (Function.prototype.bind.apply(fn, [null].concat(_toConsumableArray(dependencies))))();\n  };\n\n  var invoke = function invoke(func, context, locals) {\n    var _fnDef2 = fnDef(func, locals),\n        dependencies = _fnDef2.dependencies,\n        fn = _fnDef2.fn;\n\n    return fn.call.apply(fn, [context].concat(_toConsumableArray(dependencies)));\n  };\n\n  var createPrivateInjectorFactory = function createPrivateInjectorFactory(privateChildInjector) {\n    return annotate(function (key) {\n      return privateChildInjector.get(key);\n    });\n  };\n\n  var createChild = function createChild(modules, forceNewInstances) {\n    if (forceNewInstances && forceNewInstances.length) {\n      var fromParentModule = Object.create(null);\n      var matchedScopes = Object.create(null);\n\n      var privateInjectorsCache = [];\n      var privateChildInjectors = [];\n      var privateChildFactories = [];\n\n      var provider;\n      var cacheIdx;\n      var privateChildInjector;\n      var privateChildInjectorFactory;\n      for (var name in providers) {\n        provider = providers[name];\n\n        if (forceNewInstances.indexOf(name) !== -1) {\n          if (provider[2] === 'private') {\n            cacheIdx = privateInjectorsCache.indexOf(provider[3]);\n            if (cacheIdx === -1) {\n              privateChildInjector = provider[3].createChild([], forceNewInstances);\n              privateChildInjectorFactory = createPrivateInjectorFactory(privateChildInjector);\n              privateInjectorsCache.push(provider[3]);\n              privateChildInjectors.push(privateChildInjector);\n              privateChildFactories.push(privateChildInjectorFactory);\n              fromParentModule[name] = [privateChildInjectorFactory, name, 'private', privateChildInjector];\n            } else {\n              fromParentModule[name] = [privateChildFactories[cacheIdx], name, 'private', privateChildInjectors[cacheIdx]];\n            }\n          } else {\n            fromParentModule[name] = [provider[2], provider[1]];\n          }\n          matchedScopes[name] = true;\n        }\n\n        if ((provider[2] === 'factory' || provider[2] === 'type') && provider[1].$scope) {\n          /* jshint -W083 */\n          forceNewInstances.forEach(function (scope) {\n            if (provider[1].$scope.indexOf(scope) !== -1) {\n              fromParentModule[name] = [provider[2], provider[1]];\n              matchedScopes[scope] = true;\n            }\n          });\n        }\n      }\n\n      forceNewInstances.forEach(function (scope) {\n        if (!matchedScopes[scope]) {\n          throw new Error('No provider for \"' + scope + '\". Cannot use provider from the parent!');\n        }\n      });\n\n      modules.unshift(fromParentModule);\n    }\n\n    return new Injector(modules, self);\n  };\n\n  var factoryMap = {\n    factory: invoke,\n    type: instantiate,\n    value: function value(_value) {\n      return _value;\n    }\n  };\n\n  modules.forEach(function (module) {\n\n    function arrayUnwrap(type, value) {\n      if (type !== 'value' && isArray(value)) {\n        value = annotate(value.slice());\n      }\n\n      return value;\n    }\n\n    // TODO(vojta): handle wrong inputs (modules)\n    if (module instanceof Module) {\n      module.forEach(function (provider) {\n        var name = provider[0];\n        var type = provider[1];\n        var value = provider[2];\n\n        providers[name] = [factoryMap[type], arrayUnwrap(type, value), type];\n      });\n    } else if ((typeof module === 'undefined' ? 'undefined' : _typeof(module)) === 'object') {\n      if (module.__exports__) {\n        var clonedModule = Object.keys(module).reduce(function (m, key) {\n          if (key.substring(0, 2) !== '__') {\n            m[key] = module[key];\n          }\n          return m;\n        }, Object.create(null));\n\n        var privateInjector = new Injector((module.__modules__ || []).concat([clonedModule]), self);\n        var getFromPrivateInjector = annotate(function (key) {\n          return privateInjector.get(key);\n        });\n        module.__exports__.forEach(function (key) {\n          providers[key] = [getFromPrivateInjector, key, 'private', privateInjector];\n        });\n      } else {\n        Object.keys(module).forEach(function (name) {\n          if (module[name][2] === 'private') {\n            providers[name] = module[name];\n            return;\n          }\n\n          var type = module[name][0];\n          var value = module[name][1];\n\n          providers[name] = [factoryMap[type], arrayUnwrap(type, value), type];\n        });\n      }\n    }\n  });\n\n  // public API\n  this.get = get;\n  this.invoke = invoke;\n  this.instantiate = instantiate;\n  this.createChild = createChild;\n}\n\n// helpers /////////////////\n\nfunction hasProp(obj, prop) {\n  return Object.hasOwnProperty.call(obj, prop);\n}\n\nexports.annotate = annotate;\nexports.Module = Module;\nexports.Injector = Injector;\n","\n/**\n * Expose `parse`.\n */\n\nmodule.exports = parse;\n\n/**\n * Tests for browser support.\n */\n\nvar innerHTMLBug = false;\nvar bugTestDiv;\nif (typeof document !== 'undefined') {\n  bugTestDiv = document.createElement('div');\n  // Setup\n  bugTestDiv.innerHTML = '  <link/><table></table><a href=\"/a\">a</a><input type=\"checkbox\"/>';\n  // Make sure that link elements get serialized correctly by innerHTML\n  // This requires a wrapper element in IE\n  innerHTMLBug = !bugTestDiv.getElementsByTagName('link').length;\n  bugTestDiv = undefined;\n}\n\n/**\n * Wrap map from jquery.\n */\n\nvar map = {\n  legend: [1, '<fieldset>', '</fieldset>'],\n  tr: [2, '<table><tbody>', '</tbody></table>'],\n  col: [2, '<table><tbody></tbody><colgroup>', '</colgroup></table>'],\n  // for script/link/style tags to work in IE6-8, you have to wrap\n  // in a div with a non-whitespace character in front, ha!\n  _default: innerHTMLBug ? [1, 'X<div>', '</div>'] : [0, '', '']\n};\n\nmap.td =\nmap.th = [3, '<table><tbody><tr>', '</tr></tbody></table>'];\n\nmap.option =\nmap.optgroup = [1, '<select multiple=\"multiple\">', '</select>'];\n\nmap.thead =\nmap.tbody =\nmap.colgroup =\nmap.caption =\nmap.tfoot = [1, '<table>', '</table>'];\n\nmap.polyline =\nmap.ellipse =\nmap.polygon =\nmap.circle =\nmap.text =\nmap.line =\nmap.path =\nmap.rect =\nmap.g = [1, '<svg xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">','</svg>'];\n\n/**\n * Parse `html` and return a DOM Node instance, which could be a TextNode,\n * HTML DOM Node of some kind (<div> for example), or a DocumentFragment\n * instance, depending on the contents of the `html` string.\n *\n * @param {String} html - HTML string to \"domify\"\n * @param {Document} doc - The `document` instance to create the Node for\n * @return {DOMNode} the TextNode, DOM Node, or DocumentFragment instance\n * @api private\n */\n\nfunction parse(html, doc) {\n  if ('string' != typeof html) throw new TypeError('String expected');\n\n  // default to the global `document` object\n  if (!doc) doc = document;\n\n  // tag name\n  var m = /<([\\w:]+)/.exec(html);\n  if (!m) return doc.createTextNode(html);\n\n  html = html.replace(/^\\s+|\\s+$/g, ''); // Remove leading/trailing whitespace\n\n  var tag = m[1];\n\n  // body support\n  if (tag == 'body') {\n    var el = doc.createElement('html');\n    el.innerHTML = html;\n    return el.removeChild(el.lastChild);\n  }\n\n  // wrap map\n  var wrap = map[tag] || map._default;\n  var depth = wrap[0];\n  var prefix = wrap[1];\n  var suffix = wrap[2];\n  var el = doc.createElement('div');\n  el.innerHTML = prefix + html + suffix;\n  while (depth--) el = el.lastChild;\n\n  // one element\n  if (el.firstChild == el.lastChild) {\n    return el.removeChild(el.firstChild);\n  }\n\n  // several elements\n  var fragment = doc.createDocumentFragment();\n  while (el.firstChild) {\n    fragment.appendChild(el.removeChild(el.firstChild));\n  }\n\n  return fragment;\n}\n","/*! Hammer.JS - v2.0.7 - 2016-04-22\n * http://hammerjs.github.io/\n *\n * Copyright (c) 2016 Jorik Tangelder;\n * Licensed under the MIT license */\n(function(window, document, exportName, undefined) {\n  'use strict';\n\nvar VENDOR_PREFIXES = ['', 'webkit', 'Moz', 'MS', 'ms', 'o'];\nvar TEST_ELEMENT = document.createElement('div');\n\nvar TYPE_FUNCTION = 'function';\n\nvar round = Math.round;\nvar abs = Math.abs;\nvar now = Date.now;\n\n/**\n * set a timeout with a given scope\n * @param {Function} fn\n * @param {Number} timeout\n * @param {Object} context\n * @returns {number}\n */\nfunction setTimeoutContext(fn, timeout, context) {\n    return setTimeout(bindFn(fn, context), timeout);\n}\n\n/**\n * if the argument is an array, we want to execute the fn on each entry\n * if it aint an array we don't want to do a thing.\n * this is used by all the methods that accept a single and array argument.\n * @param {*|Array} arg\n * @param {String} fn\n * @param {Object} [context]\n * @returns {Boolean}\n */\nfunction invokeArrayArg(arg, fn, context) {\n    if (Array.isArray(arg)) {\n        each(arg, context[fn], context);\n        return true;\n    }\n    return false;\n}\n\n/**\n * walk objects and arrays\n * @param {Object} obj\n * @param {Function} iterator\n * @param {Object} context\n */\nfunction each(obj, iterator, context) {\n    var i;\n\n    if (!obj) {\n        return;\n    }\n\n    if (obj.forEach) {\n        obj.forEach(iterator, context);\n    } else if (obj.length !== undefined) {\n        i = 0;\n        while (i < obj.length) {\n            iterator.call(context, obj[i], i, obj);\n            i++;\n        }\n    } else {\n        for (i in obj) {\n            obj.hasOwnProperty(i) && iterator.call(context, obj[i], i, obj);\n        }\n    }\n}\n\n/**\n * wrap a method with a deprecation warning and stack trace\n * @param {Function} method\n * @param {String} name\n * @param {String} message\n * @returns {Function} A new function wrapping the supplied method.\n */\nfunction deprecate(method, name, message) {\n    var deprecationMessage = 'DEPRECATED METHOD: ' + name + '\\n' + message + ' AT \\n';\n    return function() {\n        var e = new Error('get-stack-trace');\n        var stack = e && e.stack ? e.stack.replace(/^[^\\(]+?[\\n$]/gm, '')\n            .replace(/^\\s+at\\s+/gm, '')\n            .replace(/^Object.<anonymous>\\s*\\(/gm, '{anonymous}()@') : 'Unknown Stack Trace';\n\n        var log = window.console && (window.console.warn || window.console.log);\n        if (log) {\n            log.call(window.console, deprecationMessage, stack);\n        }\n        return method.apply(this, arguments);\n    };\n}\n\n/**\n * extend object.\n * means that properties in dest will be overwritten by the ones in src.\n * @param {Object} target\n * @param {...Object} objects_to_assign\n * @returns {Object} target\n */\nvar assign;\nif (typeof Object.assign !== 'function') {\n    assign = function assign(target) {\n        if (target === undefined || target === null) {\n            throw new TypeError('Cannot convert undefined or null to object');\n        }\n\n        var output = Object(target);\n        for (var index = 1; index < arguments.length; index++) {\n            var source = arguments[index];\n            if (source !== undefined && source !== null) {\n                for (var nextKey in source) {\n                    if (source.hasOwnProperty(nextKey)) {\n                        output[nextKey] = source[nextKey];\n                    }\n                }\n            }\n        }\n        return output;\n    };\n} else {\n    assign = Object.assign;\n}\n\n/**\n * extend object.\n * means that properties in dest will be overwritten by the ones in src.\n * @param {Object} dest\n * @param {Object} src\n * @param {Boolean} [merge=false]\n * @returns {Object} dest\n */\nvar extend = deprecate(function extend(dest, src, merge) {\n    var keys = Object.keys(src);\n    var i = 0;\n    while (i < keys.length) {\n        if (!merge || (merge && dest[keys[i]] === undefined)) {\n            dest[keys[i]] = src[keys[i]];\n        }\n        i++;\n    }\n    return dest;\n}, 'extend', 'Use `assign`.');\n\n/**\n * merge the values from src in the dest.\n * means that properties that exist in dest will not be overwritten by src\n * @param {Object} dest\n * @param {Object} src\n * @returns {Object} dest\n */\nvar merge = deprecate(function merge(dest, src) {\n    return extend(dest, src, true);\n}, 'merge', 'Use `assign`.');\n\n/**\n * simple class inheritance\n * @param {Function} child\n * @param {Function} base\n * @param {Object} [properties]\n */\nfunction inherit(child, base, properties) {\n    var baseP = base.prototype,\n        childP;\n\n    childP = child.prototype = Object.create(baseP);\n    childP.constructor = child;\n    childP._super = baseP;\n\n    if (properties) {\n        assign(childP, properties);\n    }\n}\n\n/**\n * simple function bind\n * @param {Function} fn\n * @param {Object} context\n * @returns {Function}\n */\nfunction bindFn(fn, context) {\n    return function boundFn() {\n        return fn.apply(context, arguments);\n    };\n}\n\n/**\n * let a boolean value also be a function that must return a boolean\n * this first item in args will be used as the context\n * @param {Boolean|Function} val\n * @param {Array} [args]\n * @returns {Boolean}\n */\nfunction boolOrFn(val, args) {\n    if (typeof val == TYPE_FUNCTION) {\n        return val.apply(args ? args[0] || undefined : undefined, args);\n    }\n    return val;\n}\n\n/**\n * use the val2 when val1 is undefined\n * @param {*} val1\n * @param {*} val2\n * @returns {*}\n */\nfunction ifUndefined(val1, val2) {\n    return (val1 === undefined) ? val2 : val1;\n}\n\n/**\n * addEventListener with multiple events at once\n * @param {EventTarget} target\n * @param {String} types\n * @param {Function} handler\n */\nfunction addEventListeners(target, types, handler) {\n    each(splitStr(types), function(type) {\n        target.addEventListener(type, handler, false);\n    });\n}\n\n/**\n * removeEventListener with multiple events at once\n * @param {EventTarget} target\n * @param {String} types\n * @param {Function} handler\n */\nfunction removeEventListeners(target, types, handler) {\n    each(splitStr(types), function(type) {\n        target.removeEventListener(type, handler, false);\n    });\n}\n\n/**\n * find if a node is in the given parent\n * @method hasParent\n * @param {HTMLElement} node\n * @param {HTMLElement} parent\n * @return {Boolean} found\n */\nfunction hasParent(node, parent) {\n    while (node) {\n        if (node == parent) {\n            return true;\n        }\n        node = node.parentNode;\n    }\n    return false;\n}\n\n/**\n * small indexOf wrapper\n * @param {String} str\n * @param {String} find\n * @returns {Boolean} found\n */\nfunction inStr(str, find) {\n    return str.indexOf(find) > -1;\n}\n\n/**\n * split string on whitespace\n * @param {String} str\n * @returns {Array} words\n */\nfunction splitStr(str) {\n    return str.trim().split(/\\s+/g);\n}\n\n/**\n * find if a array contains the object using indexOf or a simple polyFill\n * @param {Array} src\n * @param {String} find\n * @param {String} [findByKey]\n * @return {Boolean|Number} false when not found, or the index\n */\nfunction inArray(src, find, findByKey) {\n    if (src.indexOf && !findByKey) {\n        return src.indexOf(find);\n    } else {\n        var i = 0;\n        while (i < src.length) {\n            if ((findByKey && src[i][findByKey] == find) || (!findByKey && src[i] === find)) {\n                return i;\n            }\n            i++;\n        }\n        return -1;\n    }\n}\n\n/**\n * convert array-like objects to real arrays\n * @param {Object} obj\n * @returns {Array}\n */\nfunction toArray(obj) {\n    return Array.prototype.slice.call(obj, 0);\n}\n\n/**\n * unique array with objects based on a key (like 'id') or just by the array's value\n * @param {Array} src [{id:1},{id:2},{id:1}]\n * @param {String} [key]\n * @param {Boolean} [sort=False]\n * @returns {Array} [{id:1},{id:2}]\n */\nfunction uniqueArray(src, key, sort) {\n    var results = [];\n    var values = [];\n    var i = 0;\n\n    while (i < src.length) {\n        var val = key ? src[i][key] : src[i];\n        if (inArray(values, val) < 0) {\n            results.push(src[i]);\n        }\n        values[i] = val;\n        i++;\n    }\n\n    if (sort) {\n        if (!key) {\n            results = results.sort();\n        } else {\n            results = results.sort(function sortUniqueArray(a, b) {\n                return a[key] > b[key];\n            });\n        }\n    }\n\n    return results;\n}\n\n/**\n * get the prefixed property\n * @param {Object} obj\n * @param {String} property\n * @returns {String|Undefined} prefixed\n */\nfunction prefixed(obj, property) {\n    var prefix, prop;\n    var camelProp = property[0].toUpperCase() + property.slice(1);\n\n    var i = 0;\n    while (i < VENDOR_PREFIXES.length) {\n        prefix = VENDOR_PREFIXES[i];\n        prop = (prefix) ? prefix + camelProp : property;\n\n        if (prop in obj) {\n            return prop;\n        }\n        i++;\n    }\n    return undefined;\n}\n\n/**\n * get a unique id\n * @returns {number} uniqueId\n */\nvar _uniqueId = 1;\nfunction uniqueId() {\n    return _uniqueId++;\n}\n\n/**\n * get the window object of an element\n * @param {HTMLElement} element\n * @returns {DocumentView|Window}\n */\nfunction getWindowForElement(element) {\n    var doc = element.ownerDocument || element;\n    return (doc.defaultView || doc.parentWindow || window);\n}\n\nvar MOBILE_REGEX = /mobile|tablet|ip(ad|hone|od)|android/i;\n\nvar SUPPORT_TOUCH = ('ontouchstart' in window);\nvar SUPPORT_POINTER_EVENTS = prefixed(window, 'PointerEvent') !== undefined;\nvar SUPPORT_ONLY_TOUCH = SUPPORT_TOUCH && MOBILE_REGEX.test(navigator.userAgent);\n\nvar INPUT_TYPE_TOUCH = 'touch';\nvar INPUT_TYPE_PEN = 'pen';\nvar INPUT_TYPE_MOUSE = 'mouse';\nvar INPUT_TYPE_KINECT = 'kinect';\n\nvar COMPUTE_INTERVAL = 25;\n\nvar INPUT_START = 1;\nvar INPUT_MOVE = 2;\nvar INPUT_END = 4;\nvar INPUT_CANCEL = 8;\n\nvar DIRECTION_NONE = 1;\nvar DIRECTION_LEFT = 2;\nvar DIRECTION_RIGHT = 4;\nvar DIRECTION_UP = 8;\nvar DIRECTION_DOWN = 16;\n\nvar DIRECTION_HORIZONTAL = DIRECTION_LEFT | DIRECTION_RIGHT;\nvar DIRECTION_VERTICAL = DIRECTION_UP | DIRECTION_DOWN;\nvar DIRECTION_ALL = DIRECTION_HORIZONTAL | DIRECTION_VERTICAL;\n\nvar PROPS_XY = ['x', 'y'];\nvar PROPS_CLIENT_XY = ['clientX', 'clientY'];\n\n/**\n * create new input type manager\n * @param {Manager} manager\n * @param {Function} callback\n * @returns {Input}\n * @constructor\n */\nfunction Input(manager, callback) {\n    var self = this;\n    this.manager = manager;\n    this.callback = callback;\n    this.element = manager.element;\n    this.target = manager.options.inputTarget;\n\n    // smaller wrapper around the handler, for the scope and the enabled state of the manager,\n    // so when disabled the input events are completely bypassed.\n    this.domHandler = function(ev) {\n        if (boolOrFn(manager.options.enable, [manager])) {\n            self.handler(ev);\n        }\n    };\n\n    this.init();\n\n}\n\nInput.prototype = {\n    /**\n     * should handle the inputEvent data and trigger the callback\n     * @virtual\n     */\n    handler: function() { },\n\n    /**\n     * bind the events\n     */\n    init: function() {\n        this.evEl && addEventListeners(this.element, this.evEl, this.domHandler);\n        this.evTarget && addEventListeners(this.target, this.evTarget, this.domHandler);\n        this.evWin && addEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);\n    },\n\n    /**\n     * unbind the events\n     */\n    destroy: function() {\n        this.evEl && removeEventListeners(this.element, this.evEl, this.domHandler);\n        this.evTarget && removeEventListeners(this.target, this.evTarget, this.domHandler);\n        this.evWin && removeEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);\n    }\n};\n\n/**\n * create new input type manager\n * called by the Manager constructor\n * @param {Hammer} manager\n * @returns {Input}\n */\nfunction createInputInstance(manager) {\n    var Type;\n    var inputClass = manager.options.inputClass;\n\n    if (inputClass) {\n        Type = inputClass;\n    } else if (SUPPORT_POINTER_EVENTS) {\n        Type = PointerEventInput;\n    } else if (SUPPORT_ONLY_TOUCH) {\n        Type = TouchInput;\n    } else if (!SUPPORT_TOUCH) {\n        Type = MouseInput;\n    } else {\n        Type = TouchMouseInput;\n    }\n    return new (Type)(manager, inputHandler);\n}\n\n/**\n * handle input events\n * @param {Manager} manager\n * @param {String} eventType\n * @param {Object} input\n */\nfunction inputHandler(manager, eventType, input) {\n    var pointersLen = input.pointers.length;\n    var changedPointersLen = input.changedPointers.length;\n    var isFirst = (eventType & INPUT_START && (pointersLen - changedPointersLen === 0));\n    var isFinal = (eventType & (INPUT_END | INPUT_CANCEL) && (pointersLen - changedPointersLen === 0));\n\n    input.isFirst = !!isFirst;\n    input.isFinal = !!isFinal;\n\n    if (isFirst) {\n        manager.session = {};\n    }\n\n    // source event is the normalized value of the domEvents\n    // like 'touchstart, mouseup, pointerdown'\n    input.eventType = eventType;\n\n    // compute scale, rotation etc\n    computeInputData(manager, input);\n\n    // emit secret event\n    manager.emit('hammer.input', input);\n\n    manager.recognize(input);\n    manager.session.prevInput = input;\n}\n\n/**\n * extend the data with some usable properties like scale, rotate, velocity etc\n * @param {Object} manager\n * @param {Object} input\n */\nfunction computeInputData(manager, input) {\n    var session = manager.session;\n    var pointers = input.pointers;\n    var pointersLength = pointers.length;\n\n    // store the first input to calculate the distance and direction\n    if (!session.firstInput) {\n        session.firstInput = simpleCloneInputData(input);\n    }\n\n    // to compute scale and rotation we need to store the multiple touches\n    if (pointersLength > 1 && !session.firstMultiple) {\n        session.firstMultiple = simpleCloneInputData(input);\n    } else if (pointersLength === 1) {\n        session.firstMultiple = false;\n    }\n\n    var firstInput = session.firstInput;\n    var firstMultiple = session.firstMultiple;\n    var offsetCenter = firstMultiple ? firstMultiple.center : firstInput.center;\n\n    var center = input.center = getCenter(pointers);\n    input.timeStamp = now();\n    input.deltaTime = input.timeStamp - firstInput.timeStamp;\n\n    input.angle = getAngle(offsetCenter, center);\n    input.distance = getDistance(offsetCenter, center);\n\n    computeDeltaXY(session, input);\n    input.offsetDirection = getDirection(input.deltaX, input.deltaY);\n\n    var overallVelocity = getVelocity(input.deltaTime, input.deltaX, input.deltaY);\n    input.overallVelocityX = overallVelocity.x;\n    input.overallVelocityY = overallVelocity.y;\n    input.overallVelocity = (abs(overallVelocity.x) > abs(overallVelocity.y)) ? overallVelocity.x : overallVelocity.y;\n\n    input.scale = firstMultiple ? getScale(firstMultiple.pointers, pointers) : 1;\n    input.rotation = firstMultiple ? getRotation(firstMultiple.pointers, pointers) : 0;\n\n    input.maxPointers = !session.prevInput ? input.pointers.length : ((input.pointers.length >\n        session.prevInput.maxPointers) ? input.pointers.length : session.prevInput.maxPointers);\n\n    computeIntervalInputData(session, input);\n\n    // find the correct target\n    var target = manager.element;\n    if (hasParent(input.srcEvent.target, target)) {\n        target = input.srcEvent.target;\n    }\n    input.target = target;\n}\n\nfunction computeDeltaXY(session, input) {\n    var center = input.center;\n    var offset = session.offsetDelta || {};\n    var prevDelta = session.prevDelta || {};\n    var prevInput = session.prevInput || {};\n\n    if (input.eventType === INPUT_START || prevInput.eventType === INPUT_END) {\n        prevDelta = session.prevDelta = {\n            x: prevInput.deltaX || 0,\n            y: prevInput.deltaY || 0\n        };\n\n        offset = session.offsetDelta = {\n            x: center.x,\n            y: center.y\n        };\n    }\n\n    input.deltaX = prevDelta.x + (center.x - offset.x);\n    input.deltaY = prevDelta.y + (center.y - offset.y);\n}\n\n/**\n * velocity is calculated every x ms\n * @param {Object} session\n * @param {Object} input\n */\nfunction computeIntervalInputData(session, input) {\n    var last = session.lastInterval || input,\n        deltaTime = input.timeStamp - last.timeStamp,\n        velocity, velocityX, velocityY, direction;\n\n    if (input.eventType != INPUT_CANCEL && (deltaTime > COMPUTE_INTERVAL || last.velocity === undefined)) {\n        var deltaX = input.deltaX - last.deltaX;\n        var deltaY = input.deltaY - last.deltaY;\n\n        var v = getVelocity(deltaTime, deltaX, deltaY);\n        velocityX = v.x;\n        velocityY = v.y;\n        velocity = (abs(v.x) > abs(v.y)) ? v.x : v.y;\n        direction = getDirection(deltaX, deltaY);\n\n        session.lastInterval = input;\n    } else {\n        // use latest velocity info if it doesn't overtake a minimum period\n        velocity = last.velocity;\n        velocityX = last.velocityX;\n        velocityY = last.velocityY;\n        direction = last.direction;\n    }\n\n    input.velocity = velocity;\n    input.velocityX = velocityX;\n    input.velocityY = velocityY;\n    input.direction = direction;\n}\n\n/**\n * create a simple clone from the input used for storage of firstInput and firstMultiple\n * @param {Object} input\n * @returns {Object} clonedInputData\n */\nfunction simpleCloneInputData(input) {\n    // make a simple copy of the pointers because we will get a reference if we don't\n    // we only need clientXY for the calculations\n    var pointers = [];\n    var i = 0;\n    while (i < input.pointers.length) {\n        pointers[i] = {\n            clientX: round(input.pointers[i].clientX),\n            clientY: round(input.pointers[i].clientY)\n        };\n        i++;\n    }\n\n    return {\n        timeStamp: now(),\n        pointers: pointers,\n        center: getCenter(pointers),\n        deltaX: input.deltaX,\n        deltaY: input.deltaY\n    };\n}\n\n/**\n * get the center of all the pointers\n * @param {Array} pointers\n * @return {Object} center contains `x` and `y` properties\n */\nfunction getCenter(pointers) {\n    var pointersLength = pointers.length;\n\n    // no need to loop when only one touch\n    if (pointersLength === 1) {\n        return {\n            x: round(pointers[0].clientX),\n            y: round(pointers[0].clientY)\n        };\n    }\n\n    var x = 0, y = 0, i = 0;\n    while (i < pointersLength) {\n        x += pointers[i].clientX;\n        y += pointers[i].clientY;\n        i++;\n    }\n\n    return {\n        x: round(x / pointersLength),\n        y: round(y / pointersLength)\n    };\n}\n\n/**\n * calculate the velocity between two points. unit is in px per ms.\n * @param {Number} deltaTime\n * @param {Number} x\n * @param {Number} y\n * @return {Object} velocity `x` and `y`\n */\nfunction getVelocity(deltaTime, x, y) {\n    return {\n        x: x / deltaTime || 0,\n        y: y / deltaTime || 0\n    };\n}\n\n/**\n * get the direction between two points\n * @param {Number} x\n * @param {Number} y\n * @return {Number} direction\n */\nfunction getDirection(x, y) {\n    if (x === y) {\n        return DIRECTION_NONE;\n    }\n\n    if (abs(x) >= abs(y)) {\n        return x < 0 ? DIRECTION_LEFT : DIRECTION_RIGHT;\n    }\n    return y < 0 ? DIRECTION_UP : DIRECTION_DOWN;\n}\n\n/**\n * calculate the absolute distance between two points\n * @param {Object} p1 {x, y}\n * @param {Object} p2 {x, y}\n * @param {Array} [props] containing x and y keys\n * @return {Number} distance\n */\nfunction getDistance(p1, p2, props) {\n    if (!props) {\n        props = PROPS_XY;\n    }\n    var x = p2[props[0]] - p1[props[0]],\n        y = p2[props[1]] - p1[props[1]];\n\n    return Math.sqrt((x * x) + (y * y));\n}\n\n/**\n * calculate the angle between two coordinates\n * @param {Object} p1\n * @param {Object} p2\n * @param {Array} [props] containing x and y keys\n * @return {Number} angle\n */\nfunction getAngle(p1, p2, props) {\n    if (!props) {\n        props = PROPS_XY;\n    }\n    var x = p2[props[0]] - p1[props[0]],\n        y = p2[props[1]] - p1[props[1]];\n    return Math.atan2(y, x) * 180 / Math.PI;\n}\n\n/**\n * calculate the rotation degrees between two pointersets\n * @param {Array} start array of pointers\n * @param {Array} end array of pointers\n * @return {Number} rotation\n */\nfunction getRotation(start, end) {\n    return getAngle(end[1], end[0], PROPS_CLIENT_XY) + getAngle(start[1], start[0], PROPS_CLIENT_XY);\n}\n\n/**\n * calculate the scale factor between two pointersets\n * no scale is 1, and goes down to 0 when pinched together, and bigger when pinched out\n * @param {Array} start array of pointers\n * @param {Array} end array of pointers\n * @return {Number} scale\n */\nfunction getScale(start, end) {\n    return getDistance(end[0], end[1], PROPS_CLIENT_XY) / getDistance(start[0], start[1], PROPS_CLIENT_XY);\n}\n\nvar MOUSE_INPUT_MAP = {\n    mousedown: INPUT_START,\n    mousemove: INPUT_MOVE,\n    mouseup: INPUT_END\n};\n\nvar MOUSE_ELEMENT_EVENTS = 'mousedown';\nvar MOUSE_WINDOW_EVENTS = 'mousemove mouseup';\n\n/**\n * Mouse events input\n * @constructor\n * @extends Input\n */\nfunction MouseInput() {\n    this.evEl = MOUSE_ELEMENT_EVENTS;\n    this.evWin = MOUSE_WINDOW_EVENTS;\n\n    this.pressed = false; // mousedown state\n\n    Input.apply(this, arguments);\n}\n\ninherit(MouseInput, Input, {\n    /**\n     * handle mouse events\n     * @param {Object} ev\n     */\n    handler: function MEhandler(ev) {\n        var eventType = MOUSE_INPUT_MAP[ev.type];\n\n        // on start we want to have the left mouse button down\n        if (eventType & INPUT_START && ev.button === 0) {\n            this.pressed = true;\n        }\n\n        if (eventType & INPUT_MOVE && ev.which !== 1) {\n            eventType = INPUT_END;\n        }\n\n        // mouse must be down\n        if (!this.pressed) {\n            return;\n        }\n\n        if (eventType & INPUT_END) {\n            this.pressed = false;\n        }\n\n        this.callback(this.manager, eventType, {\n            pointers: [ev],\n            changedPointers: [ev],\n            pointerType: INPUT_TYPE_MOUSE,\n            srcEvent: ev\n        });\n    }\n});\n\nvar POINTER_INPUT_MAP = {\n    pointerdown: INPUT_START,\n    pointermove: INPUT_MOVE,\n    pointerup: INPUT_END,\n    pointercancel: INPUT_CANCEL,\n    pointerout: INPUT_CANCEL\n};\n\n// in IE10 the pointer types is defined as an enum\nvar IE10_POINTER_TYPE_ENUM = {\n    2: INPUT_TYPE_TOUCH,\n    3: INPUT_TYPE_PEN,\n    4: INPUT_TYPE_MOUSE,\n    5: INPUT_TYPE_KINECT // see https://twitter.com/jacobrossi/status/480596438489890816\n};\n\nvar POINTER_ELEMENT_EVENTS = 'pointerdown';\nvar POINTER_WINDOW_EVENTS = 'pointermove pointerup pointercancel';\n\n// IE10 has prefixed support, and case-sensitive\nif (window.MSPointerEvent && !window.PointerEvent) {\n    POINTER_ELEMENT_EVENTS = 'MSPointerDown';\n    POINTER_WINDOW_EVENTS = 'MSPointerMove MSPointerUp MSPointerCancel';\n}\n\n/**\n * Pointer events input\n * @constructor\n * @extends Input\n */\nfunction PointerEventInput() {\n    this.evEl = POINTER_ELEMENT_EVENTS;\n    this.evWin = POINTER_WINDOW_EVENTS;\n\n    Input.apply(this, arguments);\n\n    this.store = (this.manager.session.pointerEvents = []);\n}\n\ninherit(PointerEventInput, Input, {\n    /**\n     * handle mouse events\n     * @param {Object} ev\n     */\n    handler: function PEhandler(ev) {\n        var store = this.store;\n        var removePointer = false;\n\n        var eventTypeNormalized = ev.type.toLowerCase().replace('ms', '');\n        var eventType = POINTER_INPUT_MAP[eventTypeNormalized];\n        var pointerType = IE10_POINTER_TYPE_ENUM[ev.pointerType] || ev.pointerType;\n\n        var isTouch = (pointerType == INPUT_TYPE_TOUCH);\n\n        // get index of the event in the store\n        var storeIndex = inArray(store, ev.pointerId, 'pointerId');\n\n        // start and mouse must be down\n        if (eventType & INPUT_START && (ev.button === 0 || isTouch)) {\n            if (storeIndex < 0) {\n                store.push(ev);\n                storeIndex = store.length - 1;\n            }\n        } else if (eventType & (INPUT_END | INPUT_CANCEL)) {\n            removePointer = true;\n        }\n\n        // it not found, so the pointer hasn't been down (so it's probably a hover)\n        if (storeIndex < 0) {\n            return;\n        }\n\n        // update the event in the store\n        store[storeIndex] = ev;\n\n        this.callback(this.manager, eventType, {\n            pointers: store,\n            changedPointers: [ev],\n            pointerType: pointerType,\n            srcEvent: ev\n        });\n\n        if (removePointer) {\n            // remove from the store\n            store.splice(storeIndex, 1);\n        }\n    }\n});\n\nvar SINGLE_TOUCH_INPUT_MAP = {\n    touchstart: INPUT_START,\n    touchmove: INPUT_MOVE,\n    touchend: INPUT_END,\n    touchcancel: INPUT_CANCEL\n};\n\nvar SINGLE_TOUCH_TARGET_EVENTS = 'touchstart';\nvar SINGLE_TOUCH_WINDOW_EVENTS = 'touchstart touchmove touchend touchcancel';\n\n/**\n * Touch events input\n * @constructor\n * @extends Input\n */\nfunction SingleTouchInput() {\n    this.evTarget = SINGLE_TOUCH_TARGET_EVENTS;\n    this.evWin = SINGLE_TOUCH_WINDOW_EVENTS;\n    this.started = false;\n\n    Input.apply(this, arguments);\n}\n\ninherit(SingleTouchInput, Input, {\n    handler: function TEhandler(ev) {\n        var type = SINGLE_TOUCH_INPUT_MAP[ev.type];\n\n        // should we handle the touch events?\n        if (type === INPUT_START) {\n            this.started = true;\n        }\n\n        if (!this.started) {\n            return;\n        }\n\n        var touches = normalizeSingleTouches.call(this, ev, type);\n\n        // when done, reset the started state\n        if (type & (INPUT_END | INPUT_CANCEL) && touches[0].length - touches[1].length === 0) {\n            this.started = false;\n        }\n\n        this.callback(this.manager, type, {\n            pointers: touches[0],\n            changedPointers: touches[1],\n            pointerType: INPUT_TYPE_TOUCH,\n            srcEvent: ev\n        });\n    }\n});\n\n/**\n * @this {TouchInput}\n * @param {Object} ev\n * @param {Number} type flag\n * @returns {undefined|Array} [all, changed]\n */\nfunction normalizeSingleTouches(ev, type) {\n    var all = toArray(ev.touches);\n    var changed = toArray(ev.changedTouches);\n\n    if (type & (INPUT_END | INPUT_CANCEL)) {\n        all = uniqueArray(all.concat(changed), 'identifier', true);\n    }\n\n    return [all, changed];\n}\n\nvar TOUCH_INPUT_MAP = {\n    touchstart: INPUT_START,\n    touchmove: INPUT_MOVE,\n    touchend: INPUT_END,\n    touchcancel: INPUT_CANCEL\n};\n\nvar TOUCH_TARGET_EVENTS = 'touchstart touchmove touchend touchcancel';\n\n/**\n * Multi-user touch events input\n * @constructor\n * @extends Input\n */\nfunction TouchInput() {\n    this.evTarget = TOUCH_TARGET_EVENTS;\n    this.targetIds = {};\n\n    Input.apply(this, arguments);\n}\n\ninherit(TouchInput, Input, {\n    handler: function MTEhandler(ev) {\n        var type = TOUCH_INPUT_MAP[ev.type];\n        var touches = getTouches.call(this, ev, type);\n        if (!touches) {\n            return;\n        }\n\n        this.callback(this.manager, type, {\n            pointers: touches[0],\n            changedPointers: touches[1],\n            pointerType: INPUT_TYPE_TOUCH,\n            srcEvent: ev\n        });\n    }\n});\n\n/**\n * @this {TouchInput}\n * @param {Object} ev\n * @param {Number} type flag\n * @returns {undefined|Array} [all, changed]\n */\nfunction getTouches(ev, type) {\n    var allTouches = toArray(ev.touches);\n    var targetIds = this.targetIds;\n\n    // when there is only one touch, the process can be simplified\n    if (type & (INPUT_START | INPUT_MOVE) && allTouches.length === 1) {\n        targetIds[allTouches[0].identifier] = true;\n        return [allTouches, allTouches];\n    }\n\n    var i,\n        targetTouches,\n        changedTouches = toArray(ev.changedTouches),\n        changedTargetTouches = [],\n        target = this.target;\n\n    // get target touches from touches\n    targetTouches = allTouches.filter(function(touch) {\n        return hasParent(touch.target, target);\n    });\n\n    // collect touches\n    if (type === INPUT_START) {\n        i = 0;\n        while (i < targetTouches.length) {\n            targetIds[targetTouches[i].identifier] = true;\n            i++;\n        }\n    }\n\n    // filter changed touches to only contain touches that exist in the collected target ids\n    i = 0;\n    while (i < changedTouches.length) {\n        if (targetIds[changedTouches[i].identifier]) {\n            changedTargetTouches.push(changedTouches[i]);\n        }\n\n        // cleanup removed touches\n        if (type & (INPUT_END | INPUT_CANCEL)) {\n            delete targetIds[changedTouches[i].identifier];\n        }\n        i++;\n    }\n\n    if (!changedTargetTouches.length) {\n        return;\n    }\n\n    return [\n        // merge targetTouches with changedTargetTouches so it contains ALL touches, including 'end' and 'cancel'\n        uniqueArray(targetTouches.concat(changedTargetTouches), 'identifier', true),\n        changedTargetTouches\n    ];\n}\n\n/**\n * Combined touch and mouse input\n *\n * Touch has a higher priority then mouse, and while touching no mouse events are allowed.\n * This because touch devices also emit mouse events while doing a touch.\n *\n * @constructor\n * @extends Input\n */\n\nvar DEDUP_TIMEOUT = 2500;\nvar DEDUP_DISTANCE = 25;\n\nfunction TouchMouseInput() {\n    Input.apply(this, arguments);\n\n    var handler = bindFn(this.handler, this);\n    this.touch = new TouchInput(this.manager, handler);\n    this.mouse = new MouseInput(this.manager, handler);\n\n    this.primaryTouch = null;\n    this.lastTouches = [];\n}\n\ninherit(TouchMouseInput, Input, {\n    /**\n     * handle mouse and touch events\n     * @param {Hammer} manager\n     * @param {String} inputEvent\n     * @param {Object} inputData\n     */\n    handler: function TMEhandler(manager, inputEvent, inputData) {\n        var isTouch = (inputData.pointerType == INPUT_TYPE_TOUCH),\n            isMouse = (inputData.pointerType == INPUT_TYPE_MOUSE);\n\n        if (isMouse && inputData.sourceCapabilities && inputData.sourceCapabilities.firesTouchEvents) {\n            return;\n        }\n\n        // when we're in a touch event, record touches to  de-dupe synthetic mouse event\n        if (isTouch) {\n            recordTouches.call(this, inputEvent, inputData);\n        } else if (isMouse && isSyntheticEvent.call(this, inputData)) {\n            return;\n        }\n\n        this.callback(manager, inputEvent, inputData);\n    },\n\n    /**\n     * remove the event listeners\n     */\n    destroy: function destroy() {\n        this.touch.destroy();\n        this.mouse.destroy();\n    }\n});\n\nfunction recordTouches(eventType, eventData) {\n    if (eventType & INPUT_START) {\n        this.primaryTouch = eventData.changedPointers[0].identifier;\n        setLastTouch.call(this, eventData);\n    } else if (eventType & (INPUT_END | INPUT_CANCEL)) {\n        setLastTouch.call(this, eventData);\n    }\n}\n\nfunction setLastTouch(eventData) {\n    var touch = eventData.changedPointers[0];\n\n    if (touch.identifier === this.primaryTouch) {\n        var lastTouch = {x: touch.clientX, y: touch.clientY};\n        this.lastTouches.push(lastTouch);\n        var lts = this.lastTouches;\n        var removeLastTouch = function() {\n            var i = lts.indexOf(lastTouch);\n            if (i > -1) {\n                lts.splice(i, 1);\n            }\n        };\n        setTimeout(removeLastTouch, DEDUP_TIMEOUT);\n    }\n}\n\nfunction isSyntheticEvent(eventData) {\n    var x = eventData.srcEvent.clientX, y = eventData.srcEvent.clientY;\n    for (var i = 0; i < this.lastTouches.length; i++) {\n        var t = this.lastTouches[i];\n        var dx = Math.abs(x - t.x), dy = Math.abs(y - t.y);\n        if (dx <= DEDUP_DISTANCE && dy <= DEDUP_DISTANCE) {\n            return true;\n        }\n    }\n    return false;\n}\n\nvar PREFIXED_TOUCH_ACTION = prefixed(TEST_ELEMENT.style, 'touchAction');\nvar NATIVE_TOUCH_ACTION = PREFIXED_TOUCH_ACTION !== undefined;\n\n// magical touchAction value\nvar TOUCH_ACTION_COMPUTE = 'compute';\nvar TOUCH_ACTION_AUTO = 'auto';\nvar TOUCH_ACTION_MANIPULATION = 'manipulation'; // not implemented\nvar TOUCH_ACTION_NONE = 'none';\nvar TOUCH_ACTION_PAN_X = 'pan-x';\nvar TOUCH_ACTION_PAN_Y = 'pan-y';\nvar TOUCH_ACTION_MAP = getTouchActionProps();\n\n/**\n * Touch Action\n * sets the touchAction property or uses the js alternative\n * @param {Manager} manager\n * @param {String} value\n * @constructor\n */\nfunction TouchAction(manager, value) {\n    this.manager = manager;\n    this.set(value);\n}\n\nTouchAction.prototype = {\n    /**\n     * set the touchAction value on the element or enable the polyfill\n     * @param {String} value\n     */\n    set: function(value) {\n        // find out the touch-action by the event handlers\n        if (value == TOUCH_ACTION_COMPUTE) {\n            value = this.compute();\n        }\n\n        if (NATIVE_TOUCH_ACTION && this.manager.element.style && TOUCH_ACTION_MAP[value]) {\n            this.manager.element.style[PREFIXED_TOUCH_ACTION] = value;\n        }\n        this.actions = value.toLowerCase().trim();\n    },\n\n    /**\n     * just re-set the touchAction value\n     */\n    update: function() {\n        this.set(this.manager.options.touchAction);\n    },\n\n    /**\n     * compute the value for the touchAction property based on the recognizer's settings\n     * @returns {String} value\n     */\n    compute: function() {\n        var actions = [];\n        each(this.manager.recognizers, function(recognizer) {\n            if (boolOrFn(recognizer.options.enable, [recognizer])) {\n                actions = actions.concat(recognizer.getTouchAction());\n            }\n        });\n        return cleanTouchActions(actions.join(' '));\n    },\n\n    /**\n     * this method is called on each input cycle and provides the preventing of the browser behavior\n     * @param {Object} input\n     */\n    preventDefaults: function(input) {\n        var srcEvent = input.srcEvent;\n        var direction = input.offsetDirection;\n\n        // if the touch action did prevented once this session\n        if (this.manager.session.prevented) {\n            srcEvent.preventDefault();\n            return;\n        }\n\n        var actions = this.actions;\n        var hasNone = inStr(actions, TOUCH_ACTION_NONE) && !TOUCH_ACTION_MAP[TOUCH_ACTION_NONE];\n        var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y) && !TOUCH_ACTION_MAP[TOUCH_ACTION_PAN_Y];\n        var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X) && !TOUCH_ACTION_MAP[TOUCH_ACTION_PAN_X];\n\n        if (hasNone) {\n            //do not prevent defaults if this is a tap gesture\n\n            var isTapPointer = input.pointers.length === 1;\n            var isTapMovement = input.distance < 2;\n            var isTapTouchTime = input.deltaTime < 250;\n\n            if (isTapPointer && isTapMovement && isTapTouchTime) {\n                return;\n            }\n        }\n\n        if (hasPanX && hasPanY) {\n            // `pan-x pan-y` means browser handles all scrolling/panning, do not prevent\n            return;\n        }\n\n        if (hasNone ||\n            (hasPanY && direction & DIRECTION_HORIZONTAL) ||\n            (hasPanX && direction & DIRECTION_VERTICAL)) {\n            return this.preventSrc(srcEvent);\n        }\n    },\n\n    /**\n     * call preventDefault to prevent the browser's default behavior (scrolling in most cases)\n     * @param {Object} srcEvent\n     */\n    preventSrc: function(srcEvent) {\n        this.manager.session.prevented = true;\n        srcEvent.preventDefault();\n    }\n};\n\n/**\n * when the touchActions are collected they are not a valid value, so we need to clean things up. *\n * @param {String} actions\n * @returns {*}\n */\nfunction cleanTouchActions(actions) {\n    // none\n    if (inStr(actions, TOUCH_ACTION_NONE)) {\n        return TOUCH_ACTION_NONE;\n    }\n\n    var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X);\n    var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y);\n\n    // if both pan-x and pan-y are set (different recognizers\n    // for different directions, e.g. horizontal pan but vertical swipe?)\n    // we need none (as otherwise with pan-x pan-y combined none of these\n    // recognizers will work, since the browser would handle all panning\n    if (hasPanX && hasPanY) {\n        return TOUCH_ACTION_NONE;\n    }\n\n    // pan-x OR pan-y\n    if (hasPanX || hasPanY) {\n        return hasPanX ? TOUCH_ACTION_PAN_X : TOUCH_ACTION_PAN_Y;\n    }\n\n    // manipulation\n    if (inStr(actions, TOUCH_ACTION_MANIPULATION)) {\n        return TOUCH_ACTION_MANIPULATION;\n    }\n\n    return TOUCH_ACTION_AUTO;\n}\n\nfunction getTouchActionProps() {\n    if (!NATIVE_TOUCH_ACTION) {\n        return false;\n    }\n    var touchMap = {};\n    var cssSupports = window.CSS && window.CSS.supports;\n    ['auto', 'manipulation', 'pan-y', 'pan-x', 'pan-x pan-y', 'none'].forEach(function(val) {\n\n        // If css.supports is not supported but there is native touch-action assume it supports\n        // all values. This is the case for IE 10 and 11.\n        touchMap[val] = cssSupports ? window.CSS.supports('touch-action', val) : true;\n    });\n    return touchMap;\n}\n\n/**\n * Recognizer flow explained; *\n * All recognizers have the initial state of POSSIBLE when a input session starts.\n * The definition of a input session is from the first input until the last input, with all it's movement in it. *\n * Example session for mouse-input: mousedown -> mousemove -> mouseup\n *\n * On each recognizing cycle (see Manager.recognize) the .recognize() method is executed\n * which determines with state it should be.\n *\n * If the recognizer has the state FAILED, CANCELLED or RECOGNIZED (equals ENDED), it is reset to\n * POSSIBLE to give it another change on the next cycle.\n *\n *               Possible\n *                  |\n *            +-----+---------------+\n *            |                     |\n *      +-----+-----+               |\n *      |           |               |\n *   Failed      Cancelled          |\n *                          +-------+------+\n *                          |              |\n *                      Recognized       Began\n *                                         |\n *                                      Changed\n *                                         |\n *                                  Ended/Recognized\n */\nvar STATE_POSSIBLE = 1;\nvar STATE_BEGAN = 2;\nvar STATE_CHANGED = 4;\nvar STATE_ENDED = 8;\nvar STATE_RECOGNIZED = STATE_ENDED;\nvar STATE_CANCELLED = 16;\nvar STATE_FAILED = 32;\n\n/**\n * Recognizer\n * Every recognizer needs to extend from this class.\n * @constructor\n * @param {Object} options\n */\nfunction Recognizer(options) {\n    this.options = assign({}, this.defaults, options || {});\n\n    this.id = uniqueId();\n\n    this.manager = null;\n\n    // default is enable true\n    this.options.enable = ifUndefined(this.options.enable, true);\n\n    this.state = STATE_POSSIBLE;\n\n    this.simultaneous = {};\n    this.requireFail = [];\n}\n\nRecognizer.prototype = {\n    /**\n     * @virtual\n     * @type {Object}\n     */\n    defaults: {},\n\n    /**\n     * set options\n     * @param {Object} options\n     * @return {Recognizer}\n     */\n    set: function(options) {\n        assign(this.options, options);\n\n        // also update the touchAction, in case something changed about the directions/enabled state\n        this.manager && this.manager.touchAction.update();\n        return this;\n    },\n\n    /**\n     * recognize simultaneous with an other recognizer.\n     * @param {Recognizer} otherRecognizer\n     * @returns {Recognizer} this\n     */\n    recognizeWith: function(otherRecognizer) {\n        if (invokeArrayArg(otherRecognizer, 'recognizeWith', this)) {\n            return this;\n        }\n\n        var simultaneous = this.simultaneous;\n        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);\n        if (!simultaneous[otherRecognizer.id]) {\n            simultaneous[otherRecognizer.id] = otherRecognizer;\n            otherRecognizer.recognizeWith(this);\n        }\n        return this;\n    },\n\n    /**\n     * drop the simultaneous link. it doesnt remove the link on the other recognizer.\n     * @param {Recognizer} otherRecognizer\n     * @returns {Recognizer} this\n     */\n    dropRecognizeWith: function(otherRecognizer) {\n        if (invokeArrayArg(otherRecognizer, 'dropRecognizeWith', this)) {\n            return this;\n        }\n\n        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);\n        delete this.simultaneous[otherRecognizer.id];\n        return this;\n    },\n\n    /**\n     * recognizer can only run when an other is failing\n     * @param {Recognizer} otherRecognizer\n     * @returns {Recognizer} this\n     */\n    requireFailure: function(otherRecognizer) {\n        if (invokeArrayArg(otherRecognizer, 'requireFailure', this)) {\n            return this;\n        }\n\n        var requireFail = this.requireFail;\n        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);\n        if (inArray(requireFail, otherRecognizer) === -1) {\n            requireFail.push(otherRecognizer);\n            otherRecognizer.requireFailure(this);\n        }\n        return this;\n    },\n\n    /**\n     * drop the requireFailure link. it does not remove the link on the other recognizer.\n     * @param {Recognizer} otherRecognizer\n     * @returns {Recognizer} this\n     */\n    dropRequireFailure: function(otherRecognizer) {\n        if (invokeArrayArg(otherRecognizer, 'dropRequireFailure', this)) {\n            return this;\n        }\n\n        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);\n        var index = inArray(this.requireFail, otherRecognizer);\n        if (index > -1) {\n            this.requireFail.splice(index, 1);\n        }\n        return this;\n    },\n\n    /**\n     * has require failures boolean\n     * @returns {boolean}\n     */\n    hasRequireFailures: function() {\n        return this.requireFail.length > 0;\n    },\n\n    /**\n     * if the recognizer can recognize simultaneous with an other recognizer\n     * @param {Recognizer} otherRecognizer\n     * @returns {Boolean}\n     */\n    canRecognizeWith: function(otherRecognizer) {\n        return !!this.simultaneous[otherRecognizer.id];\n    },\n\n    /**\n     * You should use `tryEmit` instead of `emit` directly to check\n     * that all the needed recognizers has failed before emitting.\n     * @param {Object} input\n     */\n    emit: function(input) {\n        var self = this;\n        var state = this.state;\n\n        function emit(event) {\n            self.manager.emit(event, input);\n        }\n\n        // 'panstart' and 'panmove'\n        if (state < STATE_ENDED) {\n            emit(self.options.event + stateStr(state));\n        }\n\n        emit(self.options.event); // simple 'eventName' events\n\n        if (input.additionalEvent) { // additional event(panleft, panright, pinchin, pinchout...)\n            emit(input.additionalEvent);\n        }\n\n        // panend and pancancel\n        if (state >= STATE_ENDED) {\n            emit(self.options.event + stateStr(state));\n        }\n    },\n\n    /**\n     * Check that all the require failure recognizers has failed,\n     * if true, it emits a gesture event,\n     * otherwise, setup the state to FAILED.\n     * @param {Object} input\n     */\n    tryEmit: function(input) {\n        if (this.canEmit()) {\n            return this.emit(input);\n        }\n        // it's failing anyway\n        this.state = STATE_FAILED;\n    },\n\n    /**\n     * can we emit?\n     * @returns {boolean}\n     */\n    canEmit: function() {\n        var i = 0;\n        while (i < this.requireFail.length) {\n            if (!(this.requireFail[i].state & (STATE_FAILED | STATE_POSSIBLE))) {\n                return false;\n            }\n            i++;\n        }\n        return true;\n    },\n\n    /**\n     * update the recognizer\n     * @param {Object} inputData\n     */\n    recognize: function(inputData) {\n        // make a new copy of the inputData\n        // so we can change the inputData without messing up the other recognizers\n        var inputDataClone = assign({}, inputData);\n\n        // is is enabled and allow recognizing?\n        if (!boolOrFn(this.options.enable, [this, inputDataClone])) {\n            this.reset();\n            this.state = STATE_FAILED;\n            return;\n        }\n\n        // reset when we've reached the end\n        if (this.state & (STATE_RECOGNIZED | STATE_CANCELLED | STATE_FAILED)) {\n            this.state = STATE_POSSIBLE;\n        }\n\n        this.state = this.process(inputDataClone);\n\n        // the recognizer has recognized a gesture\n        // so trigger an event\n        if (this.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED | STATE_CANCELLED)) {\n            this.tryEmit(inputDataClone);\n        }\n    },\n\n    /**\n     * return the state of the recognizer\n     * the actual recognizing happens in this method\n     * @virtual\n     * @param {Object} inputData\n     * @returns {Const} STATE\n     */\n    process: function(inputData) { }, // jshint ignore:line\n\n    /**\n     * return the preferred touch-action\n     * @virtual\n     * @returns {Array}\n     */\n    getTouchAction: function() { },\n\n    /**\n     * called when the gesture isn't allowed to recognize\n     * like when another is being recognized or it is disabled\n     * @virtual\n     */\n    reset: function() { }\n};\n\n/**\n * get a usable string, used as event postfix\n * @param {Const} state\n * @returns {String} state\n */\nfunction stateStr(state) {\n    if (state & STATE_CANCELLED) {\n        return 'cancel';\n    } else if (state & STATE_ENDED) {\n        return 'end';\n    } else if (state & STATE_CHANGED) {\n        return 'move';\n    } else if (state & STATE_BEGAN) {\n        return 'start';\n    }\n    return '';\n}\n\n/**\n * direction cons to string\n * @param {Const} direction\n * @returns {String}\n */\nfunction directionStr(direction) {\n    if (direction == DIRECTION_DOWN) {\n        return 'down';\n    } else if (direction == DIRECTION_UP) {\n        return 'up';\n    } else if (direction == DIRECTION_LEFT) {\n        return 'left';\n    } else if (direction == DIRECTION_RIGHT) {\n        return 'right';\n    }\n    return '';\n}\n\n/**\n * get a recognizer by name if it is bound to a manager\n * @param {Recognizer|String} otherRecognizer\n * @param {Recognizer} recognizer\n * @returns {Recognizer}\n */\nfunction getRecognizerByNameIfManager(otherRecognizer, recognizer) {\n    var manager = recognizer.manager;\n    if (manager) {\n        return manager.get(otherRecognizer);\n    }\n    return otherRecognizer;\n}\n\n/**\n * This recognizer is just used as a base for the simple attribute recognizers.\n * @constructor\n * @extends Recognizer\n */\nfunction AttrRecognizer() {\n    Recognizer.apply(this, arguments);\n}\n\ninherit(AttrRecognizer, Recognizer, {\n    /**\n     * @namespace\n     * @memberof AttrRecognizer\n     */\n    defaults: {\n        /**\n         * @type {Number}\n         * @default 1\n         */\n        pointers: 1\n    },\n\n    /**\n     * Used to check if it the recognizer receives valid input, like input.distance > 10.\n     * @memberof AttrRecognizer\n     * @param {Object} input\n     * @returns {Boolean} recognized\n     */\n    attrTest: function(input) {\n        var optionPointers = this.options.pointers;\n        return optionPointers === 0 || input.pointers.length === optionPointers;\n    },\n\n    /**\n     * Process the input and return the state for the recognizer\n     * @memberof AttrRecognizer\n     * @param {Object} input\n     * @returns {*} State\n     */\n    process: function(input) {\n        var state = this.state;\n        var eventType = input.eventType;\n\n        var isRecognized = state & (STATE_BEGAN | STATE_CHANGED);\n        var isValid = this.attrTest(input);\n\n        // on cancel input and we've recognized before, return STATE_CANCELLED\n        if (isRecognized && (eventType & INPUT_CANCEL || !isValid)) {\n            return state | STATE_CANCELLED;\n        } else if (isRecognized || isValid) {\n            if (eventType & INPUT_END) {\n                return state | STATE_ENDED;\n            } else if (!(state & STATE_BEGAN)) {\n                return STATE_BEGAN;\n            }\n            return state | STATE_CHANGED;\n        }\n        return STATE_FAILED;\n    }\n});\n\n/**\n * Pan\n * Recognized when the pointer is down and moved in the allowed direction.\n * @constructor\n * @extends AttrRecognizer\n */\nfunction PanRecognizer() {\n    AttrRecognizer.apply(this, arguments);\n\n    this.pX = null;\n    this.pY = null;\n}\n\ninherit(PanRecognizer, AttrRecognizer, {\n    /**\n     * @namespace\n     * @memberof PanRecognizer\n     */\n    defaults: {\n        event: 'pan',\n        threshold: 10,\n        pointers: 1,\n        direction: DIRECTION_ALL\n    },\n\n    getTouchAction: function() {\n        var direction = this.options.direction;\n        var actions = [];\n        if (direction & DIRECTION_HORIZONTAL) {\n            actions.push(TOUCH_ACTION_PAN_Y);\n        }\n        if (direction & DIRECTION_VERTICAL) {\n            actions.push(TOUCH_ACTION_PAN_X);\n        }\n        return actions;\n    },\n\n    directionTest: function(input) {\n        var options = this.options;\n        var hasMoved = true;\n        var distance = input.distance;\n        var direction = input.direction;\n        var x = input.deltaX;\n        var y = input.deltaY;\n\n        // lock to axis?\n        if (!(direction & options.direction)) {\n            if (options.direction & DIRECTION_HORIZONTAL) {\n                direction = (x === 0) ? DIRECTION_NONE : (x < 0) ? DIRECTION_LEFT : DIRECTION_RIGHT;\n                hasMoved = x != this.pX;\n                distance = Math.abs(input.deltaX);\n            } else {\n                direction = (y === 0) ? DIRECTION_NONE : (y < 0) ? DIRECTION_UP : DIRECTION_DOWN;\n                hasMoved = y != this.pY;\n                distance = Math.abs(input.deltaY);\n            }\n        }\n        input.direction = direction;\n        return hasMoved && distance > options.threshold && direction & options.direction;\n    },\n\n    attrTest: function(input) {\n        return AttrRecognizer.prototype.attrTest.call(this, input) &&\n            (this.state & STATE_BEGAN || (!(this.state & STATE_BEGAN) && this.directionTest(input)));\n    },\n\n    emit: function(input) {\n\n        this.pX = input.deltaX;\n        this.pY = input.deltaY;\n\n        var direction = directionStr(input.direction);\n\n        if (direction) {\n            input.additionalEvent = this.options.event + direction;\n        }\n        this._super.emit.call(this, input);\n    }\n});\n\n/**\n * Pinch\n * Recognized when two or more pointers are moving toward (zoom-in) or away from each other (zoom-out).\n * @constructor\n * @extends AttrRecognizer\n */\nfunction PinchRecognizer() {\n    AttrRecognizer.apply(this, arguments);\n}\n\ninherit(PinchRecognizer, AttrRecognizer, {\n    /**\n     * @namespace\n     * @memberof PinchRecognizer\n     */\n    defaults: {\n        event: 'pinch',\n        threshold: 0,\n        pointers: 2\n    },\n\n    getTouchAction: function() {\n        return [TOUCH_ACTION_NONE];\n    },\n\n    attrTest: function(input) {\n        return this._super.attrTest.call(this, input) &&\n            (Math.abs(input.scale - 1) > this.options.threshold || this.state & STATE_BEGAN);\n    },\n\n    emit: function(input) {\n        if (input.scale !== 1) {\n            var inOut = input.scale < 1 ? 'in' : 'out';\n            input.additionalEvent = this.options.event + inOut;\n        }\n        this._super.emit.call(this, input);\n    }\n});\n\n/**\n * Press\n * Recognized when the pointer is down for x ms without any movement.\n * @constructor\n * @extends Recognizer\n */\nfunction PressRecognizer() {\n    Recognizer.apply(this, arguments);\n\n    this._timer = null;\n    this._input = null;\n}\n\ninherit(PressRecognizer, Recognizer, {\n    /**\n     * @namespace\n     * @memberof PressRecognizer\n     */\n    defaults: {\n        event: 'press',\n        pointers: 1,\n        time: 251, // minimal time of the pointer to be pressed\n        threshold: 9 // a minimal movement is ok, but keep it low\n    },\n\n    getTouchAction: function() {\n        return [TOUCH_ACTION_AUTO];\n    },\n\n    process: function(input) {\n        var options = this.options;\n        var validPointers = input.pointers.length === options.pointers;\n        var validMovement = input.distance < options.threshold;\n        var validTime = input.deltaTime > options.time;\n\n        this._input = input;\n\n        // we only allow little movement\n        // and we've reached an end event, so a tap is possible\n        if (!validMovement || !validPointers || (input.eventType & (INPUT_END | INPUT_CANCEL) && !validTime)) {\n            this.reset();\n        } else if (input.eventType & INPUT_START) {\n            this.reset();\n            this._timer = setTimeoutContext(function() {\n                this.state = STATE_RECOGNIZED;\n                this.tryEmit();\n            }, options.time, this);\n        } else if (input.eventType & INPUT_END) {\n            return STATE_RECOGNIZED;\n        }\n        return STATE_FAILED;\n    },\n\n    reset: function() {\n        clearTimeout(this._timer);\n    },\n\n    emit: function(input) {\n        if (this.state !== STATE_RECOGNIZED) {\n            return;\n        }\n\n        if (input && (input.eventType & INPUT_END)) {\n            this.manager.emit(this.options.event + 'up', input);\n        } else {\n            this._input.timeStamp = now();\n            this.manager.emit(this.options.event, this._input);\n        }\n    }\n});\n\n/**\n * Rotate\n * Recognized when two or more pointer are moving in a circular motion.\n * @constructor\n * @extends AttrRecognizer\n */\nfunction RotateRecognizer() {\n    AttrRecognizer.apply(this, arguments);\n}\n\ninherit(RotateRecognizer, AttrRecognizer, {\n    /**\n     * @namespace\n     * @memberof RotateRecognizer\n     */\n    defaults: {\n        event: 'rotate',\n        threshold: 0,\n        pointers: 2\n    },\n\n    getTouchAction: function() {\n        return [TOUCH_ACTION_NONE];\n    },\n\n    attrTest: function(input) {\n        return this._super.attrTest.call(this, input) &&\n            (Math.abs(input.rotation) > this.options.threshold || this.state & STATE_BEGAN);\n    }\n});\n\n/**\n * Swipe\n * Recognized when the pointer is moving fast (velocity), with enough distance in the allowed direction.\n * @constructor\n * @extends AttrRecognizer\n */\nfunction SwipeRecognizer() {\n    AttrRecognizer.apply(this, arguments);\n}\n\ninherit(SwipeRecognizer, AttrRecognizer, {\n    /**\n     * @namespace\n     * @memberof SwipeRecognizer\n     */\n    defaults: {\n        event: 'swipe',\n        threshold: 10,\n        velocity: 0.3,\n        direction: DIRECTION_HORIZONTAL | DIRECTION_VERTICAL,\n        pointers: 1\n    },\n\n    getTouchAction: function() {\n        return PanRecognizer.prototype.getTouchAction.call(this);\n    },\n\n    attrTest: function(input) {\n        var direction = this.options.direction;\n        var velocity;\n\n        if (direction & (DIRECTION_HORIZONTAL | DIRECTION_VERTICAL)) {\n            velocity = input.overallVelocity;\n        } else if (direction & DIRECTION_HORIZONTAL) {\n            velocity = input.overallVelocityX;\n        } else if (direction & DIRECTION_VERTICAL) {\n            velocity = input.overallVelocityY;\n        }\n\n        return this._super.attrTest.call(this, input) &&\n            direction & input.offsetDirection &&\n            input.distance > this.options.threshold &&\n            input.maxPointers == this.options.pointers &&\n            abs(velocity) > this.options.velocity && input.eventType & INPUT_END;\n    },\n\n    emit: function(input) {\n        var direction = directionStr(input.offsetDirection);\n        if (direction) {\n            this.manager.emit(this.options.event + direction, input);\n        }\n\n        this.manager.emit(this.options.event, input);\n    }\n});\n\n/**\n * A tap is ecognized when the pointer is doing a small tap/click. Multiple taps are recognized if they occur\n * between the given interval and position. The delay option can be used to recognize multi-taps without firing\n * a single tap.\n *\n * The eventData from the emitted event contains the property `tapCount`, which contains the amount of\n * multi-taps being recognized.\n * @constructor\n * @extends Recognizer\n */\nfunction TapRecognizer() {\n    Recognizer.apply(this, arguments);\n\n    // previous time and center,\n    // used for tap counting\n    this.pTime = false;\n    this.pCenter = false;\n\n    this._timer = null;\n    this._input = null;\n    this.count = 0;\n}\n\ninherit(TapRecognizer, Recognizer, {\n    /**\n     * @namespace\n     * @memberof PinchRecognizer\n     */\n    defaults: {\n        event: 'tap',\n        pointers: 1,\n        taps: 1,\n        interval: 300, // max time between the multi-tap taps\n        time: 250, // max time of the pointer to be down (like finger on the screen)\n        threshold: 9, // a minimal movement is ok, but keep it low\n        posThreshold: 10 // a multi-tap can be a bit off the initial position\n    },\n\n    getTouchAction: function() {\n        return [TOUCH_ACTION_MANIPULATION];\n    },\n\n    process: function(input) {\n        var options = this.options;\n\n        var validPointers = input.pointers.length === options.pointers;\n        var validMovement = input.distance < options.threshold;\n        var validTouchTime = input.deltaTime < options.time;\n\n        this.reset();\n\n        if ((input.eventType & INPUT_START) && (this.count === 0)) {\n            return this.failTimeout();\n        }\n\n        // we only allow little movement\n        // and we've reached an end event, so a tap is possible\n        if (validMovement && validTouchTime && validPointers) {\n            if (input.eventType != INPUT_END) {\n                return this.failTimeout();\n            }\n\n            var validInterval = this.pTime ? (input.timeStamp - this.pTime < options.interval) : true;\n            var validMultiTap = !this.pCenter || getDistance(this.pCenter, input.center) < options.posThreshold;\n\n            this.pTime = input.timeStamp;\n            this.pCenter = input.center;\n\n            if (!validMultiTap || !validInterval) {\n                this.count = 1;\n            } else {\n                this.count += 1;\n            }\n\n            this._input = input;\n\n            // if tap count matches we have recognized it,\n            // else it has began recognizing...\n            var tapCount = this.count % options.taps;\n            if (tapCount === 0) {\n                // no failing requirements, immediately trigger the tap event\n                // or wait as long as the multitap interval to trigger\n                if (!this.hasRequireFailures()) {\n                    return STATE_RECOGNIZED;\n                } else {\n                    this._timer = setTimeoutContext(function() {\n                        this.state = STATE_RECOGNIZED;\n                        this.tryEmit();\n                    }, options.interval, this);\n                    return STATE_BEGAN;\n                }\n            }\n        }\n        return STATE_FAILED;\n    },\n\n    failTimeout: function() {\n        this._timer = setTimeoutContext(function() {\n            this.state = STATE_FAILED;\n        }, this.options.interval, this);\n        return STATE_FAILED;\n    },\n\n    reset: function() {\n        clearTimeout(this._timer);\n    },\n\n    emit: function() {\n        if (this.state == STATE_RECOGNIZED) {\n            this._input.tapCount = this.count;\n            this.manager.emit(this.options.event, this._input);\n        }\n    }\n});\n\n/**\n * Simple way to create a manager with a default set of recognizers.\n * @param {HTMLElement} element\n * @param {Object} [options]\n * @constructor\n */\nfunction Hammer(element, options) {\n    options = options || {};\n    options.recognizers = ifUndefined(options.recognizers, Hammer.defaults.preset);\n    return new Manager(element, options);\n}\n\n/**\n * @const {string}\n */\nHammer.VERSION = '2.0.7';\n\n/**\n * default settings\n * @namespace\n */\nHammer.defaults = {\n    /**\n     * set if DOM events are being triggered.\n     * But this is slower and unused by simple implementations, so disabled by default.\n     * @type {Boolean}\n     * @default false\n     */\n    domEvents: false,\n\n    /**\n     * The value for the touchAction property/fallback.\n     * When set to `compute` it will magically set the correct value based on the added recognizers.\n     * @type {String}\n     * @default compute\n     */\n    touchAction: TOUCH_ACTION_COMPUTE,\n\n    /**\n     * @type {Boolean}\n     * @default true\n     */\n    enable: true,\n\n    /**\n     * EXPERIMENTAL FEATURE -- can be removed/changed\n     * Change the parent input target element.\n     * If Null, then it is being set the to main element.\n     * @type {Null|EventTarget}\n     * @default null\n     */\n    inputTarget: null,\n\n    /**\n     * force an input class\n     * @type {Null|Function}\n     * @default null\n     */\n    inputClass: null,\n\n    /**\n     * Default recognizer setup when calling `Hammer()`\n     * When creating a new Manager these will be skipped.\n     * @type {Array}\n     */\n    preset: [\n        // RecognizerClass, options, [recognizeWith, ...], [requireFailure, ...]\n        [RotateRecognizer, {enable: false}],\n        [PinchRecognizer, {enable: false}, ['rotate']],\n        [SwipeRecognizer, {direction: DIRECTION_HORIZONTAL}],\n        [PanRecognizer, {direction: DIRECTION_HORIZONTAL}, ['swipe']],\n        [TapRecognizer],\n        [TapRecognizer, {event: 'doubletap', taps: 2}, ['tap']],\n        [PressRecognizer]\n    ],\n\n    /**\n     * Some CSS properties can be used to improve the working of Hammer.\n     * Add them to this method and they will be set when creating a new Manager.\n     * @namespace\n     */\n    cssProps: {\n        /**\n         * Disables text selection to improve the dragging gesture. Mainly for desktop browsers.\n         * @type {String}\n         * @default 'none'\n         */\n        userSelect: 'none',\n\n        /**\n         * Disable the Windows Phone grippers when pressing an element.\n         * @type {String}\n         * @default 'none'\n         */\n        touchSelect: 'none',\n\n        /**\n         * Disables the default callout shown when you touch and hold a touch target.\n         * On iOS, when you touch and hold a touch target such as a link, Safari displays\n         * a callout containing information about the link. This property allows you to disable that callout.\n         * @type {String}\n         * @default 'none'\n         */\n        touchCallout: 'none',\n\n        /**\n         * Specifies whether zooming is enabled. Used by IE10>\n         * @type {String}\n         * @default 'none'\n         */\n        contentZooming: 'none',\n\n        /**\n         * Specifies that an entire element should be draggable instead of its contents. Mainly for desktop browsers.\n         * @type {String}\n         * @default 'none'\n         */\n        userDrag: 'none',\n\n        /**\n         * Overrides the highlight color shown when the user taps a link or a JavaScript\n         * clickable element in iOS. This property obeys the alpha value, if specified.\n         * @type {String}\n         * @default 'rgba(0,0,0,0)'\n         */\n        tapHighlightColor: 'rgba(0,0,0,0)'\n    }\n};\n\nvar STOP = 1;\nvar FORCED_STOP = 2;\n\n/**\n * Manager\n * @param {HTMLElement} element\n * @param {Object} [options]\n * @constructor\n */\nfunction Manager(element, options) {\n    this.options = assign({}, Hammer.defaults, options || {});\n\n    this.options.inputTarget = this.options.inputTarget || element;\n\n    this.handlers = {};\n    this.session = {};\n    this.recognizers = [];\n    this.oldCssProps = {};\n\n    this.element = element;\n    this.input = createInputInstance(this);\n    this.touchAction = new TouchAction(this, this.options.touchAction);\n\n    toggleCssProps(this, true);\n\n    each(this.options.recognizers, function(item) {\n        var recognizer = this.add(new (item[0])(item[1]));\n        item[2] && recognizer.recognizeWith(item[2]);\n        item[3] && recognizer.requireFailure(item[3]);\n    }, this);\n}\n\nManager.prototype = {\n    /**\n     * set options\n     * @param {Object} options\n     * @returns {Manager}\n     */\n    set: function(options) {\n        assign(this.options, options);\n\n        // Options that need a little more setup\n        if (options.touchAction) {\n            this.touchAction.update();\n        }\n        if (options.inputTarget) {\n            // Clean up existing event listeners and reinitialize\n            this.input.destroy();\n            this.input.target = options.inputTarget;\n            this.input.init();\n        }\n        return this;\n    },\n\n    /**\n     * stop recognizing for this session.\n     * This session will be discarded, when a new [input]start event is fired.\n     * When forced, the recognizer cycle is stopped immediately.\n     * @param {Boolean} [force]\n     */\n    stop: function(force) {\n        this.session.stopped = force ? FORCED_STOP : STOP;\n    },\n\n    /**\n     * run the recognizers!\n     * called by the inputHandler function on every movement of the pointers (touches)\n     * it walks through all the recognizers and tries to detect the gesture that is being made\n     * @param {Object} inputData\n     */\n    recognize: function(inputData) {\n        var session = this.session;\n        if (session.stopped) {\n            return;\n        }\n\n        // run the touch-action polyfill\n        this.touchAction.preventDefaults(inputData);\n\n        var recognizer;\n        var recognizers = this.recognizers;\n\n        // this holds the recognizer that is being recognized.\n        // so the recognizer's state needs to be BEGAN, CHANGED, ENDED or RECOGNIZED\n        // if no recognizer is detecting a thing, it is set to `null`\n        var curRecognizer = session.curRecognizer;\n\n        // reset when the last recognizer is recognized\n        // or when we're in a new session\n        if (!curRecognizer || (curRecognizer && curRecognizer.state & STATE_RECOGNIZED)) {\n            curRecognizer = session.curRecognizer = null;\n        }\n\n        var i = 0;\n        while (i < recognizers.length) {\n            recognizer = recognizers[i];\n\n            // find out if we are allowed try to recognize the input for this one.\n            // 1.   allow if the session is NOT forced stopped (see the .stop() method)\n            // 2.   allow if we still haven't recognized a gesture in this session, or the this recognizer is the one\n            //      that is being recognized.\n            // 3.   allow if the recognizer is allowed to run simultaneous with the current recognized recognizer.\n            //      this can be setup with the `recognizeWith()` method on the recognizer.\n            if (session.stopped !== FORCED_STOP && ( // 1\n                    !curRecognizer || recognizer == curRecognizer || // 2\n                    recognizer.canRecognizeWith(curRecognizer))) { // 3\n                recognizer.recognize(inputData);\n            } else {\n                recognizer.reset();\n            }\n\n            // if the recognizer has been recognizing the input as a valid gesture, we want to store this one as the\n            // current active recognizer. but only if we don't already have an active recognizer\n            if (!curRecognizer && recognizer.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED)) {\n                curRecognizer = session.curRecognizer = recognizer;\n            }\n            i++;\n        }\n    },\n\n    /**\n     * get a recognizer by its event name.\n     * @param {Recognizer|String} recognizer\n     * @returns {Recognizer|Null}\n     */\n    get: function(recognizer) {\n        if (recognizer instanceof Recognizer) {\n            return recognizer;\n        }\n\n        var recognizers = this.recognizers;\n        for (var i = 0; i < recognizers.length; i++) {\n            if (recognizers[i].options.event == recognizer) {\n                return recognizers[i];\n            }\n        }\n        return null;\n    },\n\n    /**\n     * add a recognizer to the manager\n     * existing recognizers with the same event name will be removed\n     * @param {Recognizer} recognizer\n     * @returns {Recognizer|Manager}\n     */\n    add: function(recognizer) {\n        if (invokeArrayArg(recognizer, 'add', this)) {\n            return this;\n        }\n\n        // remove existing\n        var existing = this.get(recognizer.options.event);\n        if (existing) {\n            this.remove(existing);\n        }\n\n        this.recognizers.push(recognizer);\n        recognizer.manager = this;\n\n        this.touchAction.update();\n        return recognizer;\n    },\n\n    /**\n     * remove a recognizer by name or instance\n     * @param {Recognizer|String} recognizer\n     * @returns {Manager}\n     */\n    remove: function(recognizer) {\n        if (invokeArrayArg(recognizer, 'remove', this)) {\n            return this;\n        }\n\n        recognizer = this.get(recognizer);\n\n        // let's make sure this recognizer exists\n        if (recognizer) {\n            var recognizers = this.recognizers;\n            var index = inArray(recognizers, recognizer);\n\n            if (index !== -1) {\n                recognizers.splice(index, 1);\n                this.touchAction.update();\n            }\n        }\n\n        return this;\n    },\n\n    /**\n     * bind event\n     * @param {String} events\n     * @param {Function} handler\n     * @returns {EventEmitter} this\n     */\n    on: function(events, handler) {\n        if (events === undefined) {\n            return;\n        }\n        if (handler === undefined) {\n            return;\n        }\n\n        var handlers = this.handlers;\n        each(splitStr(events), function(event) {\n            handlers[event] = handlers[event] || [];\n            handlers[event].push(handler);\n        });\n        return this;\n    },\n\n    /**\n     * unbind event, leave emit blank to remove all handlers\n     * @param {String} events\n     * @param {Function} [handler]\n     * @returns {EventEmitter} this\n     */\n    off: function(events, handler) {\n        if (events === undefined) {\n            return;\n        }\n\n        var handlers = this.handlers;\n        each(splitStr(events), function(event) {\n            if (!handler) {\n                delete handlers[event];\n            } else {\n                handlers[event] && handlers[event].splice(inArray(handlers[event], handler), 1);\n            }\n        });\n        return this;\n    },\n\n    /**\n     * emit event to the listeners\n     * @param {String} event\n     * @param {Object} data\n     */\n    emit: function(event, data) {\n        // we also want to trigger dom events\n        if (this.options.domEvents) {\n            triggerDomEvent(event, data);\n        }\n\n        // no handlers, so skip it all\n        var handlers = this.handlers[event] && this.handlers[event].slice();\n        if (!handlers || !handlers.length) {\n            return;\n        }\n\n        data.type = event;\n        data.preventDefault = function() {\n            data.srcEvent.preventDefault();\n        };\n\n        var i = 0;\n        while (i < handlers.length) {\n            handlers[i](data);\n            i++;\n        }\n    },\n\n    /**\n     * destroy the manager and unbinds all events\n     * it doesn't unbind dom events, that is the user own responsibility\n     */\n    destroy: function() {\n        this.element && toggleCssProps(this, false);\n\n        this.handlers = {};\n        this.session = {};\n        this.input.destroy();\n        this.element = null;\n    }\n};\n\n/**\n * add/remove the css properties as defined in manager.options.cssProps\n * @param {Manager} manager\n * @param {Boolean} add\n */\nfunction toggleCssProps(manager, add) {\n    var element = manager.element;\n    if (!element.style) {\n        return;\n    }\n    var prop;\n    each(manager.options.cssProps, function(value, name) {\n        prop = prefixed(element.style, name);\n        if (add) {\n            manager.oldCssProps[prop] = element.style[prop];\n            element.style[prop] = value;\n        } else {\n            element.style[prop] = manager.oldCssProps[prop] || '';\n        }\n    });\n    if (!add) {\n        manager.oldCssProps = {};\n    }\n}\n\n/**\n * trigger dom event\n * @param {String} event\n * @param {Object} data\n */\nfunction triggerDomEvent(event, data) {\n    var gestureEvent = document.createEvent('Event');\n    gestureEvent.initEvent(event, true, true);\n    gestureEvent.gesture = data;\n    data.target.dispatchEvent(gestureEvent);\n}\n\nassign(Hammer, {\n    INPUT_START: INPUT_START,\n    INPUT_MOVE: INPUT_MOVE,\n    INPUT_END: INPUT_END,\n    INPUT_CANCEL: INPUT_CANCEL,\n\n    STATE_POSSIBLE: STATE_POSSIBLE,\n    STATE_BEGAN: STATE_BEGAN,\n    STATE_CHANGED: STATE_CHANGED,\n    STATE_ENDED: STATE_ENDED,\n    STATE_RECOGNIZED: STATE_RECOGNIZED,\n    STATE_CANCELLED: STATE_CANCELLED,\n    STATE_FAILED: STATE_FAILED,\n\n    DIRECTION_NONE: DIRECTION_NONE,\n    DIRECTION_LEFT: DIRECTION_LEFT,\n    DIRECTION_RIGHT: DIRECTION_RIGHT,\n    DIRECTION_UP: DIRECTION_UP,\n    DIRECTION_DOWN: DIRECTION_DOWN,\n    DIRECTION_HORIZONTAL: DIRECTION_HORIZONTAL,\n    DIRECTION_VERTICAL: DIRECTION_VERTICAL,\n    DIRECTION_ALL: DIRECTION_ALL,\n\n    Manager: Manager,\n    Input: Input,\n    TouchAction: TouchAction,\n\n    TouchInput: TouchInput,\n    MouseInput: MouseInput,\n    PointerEventInput: PointerEventInput,\n    TouchMouseInput: TouchMouseInput,\n    SingleTouchInput: SingleTouchInput,\n\n    Recognizer: Recognizer,\n    AttrRecognizer: AttrRecognizer,\n    Tap: TapRecognizer,\n    Pan: PanRecognizer,\n    Swipe: SwipeRecognizer,\n    Pinch: PinchRecognizer,\n    Rotate: RotateRecognizer,\n    Press: PressRecognizer,\n\n    on: addEventListeners,\n    off: removeEventListeners,\n    each: each,\n    merge: merge,\n    extend: extend,\n    assign: assign,\n    inherit: inherit,\n    bindFn: bindFn,\n    prefixed: prefixed\n});\n\n// this prevents errors when Hammer is loaded in the presence of an AMD\n//  style loader but by script tag, not by the loader.\nvar freeGlobal = (typeof window !== 'undefined' ? window : (typeof self !== 'undefined' ? self : {})); // jshint ignore:line\nfreeGlobal.Hammer = Hammer;\n\nif (typeof define === 'function' && define.amd) {\n    define(function() {\n        return Hammer;\n    });\n} else if (typeof module != 'undefined' && module.exports) {\n    module.exports = Hammer;\n} else {\n    window[exportName] = Hammer;\n}\n\n})(window, document, 'Hammer');\n","var hat = module.exports = function (bits, base) {\n    if (!base) base = 16;\n    if (bits === undefined) bits = 128;\n    if (bits <= 0) return '0';\n    \n    var digits = Math.log(Math.pow(2, bits)) / Math.log(base);\n    for (var i = 2; digits === Infinity; i *= 2) {\n        digits = Math.log(Math.pow(2, bits / i)) / Math.log(base) * i;\n    }\n    \n    var rem = digits - Math.floor(digits);\n    \n    var res = '';\n    \n    for (var i = 0; i < Math.floor(digits); i++) {\n        var x = Math.floor(Math.random() * base).toString(base);\n        res = x + res;\n    }\n    \n    if (rem) {\n        var b = Math.pow(base, rem);\n        var x = Math.floor(Math.random() * b).toString(base);\n        res = x + res;\n    }\n    \n    var parsed = parseInt(res, base);\n    if (parsed !== Infinity && parsed >= Math.pow(2, bits)) {\n        return hat(bits, base)\n    }\n    else return res;\n};\n\nhat.rack = function (bits, base, expandBy) {\n    var fn = function (data) {\n        var iters = 0;\n        do {\n            if (iters ++ > 10) {\n                if (expandBy) bits += expandBy;\n                else throw new Error('too many ID collisions, use more bits')\n            }\n            \n            var id = hat(bits, base);\n        } while (Object.hasOwnProperty.call(hats, id));\n        \n        hats[id] = data;\n        return id;\n    };\n    var hats = fn.hats = {};\n    \n    fn.get = function (id) {\n        return fn.hats[id];\n    };\n    \n    fn.set = function (id, value) {\n        fn.hats[id] = value;\n        return fn;\n    };\n    \n    fn.bits = bits || 128;\n    fn.base = base || 16;\n    return fn;\n};\n","'use strict';\n\nvar hat = require('hat');\n\n\n/**\n * Create a new id generator / cache instance.\n *\n * You may optionally provide a seed that is used internally.\n *\n * @param {Seed} seed\n */\nfunction Ids(seed) {\n\n  if (!(this instanceof Ids)) {\n    return new Ids(seed);\n  }\n\n  seed = seed || [ 128, 36, 1 ];\n  this._seed = seed.length ? hat.rack(seed[0], seed[1], seed[2]) : seed;\n}\n\nmodule.exports = Ids;\n\n/**\n * Generate a next id.\n *\n * @param {Object} [element] element to bind the id to\n *\n * @return {String} id\n */\nIds.prototype.next = function(element) {\n  return this._seed(element || true);\n};\n\n/**\n * Generate a next id with a given prefix.\n *\n * @param {Object} [element] element to bind the id to\n *\n * @return {String} id\n */\nIds.prototype.nextPrefixed = function(prefix, element) {\n  var id;\n\n  do {\n    id = prefix + this.next(true);\n  } while (this.assigned(id));\n\n  // claim {prefix}{random}\n  this.claim(id, element);\n\n  // return\n  return id;\n};\n\n/**\n * Manually claim an existing id.\n *\n * @param {String} id\n * @param {String} [element] element the id is claimed by\n */\nIds.prototype.claim = function(id, element) {\n  this._seed.set(id, element || true);\n};\n\n/**\n * Returns true if the given id has already been assigned.\n *\n * @param  {String} id\n * @return {Boolean}\n */\nIds.prototype.assigned = function(id) {\n  return this._seed.get(id) || false;\n};\n\n/**\n * Unclaim an id.\n *\n * @param  {String} id the id to unclaim\n */\nIds.prototype.unclaim = function(id) {\n  delete this._seed.hats[id];\n};\n\n\n/**\n * Clear all claimed ids.\n */\nIds.prototype.clear = function() {\n\n  var hats = this._seed.hats,\n      id;\n\n  for (id in hats) {\n    this.unclaim(id);\n  }\n};","if (typeof Object.create === 'function') {\n  // implementation from standard node.js 'util' module\n  module.exports = function inherits(ctor, superCtor) {\n    ctor.super_ = superCtor\n    ctor.prototype = Object.create(superCtor.prototype, {\n      constructor: {\n        value: ctor,\n        enumerable: false,\n        writable: true,\n        configurable: true\n      }\n    });\n  };\n} else {\n  // old school shim for old browsers\n  module.exports = function inherits(ctor, superCtor) {\n    ctor.super_ = superCtor\n    var TempCtor = function () {}\n    TempCtor.prototype = superCtor.prototype\n    ctor.prototype = new TempCtor()\n    ctor.prototype.constructor = ctor\n  }\n}\n","/*!\n * jQuery JavaScript Library v3.3.1\n * https://jquery.com/\n *\n * Includes Sizzle.js\n * https://sizzlejs.com/\n *\n * Copyright JS Foundation and other contributors\n * Released under the MIT license\n * https://jquery.org/license\n *\n * Date: 2018-01-20T17:24Z\n */\n( function( global, factory ) {\n\n\t\"use strict\";\n\n\tif ( typeof module === \"object\" && typeof module.exports === \"object\" ) {\n\n\t\t// For CommonJS and CommonJS-like environments where a proper `window`\n\t\t// is present, execute the factory and get jQuery.\n\t\t// For environments that do not have a `window` with a `document`\n\t\t// (such as Node.js), expose a factory as module.exports.\n\t\t// This accentuates the need for the creation of a real `window`.\n\t\t// e.g. var jQuery = require(\"jquery\")(window);\n\t\t// See ticket #14549 for more info.\n\t\tmodule.exports = global.document ?\n\t\t\tfactory( global, true ) :\n\t\t\tfunction( w ) {\n\t\t\t\tif ( !w.document ) {\n\t\t\t\t\tthrow new Error( \"jQuery requires a window with a document\" );\n\t\t\t\t}\n\t\t\t\treturn factory( w );\n\t\t\t};\n\t} else {\n\t\tfactory( global );\n\t}\n\n// Pass this if window is not defined yet\n} )( typeof window !== \"undefined\" ? window : this, function( window, noGlobal ) {\n\n// Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1\n// throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode\n// arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common\n// enough that all such attempts are guarded in a try block.\n\"use strict\";\n\nvar arr = [];\n\nvar document = window.document;\n\nvar getProto = Object.getPrototypeOf;\n\nvar slice = arr.slice;\n\nvar concat = arr.concat;\n\nvar push = arr.push;\n\nvar indexOf = arr.indexOf;\n\nvar class2type = {};\n\nvar toString = class2type.toString;\n\nvar hasOwn = class2type.hasOwnProperty;\n\nvar fnToString = hasOwn.toString;\n\nvar ObjectFunctionString = fnToString.call( Object );\n\nvar support = {};\n\nvar isFunction = function isFunction( obj ) {\n\n      // Support: Chrome <=57, Firefox <=52\n      // In some browsers, typeof returns \"function\" for HTML <object> elements\n      // (i.e., `typeof document.createElement( \"object\" ) === \"function\"`).\n      // We don't want to classify *any* DOM node as a function.\n      return typeof obj === \"function\" && typeof obj.nodeType !== \"number\";\n  };\n\n\nvar isWindow = function isWindow( obj ) {\n\t\treturn obj != null && obj === obj.window;\n\t};\n\n\n\n\n\tvar preservedScriptAttributes = {\n\t\ttype: true,\n\t\tsrc: true,\n\t\tnoModule: true\n\t};\n\n\tfunction DOMEval( code, doc, node ) {\n\t\tdoc = doc || document;\n\n\t\tvar i,\n\t\t\tscript = doc.createElement( \"script\" );\n\n\t\tscript.text = code;\n\t\tif ( node ) {\n\t\t\tfor ( i in preservedScriptAttributes ) {\n\t\t\t\tif ( node[ i ] ) {\n\t\t\t\t\tscript[ i ] = node[ i ];\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tdoc.head.appendChild( script ).parentNode.removeChild( script );\n\t}\n\n\nfunction toType( obj ) {\n\tif ( obj == null ) {\n\t\treturn obj + \"\";\n\t}\n\n\t// Support: Android <=2.3 only (functionish RegExp)\n\treturn typeof obj === \"object\" || typeof obj === \"function\" ?\n\t\tclass2type[ toString.call( obj ) ] || \"object\" :\n\t\ttypeof obj;\n}\n/* global Symbol */\n// Defining this global in .eslintrc.json would create a danger of using the global\n// unguarded in another place, it seems safer to define global only for this module\n\n\n\nvar\n\tversion = \"3.3.1\",\n\n\t// Define a local copy of jQuery\n\tjQuery = function( selector, context ) {\n\n\t\t// The jQuery object is actually just the init constructor 'enhanced'\n\t\t// Need init if jQuery is called (just allow error to be thrown if not included)\n\t\treturn new jQuery.fn.init( selector, context );\n\t},\n\n\t// Support: Android <=4.0 only\n\t// Make sure we trim BOM and NBSP\n\trtrim = /^[\\s\\uFEFF\\xA0]+|[\\s\\uFEFF\\xA0]+$/g;\n\njQuery.fn = jQuery.prototype = {\n\n\t// The current version of jQuery being used\n\tjquery: version,\n\n\tconstructor: jQuery,\n\n\t// The default length of a jQuery object is 0\n\tlength: 0,\n\n\ttoArray: function() {\n\t\treturn slice.call( this );\n\t},\n\n\t// Get the Nth element in the matched element set OR\n\t// Get the whole matched element set as a clean array\n\tget: function( num ) {\n\n\t\t// Return all the elements in a clean array\n\t\tif ( num == null ) {\n\t\t\treturn slice.call( this );\n\t\t}\n\n\t\t// Return just the one element from the set\n\t\treturn num < 0 ? this[ num + this.length ] : this[ num ];\n\t},\n\n\t// Take an array of elements and push it onto the stack\n\t// (returning the new matched element set)\n\tpushStack: function( elems ) {\n\n\t\t// Build a new jQuery matched element set\n\t\tvar ret = jQuery.merge( this.constructor(), elems );\n\n\t\t// Add the old object onto the stack (as a reference)\n\t\tret.prevObject = this;\n\n\t\t// Return the newly-formed element set\n\t\treturn ret;\n\t},\n\n\t// Execute a callback for every element in the matched set.\n\teach: function( callback ) {\n\t\treturn jQuery.each( this, callback );\n\t},\n\n\tmap: function( callback ) {\n\t\treturn this.pushStack( jQuery.map( this, function( elem, i ) {\n\t\t\treturn callback.call( elem, i, elem );\n\t\t} ) );\n\t},\n\n\tslice: function() {\n\t\treturn this.pushStack( slice.apply( this, arguments ) );\n\t},\n\n\tfirst: function() {\n\t\treturn this.eq( 0 );\n\t},\n\n\tlast: function() {\n\t\treturn this.eq( -1 );\n\t},\n\n\teq: function( i ) {\n\t\tvar len = this.length,\n\t\t\tj = +i + ( i < 0 ? len : 0 );\n\t\treturn this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );\n\t},\n\n\tend: function() {\n\t\treturn this.prevObject || this.constructor();\n\t},\n\n\t// For internal use only.\n\t// Behaves like an Array's method, not like a jQuery method.\n\tpush: push,\n\tsort: arr.sort,\n\tsplice: arr.splice\n};\n\njQuery.extend = jQuery.fn.extend = function() {\n\tvar options, name, src, copy, copyIsArray, clone,\n\t\ttarget = arguments[ 0 ] || {},\n\t\ti = 1,\n\t\tlength = arguments.length,\n\t\tdeep = false;\n\n\t// Handle a deep copy situation\n\tif ( typeof target === \"boolean\" ) {\n\t\tdeep = target;\n\n\t\t// Skip the boolean and the target\n\t\ttarget = arguments[ i ] || {};\n\t\ti++;\n\t}\n\n\t// Handle case when target is a string or something (possible in deep copy)\n\tif ( typeof target !== \"object\" && !isFunction( target ) ) {\n\t\ttarget = {};\n\t}\n\n\t// Extend jQuery itself if only one argument is passed\n\tif ( i === length ) {\n\t\ttarget = this;\n\t\ti--;\n\t}\n\n\tfor ( ; i < length; i++ ) {\n\n\t\t// Only deal with non-null/undefined values\n\t\tif ( ( options = arguments[ i ] ) != null ) {\n\n\t\t\t// Extend the base object\n\t\t\tfor ( name in options ) {\n\t\t\t\tsrc = target[ name ];\n\t\t\t\tcopy = options[ name ];\n\n\t\t\t\t// Prevent never-ending loop\n\t\t\t\tif ( target === copy ) {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\n\t\t\t\t// Recurse if we're merging plain objects or arrays\n\t\t\t\tif ( deep && copy && ( jQuery.isPlainObject( copy ) ||\n\t\t\t\t\t( copyIsArray = Array.isArray( copy ) ) ) ) {\n\n\t\t\t\t\tif ( copyIsArray ) {\n\t\t\t\t\t\tcopyIsArray = false;\n\t\t\t\t\t\tclone = src && Array.isArray( src ) ? src : [];\n\n\t\t\t\t\t} else {\n\t\t\t\t\t\tclone = src && jQuery.isPlainObject( src ) ? src : {};\n\t\t\t\t\t}\n\n\t\t\t\t\t// Never move original objects, clone them\n\t\t\t\t\ttarget[ name ] = jQuery.extend( deep, clone, copy );\n\n\t\t\t\t// Don't bring in undefined values\n\t\t\t\t} else if ( copy !== undefined ) {\n\t\t\t\t\ttarget[ name ] = copy;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// Return the modified object\n\treturn target;\n};\n\njQuery.extend( {\n\n\t// Unique for each copy of jQuery on the page\n\texpando: \"jQuery\" + ( version + Math.random() ).replace( /\\D/g, \"\" ),\n\n\t// Assume jQuery is ready without the ready module\n\tisReady: true,\n\n\terror: function( msg ) {\n\t\tthrow new Error( msg );\n\t},\n\n\tnoop: function() {},\n\n\tisPlainObject: function( obj ) {\n\t\tvar proto, Ctor;\n\n\t\t// Detect obvious negatives\n\t\t// Use toString instead of jQuery.type to catch host objects\n\t\tif ( !obj || toString.call( obj ) !== \"[object Object]\" ) {\n\t\t\treturn false;\n\t\t}\n\n\t\tproto = getProto( obj );\n\n\t\t// Objects with no prototype (e.g., `Object.create( null )`) are plain\n\t\tif ( !proto ) {\n\t\t\treturn true;\n\t\t}\n\n\t\t// Objects with prototype are plain iff they were constructed by a global Object function\n\t\tCtor = hasOwn.call( proto, \"constructor\" ) && proto.constructor;\n\t\treturn typeof Ctor === \"function\" && fnToString.call( Ctor ) === ObjectFunctionString;\n\t},\n\n\tisEmptyObject: function( obj ) {\n\n\t\t/* eslint-disable no-unused-vars */\n\t\t// See https://github.com/eslint/eslint/issues/6125\n\t\tvar name;\n\n\t\tfor ( name in obj ) {\n\t\t\treturn false;\n\t\t}\n\t\treturn true;\n\t},\n\n\t// Evaluates a script in a global context\n\tglobalEval: function( code ) {\n\t\tDOMEval( code );\n\t},\n\n\teach: function( obj, callback ) {\n\t\tvar length, i = 0;\n\n\t\tif ( isArrayLike( obj ) ) {\n\t\t\tlength = obj.length;\n\t\t\tfor ( ; i < length; i++ ) {\n\t\t\t\tif ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tfor ( i in obj ) {\n\t\t\t\tif ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn obj;\n\t},\n\n\t// Support: Android <=4.0 only\n\ttrim: function( text ) {\n\t\treturn text == null ?\n\t\t\t\"\" :\n\t\t\t( text + \"\" ).replace( rtrim, \"\" );\n\t},\n\n\t// results is for internal usage only\n\tmakeArray: function( arr, results ) {\n\t\tvar ret = results || [];\n\n\t\tif ( arr != null ) {\n\t\t\tif ( isArrayLike( Object( arr ) ) ) {\n\t\t\t\tjQuery.merge( ret,\n\t\t\t\t\ttypeof arr === \"string\" ?\n\t\t\t\t\t[ arr ] : arr\n\t\t\t\t);\n\t\t\t} else {\n\t\t\t\tpush.call( ret, arr );\n\t\t\t}\n\t\t}\n\n\t\treturn ret;\n\t},\n\n\tinArray: function( elem, arr, i ) {\n\t\treturn arr == null ? -1 : indexOf.call( arr, elem, i );\n\t},\n\n\t// Support: Android <=4.0 only, PhantomJS 1 only\n\t// push.apply(_, arraylike) throws on ancient WebKit\n\tmerge: function( first, second ) {\n\t\tvar len = +second.length,\n\t\t\tj = 0,\n\t\t\ti = first.length;\n\n\t\tfor ( ; j < len; j++ ) {\n\t\t\tfirst[ i++ ] = second[ j ];\n\t\t}\n\n\t\tfirst.length = i;\n\n\t\treturn first;\n\t},\n\n\tgrep: function( elems, callback, invert ) {\n\t\tvar callbackInverse,\n\t\t\tmatches = [],\n\t\t\ti = 0,\n\t\t\tlength = elems.length,\n\t\t\tcallbackExpect = !invert;\n\n\t\t// Go through the array, only saving the items\n\t\t// that pass the validator function\n\t\tfor ( ; i < length; i++ ) {\n\t\t\tcallbackInverse = !callback( elems[ i ], i );\n\t\t\tif ( callbackInverse !== callbackExpect ) {\n\t\t\t\tmatches.push( elems[ i ] );\n\t\t\t}\n\t\t}\n\n\t\treturn matches;\n\t},\n\n\t// arg is for internal usage only\n\tmap: function( elems, callback, arg ) {\n\t\tvar length, value,\n\t\t\ti = 0,\n\t\t\tret = [];\n\n\t\t// Go through the array, translating each of the items to their new values\n\t\tif ( isArrayLike( elems ) ) {\n\t\t\tlength = elems.length;\n\t\t\tfor ( ; i < length; i++ ) {\n\t\t\t\tvalue = callback( elems[ i ], i, arg );\n\n\t\t\t\tif ( value != null ) {\n\t\t\t\t\tret.push( value );\n\t\t\t\t}\n\t\t\t}\n\n\t\t// Go through every key on the object,\n\t\t} else {\n\t\t\tfor ( i in elems ) {\n\t\t\t\tvalue = callback( elems[ i ], i, arg );\n\n\t\t\t\tif ( value != null ) {\n\t\t\t\t\tret.push( value );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Flatten any nested arrays\n\t\treturn concat.apply( [], ret );\n\t},\n\n\t// A global GUID counter for objects\n\tguid: 1,\n\n\t// jQuery.support is not used in Core but other projects attach their\n\t// properties to it so it needs to exist.\n\tsupport: support\n} );\n\nif ( typeof Symbol === \"function\" ) {\n\tjQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];\n}\n\n// Populate the class2type map\njQuery.each( \"Boolean Number String Function Array Date RegExp Object Error Symbol\".split( \" \" ),\nfunction( i, name ) {\n\tclass2type[ \"[object \" + name + \"]\" ] = name.toLowerCase();\n} );\n\nfunction isArrayLike( obj ) {\n\n\t// Support: real iOS 8.2 only (not reproducible in simulator)\n\t// `in` check used to prevent JIT error (gh-2145)\n\t// hasOwn isn't used here due to false negatives\n\t// regarding Nodelist length in IE\n\tvar length = !!obj && \"length\" in obj && obj.length,\n\t\ttype = toType( obj );\n\n\tif ( isFunction( obj ) || isWindow( obj ) ) {\n\t\treturn false;\n\t}\n\n\treturn type === \"array\" || length === 0 ||\n\t\ttypeof length === \"number\" && length > 0 && ( length - 1 ) in obj;\n}\nvar Sizzle =\n/*!\n * Sizzle CSS Selector Engine v2.3.3\n * https://sizzlejs.com/\n *\n * Copyright jQuery Foundation and other contributors\n * Released under the MIT license\n * http://jquery.org/license\n *\n * Date: 2016-08-08\n */\n(function( window ) {\n\nvar i,\n\tsupport,\n\tExpr,\n\tgetText,\n\tisXML,\n\ttokenize,\n\tcompile,\n\tselect,\n\toutermostContext,\n\tsortInput,\n\thasDuplicate,\n\n\t// Local document vars\n\tsetDocument,\n\tdocument,\n\tdocElem,\n\tdocumentIsHTML,\n\trbuggyQSA,\n\trbuggyMatches,\n\tmatches,\n\tcontains,\n\n\t// Instance-specific data\n\texpando = \"sizzle\" + 1 * new Date(),\n\tpreferredDoc = window.document,\n\tdirruns = 0,\n\tdone = 0,\n\tclassCache = createCache(),\n\ttokenCache = createCache(),\n\tcompilerCache = createCache(),\n\tsortOrder = function( a, b ) {\n\t\tif ( a === b ) {\n\t\t\thasDuplicate = true;\n\t\t}\n\t\treturn 0;\n\t},\n\n\t// Instance methods\n\thasOwn = ({}).hasOwnProperty,\n\tarr = [],\n\tpop = arr.pop,\n\tpush_native = arr.push,\n\tpush = arr.push,\n\tslice = arr.slice,\n\t// Use a stripped-down indexOf as it's faster than native\n\t// https://jsperf.com/thor-indexof-vs-for/5\n\tindexOf = function( list, elem ) {\n\t\tvar i = 0,\n\t\t\tlen = list.length;\n\t\tfor ( ; i < len; i++ ) {\n\t\t\tif ( list[i] === elem ) {\n\t\t\t\treturn i;\n\t\t\t}\n\t\t}\n\t\treturn -1;\n\t},\n\n\tbooleans = \"checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped\",\n\n\t// Regular expressions\n\n\t// http://www.w3.org/TR/css3-selectors/#whitespace\n\twhitespace = \"[\\\\x20\\\\t\\\\r\\\\n\\\\f]\",\n\n\t// http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier\n\tidentifier = \"(?:\\\\\\\\.|[\\\\w-]|[^\\0-\\\\xa0])+\",\n\n\t// Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors\n\tattributes = \"\\\\[\" + whitespace + \"*(\" + identifier + \")(?:\" + whitespace +\n\t\t// Operator (capture 2)\n\t\t\"*([*^$|!~]?=)\" + whitespace +\n\t\t// \"Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]\"\n\t\t\"*(?:'((?:\\\\\\\\.|[^\\\\\\\\'])*)'|\\\"((?:\\\\\\\\.|[^\\\\\\\\\\\"])*)\\\"|(\" + identifier + \"))|)\" + whitespace +\n\t\t\"*\\\\]\",\n\n\tpseudos = \":(\" + identifier + \")(?:\\\\((\" +\n\t\t// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:\n\t\t// 1. quoted (capture 3; capture 4 or capture 5)\n\t\t\"('((?:\\\\\\\\.|[^\\\\\\\\'])*)'|\\\"((?:\\\\\\\\.|[^\\\\\\\\\\\"])*)\\\")|\" +\n\t\t// 2. simple (capture 6)\n\t\t\"((?:\\\\\\\\.|[^\\\\\\\\()[\\\\]]|\" + attributes + \")*)|\" +\n\t\t// 3. anything else (capture 2)\n\t\t\".*\" +\n\t\t\")\\\\)|)\",\n\n\t// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter\n\trwhitespace = new RegExp( whitespace + \"+\", \"g\" ),\n\trtrim = new RegExp( \"^\" + whitespace + \"+|((?:^|[^\\\\\\\\])(?:\\\\\\\\.)*)\" + whitespace + \"+$\", \"g\" ),\n\n\trcomma = new RegExp( \"^\" + whitespace + \"*,\" + whitespace + \"*\" ),\n\trcombinators = new RegExp( \"^\" + whitespace + \"*([>+~]|\" + whitespace + \")\" + whitespace + \"*\" ),\n\n\trattributeQuotes = new RegExp( \"=\" + whitespace + \"*([^\\\\]'\\\"]*?)\" + whitespace + \"*\\\\]\", \"g\" ),\n\n\trpseudo = new RegExp( pseudos ),\n\tridentifier = new RegExp( \"^\" + identifier + \"$\" ),\n\n\tmatchExpr = {\n\t\t\"ID\": new RegExp( \"^#(\" + identifier + \")\" ),\n\t\t\"CLASS\": new RegExp( \"^\\\\.(\" + identifier + \")\" ),\n\t\t\"TAG\": new RegExp( \"^(\" + identifier + \"|[*])\" ),\n\t\t\"ATTR\": new RegExp( \"^\" + attributes ),\n\t\t\"PSEUDO\": new RegExp( \"^\" + pseudos ),\n\t\t\"CHILD\": new RegExp( \"^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\\\(\" + whitespace +\n\t\t\t\"*(even|odd|(([+-]|)(\\\\d*)n|)\" + whitespace + \"*(?:([+-]|)\" + whitespace +\n\t\t\t\"*(\\\\d+)|))\" + whitespace + \"*\\\\)|)\", \"i\" ),\n\t\t\"bool\": new RegExp( \"^(?:\" + booleans + \")$\", \"i\" ),\n\t\t// For use in libraries implementing .is()\n\t\t// We use this for POS matching in `select`\n\t\t\"needsContext\": new RegExp( \"^\" + whitespace + \"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\\\(\" +\n\t\t\twhitespace + \"*((?:-\\\\d)?\\\\d*)\" + whitespace + \"*\\\\)|)(?=[^-]|$)\", \"i\" )\n\t},\n\n\trinputs = /^(?:input|select|textarea|button)$/i,\n\trheader = /^h\\d$/i,\n\n\trnative = /^[^{]+\\{\\s*\\[native \\w/,\n\n\t// Easily-parseable/retrievable ID or TAG or CLASS selectors\n\trquickExpr = /^(?:#([\\w-]+)|(\\w+)|\\.([\\w-]+))$/,\n\n\trsibling = /[+~]/,\n\n\t// CSS escapes\n\t// http://www.w3.org/TR/CSS21/syndata.html#escaped-characters\n\trunescape = new RegExp( \"\\\\\\\\([\\\\da-f]{1,6}\" + whitespace + \"?|(\" + whitespace + \")|.)\", \"ig\" ),\n\tfunescape = function( _, escaped, escapedWhitespace ) {\n\t\tvar high = \"0x\" + escaped - 0x10000;\n\t\t// NaN means non-codepoint\n\t\t// Support: Firefox<24\n\t\t// Workaround erroneous numeric interpretation of +\"0x\"\n\t\treturn high !== high || escapedWhitespace ?\n\t\t\tescaped :\n\t\t\thigh < 0 ?\n\t\t\t\t// BMP codepoint\n\t\t\t\tString.fromCharCode( high + 0x10000 ) :\n\t\t\t\t// Supplemental Plane codepoint (surrogate pair)\n\t\t\t\tString.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );\n\t},\n\n\t// CSS string/identifier serialization\n\t// https://drafts.csswg.org/cssom/#common-serializing-idioms\n\trcssescape = /([\\0-\\x1f\\x7f]|^-?\\d)|^-$|[^\\0-\\x1f\\x7f-\\uFFFF\\w-]/g,\n\tfcssescape = function( ch, asCodePoint ) {\n\t\tif ( asCodePoint ) {\n\n\t\t\t// U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER\n\t\t\tif ( ch === \"\\0\" ) {\n\t\t\t\treturn \"\\uFFFD\";\n\t\t\t}\n\n\t\t\t// Control characters and (dependent upon position) numbers get escaped as code points\n\t\t\treturn ch.slice( 0, -1 ) + \"\\\\\" + ch.charCodeAt( ch.length - 1 ).toString( 16 ) + \" \";\n\t\t}\n\n\t\t// Other potentially-special ASCII characters get backslash-escaped\n\t\treturn \"\\\\\" + ch;\n\t},\n\n\t// Used for iframes\n\t// See setDocument()\n\t// Removing the function wrapper causes a \"Permission Denied\"\n\t// error in IE\n\tunloadHandler = function() {\n\t\tsetDocument();\n\t},\n\n\tdisabledAncestor = addCombinator(\n\t\tfunction( elem ) {\n\t\t\treturn elem.disabled === true && (\"form\" in elem || \"label\" in elem);\n\t\t},\n\t\t{ dir: \"parentNode\", next: \"legend\" }\n\t);\n\n// Optimize for push.apply( _, NodeList )\ntry {\n\tpush.apply(\n\t\t(arr = slice.call( preferredDoc.childNodes )),\n\t\tpreferredDoc.childNodes\n\t);\n\t// Support: Android<4.0\n\t// Detect silently failing push.apply\n\tarr[ preferredDoc.childNodes.length ].nodeType;\n} catch ( e ) {\n\tpush = { apply: arr.length ?\n\n\t\t// Leverage slice if possible\n\t\tfunction( target, els ) {\n\t\t\tpush_native.apply( target, slice.call(els) );\n\t\t} :\n\n\t\t// Support: IE<9\n\t\t// Otherwise append directly\n\t\tfunction( target, els ) {\n\t\t\tvar j = target.length,\n\t\t\t\ti = 0;\n\t\t\t// Can't trust NodeList.length\n\t\t\twhile ( (target[j++] = els[i++]) ) {}\n\t\t\ttarget.length = j - 1;\n\t\t}\n\t};\n}\n\nfunction Sizzle( selector, context, results, seed ) {\n\tvar m, i, elem, nid, match, groups, newSelector,\n\t\tnewContext = context && context.ownerDocument,\n\n\t\t// nodeType defaults to 9, since context defaults to document\n\t\tnodeType = context ? context.nodeType : 9;\n\n\tresults = results || [];\n\n\t// Return early from calls with invalid selector or context\n\tif ( typeof selector !== \"string\" || !selector ||\n\t\tnodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {\n\n\t\treturn results;\n\t}\n\n\t// Try to shortcut find operations (as opposed to filters) in HTML documents\n\tif ( !seed ) {\n\n\t\tif ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) {\n\t\t\tsetDocument( context );\n\t\t}\n\t\tcontext = context || document;\n\n\t\tif ( documentIsHTML ) {\n\n\t\t\t// If the selector is sufficiently simple, try using a \"get*By*\" DOM method\n\t\t\t// (excepting DocumentFragment context, where the methods don't exist)\n\t\t\tif ( nodeType !== 11 && (match = rquickExpr.exec( selector )) ) {\n\n\t\t\t\t// ID selector\n\t\t\t\tif ( (m = match[1]) ) {\n\n\t\t\t\t\t// Document context\n\t\t\t\t\tif ( nodeType === 9 ) {\n\t\t\t\t\t\tif ( (elem = context.getElementById( m )) ) {\n\n\t\t\t\t\t\t\t// Support: IE, Opera, Webkit\n\t\t\t\t\t\t\t// TODO: identify versions\n\t\t\t\t\t\t\t// getElementById can match elements by name instead of ID\n\t\t\t\t\t\t\tif ( elem.id === m ) {\n\t\t\t\t\t\t\t\tresults.push( elem );\n\t\t\t\t\t\t\t\treturn results;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\treturn results;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t// Element context\n\t\t\t\t\t} else {\n\n\t\t\t\t\t\t// Support: IE, Opera, Webkit\n\t\t\t\t\t\t// TODO: identify versions\n\t\t\t\t\t\t// getElementById can match elements by name instead of ID\n\t\t\t\t\t\tif ( newContext && (elem = newContext.getElementById( m )) &&\n\t\t\t\t\t\t\tcontains( context, elem ) &&\n\t\t\t\t\t\t\telem.id === m ) {\n\n\t\t\t\t\t\t\tresults.push( elem );\n\t\t\t\t\t\t\treturn results;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t// Type selector\n\t\t\t\t} else if ( match[2] ) {\n\t\t\t\t\tpush.apply( results, context.getElementsByTagName( selector ) );\n\t\t\t\t\treturn results;\n\n\t\t\t\t// Class selector\n\t\t\t\t} else if ( (m = match[3]) && support.getElementsByClassName &&\n\t\t\t\t\tcontext.getElementsByClassName ) {\n\n\t\t\t\t\tpush.apply( results, context.getElementsByClassName( m ) );\n\t\t\t\t\treturn results;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Take advantage of querySelectorAll\n\t\t\tif ( support.qsa &&\n\t\t\t\t!compilerCache[ selector + \" \" ] &&\n\t\t\t\t(!rbuggyQSA || !rbuggyQSA.test( selector )) ) {\n\n\t\t\t\tif ( nodeType !== 1 ) {\n\t\t\t\t\tnewContext = context;\n\t\t\t\t\tnewSelector = selector;\n\n\t\t\t\t// qSA looks outside Element context, which is not what we want\n\t\t\t\t// Thanks to Andrew Dupont for this workaround technique\n\t\t\t\t// Support: IE <=8\n\t\t\t\t// Exclude object elements\n\t\t\t\t} else if ( context.nodeName.toLowerCase() !== \"object\" ) {\n\n\t\t\t\t\t// Capture the context ID, setting it first if necessary\n\t\t\t\t\tif ( (nid = context.getAttribute( \"id\" )) ) {\n\t\t\t\t\t\tnid = nid.replace( rcssescape, fcssescape );\n\t\t\t\t\t} else {\n\t\t\t\t\t\tcontext.setAttribute( \"id\", (nid = expando) );\n\t\t\t\t\t}\n\n\t\t\t\t\t// Prefix every selector in the list\n\t\t\t\t\tgroups = tokenize( selector );\n\t\t\t\t\ti = groups.length;\n\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\tgroups[i] = \"#\" + nid + \" \" + toSelector( groups[i] );\n\t\t\t\t\t}\n\t\t\t\t\tnewSelector = groups.join( \",\" );\n\n\t\t\t\t\t// Expand context for sibling selectors\n\t\t\t\t\tnewContext = rsibling.test( selector ) && testContext( context.parentNode ) ||\n\t\t\t\t\t\tcontext;\n\t\t\t\t}\n\n\t\t\t\tif ( newSelector ) {\n\t\t\t\t\ttry {\n\t\t\t\t\t\tpush.apply( results,\n\t\t\t\t\t\t\tnewContext.querySelectorAll( newSelector )\n\t\t\t\t\t\t);\n\t\t\t\t\t\treturn results;\n\t\t\t\t\t} catch ( qsaError ) {\n\t\t\t\t\t} finally {\n\t\t\t\t\t\tif ( nid === expando ) {\n\t\t\t\t\t\t\tcontext.removeAttribute( \"id\" );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// All others\n\treturn select( selector.replace( rtrim, \"$1\" ), context, results, seed );\n}\n\n/**\n * Create key-value caches of limited size\n * @returns {function(string, object)} Returns the Object data after storing it on itself with\n *\tproperty name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)\n *\tdeleting the oldest entry\n */\nfunction createCache() {\n\tvar keys = [];\n\n\tfunction cache( key, value ) {\n\t\t// Use (key + \" \") to avoid collision with native prototype properties (see Issue #157)\n\t\tif ( keys.push( key + \" \" ) > Expr.cacheLength ) {\n\t\t\t// Only keep the most recent entries\n\t\t\tdelete cache[ keys.shift() ];\n\t\t}\n\t\treturn (cache[ key + \" \" ] = value);\n\t}\n\treturn cache;\n}\n\n/**\n * Mark a function for special use by Sizzle\n * @param {Function} fn The function to mark\n */\nfunction markFunction( fn ) {\n\tfn[ expando ] = true;\n\treturn fn;\n}\n\n/**\n * Support testing using an element\n * @param {Function} fn Passed the created element and returns a boolean result\n */\nfunction assert( fn ) {\n\tvar el = document.createElement(\"fieldset\");\n\n\ttry {\n\t\treturn !!fn( el );\n\t} catch (e) {\n\t\treturn false;\n\t} finally {\n\t\t// Remove from its parent by default\n\t\tif ( el.parentNode ) {\n\t\t\tel.parentNode.removeChild( el );\n\t\t}\n\t\t// release memory in IE\n\t\tel = null;\n\t}\n}\n\n/**\n * Adds the same handler for all of the specified attrs\n * @param {String} attrs Pipe-separated list of attributes\n * @param {Function} handler The method that will be applied\n */\nfunction addHandle( attrs, handler ) {\n\tvar arr = attrs.split(\"|\"),\n\t\ti = arr.length;\n\n\twhile ( i-- ) {\n\t\tExpr.attrHandle[ arr[i] ] = handler;\n\t}\n}\n\n/**\n * Checks document order of two siblings\n * @param {Element} a\n * @param {Element} b\n * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b\n */\nfunction siblingCheck( a, b ) {\n\tvar cur = b && a,\n\t\tdiff = cur && a.nodeType === 1 && b.nodeType === 1 &&\n\t\t\ta.sourceIndex - b.sourceIndex;\n\n\t// Use IE sourceIndex if available on both nodes\n\tif ( diff ) {\n\t\treturn diff;\n\t}\n\n\t// Check if b follows a\n\tif ( cur ) {\n\t\twhile ( (cur = cur.nextSibling) ) {\n\t\t\tif ( cur === b ) {\n\t\t\t\treturn -1;\n\t\t\t}\n\t\t}\n\t}\n\n\treturn a ? 1 : -1;\n}\n\n/**\n * Returns a function to use in pseudos for input types\n * @param {String} type\n */\nfunction createInputPseudo( type ) {\n\treturn function( elem ) {\n\t\tvar name = elem.nodeName.toLowerCase();\n\t\treturn name === \"input\" && elem.type === type;\n\t};\n}\n\n/**\n * Returns a function to use in pseudos for buttons\n * @param {String} type\n */\nfunction createButtonPseudo( type ) {\n\treturn function( elem ) {\n\t\tvar name = elem.nodeName.toLowerCase();\n\t\treturn (name === \"input\" || name === \"button\") && elem.type === type;\n\t};\n}\n\n/**\n * Returns a function to use in pseudos for :enabled/:disabled\n * @param {Boolean} disabled true for :disabled; false for :enabled\n */\nfunction createDisabledPseudo( disabled ) {\n\n\t// Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable\n\treturn function( elem ) {\n\n\t\t// Only certain elements can match :enabled or :disabled\n\t\t// https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled\n\t\t// https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled\n\t\tif ( \"form\" in elem ) {\n\n\t\t\t// Check for inherited disabledness on relevant non-disabled elements:\n\t\t\t// * listed form-associated elements in a disabled fieldset\n\t\t\t//   https://html.spec.whatwg.org/multipage/forms.html#category-listed\n\t\t\t//   https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled\n\t\t\t// * option elements in a disabled optgroup\n\t\t\t//   https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled\n\t\t\t// All such elements have a \"form\" property.\n\t\t\tif ( elem.parentNode && elem.disabled === false ) {\n\n\t\t\t\t// Option elements defer to a parent optgroup if present\n\t\t\t\tif ( \"label\" in elem ) {\n\t\t\t\t\tif ( \"label\" in elem.parentNode ) {\n\t\t\t\t\t\treturn elem.parentNode.disabled === disabled;\n\t\t\t\t\t} else {\n\t\t\t\t\t\treturn elem.disabled === disabled;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Support: IE 6 - 11\n\t\t\t\t// Use the isDisabled shortcut property to check for disabled fieldset ancestors\n\t\t\t\treturn elem.isDisabled === disabled ||\n\n\t\t\t\t\t// Where there is no isDisabled, check manually\n\t\t\t\t\t/* jshint -W018 */\n\t\t\t\t\telem.isDisabled !== !disabled &&\n\t\t\t\t\t\tdisabledAncestor( elem ) === disabled;\n\t\t\t}\n\n\t\t\treturn elem.disabled === disabled;\n\n\t\t// Try to winnow out elements that can't be disabled before trusting the disabled property.\n\t\t// Some victims get caught in our net (label, legend, menu, track), but it shouldn't\n\t\t// even exist on them, let alone have a boolean value.\n\t\t} else if ( \"label\" in elem ) {\n\t\t\treturn elem.disabled === disabled;\n\t\t}\n\n\t\t// Remaining elements are neither :enabled nor :disabled\n\t\treturn false;\n\t};\n}\n\n/**\n * Returns a function to use in pseudos for positionals\n * @param {Function} fn\n */\nfunction createPositionalPseudo( fn ) {\n\treturn markFunction(function( argument ) {\n\t\targument = +argument;\n\t\treturn markFunction(function( seed, matches ) {\n\t\t\tvar j,\n\t\t\t\tmatchIndexes = fn( [], seed.length, argument ),\n\t\t\t\ti = matchIndexes.length;\n\n\t\t\t// Match elements found at the specified indexes\n\t\t\twhile ( i-- ) {\n\t\t\t\tif ( seed[ (j = matchIndexes[i]) ] ) {\n\t\t\t\t\tseed[j] = !(matches[j] = seed[j]);\n\t\t\t\t}\n\t\t\t}\n\t\t});\n\t});\n}\n\n/**\n * Checks a node for validity as a Sizzle context\n * @param {Element|Object=} context\n * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value\n */\nfunction testContext( context ) {\n\treturn context && typeof context.getElementsByTagName !== \"undefined\" && context;\n}\n\n// Expose support vars for convenience\nsupport = Sizzle.support = {};\n\n/**\n * Detects XML nodes\n * @param {Element|Object} elem An element or a document\n * @returns {Boolean} True iff elem is a non-HTML XML node\n */\nisXML = Sizzle.isXML = function( elem ) {\n\t// documentElement is verified for cases where it doesn't yet exist\n\t// (such as loading iframes in IE - #4833)\n\tvar documentElement = elem && (elem.ownerDocument || elem).documentElement;\n\treturn documentElement ? documentElement.nodeName !== \"HTML\" : false;\n};\n\n/**\n * Sets document-related variables once based on the current document\n * @param {Element|Object} [doc] An element or document object to use to set the document\n * @returns {Object} Returns the current document\n */\nsetDocument = Sizzle.setDocument = function( node ) {\n\tvar hasCompare, subWindow,\n\t\tdoc = node ? node.ownerDocument || node : preferredDoc;\n\n\t// Return early if doc is invalid or already selected\n\tif ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) {\n\t\treturn document;\n\t}\n\n\t// Update global variables\n\tdocument = doc;\n\tdocElem = document.documentElement;\n\tdocumentIsHTML = !isXML( document );\n\n\t// Support: IE 9-11, Edge\n\t// Accessing iframe documents after unload throws \"permission denied\" errors (jQuery #13936)\n\tif ( preferredDoc !== document &&\n\t\t(subWindow = document.defaultView) && subWindow.top !== subWindow ) {\n\n\t\t// Support: IE 11, Edge\n\t\tif ( subWindow.addEventListener ) {\n\t\t\tsubWindow.addEventListener( \"unload\", unloadHandler, false );\n\n\t\t// Support: IE 9 - 10 only\n\t\t} else if ( subWindow.attachEvent ) {\n\t\t\tsubWindow.attachEvent( \"onunload\", unloadHandler );\n\t\t}\n\t}\n\n\t/* Attributes\n\t---------------------------------------------------------------------- */\n\n\t// Support: IE<8\n\t// Verify that getAttribute really returns attributes and not properties\n\t// (excepting IE8 booleans)\n\tsupport.attributes = assert(function( el ) {\n\t\tel.className = \"i\";\n\t\treturn !el.getAttribute(\"className\");\n\t});\n\n\t/* getElement(s)By*\n\t---------------------------------------------------------------------- */\n\n\t// Check if getElementsByTagName(\"*\") returns only elements\n\tsupport.getElementsByTagName = assert(function( el ) {\n\t\tel.appendChild( document.createComment(\"\") );\n\t\treturn !el.getElementsByTagName(\"*\").length;\n\t});\n\n\t// Support: IE<9\n\tsupport.getElementsByClassName = rnative.test( document.getElementsByClassName );\n\n\t// Support: IE<10\n\t// Check if getElementById returns elements by name\n\t// The broken getElementById methods don't pick up programmatically-set names,\n\t// so use a roundabout getElementsByName test\n\tsupport.getById = assert(function( el ) {\n\t\tdocElem.appendChild( el ).id = expando;\n\t\treturn !document.getElementsByName || !document.getElementsByName( expando ).length;\n\t});\n\n\t// ID filter and find\n\tif ( support.getById ) {\n\t\tExpr.filter[\"ID\"] = function( id ) {\n\t\t\tvar attrId = id.replace( runescape, funescape );\n\t\t\treturn function( elem ) {\n\t\t\t\treturn elem.getAttribute(\"id\") === attrId;\n\t\t\t};\n\t\t};\n\t\tExpr.find[\"ID\"] = function( id, context ) {\n\t\t\tif ( typeof context.getElementById !== \"undefined\" && documentIsHTML ) {\n\t\t\t\tvar elem = context.getElementById( id );\n\t\t\t\treturn elem ? [ elem ] : [];\n\t\t\t}\n\t\t};\n\t} else {\n\t\tExpr.filter[\"ID\"] =  function( id ) {\n\t\t\tvar attrId = id.replace( runescape, funescape );\n\t\t\treturn function( elem ) {\n\t\t\t\tvar node = typeof elem.getAttributeNode !== \"undefined\" &&\n\t\t\t\t\telem.getAttributeNode(\"id\");\n\t\t\t\treturn node && node.value === attrId;\n\t\t\t};\n\t\t};\n\n\t\t// Support: IE 6 - 7 only\n\t\t// getElementById is not reliable as a find shortcut\n\t\tExpr.find[\"ID\"] = function( id, context ) {\n\t\t\tif ( typeof context.getElementById !== \"undefined\" && documentIsHTML ) {\n\t\t\t\tvar node, i, elems,\n\t\t\t\t\telem = context.getElementById( id );\n\n\t\t\t\tif ( elem ) {\n\n\t\t\t\t\t// Verify the id attribute\n\t\t\t\t\tnode = elem.getAttributeNode(\"id\");\n\t\t\t\t\tif ( node && node.value === id ) {\n\t\t\t\t\t\treturn [ elem ];\n\t\t\t\t\t}\n\n\t\t\t\t\t// Fall back on getElementsByName\n\t\t\t\t\telems = context.getElementsByName( id );\n\t\t\t\t\ti = 0;\n\t\t\t\t\twhile ( (elem = elems[i++]) ) {\n\t\t\t\t\t\tnode = elem.getAttributeNode(\"id\");\n\t\t\t\t\t\tif ( node && node.value === id ) {\n\t\t\t\t\t\t\treturn [ elem ];\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\treturn [];\n\t\t\t}\n\t\t};\n\t}\n\n\t// Tag\n\tExpr.find[\"TAG\"] = support.getElementsByTagName ?\n\t\tfunction( tag, context ) {\n\t\t\tif ( typeof context.getElementsByTagName !== \"undefined\" ) {\n\t\t\t\treturn context.getElementsByTagName( tag );\n\n\t\t\t// DocumentFragment nodes don't have gEBTN\n\t\t\t} else if ( support.qsa ) {\n\t\t\t\treturn context.querySelectorAll( tag );\n\t\t\t}\n\t\t} :\n\n\t\tfunction( tag, context ) {\n\t\t\tvar elem,\n\t\t\t\ttmp = [],\n\t\t\t\ti = 0,\n\t\t\t\t// By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too\n\t\t\t\tresults = context.getElementsByTagName( tag );\n\n\t\t\t// Filter out possible comments\n\t\t\tif ( tag === \"*\" ) {\n\t\t\t\twhile ( (elem = results[i++]) ) {\n\t\t\t\t\tif ( elem.nodeType === 1 ) {\n\t\t\t\t\t\ttmp.push( elem );\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\treturn tmp;\n\t\t\t}\n\t\t\treturn results;\n\t\t};\n\n\t// Class\n\tExpr.find[\"CLASS\"] = support.getElementsByClassName && function( className, context ) {\n\t\tif ( typeof context.getElementsByClassName !== \"undefined\" && documentIsHTML ) {\n\t\t\treturn context.getElementsByClassName( className );\n\t\t}\n\t};\n\n\t/* QSA/matchesSelector\n\t---------------------------------------------------------------------- */\n\n\t// QSA and matchesSelector support\n\n\t// matchesSelector(:active) reports false when true (IE9/Opera 11.5)\n\trbuggyMatches = [];\n\n\t// qSa(:focus) reports false when true (Chrome 21)\n\t// We allow this because of a bug in IE8/9 that throws an error\n\t// whenever `document.activeElement` is accessed on an iframe\n\t// So, we allow :focus to pass through QSA all the time to avoid the IE error\n\t// See https://bugs.jquery.com/ticket/13378\n\trbuggyQSA = [];\n\n\tif ( (support.qsa = rnative.test( document.querySelectorAll )) ) {\n\t\t// Build QSA regex\n\t\t// Regex strategy adopted from Diego Perini\n\t\tassert(function( el ) {\n\t\t\t// Select is set to empty string on purpose\n\t\t\t// This is to test IE's treatment of not explicitly\n\t\t\t// setting a boolean content attribute,\n\t\t\t// since its presence should be enough\n\t\t\t// https://bugs.jquery.com/ticket/12359\n\t\t\tdocElem.appendChild( el ).innerHTML = \"<a id='\" + expando + \"'></a>\" +\n\t\t\t\t\"<select id='\" + expando + \"-\\r\\\\' msallowcapture=''>\" +\n\t\t\t\t\"<option selected=''></option></select>\";\n\n\t\t\t// Support: IE8, Opera 11-12.16\n\t\t\t// Nothing should be selected when empty strings follow ^= or $= or *=\n\t\t\t// The test attribute must be unknown in Opera but \"safe\" for WinRT\n\t\t\t// https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section\n\t\t\tif ( el.querySelectorAll(\"[msallowcapture^='']\").length ) {\n\t\t\t\trbuggyQSA.push( \"[*^$]=\" + whitespace + \"*(?:''|\\\"\\\")\" );\n\t\t\t}\n\n\t\t\t// Support: IE8\n\t\t\t// Boolean attributes and \"value\" are not treated correctly\n\t\t\tif ( !el.querySelectorAll(\"[selected]\").length ) {\n\t\t\t\trbuggyQSA.push( \"\\\\[\" + whitespace + \"*(?:value|\" + booleans + \")\" );\n\t\t\t}\n\n\t\t\t// Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+\n\t\t\tif ( !el.querySelectorAll( \"[id~=\" + expando + \"-]\" ).length ) {\n\t\t\t\trbuggyQSA.push(\"~=\");\n\t\t\t}\n\n\t\t\t// Webkit/Opera - :checked should return selected option elements\n\t\t\t// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked\n\t\t\t// IE8 throws error here and will not see later tests\n\t\t\tif ( !el.querySelectorAll(\":checked\").length ) {\n\t\t\t\trbuggyQSA.push(\":checked\");\n\t\t\t}\n\n\t\t\t// Support: Safari 8+, iOS 8+\n\t\t\t// https://bugs.webkit.org/show_bug.cgi?id=136851\n\t\t\t// In-page `selector#id sibling-combinator selector` fails\n\t\t\tif ( !el.querySelectorAll( \"a#\" + expando + \"+*\" ).length ) {\n\t\t\t\trbuggyQSA.push(\".#.+[+~]\");\n\t\t\t}\n\t\t});\n\n\t\tassert(function( el ) {\n\t\t\tel.innerHTML = \"<a href='' disabled='disabled'></a>\" +\n\t\t\t\t\"<select disabled='disabled'><option/></select>\";\n\n\t\t\t// Support: Windows 8 Native Apps\n\t\t\t// The type and name attributes are restricted during .innerHTML assignment\n\t\t\tvar input = document.createElement(\"input\");\n\t\t\tinput.setAttribute( \"type\", \"hidden\" );\n\t\t\tel.appendChild( input ).setAttribute( \"name\", \"D\" );\n\n\t\t\t// Support: IE8\n\t\t\t// Enforce case-sensitivity of name attribute\n\t\t\tif ( el.querySelectorAll(\"[name=d]\").length ) {\n\t\t\t\trbuggyQSA.push( \"name\" + whitespace + \"*[*^$|!~]?=\" );\n\t\t\t}\n\n\t\t\t// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)\n\t\t\t// IE8 throws error here and will not see later tests\n\t\t\tif ( el.querySelectorAll(\":enabled\").length !== 2 ) {\n\t\t\t\trbuggyQSA.push( \":enabled\", \":disabled\" );\n\t\t\t}\n\n\t\t\t// Support: IE9-11+\n\t\t\t// IE's :disabled selector does not pick up the children of disabled fieldsets\n\t\t\tdocElem.appendChild( el ).disabled = true;\n\t\t\tif ( el.querySelectorAll(\":disabled\").length !== 2 ) {\n\t\t\t\trbuggyQSA.push( \":enabled\", \":disabled\" );\n\t\t\t}\n\n\t\t\t// Opera 10-11 does not throw on post-comma invalid pseudos\n\t\t\tel.querySelectorAll(\"*,:x\");\n\t\t\trbuggyQSA.push(\",.*:\");\n\t\t});\n\t}\n\n\tif ( (support.matchesSelector = rnative.test( (matches = docElem.matches ||\n\t\tdocElem.webkitMatchesSelector ||\n\t\tdocElem.mozMatchesSelector ||\n\t\tdocElem.oMatchesSelector ||\n\t\tdocElem.msMatchesSelector) )) ) {\n\n\t\tassert(function( el ) {\n\t\t\t// Check to see if it's possible to do matchesSelector\n\t\t\t// on a disconnected node (IE 9)\n\t\t\tsupport.disconnectedMatch = matches.call( el, \"*\" );\n\n\t\t\t// This should fail with an exception\n\t\t\t// Gecko does not error, returns false instead\n\t\t\tmatches.call( el, \"[s!='']:x\" );\n\t\t\trbuggyMatches.push( \"!=\", pseudos );\n\t\t});\n\t}\n\n\trbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join(\"|\") );\n\trbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join(\"|\") );\n\n\t/* Contains\n\t---------------------------------------------------------------------- */\n\thasCompare = rnative.test( docElem.compareDocumentPosition );\n\n\t// Element contains another\n\t// Purposefully self-exclusive\n\t// As in, an element does not contain itself\n\tcontains = hasCompare || rnative.test( docElem.contains ) ?\n\t\tfunction( a, b ) {\n\t\t\tvar adown = a.nodeType === 9 ? a.documentElement : a,\n\t\t\t\tbup = b && b.parentNode;\n\t\t\treturn a === bup || !!( bup && bup.nodeType === 1 && (\n\t\t\t\tadown.contains ?\n\t\t\t\t\tadown.contains( bup ) :\n\t\t\t\t\ta.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16\n\t\t\t));\n\t\t} :\n\t\tfunction( a, b ) {\n\t\t\tif ( b ) {\n\t\t\t\twhile ( (b = b.parentNode) ) {\n\t\t\t\t\tif ( b === a ) {\n\t\t\t\t\t\treturn true;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn false;\n\t\t};\n\n\t/* Sorting\n\t---------------------------------------------------------------------- */\n\n\t// Document order sorting\n\tsortOrder = hasCompare ?\n\tfunction( a, b ) {\n\n\t\t// Flag for duplicate removal\n\t\tif ( a === b ) {\n\t\t\thasDuplicate = true;\n\t\t\treturn 0;\n\t\t}\n\n\t\t// Sort on method existence if only one input has compareDocumentPosition\n\t\tvar compare = !a.compareDocumentPosition - !b.compareDocumentPosition;\n\t\tif ( compare ) {\n\t\t\treturn compare;\n\t\t}\n\n\t\t// Calculate position if both inputs belong to the same document\n\t\tcompare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ?\n\t\t\ta.compareDocumentPosition( b ) :\n\n\t\t\t// Otherwise we know they are disconnected\n\t\t\t1;\n\n\t\t// Disconnected nodes\n\t\tif ( compare & 1 ||\n\t\t\t(!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) {\n\n\t\t\t// Choose the first element that is related to our preferred document\n\t\t\tif ( a === document || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) {\n\t\t\t\treturn -1;\n\t\t\t}\n\t\t\tif ( b === document || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ) {\n\t\t\t\treturn 1;\n\t\t\t}\n\n\t\t\t// Maintain original order\n\t\t\treturn sortInput ?\n\t\t\t\t( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :\n\t\t\t\t0;\n\t\t}\n\n\t\treturn compare & 4 ? -1 : 1;\n\t} :\n\tfunction( a, b ) {\n\t\t// Exit early if the nodes are identical\n\t\tif ( a === b ) {\n\t\t\thasDuplicate = true;\n\t\t\treturn 0;\n\t\t}\n\n\t\tvar cur,\n\t\t\ti = 0,\n\t\t\taup = a.parentNode,\n\t\t\tbup = b.parentNode,\n\t\t\tap = [ a ],\n\t\t\tbp = [ b ];\n\n\t\t// Parentless nodes are either documents or disconnected\n\t\tif ( !aup || !bup ) {\n\t\t\treturn a === document ? -1 :\n\t\t\t\tb === document ? 1 :\n\t\t\t\taup ? -1 :\n\t\t\t\tbup ? 1 :\n\t\t\t\tsortInput ?\n\t\t\t\t( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :\n\t\t\t\t0;\n\n\t\t// If the nodes are siblings, we can do a quick check\n\t\t} else if ( aup === bup ) {\n\t\t\treturn siblingCheck( a, b );\n\t\t}\n\n\t\t// Otherwise we need full lists of their ancestors for comparison\n\t\tcur = a;\n\t\twhile ( (cur = cur.parentNode) ) {\n\t\t\tap.unshift( cur );\n\t\t}\n\t\tcur = b;\n\t\twhile ( (cur = cur.parentNode) ) {\n\t\t\tbp.unshift( cur );\n\t\t}\n\n\t\t// Walk down the tree looking for a discrepancy\n\t\twhile ( ap[i] === bp[i] ) {\n\t\t\ti++;\n\t\t}\n\n\t\treturn i ?\n\t\t\t// Do a sibling check if the nodes have a common ancestor\n\t\t\tsiblingCheck( ap[i], bp[i] ) :\n\n\t\t\t// Otherwise nodes in our document sort first\n\t\t\tap[i] === preferredDoc ? -1 :\n\t\t\tbp[i] === preferredDoc ? 1 :\n\t\t\t0;\n\t};\n\n\treturn document;\n};\n\nSizzle.matches = function( expr, elements ) {\n\treturn Sizzle( expr, null, null, elements );\n};\n\nSizzle.matchesSelector = function( elem, expr ) {\n\t// Set document vars if needed\n\tif ( ( elem.ownerDocument || elem ) !== document ) {\n\t\tsetDocument( elem );\n\t}\n\n\t// Make sure that attribute selectors are quoted\n\texpr = expr.replace( rattributeQuotes, \"='$1']\" );\n\n\tif ( support.matchesSelector && documentIsHTML &&\n\t\t!compilerCache[ expr + \" \" ] &&\n\t\t( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&\n\t\t( !rbuggyQSA     || !rbuggyQSA.test( expr ) ) ) {\n\n\t\ttry {\n\t\t\tvar ret = matches.call( elem, expr );\n\n\t\t\t// IE 9's matchesSelector returns false on disconnected nodes\n\t\t\tif ( ret || support.disconnectedMatch ||\n\t\t\t\t\t// As well, disconnected nodes are said to be in a document\n\t\t\t\t\t// fragment in IE 9\n\t\t\t\t\telem.document && elem.document.nodeType !== 11 ) {\n\t\t\t\treturn ret;\n\t\t\t}\n\t\t} catch (e) {}\n\t}\n\n\treturn Sizzle( expr, document, null, [ elem ] ).length > 0;\n};\n\nSizzle.contains = function( context, elem ) {\n\t// Set document vars if needed\n\tif ( ( context.ownerDocument || context ) !== document ) {\n\t\tsetDocument( context );\n\t}\n\treturn contains( context, elem );\n};\n\nSizzle.attr = function( elem, name ) {\n\t// Set document vars if needed\n\tif ( ( elem.ownerDocument || elem ) !== document ) {\n\t\tsetDocument( elem );\n\t}\n\n\tvar fn = Expr.attrHandle[ name.toLowerCase() ],\n\t\t// Don't get fooled by Object.prototype properties (jQuery #13807)\n\t\tval = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?\n\t\t\tfn( elem, name, !documentIsHTML ) :\n\t\t\tundefined;\n\n\treturn val !== undefined ?\n\t\tval :\n\t\tsupport.attributes || !documentIsHTML ?\n\t\t\telem.getAttribute( name ) :\n\t\t\t(val = elem.getAttributeNode(name)) && val.specified ?\n\t\t\t\tval.value :\n\t\t\t\tnull;\n};\n\nSizzle.escape = function( sel ) {\n\treturn (sel + \"\").replace( rcssescape, fcssescape );\n};\n\nSizzle.error = function( msg ) {\n\tthrow new Error( \"Syntax error, unrecognized expression: \" + msg );\n};\n\n/**\n * Document sorting and removing duplicates\n * @param {ArrayLike} results\n */\nSizzle.uniqueSort = function( results ) {\n\tvar elem,\n\t\tduplicates = [],\n\t\tj = 0,\n\t\ti = 0;\n\n\t// Unless we *know* we can detect duplicates, assume their presence\n\thasDuplicate = !support.detectDuplicates;\n\tsortInput = !support.sortStable && results.slice( 0 );\n\tresults.sort( sortOrder );\n\n\tif ( hasDuplicate ) {\n\t\twhile ( (elem = results[i++]) ) {\n\t\t\tif ( elem === results[ i ] ) {\n\t\t\t\tj = duplicates.push( i );\n\t\t\t}\n\t\t}\n\t\twhile ( j-- ) {\n\t\t\tresults.splice( duplicates[ j ], 1 );\n\t\t}\n\t}\n\n\t// Clear input after sorting to release objects\n\t// See https://github.com/jquery/sizzle/pull/225\n\tsortInput = null;\n\n\treturn results;\n};\n\n/**\n * Utility function for retrieving the text value of an array of DOM nodes\n * @param {Array|Element} elem\n */\ngetText = Sizzle.getText = function( elem ) {\n\tvar node,\n\t\tret = \"\",\n\t\ti = 0,\n\t\tnodeType = elem.nodeType;\n\n\tif ( !nodeType ) {\n\t\t// If no nodeType, this is expected to be an array\n\t\twhile ( (node = elem[i++]) ) {\n\t\t\t// Do not traverse comment nodes\n\t\t\tret += getText( node );\n\t\t}\n\t} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {\n\t\t// Use textContent for elements\n\t\t// innerText usage removed for consistency of new lines (jQuery #11153)\n\t\tif ( typeof elem.textContent === \"string\" ) {\n\t\t\treturn elem.textContent;\n\t\t} else {\n\t\t\t// Traverse its children\n\t\t\tfor ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {\n\t\t\t\tret += getText( elem );\n\t\t\t}\n\t\t}\n\t} else if ( nodeType === 3 || nodeType === 4 ) {\n\t\treturn elem.nodeValue;\n\t}\n\t// Do not include comment or processing instruction nodes\n\n\treturn ret;\n};\n\nExpr = Sizzle.selectors = {\n\n\t// Can be adjusted by the user\n\tcacheLength: 50,\n\n\tcreatePseudo: markFunction,\n\n\tmatch: matchExpr,\n\n\tattrHandle: {},\n\n\tfind: {},\n\n\trelative: {\n\t\t\">\": { dir: \"parentNode\", first: true },\n\t\t\" \": { dir: \"parentNode\" },\n\t\t\"+\": { dir: \"previousSibling\", first: true },\n\t\t\"~\": { dir: \"previousSibling\" }\n\t},\n\n\tpreFilter: {\n\t\t\"ATTR\": function( match ) {\n\t\t\tmatch[1] = match[1].replace( runescape, funescape );\n\n\t\t\t// Move the given value to match[3] whether quoted or unquoted\n\t\t\tmatch[3] = ( match[3] || match[4] || match[5] || \"\" ).replace( runescape, funescape );\n\n\t\t\tif ( match[2] === \"~=\" ) {\n\t\t\t\tmatch[3] = \" \" + match[3] + \" \";\n\t\t\t}\n\n\t\t\treturn match.slice( 0, 4 );\n\t\t},\n\n\t\t\"CHILD\": function( match ) {\n\t\t\t/* matches from matchExpr[\"CHILD\"]\n\t\t\t\t1 type (only|nth|...)\n\t\t\t\t2 what (child|of-type)\n\t\t\t\t3 argument (even|odd|\\d*|\\d*n([+-]\\d+)?|...)\n\t\t\t\t4 xn-component of xn+y argument ([+-]?\\d*n|)\n\t\t\t\t5 sign of xn-component\n\t\t\t\t6 x of xn-component\n\t\t\t\t7 sign of y-component\n\t\t\t\t8 y of y-component\n\t\t\t*/\n\t\t\tmatch[1] = match[1].toLowerCase();\n\n\t\t\tif ( match[1].slice( 0, 3 ) === \"nth\" ) {\n\t\t\t\t// nth-* requires argument\n\t\t\t\tif ( !match[3] ) {\n\t\t\t\t\tSizzle.error( match[0] );\n\t\t\t\t}\n\n\t\t\t\t// numeric x and y parameters for Expr.filter.CHILD\n\t\t\t\t// remember that false/true cast respectively to 0/1\n\t\t\t\tmatch[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === \"even\" || match[3] === \"odd\" ) );\n\t\t\t\tmatch[5] = +( ( match[7] + match[8] ) || match[3] === \"odd\" );\n\n\t\t\t// other types prohibit arguments\n\t\t\t} else if ( match[3] ) {\n\t\t\t\tSizzle.error( match[0] );\n\t\t\t}\n\n\t\t\treturn match;\n\t\t},\n\n\t\t\"PSEUDO\": function( match ) {\n\t\t\tvar excess,\n\t\t\t\tunquoted = !match[6] && match[2];\n\n\t\t\tif ( matchExpr[\"CHILD\"].test( match[0] ) ) {\n\t\t\t\treturn null;\n\t\t\t}\n\n\t\t\t// Accept quoted arguments as-is\n\t\t\tif ( match[3] ) {\n\t\t\t\tmatch[2] = match[4] || match[5] || \"\";\n\n\t\t\t// Strip excess characters from unquoted arguments\n\t\t\t} else if ( unquoted && rpseudo.test( unquoted ) &&\n\t\t\t\t// Get excess from tokenize (recursively)\n\t\t\t\t(excess = tokenize( unquoted, true )) &&\n\t\t\t\t// advance to the next closing parenthesis\n\t\t\t\t(excess = unquoted.indexOf( \")\", unquoted.length - excess ) - unquoted.length) ) {\n\n\t\t\t\t// excess is a negative index\n\t\t\t\tmatch[0] = match[0].slice( 0, excess );\n\t\t\t\tmatch[2] = unquoted.slice( 0, excess );\n\t\t\t}\n\n\t\t\t// Return only captures needed by the pseudo filter method (type and argument)\n\t\t\treturn match.slice( 0, 3 );\n\t\t}\n\t},\n\n\tfilter: {\n\n\t\t\"TAG\": function( nodeNameSelector ) {\n\t\t\tvar nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();\n\t\t\treturn nodeNameSelector === \"*\" ?\n\t\t\t\tfunction() { return true; } :\n\t\t\t\tfunction( elem ) {\n\t\t\t\t\treturn elem.nodeName && elem.nodeName.toLowerCase() === nodeName;\n\t\t\t\t};\n\t\t},\n\n\t\t\"CLASS\": function( className ) {\n\t\t\tvar pattern = classCache[ className + \" \" ];\n\n\t\t\treturn pattern ||\n\t\t\t\t(pattern = new RegExp( \"(^|\" + whitespace + \")\" + className + \"(\" + whitespace + \"|$)\" )) &&\n\t\t\t\tclassCache( className, function( elem ) {\n\t\t\t\t\treturn pattern.test( typeof elem.className === \"string\" && elem.className || typeof elem.getAttribute !== \"undefined\" && elem.getAttribute(\"class\") || \"\" );\n\t\t\t\t});\n\t\t},\n\n\t\t\"ATTR\": function( name, operator, check ) {\n\t\t\treturn function( elem ) {\n\t\t\t\tvar result = Sizzle.attr( elem, name );\n\n\t\t\t\tif ( result == null ) {\n\t\t\t\t\treturn operator === \"!=\";\n\t\t\t\t}\n\t\t\t\tif ( !operator ) {\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\n\t\t\t\tresult += \"\";\n\n\t\t\t\treturn operator === \"=\" ? result === check :\n\t\t\t\t\toperator === \"!=\" ? result !== check :\n\t\t\t\t\toperator === \"^=\" ? check && result.indexOf( check ) === 0 :\n\t\t\t\t\toperator === \"*=\" ? check && result.indexOf( check ) > -1 :\n\t\t\t\t\toperator === \"$=\" ? check && result.slice( -check.length ) === check :\n\t\t\t\t\toperator === \"~=\" ? ( \" \" + result.replace( rwhitespace, \" \" ) + \" \" ).indexOf( check ) > -1 :\n\t\t\t\t\toperator === \"|=\" ? result === check || result.slice( 0, check.length + 1 ) === check + \"-\" :\n\t\t\t\t\tfalse;\n\t\t\t};\n\t\t},\n\n\t\t\"CHILD\": function( type, what, argument, first, last ) {\n\t\t\tvar simple = type.slice( 0, 3 ) !== \"nth\",\n\t\t\t\tforward = type.slice( -4 ) !== \"last\",\n\t\t\t\tofType = what === \"of-type\";\n\n\t\t\treturn first === 1 && last === 0 ?\n\n\t\t\t\t// Shortcut for :nth-*(n)\n\t\t\t\tfunction( elem ) {\n\t\t\t\t\treturn !!elem.parentNode;\n\t\t\t\t} :\n\n\t\t\t\tfunction( elem, context, xml ) {\n\t\t\t\t\tvar cache, uniqueCache, outerCache, node, nodeIndex, start,\n\t\t\t\t\t\tdir = simple !== forward ? \"nextSibling\" : \"previousSibling\",\n\t\t\t\t\t\tparent = elem.parentNode,\n\t\t\t\t\t\tname = ofType && elem.nodeName.toLowerCase(),\n\t\t\t\t\t\tuseCache = !xml && !ofType,\n\t\t\t\t\t\tdiff = false;\n\n\t\t\t\t\tif ( parent ) {\n\n\t\t\t\t\t\t// :(first|last|only)-(child|of-type)\n\t\t\t\t\t\tif ( simple ) {\n\t\t\t\t\t\t\twhile ( dir ) {\n\t\t\t\t\t\t\t\tnode = elem;\n\t\t\t\t\t\t\t\twhile ( (node = node[ dir ]) ) {\n\t\t\t\t\t\t\t\t\tif ( ofType ?\n\t\t\t\t\t\t\t\t\t\tnode.nodeName.toLowerCase() === name :\n\t\t\t\t\t\t\t\t\t\tnode.nodeType === 1 ) {\n\n\t\t\t\t\t\t\t\t\t\treturn false;\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t// Reverse direction for :only-* (if we haven't yet done so)\n\t\t\t\t\t\t\t\tstart = dir = type === \"only\" && !start && \"nextSibling\";\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\treturn true;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tstart = [ forward ? parent.firstChild : parent.lastChild ];\n\n\t\t\t\t\t\t// non-xml :nth-child(...) stores cache data on `parent`\n\t\t\t\t\t\tif ( forward && useCache ) {\n\n\t\t\t\t\t\t\t// Seek `elem` from a previously-cached index\n\n\t\t\t\t\t\t\t// ...in a gzip-friendly way\n\t\t\t\t\t\t\tnode = parent;\n\t\t\t\t\t\t\touterCache = node[ expando ] || (node[ expando ] = {});\n\n\t\t\t\t\t\t\t// Support: IE <9 only\n\t\t\t\t\t\t\t// Defend against cloned attroperties (jQuery gh-1709)\n\t\t\t\t\t\t\tuniqueCache = outerCache[ node.uniqueID ] ||\n\t\t\t\t\t\t\t\t(outerCache[ node.uniqueID ] = {});\n\n\t\t\t\t\t\t\tcache = uniqueCache[ type ] || [];\n\t\t\t\t\t\t\tnodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];\n\t\t\t\t\t\t\tdiff = nodeIndex && cache[ 2 ];\n\t\t\t\t\t\t\tnode = nodeIndex && parent.childNodes[ nodeIndex ];\n\n\t\t\t\t\t\t\twhile ( (node = ++nodeIndex && node && node[ dir ] ||\n\n\t\t\t\t\t\t\t\t// Fallback to seeking `elem` from the start\n\t\t\t\t\t\t\t\t(diff = nodeIndex = 0) || start.pop()) ) {\n\n\t\t\t\t\t\t\t\t// When found, cache indexes on `parent` and break\n\t\t\t\t\t\t\t\tif ( node.nodeType === 1 && ++diff && node === elem ) {\n\t\t\t\t\t\t\t\t\tuniqueCache[ type ] = [ dirruns, nodeIndex, diff ];\n\t\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t// Use previously-cached element index if available\n\t\t\t\t\t\t\tif ( useCache ) {\n\t\t\t\t\t\t\t\t// ...in a gzip-friendly way\n\t\t\t\t\t\t\t\tnode = elem;\n\t\t\t\t\t\t\t\touterCache = node[ expando ] || (node[ expando ] = {});\n\n\t\t\t\t\t\t\t\t// Support: IE <9 only\n\t\t\t\t\t\t\t\t// Defend against cloned attroperties (jQuery gh-1709)\n\t\t\t\t\t\t\t\tuniqueCache = outerCache[ node.uniqueID ] ||\n\t\t\t\t\t\t\t\t\t(outerCache[ node.uniqueID ] = {});\n\n\t\t\t\t\t\t\t\tcache = uniqueCache[ type ] || [];\n\t\t\t\t\t\t\t\tnodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];\n\t\t\t\t\t\t\t\tdiff = nodeIndex;\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t// xml :nth-child(...)\n\t\t\t\t\t\t\t// or :nth-last-child(...) or :nth(-last)?-of-type(...)\n\t\t\t\t\t\t\tif ( diff === false ) {\n\t\t\t\t\t\t\t\t// Use the same loop as above to seek `elem` from the start\n\t\t\t\t\t\t\t\twhile ( (node = ++nodeIndex && node && node[ dir ] ||\n\t\t\t\t\t\t\t\t\t(diff = nodeIndex = 0) || start.pop()) ) {\n\n\t\t\t\t\t\t\t\t\tif ( ( ofType ?\n\t\t\t\t\t\t\t\t\t\tnode.nodeName.toLowerCase() === name :\n\t\t\t\t\t\t\t\t\t\tnode.nodeType === 1 ) &&\n\t\t\t\t\t\t\t\t\t\t++diff ) {\n\n\t\t\t\t\t\t\t\t\t\t// Cache the index of each encountered element\n\t\t\t\t\t\t\t\t\t\tif ( useCache ) {\n\t\t\t\t\t\t\t\t\t\t\touterCache = node[ expando ] || (node[ expando ] = {});\n\n\t\t\t\t\t\t\t\t\t\t\t// Support: IE <9 only\n\t\t\t\t\t\t\t\t\t\t\t// Defend against cloned attroperties (jQuery gh-1709)\n\t\t\t\t\t\t\t\t\t\t\tuniqueCache = outerCache[ node.uniqueID ] ||\n\t\t\t\t\t\t\t\t\t\t\t\t(outerCache[ node.uniqueID ] = {});\n\n\t\t\t\t\t\t\t\t\t\t\tuniqueCache[ type ] = [ dirruns, diff ];\n\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t\tif ( node === elem ) {\n\t\t\t\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Incorporate the offset, then check against cycle size\n\t\t\t\t\t\tdiff -= last;\n\t\t\t\t\t\treturn diff === first || ( diff % first === 0 && diff / first >= 0 );\n\t\t\t\t\t}\n\t\t\t\t};\n\t\t},\n\n\t\t\"PSEUDO\": function( pseudo, argument ) {\n\t\t\t// pseudo-class names are case-insensitive\n\t\t\t// http://www.w3.org/TR/selectors/#pseudo-classes\n\t\t\t// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters\n\t\t\t// Remember that setFilters inherits from pseudos\n\t\t\tvar args,\n\t\t\t\tfn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||\n\t\t\t\t\tSizzle.error( \"unsupported pseudo: \" + pseudo );\n\n\t\t\t// The user may use createPseudo to indicate that\n\t\t\t// arguments are needed to create the filter function\n\t\t\t// just as Sizzle does\n\t\t\tif ( fn[ expando ] ) {\n\t\t\t\treturn fn( argument );\n\t\t\t}\n\n\t\t\t// But maintain support for old signatures\n\t\t\tif ( fn.length > 1 ) {\n\t\t\t\targs = [ pseudo, pseudo, \"\", argument ];\n\t\t\t\treturn Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?\n\t\t\t\t\tmarkFunction(function( seed, matches ) {\n\t\t\t\t\t\tvar idx,\n\t\t\t\t\t\t\tmatched = fn( seed, argument ),\n\t\t\t\t\t\t\ti = matched.length;\n\t\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\t\tidx = indexOf( seed, matched[i] );\n\t\t\t\t\t\t\tseed[ idx ] = !( matches[ idx ] = matched[i] );\n\t\t\t\t\t\t}\n\t\t\t\t\t}) :\n\t\t\t\t\tfunction( elem ) {\n\t\t\t\t\t\treturn fn( elem, 0, args );\n\t\t\t\t\t};\n\t\t\t}\n\n\t\t\treturn fn;\n\t\t}\n\t},\n\n\tpseudos: {\n\t\t// Potentially complex pseudos\n\t\t\"not\": markFunction(function( selector ) {\n\t\t\t// Trim the selector passed to compile\n\t\t\t// to avoid treating leading and trailing\n\t\t\t// spaces as combinators\n\t\t\tvar input = [],\n\t\t\t\tresults = [],\n\t\t\t\tmatcher = compile( selector.replace( rtrim, \"$1\" ) );\n\n\t\t\treturn matcher[ expando ] ?\n\t\t\t\tmarkFunction(function( seed, matches, context, xml ) {\n\t\t\t\t\tvar elem,\n\t\t\t\t\t\tunmatched = matcher( seed, null, xml, [] ),\n\t\t\t\t\t\ti = seed.length;\n\n\t\t\t\t\t// Match elements unmatched by `matcher`\n\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\tif ( (elem = unmatched[i]) ) {\n\t\t\t\t\t\t\tseed[i] = !(matches[i] = elem);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}) :\n\t\t\t\tfunction( elem, context, xml ) {\n\t\t\t\t\tinput[0] = elem;\n\t\t\t\t\tmatcher( input, null, xml, results );\n\t\t\t\t\t// Don't keep the element (issue #299)\n\t\t\t\t\tinput[0] = null;\n\t\t\t\t\treturn !results.pop();\n\t\t\t\t};\n\t\t}),\n\n\t\t\"has\": markFunction(function( selector ) {\n\t\t\treturn function( elem ) {\n\t\t\t\treturn Sizzle( selector, elem ).length > 0;\n\t\t\t};\n\t\t}),\n\n\t\t\"contains\": markFunction(function( text ) {\n\t\t\ttext = text.replace( runescape, funescape );\n\t\t\treturn function( elem ) {\n\t\t\t\treturn ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1;\n\t\t\t};\n\t\t}),\n\n\t\t// \"Whether an element is represented by a :lang() selector\n\t\t// is based solely on the element's language value\n\t\t// being equal to the identifier C,\n\t\t// or beginning with the identifier C immediately followed by \"-\".\n\t\t// The matching of C against the element's language value is performed case-insensitively.\n\t\t// The identifier C does not have to be a valid language name.\"\n\t\t// http://www.w3.org/TR/selectors/#lang-pseudo\n\t\t\"lang\": markFunction( function( lang ) {\n\t\t\t// lang value must be a valid identifier\n\t\t\tif ( !ridentifier.test(lang || \"\") ) {\n\t\t\t\tSizzle.error( \"unsupported lang: \" + lang );\n\t\t\t}\n\t\t\tlang = lang.replace( runescape, funescape ).toLowerCase();\n\t\t\treturn function( elem ) {\n\t\t\t\tvar elemLang;\n\t\t\t\tdo {\n\t\t\t\t\tif ( (elemLang = documentIsHTML ?\n\t\t\t\t\t\telem.lang :\n\t\t\t\t\t\telem.getAttribute(\"xml:lang\") || elem.getAttribute(\"lang\")) ) {\n\n\t\t\t\t\t\telemLang = elemLang.toLowerCase();\n\t\t\t\t\t\treturn elemLang === lang || elemLang.indexOf( lang + \"-\" ) === 0;\n\t\t\t\t\t}\n\t\t\t\t} while ( (elem = elem.parentNode) && elem.nodeType === 1 );\n\t\t\t\treturn false;\n\t\t\t};\n\t\t}),\n\n\t\t// Miscellaneous\n\t\t\"target\": function( elem ) {\n\t\t\tvar hash = window.location && window.location.hash;\n\t\t\treturn hash && hash.slice( 1 ) === elem.id;\n\t\t},\n\n\t\t\"root\": function( elem ) {\n\t\t\treturn elem === docElem;\n\t\t},\n\n\t\t\"focus\": function( elem ) {\n\t\t\treturn elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);\n\t\t},\n\n\t\t// Boolean properties\n\t\t\"enabled\": createDisabledPseudo( false ),\n\t\t\"disabled\": createDisabledPseudo( true ),\n\n\t\t\"checked\": function( elem ) {\n\t\t\t// In CSS3, :checked should return both checked and selected elements\n\t\t\t// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked\n\t\t\tvar nodeName = elem.nodeName.toLowerCase();\n\t\t\treturn (nodeName === \"input\" && !!elem.checked) || (nodeName === \"option\" && !!elem.selected);\n\t\t},\n\n\t\t\"selected\": function( elem ) {\n\t\t\t// Accessing this property makes selected-by-default\n\t\t\t// options in Safari work properly\n\t\t\tif ( elem.parentNode ) {\n\t\t\t\telem.parentNode.selectedIndex;\n\t\t\t}\n\n\t\t\treturn elem.selected === true;\n\t\t},\n\n\t\t// Contents\n\t\t\"empty\": function( elem ) {\n\t\t\t// http://www.w3.org/TR/selectors/#empty-pseudo\n\t\t\t// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),\n\t\t\t//   but not by others (comment: 8; processing instruction: 7; etc.)\n\t\t\t// nodeType < 6 works because attributes (2) do not appear as children\n\t\t\tfor ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {\n\t\t\t\tif ( elem.nodeType < 6 ) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn true;\n\t\t},\n\n\t\t\"parent\": function( elem ) {\n\t\t\treturn !Expr.pseudos[\"empty\"]( elem );\n\t\t},\n\n\t\t// Element/input types\n\t\t\"header\": function( elem ) {\n\t\t\treturn rheader.test( elem.nodeName );\n\t\t},\n\n\t\t\"input\": function( elem ) {\n\t\t\treturn rinputs.test( elem.nodeName );\n\t\t},\n\n\t\t\"button\": function( elem ) {\n\t\t\tvar name = elem.nodeName.toLowerCase();\n\t\t\treturn name === \"input\" && elem.type === \"button\" || name === \"button\";\n\t\t},\n\n\t\t\"text\": function( elem ) {\n\t\t\tvar attr;\n\t\t\treturn elem.nodeName.toLowerCase() === \"input\" &&\n\t\t\t\telem.type === \"text\" &&\n\n\t\t\t\t// Support: IE<8\n\t\t\t\t// New HTML5 attribute values (e.g., \"search\") appear with elem.type === \"text\"\n\t\t\t\t( (attr = elem.getAttribute(\"type\")) == null || attr.toLowerCase() === \"text\" );\n\t\t},\n\n\t\t// Position-in-collection\n\t\t\"first\": createPositionalPseudo(function() {\n\t\t\treturn [ 0 ];\n\t\t}),\n\n\t\t\"last\": createPositionalPseudo(function( matchIndexes, length ) {\n\t\t\treturn [ length - 1 ];\n\t\t}),\n\n\t\t\"eq\": createPositionalPseudo(function( matchIndexes, length, argument ) {\n\t\t\treturn [ argument < 0 ? argument + length : argument ];\n\t\t}),\n\n\t\t\"even\": createPositionalPseudo(function( matchIndexes, length ) {\n\t\t\tvar i = 0;\n\t\t\tfor ( ; i < length; i += 2 ) {\n\t\t\t\tmatchIndexes.push( i );\n\t\t\t}\n\t\t\treturn matchIndexes;\n\t\t}),\n\n\t\t\"odd\": createPositionalPseudo(function( matchIndexes, length ) {\n\t\t\tvar i = 1;\n\t\t\tfor ( ; i < length; i += 2 ) {\n\t\t\t\tmatchIndexes.push( i );\n\t\t\t}\n\t\t\treturn matchIndexes;\n\t\t}),\n\n\t\t\"lt\": createPositionalPseudo(function( matchIndexes, length, argument ) {\n\t\t\tvar i = argument < 0 ? argument + length : argument;\n\t\t\tfor ( ; --i >= 0; ) {\n\t\t\t\tmatchIndexes.push( i );\n\t\t\t}\n\t\t\treturn matchIndexes;\n\t\t}),\n\n\t\t\"gt\": createPositionalPseudo(function( matchIndexes, length, argument ) {\n\t\t\tvar i = argument < 0 ? argument + length : argument;\n\t\t\tfor ( ; ++i < length; ) {\n\t\t\t\tmatchIndexes.push( i );\n\t\t\t}\n\t\t\treturn matchIndexes;\n\t\t})\n\t}\n};\n\nExpr.pseudos[\"nth\"] = Expr.pseudos[\"eq\"];\n\n// Add button/input type pseudos\nfor ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {\n\tExpr.pseudos[ i ] = createInputPseudo( i );\n}\nfor ( i in { submit: true, reset: true } ) {\n\tExpr.pseudos[ i ] = createButtonPseudo( i );\n}\n\n// Easy API for creating new setFilters\nfunction setFilters() {}\nsetFilters.prototype = Expr.filters = Expr.pseudos;\nExpr.setFilters = new setFilters();\n\ntokenize = Sizzle.tokenize = function( selector, parseOnly ) {\n\tvar matched, match, tokens, type,\n\t\tsoFar, groups, preFilters,\n\t\tcached = tokenCache[ selector + \" \" ];\n\n\tif ( cached ) {\n\t\treturn parseOnly ? 0 : cached.slice( 0 );\n\t}\n\n\tsoFar = selector;\n\tgroups = [];\n\tpreFilters = Expr.preFilter;\n\n\twhile ( soFar ) {\n\n\t\t// Comma and first run\n\t\tif ( !matched || (match = rcomma.exec( soFar )) ) {\n\t\t\tif ( match ) {\n\t\t\t\t// Don't consume trailing commas as valid\n\t\t\t\tsoFar = soFar.slice( match[0].length ) || soFar;\n\t\t\t}\n\t\t\tgroups.push( (tokens = []) );\n\t\t}\n\n\t\tmatched = false;\n\n\t\t// Combinators\n\t\tif ( (match = rcombinators.exec( soFar )) ) {\n\t\t\tmatched = match.shift();\n\t\t\ttokens.push({\n\t\t\t\tvalue: matched,\n\t\t\t\t// Cast descendant combinators to space\n\t\t\t\ttype: match[0].replace( rtrim, \" \" )\n\t\t\t});\n\t\t\tsoFar = soFar.slice( matched.length );\n\t\t}\n\n\t\t// Filters\n\t\tfor ( type in Expr.filter ) {\n\t\t\tif ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] ||\n\t\t\t\t(match = preFilters[ type ]( match ))) ) {\n\t\t\t\tmatched = match.shift();\n\t\t\t\ttokens.push({\n\t\t\t\t\tvalue: matched,\n\t\t\t\t\ttype: type,\n\t\t\t\t\tmatches: match\n\t\t\t\t});\n\t\t\t\tsoFar = soFar.slice( matched.length );\n\t\t\t}\n\t\t}\n\n\t\tif ( !matched ) {\n\t\t\tbreak;\n\t\t}\n\t}\n\n\t// Return the length of the invalid excess\n\t// if we're just parsing\n\t// Otherwise, throw an error or return tokens\n\treturn parseOnly ?\n\t\tsoFar.length :\n\t\tsoFar ?\n\t\t\tSizzle.error( selector ) :\n\t\t\t// Cache the tokens\n\t\t\ttokenCache( selector, groups ).slice( 0 );\n};\n\nfunction toSelector( tokens ) {\n\tvar i = 0,\n\t\tlen = tokens.length,\n\t\tselector = \"\";\n\tfor ( ; i < len; i++ ) {\n\t\tselector += tokens[i].value;\n\t}\n\treturn selector;\n}\n\nfunction addCombinator( matcher, combinator, base ) {\n\tvar dir = combinator.dir,\n\t\tskip = combinator.next,\n\t\tkey = skip || dir,\n\t\tcheckNonElements = base && key === \"parentNode\",\n\t\tdoneName = done++;\n\n\treturn combinator.first ?\n\t\t// Check against closest ancestor/preceding element\n\t\tfunction( elem, context, xml ) {\n\t\t\twhile ( (elem = elem[ dir ]) ) {\n\t\t\t\tif ( elem.nodeType === 1 || checkNonElements ) {\n\t\t\t\t\treturn matcher( elem, context, xml );\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn false;\n\t\t} :\n\n\t\t// Check against all ancestor/preceding elements\n\t\tfunction( elem, context, xml ) {\n\t\t\tvar oldCache, uniqueCache, outerCache,\n\t\t\t\tnewCache = [ dirruns, doneName ];\n\n\t\t\t// We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching\n\t\t\tif ( xml ) {\n\t\t\t\twhile ( (elem = elem[ dir ]) ) {\n\t\t\t\t\tif ( elem.nodeType === 1 || checkNonElements ) {\n\t\t\t\t\t\tif ( matcher( elem, context, xml ) ) {\n\t\t\t\t\t\t\treturn true;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\twhile ( (elem = elem[ dir ]) ) {\n\t\t\t\t\tif ( elem.nodeType === 1 || checkNonElements ) {\n\t\t\t\t\t\touterCache = elem[ expando ] || (elem[ expando ] = {});\n\n\t\t\t\t\t\t// Support: IE <9 only\n\t\t\t\t\t\t// Defend against cloned attroperties (jQuery gh-1709)\n\t\t\t\t\t\tuniqueCache = outerCache[ elem.uniqueID ] || (outerCache[ elem.uniqueID ] = {});\n\n\t\t\t\t\t\tif ( skip && skip === elem.nodeName.toLowerCase() ) {\n\t\t\t\t\t\t\telem = elem[ dir ] || elem;\n\t\t\t\t\t\t} else if ( (oldCache = uniqueCache[ key ]) &&\n\t\t\t\t\t\t\toldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {\n\n\t\t\t\t\t\t\t// Assign to newCache so results back-propagate to previous elements\n\t\t\t\t\t\t\treturn (newCache[ 2 ] = oldCache[ 2 ]);\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t// Reuse newcache so results back-propagate to previous elements\n\t\t\t\t\t\t\tuniqueCache[ key ] = newCache;\n\n\t\t\t\t\t\t\t// A match means we're done; a fail means we have to keep checking\n\t\t\t\t\t\t\tif ( (newCache[ 2 ] = matcher( elem, context, xml )) ) {\n\t\t\t\t\t\t\t\treturn true;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn false;\n\t\t};\n}\n\nfunction elementMatcher( matchers ) {\n\treturn matchers.length > 1 ?\n\t\tfunction( elem, context, xml ) {\n\t\t\tvar i = matchers.length;\n\t\t\twhile ( i-- ) {\n\t\t\t\tif ( !matchers[i]( elem, context, xml ) ) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn true;\n\t\t} :\n\t\tmatchers[0];\n}\n\nfunction multipleContexts( selector, contexts, results ) {\n\tvar i = 0,\n\t\tlen = contexts.length;\n\tfor ( ; i < len; i++ ) {\n\t\tSizzle( selector, contexts[i], results );\n\t}\n\treturn results;\n}\n\nfunction condense( unmatched, map, filter, context, xml ) {\n\tvar elem,\n\t\tnewUnmatched = [],\n\t\ti = 0,\n\t\tlen = unmatched.length,\n\t\tmapped = map != null;\n\n\tfor ( ; i < len; i++ ) {\n\t\tif ( (elem = unmatched[i]) ) {\n\t\t\tif ( !filter || filter( elem, context, xml ) ) {\n\t\t\t\tnewUnmatched.push( elem );\n\t\t\t\tif ( mapped ) {\n\t\t\t\t\tmap.push( i );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn newUnmatched;\n}\n\nfunction setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {\n\tif ( postFilter && !postFilter[ expando ] ) {\n\t\tpostFilter = setMatcher( postFilter );\n\t}\n\tif ( postFinder && !postFinder[ expando ] ) {\n\t\tpostFinder = setMatcher( postFinder, postSelector );\n\t}\n\treturn markFunction(function( seed, results, context, xml ) {\n\t\tvar temp, i, elem,\n\t\t\tpreMap = [],\n\t\t\tpostMap = [],\n\t\t\tpreexisting = results.length,\n\n\t\t\t// Get initial elements from seed or context\n\t\t\telems = seed || multipleContexts( selector || \"*\", context.nodeType ? [ context ] : context, [] ),\n\n\t\t\t// Prefilter to get matcher input, preserving a map for seed-results synchronization\n\t\t\tmatcherIn = preFilter && ( seed || !selector ) ?\n\t\t\t\tcondense( elems, preMap, preFilter, context, xml ) :\n\t\t\t\telems,\n\n\t\t\tmatcherOut = matcher ?\n\t\t\t\t// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,\n\t\t\t\tpostFinder || ( seed ? preFilter : preexisting || postFilter ) ?\n\n\t\t\t\t\t// ...intermediate processing is necessary\n\t\t\t\t\t[] :\n\n\t\t\t\t\t// ...otherwise use results directly\n\t\t\t\t\tresults :\n\t\t\t\tmatcherIn;\n\n\t\t// Find primary matches\n\t\tif ( matcher ) {\n\t\t\tmatcher( matcherIn, matcherOut, context, xml );\n\t\t}\n\n\t\t// Apply postFilter\n\t\tif ( postFilter ) {\n\t\t\ttemp = condense( matcherOut, postMap );\n\t\t\tpostFilter( temp, [], context, xml );\n\n\t\t\t// Un-match failing elements by moving them back to matcherIn\n\t\t\ti = temp.length;\n\t\t\twhile ( i-- ) {\n\t\t\t\tif ( (elem = temp[i]) ) {\n\t\t\t\t\tmatcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif ( seed ) {\n\t\t\tif ( postFinder || preFilter ) {\n\t\t\t\tif ( postFinder ) {\n\t\t\t\t\t// Get the final matcherOut by condensing this intermediate into postFinder contexts\n\t\t\t\t\ttemp = [];\n\t\t\t\t\ti = matcherOut.length;\n\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\tif ( (elem = matcherOut[i]) ) {\n\t\t\t\t\t\t\t// Restore matcherIn since elem is not yet a final match\n\t\t\t\t\t\t\ttemp.push( (matcherIn[i] = elem) );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tpostFinder( null, (matcherOut = []), temp, xml );\n\t\t\t\t}\n\n\t\t\t\t// Move matched elements from seed to results to keep them synchronized\n\t\t\t\ti = matcherOut.length;\n\t\t\t\twhile ( i-- ) {\n\t\t\t\t\tif ( (elem = matcherOut[i]) &&\n\t\t\t\t\t\t(temp = postFinder ? indexOf( seed, elem ) : preMap[i]) > -1 ) {\n\n\t\t\t\t\t\tseed[temp] = !(results[temp] = elem);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t// Add elements to results, through postFinder if defined\n\t\t} else {\n\t\t\tmatcherOut = condense(\n\t\t\t\tmatcherOut === results ?\n\t\t\t\t\tmatcherOut.splice( preexisting, matcherOut.length ) :\n\t\t\t\t\tmatcherOut\n\t\t\t);\n\t\t\tif ( postFinder ) {\n\t\t\t\tpostFinder( null, results, matcherOut, xml );\n\t\t\t} else {\n\t\t\t\tpush.apply( results, matcherOut );\n\t\t\t}\n\t\t}\n\t});\n}\n\nfunction matcherFromTokens( tokens ) {\n\tvar checkContext, matcher, j,\n\t\tlen = tokens.length,\n\t\tleadingRelative = Expr.relative[ tokens[0].type ],\n\t\timplicitRelative = leadingRelative || Expr.relative[\" \"],\n\t\ti = leadingRelative ? 1 : 0,\n\n\t\t// The foundational matcher ensures that elements are reachable from top-level context(s)\n\t\tmatchContext = addCombinator( function( elem ) {\n\t\t\treturn elem === checkContext;\n\t\t}, implicitRelative, true ),\n\t\tmatchAnyContext = addCombinator( function( elem ) {\n\t\t\treturn indexOf( checkContext, elem ) > -1;\n\t\t}, implicitRelative, true ),\n\t\tmatchers = [ function( elem, context, xml ) {\n\t\t\tvar ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || (\n\t\t\t\t(checkContext = context).nodeType ?\n\t\t\t\t\tmatchContext( elem, context, xml ) :\n\t\t\t\t\tmatchAnyContext( elem, context, xml ) );\n\t\t\t// Avoid hanging onto element (issue #299)\n\t\t\tcheckContext = null;\n\t\t\treturn ret;\n\t\t} ];\n\n\tfor ( ; i < len; i++ ) {\n\t\tif ( (matcher = Expr.relative[ tokens[i].type ]) ) {\n\t\t\tmatchers = [ addCombinator(elementMatcher( matchers ), matcher) ];\n\t\t} else {\n\t\t\tmatcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches );\n\n\t\t\t// Return special upon seeing a positional matcher\n\t\t\tif ( matcher[ expando ] ) {\n\t\t\t\t// Find the next relative operator (if any) for proper handling\n\t\t\t\tj = ++i;\n\t\t\t\tfor ( ; j < len; j++ ) {\n\t\t\t\t\tif ( Expr.relative[ tokens[j].type ] ) {\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn setMatcher(\n\t\t\t\t\ti > 1 && elementMatcher( matchers ),\n\t\t\t\t\ti > 1 && toSelector(\n\t\t\t\t\t\t// If the preceding token was a descendant combinator, insert an implicit any-element `*`\n\t\t\t\t\t\ttokens.slice( 0, i - 1 ).concat({ value: tokens[ i - 2 ].type === \" \" ? \"*\" : \"\" })\n\t\t\t\t\t).replace( rtrim, \"$1\" ),\n\t\t\t\t\tmatcher,\n\t\t\t\t\ti < j && matcherFromTokens( tokens.slice( i, j ) ),\n\t\t\t\t\tj < len && matcherFromTokens( (tokens = tokens.slice( j )) ),\n\t\t\t\t\tj < len && toSelector( tokens )\n\t\t\t\t);\n\t\t\t}\n\t\t\tmatchers.push( matcher );\n\t\t}\n\t}\n\n\treturn elementMatcher( matchers );\n}\n\nfunction matcherFromGroupMatchers( elementMatchers, setMatchers ) {\n\tvar bySet = setMatchers.length > 0,\n\t\tbyElement = elementMatchers.length > 0,\n\t\tsuperMatcher = function( seed, context, xml, results, outermost ) {\n\t\t\tvar elem, j, matcher,\n\t\t\t\tmatchedCount = 0,\n\t\t\t\ti = \"0\",\n\t\t\t\tunmatched = seed && [],\n\t\t\t\tsetMatched = [],\n\t\t\t\tcontextBackup = outermostContext,\n\t\t\t\t// We must always have either seed elements or outermost context\n\t\t\t\telems = seed || byElement && Expr.find[\"TAG\"]( \"*\", outermost ),\n\t\t\t\t// Use integer dirruns iff this is the outermost matcher\n\t\t\t\tdirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1),\n\t\t\t\tlen = elems.length;\n\n\t\t\tif ( outermost ) {\n\t\t\t\toutermostContext = context === document || context || outermost;\n\t\t\t}\n\n\t\t\t// Add elements passing elementMatchers directly to results\n\t\t\t// Support: IE<9, Safari\n\t\t\t// Tolerate NodeList properties (IE: \"length\"; Safari: <number>) matching elements by id\n\t\t\tfor ( ; i !== len && (elem = elems[i]) != null; i++ ) {\n\t\t\t\tif ( byElement && elem ) {\n\t\t\t\t\tj = 0;\n\t\t\t\t\tif ( !context && elem.ownerDocument !== document ) {\n\t\t\t\t\t\tsetDocument( elem );\n\t\t\t\t\t\txml = !documentIsHTML;\n\t\t\t\t\t}\n\t\t\t\t\twhile ( (matcher = elementMatchers[j++]) ) {\n\t\t\t\t\t\tif ( matcher( elem, context || document, xml) ) {\n\t\t\t\t\t\t\tresults.push( elem );\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tif ( outermost ) {\n\t\t\t\t\t\tdirruns = dirrunsUnique;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Track unmatched elements for set filters\n\t\t\t\tif ( bySet ) {\n\t\t\t\t\t// They will have gone through all possible matchers\n\t\t\t\t\tif ( (elem = !matcher && elem) ) {\n\t\t\t\t\t\tmatchedCount--;\n\t\t\t\t\t}\n\n\t\t\t\t\t// Lengthen the array for every element, matched or not\n\t\t\t\t\tif ( seed ) {\n\t\t\t\t\t\tunmatched.push( elem );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// `i` is now the count of elements visited above, and adding it to `matchedCount`\n\t\t\t// makes the latter nonnegative.\n\t\t\tmatchedCount += i;\n\n\t\t\t// Apply set filters to unmatched elements\n\t\t\t// NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`\n\t\t\t// equals `i`), unless we didn't visit _any_ elements in the above loop because we have\n\t\t\t// no element matchers and no seed.\n\t\t\t// Incrementing an initially-string \"0\" `i` allows `i` to remain a string only in that\n\t\t\t// case, which will result in a \"00\" `matchedCount` that differs from `i` but is also\n\t\t\t// numerically zero.\n\t\t\tif ( bySet && i !== matchedCount ) {\n\t\t\t\tj = 0;\n\t\t\t\twhile ( (matcher = setMatchers[j++]) ) {\n\t\t\t\t\tmatcher( unmatched, setMatched, context, xml );\n\t\t\t\t}\n\n\t\t\t\tif ( seed ) {\n\t\t\t\t\t// Reintegrate element matches to eliminate the need for sorting\n\t\t\t\t\tif ( matchedCount > 0 ) {\n\t\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\t\tif ( !(unmatched[i] || setMatched[i]) ) {\n\t\t\t\t\t\t\t\tsetMatched[i] = pop.call( results );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Discard index placeholder values to get only actual matches\n\t\t\t\t\tsetMatched = condense( setMatched );\n\t\t\t\t}\n\n\t\t\t\t// Add matches to results\n\t\t\t\tpush.apply( results, setMatched );\n\n\t\t\t\t// Seedless set matches succeeding multiple successful matchers stipulate sorting\n\t\t\t\tif ( outermost && !seed && setMatched.length > 0 &&\n\t\t\t\t\t( matchedCount + setMatchers.length ) > 1 ) {\n\n\t\t\t\t\tSizzle.uniqueSort( results );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Override manipulation of globals by nested matchers\n\t\t\tif ( outermost ) {\n\t\t\t\tdirruns = dirrunsUnique;\n\t\t\t\toutermostContext = contextBackup;\n\t\t\t}\n\n\t\t\treturn unmatched;\n\t\t};\n\n\treturn bySet ?\n\t\tmarkFunction( superMatcher ) :\n\t\tsuperMatcher;\n}\n\ncompile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {\n\tvar i,\n\t\tsetMatchers = [],\n\t\telementMatchers = [],\n\t\tcached = compilerCache[ selector + \" \" ];\n\n\tif ( !cached ) {\n\t\t// Generate a function of recursive functions that can be used to check each element\n\t\tif ( !match ) {\n\t\t\tmatch = tokenize( selector );\n\t\t}\n\t\ti = match.length;\n\t\twhile ( i-- ) {\n\t\t\tcached = matcherFromTokens( match[i] );\n\t\t\tif ( cached[ expando ] ) {\n\t\t\t\tsetMatchers.push( cached );\n\t\t\t} else {\n\t\t\t\telementMatchers.push( cached );\n\t\t\t}\n\t\t}\n\n\t\t// Cache the compiled function\n\t\tcached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) );\n\n\t\t// Save selector and tokenization\n\t\tcached.selector = selector;\n\t}\n\treturn cached;\n};\n\n/**\n * A low-level selection function that works with Sizzle's compiled\n *  selector functions\n * @param {String|Function} selector A selector or a pre-compiled\n *  selector function built with Sizzle.compile\n * @param {Element} context\n * @param {Array} [results]\n * @param {Array} [seed] A set of elements to match against\n */\nselect = Sizzle.select = function( selector, context, results, seed ) {\n\tvar i, tokens, token, type, find,\n\t\tcompiled = typeof selector === \"function\" && selector,\n\t\tmatch = !seed && tokenize( (selector = compiled.selector || selector) );\n\n\tresults = results || [];\n\n\t// Try to minimize operations if there is only one selector in the list and no seed\n\t// (the latter of which guarantees us context)\n\tif ( match.length === 1 ) {\n\n\t\t// Reduce context if the leading compound selector is an ID\n\t\ttokens = match[0] = match[0].slice( 0 );\n\t\tif ( tokens.length > 2 && (token = tokens[0]).type === \"ID\" &&\n\t\t\t\tcontext.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[1].type ] ) {\n\n\t\t\tcontext = ( Expr.find[\"ID\"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0];\n\t\t\tif ( !context ) {\n\t\t\t\treturn results;\n\n\t\t\t// Precompiled matchers will still verify ancestry, so step up a level\n\t\t\t} else if ( compiled ) {\n\t\t\t\tcontext = context.parentNode;\n\t\t\t}\n\n\t\t\tselector = selector.slice( tokens.shift().value.length );\n\t\t}\n\n\t\t// Fetch a seed set for right-to-left matching\n\t\ti = matchExpr[\"needsContext\"].test( selector ) ? 0 : tokens.length;\n\t\twhile ( i-- ) {\n\t\t\ttoken = tokens[i];\n\n\t\t\t// Abort if we hit a combinator\n\t\t\tif ( Expr.relative[ (type = token.type) ] ) {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tif ( (find = Expr.find[ type ]) ) {\n\t\t\t\t// Search, expanding context for leading sibling combinators\n\t\t\t\tif ( (seed = find(\n\t\t\t\t\ttoken.matches[0].replace( runescape, funescape ),\n\t\t\t\t\trsibling.test( tokens[0].type ) && testContext( context.parentNode ) || context\n\t\t\t\t)) ) {\n\n\t\t\t\t\t// If seed is empty or no tokens remain, we can return early\n\t\t\t\t\ttokens.splice( i, 1 );\n\t\t\t\t\tselector = seed.length && toSelector( tokens );\n\t\t\t\t\tif ( !selector ) {\n\t\t\t\t\t\tpush.apply( results, seed );\n\t\t\t\t\t\treturn results;\n\t\t\t\t\t}\n\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// Compile and execute a filtering function if one is not provided\n\t// Provide `match` to avoid retokenization if we modified the selector above\n\t( compiled || compile( selector, match ) )(\n\t\tseed,\n\t\tcontext,\n\t\t!documentIsHTML,\n\t\tresults,\n\t\t!context || rsibling.test( selector ) && testContext( context.parentNode ) || context\n\t);\n\treturn results;\n};\n\n// One-time assignments\n\n// Sort stability\nsupport.sortStable = expando.split(\"\").sort( sortOrder ).join(\"\") === expando;\n\n// Support: Chrome 14-35+\n// Always assume duplicates if they aren't passed to the comparison function\nsupport.detectDuplicates = !!hasDuplicate;\n\n// Initialize against the default document\nsetDocument();\n\n// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)\n// Detached nodes confoundingly follow *each other*\nsupport.sortDetached = assert(function( el ) {\n\t// Should return 1, but returns 4 (following)\n\treturn el.compareDocumentPosition( document.createElement(\"fieldset\") ) & 1;\n});\n\n// Support: IE<8\n// Prevent attribute/property \"interpolation\"\n// https://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx\nif ( !assert(function( el ) {\n\tel.innerHTML = \"<a href='#'></a>\";\n\treturn el.firstChild.getAttribute(\"href\") === \"#\" ;\n}) ) {\n\taddHandle( \"type|href|height|width\", function( elem, name, isXML ) {\n\t\tif ( !isXML ) {\n\t\t\treturn elem.getAttribute( name, name.toLowerCase() === \"type\" ? 1 : 2 );\n\t\t}\n\t});\n}\n\n// Support: IE<9\n// Use defaultValue in place of getAttribute(\"value\")\nif ( !support.attributes || !assert(function( el ) {\n\tel.innerHTML = \"<input/>\";\n\tel.firstChild.setAttribute( \"value\", \"\" );\n\treturn el.firstChild.getAttribute( \"value\" ) === \"\";\n}) ) {\n\taddHandle( \"value\", function( elem, name, isXML ) {\n\t\tif ( !isXML && elem.nodeName.toLowerCase() === \"input\" ) {\n\t\t\treturn elem.defaultValue;\n\t\t}\n\t});\n}\n\n// Support: IE<9\n// Use getAttributeNode to fetch booleans when getAttribute lies\nif ( !assert(function( el ) {\n\treturn el.getAttribute(\"disabled\") == null;\n}) ) {\n\taddHandle( booleans, function( elem, name, isXML ) {\n\t\tvar val;\n\t\tif ( !isXML ) {\n\t\t\treturn elem[ name ] === true ? name.toLowerCase() :\n\t\t\t\t\t(val = elem.getAttributeNode( name )) && val.specified ?\n\t\t\t\t\tval.value :\n\t\t\t\tnull;\n\t\t}\n\t});\n}\n\nreturn Sizzle;\n\n})( window );\n\n\n\njQuery.find = Sizzle;\njQuery.expr = Sizzle.selectors;\n\n// Deprecated\njQuery.expr[ \":\" ] = jQuery.expr.pseudos;\njQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort;\njQuery.text = Sizzle.getText;\njQuery.isXMLDoc = Sizzle.isXML;\njQuery.contains = Sizzle.contains;\njQuery.escapeSelector = Sizzle.escape;\n\n\n\n\nvar dir = function( elem, dir, until ) {\n\tvar matched = [],\n\t\ttruncate = until !== undefined;\n\n\twhile ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) {\n\t\tif ( elem.nodeType === 1 ) {\n\t\t\tif ( truncate && jQuery( elem ).is( until ) ) {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tmatched.push( elem );\n\t\t}\n\t}\n\treturn matched;\n};\n\n\nvar siblings = function( n, elem ) {\n\tvar matched = [];\n\n\tfor ( ; n; n = n.nextSibling ) {\n\t\tif ( n.nodeType === 1 && n !== elem ) {\n\t\t\tmatched.push( n );\n\t\t}\n\t}\n\n\treturn matched;\n};\n\n\nvar rneedsContext = jQuery.expr.match.needsContext;\n\n\n\nfunction nodeName( elem, name ) {\n\n  return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();\n\n};\nvar rsingleTag = ( /^<([a-z][^\\/\\0>:\\x20\\t\\r\\n\\f]*)[\\x20\\t\\r\\n\\f]*\\/?>(?:<\\/\\1>|)$/i );\n\n\n\n// Implement the identical functionality for filter and not\nfunction winnow( elements, qualifier, not ) {\n\tif ( isFunction( qualifier ) ) {\n\t\treturn jQuery.grep( elements, function( elem, i ) {\n\t\t\treturn !!qualifier.call( elem, i, elem ) !== not;\n\t\t} );\n\t}\n\n\t// Single element\n\tif ( qualifier.nodeType ) {\n\t\treturn jQuery.grep( elements, function( elem ) {\n\t\t\treturn ( elem === qualifier ) !== not;\n\t\t} );\n\t}\n\n\t// Arraylike of elements (jQuery, arguments, Array)\n\tif ( typeof qualifier !== \"string\" ) {\n\t\treturn jQuery.grep( elements, function( elem ) {\n\t\t\treturn ( indexOf.call( qualifier, elem ) > -1 ) !== not;\n\t\t} );\n\t}\n\n\t// Filtered directly for both simple and complex selectors\n\treturn jQuery.filter( qualifier, elements, not );\n}\n\njQuery.filter = function( expr, elems, not ) {\n\tvar elem = elems[ 0 ];\n\n\tif ( not ) {\n\t\texpr = \":not(\" + expr + \")\";\n\t}\n\n\tif ( elems.length === 1 && elem.nodeType === 1 ) {\n\t\treturn jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [];\n\t}\n\n\treturn jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {\n\t\treturn elem.nodeType === 1;\n\t} ) );\n};\n\njQuery.fn.extend( {\n\tfind: function( selector ) {\n\t\tvar i, ret,\n\t\t\tlen = this.length,\n\t\t\tself = this;\n\n\t\tif ( typeof selector !== \"string\" ) {\n\t\t\treturn this.pushStack( jQuery( selector ).filter( function() {\n\t\t\t\tfor ( i = 0; i < len; i++ ) {\n\t\t\t\t\tif ( jQuery.contains( self[ i ], this ) ) {\n\t\t\t\t\t\treturn true;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} ) );\n\t\t}\n\n\t\tret = this.pushStack( [] );\n\n\t\tfor ( i = 0; i < len; i++ ) {\n\t\t\tjQuery.find( selector, self[ i ], ret );\n\t\t}\n\n\t\treturn len > 1 ? jQuery.uniqueSort( ret ) : ret;\n\t},\n\tfilter: function( selector ) {\n\t\treturn this.pushStack( winnow( this, selector || [], false ) );\n\t},\n\tnot: function( selector ) {\n\t\treturn this.pushStack( winnow( this, selector || [], true ) );\n\t},\n\tis: function( selector ) {\n\t\treturn !!winnow(\n\t\t\tthis,\n\n\t\t\t// If this is a positional/relative selector, check membership in the returned set\n\t\t\t// so $(\"p:first\").is(\"p:last\") won't return true for a doc with two \"p\".\n\t\t\ttypeof selector === \"string\" && rneedsContext.test( selector ) ?\n\t\t\t\tjQuery( selector ) :\n\t\t\t\tselector || [],\n\t\t\tfalse\n\t\t).length;\n\t}\n} );\n\n\n// Initialize a jQuery object\n\n\n// A central reference to the root jQuery(document)\nvar rootjQuery,\n\n\t// A simple way to check for HTML strings\n\t// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)\n\t// Strict HTML recognition (#11290: must start with <)\n\t// Shortcut simple #id case for speed\n\trquickExpr = /^(?:\\s*(<[\\w\\W]+>)[^>]*|#([\\w-]+))$/,\n\n\tinit = jQuery.fn.init = function( selector, context, root ) {\n\t\tvar match, elem;\n\n\t\t// HANDLE: $(\"\"), $(null), $(undefined), $(false)\n\t\tif ( !selector ) {\n\t\t\treturn this;\n\t\t}\n\n\t\t// Method init() accepts an alternate rootjQuery\n\t\t// so migrate can support jQuery.sub (gh-2101)\n\t\troot = root || rootjQuery;\n\n\t\t// Handle HTML strings\n\t\tif ( typeof selector === \"string\" ) {\n\t\t\tif ( selector[ 0 ] === \"<\" &&\n\t\t\t\tselector[ selector.length - 1 ] === \">\" &&\n\t\t\t\tselector.length >= 3 ) {\n\n\t\t\t\t// Assume that strings that start and end with <> are HTML and skip the regex check\n\t\t\t\tmatch = [ null, selector, null ];\n\n\t\t\t} else {\n\t\t\t\tmatch = rquickExpr.exec( selector );\n\t\t\t}\n\n\t\t\t// Match html or make sure no context is specified for #id\n\t\t\tif ( match && ( match[ 1 ] || !context ) ) {\n\n\t\t\t\t// HANDLE: $(html) -> $(array)\n\t\t\t\tif ( match[ 1 ] ) {\n\t\t\t\t\tcontext = context instanceof jQuery ? context[ 0 ] : context;\n\n\t\t\t\t\t// Option to run scripts is true for back-compat\n\t\t\t\t\t// Intentionally let the error be thrown if parseHTML is not present\n\t\t\t\t\tjQuery.merge( this, jQuery.parseHTML(\n\t\t\t\t\t\tmatch[ 1 ],\n\t\t\t\t\t\tcontext && context.nodeType ? context.ownerDocument || context : document,\n\t\t\t\t\t\ttrue\n\t\t\t\t\t) );\n\n\t\t\t\t\t// HANDLE: $(html, props)\n\t\t\t\t\tif ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) {\n\t\t\t\t\t\tfor ( match in context ) {\n\n\t\t\t\t\t\t\t// Properties of context are called as methods if possible\n\t\t\t\t\t\t\tif ( isFunction( this[ match ] ) ) {\n\t\t\t\t\t\t\t\tthis[ match ]( context[ match ] );\n\n\t\t\t\t\t\t\t// ...and otherwise set as attributes\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tthis.attr( match, context[ match ] );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\treturn this;\n\n\t\t\t\t// HANDLE: $(#id)\n\t\t\t\t} else {\n\t\t\t\t\telem = document.getElementById( match[ 2 ] );\n\n\t\t\t\t\tif ( elem ) {\n\n\t\t\t\t\t\t// Inject the element directly into the jQuery object\n\t\t\t\t\t\tthis[ 0 ] = elem;\n\t\t\t\t\t\tthis.length = 1;\n\t\t\t\t\t}\n\t\t\t\t\treturn this;\n\t\t\t\t}\n\n\t\t\t// HANDLE: $(expr, $(...))\n\t\t\t} else if ( !context || context.jquery ) {\n\t\t\t\treturn ( context || root ).find( selector );\n\n\t\t\t// HANDLE: $(expr, context)\n\t\t\t// (which is just equivalent to: $(context).find(expr)\n\t\t\t} else {\n\t\t\t\treturn this.constructor( context ).find( selector );\n\t\t\t}\n\n\t\t// HANDLE: $(DOMElement)\n\t\t} else if ( selector.nodeType ) {\n\t\t\tthis[ 0 ] = selector;\n\t\t\tthis.length = 1;\n\t\t\treturn this;\n\n\t\t// HANDLE: $(function)\n\t\t// Shortcut for document ready\n\t\t} else if ( isFunction( selector ) ) {\n\t\t\treturn root.ready !== undefined ?\n\t\t\t\troot.ready( selector ) :\n\n\t\t\t\t// Execute immediately if ready is not present\n\t\t\t\tselector( jQuery );\n\t\t}\n\n\t\treturn jQuery.makeArray( selector, this );\n\t};\n\n// Give the init function the jQuery prototype for later instantiation\ninit.prototype = jQuery.fn;\n\n// Initialize central reference\nrootjQuery = jQuery( document );\n\n\nvar rparentsprev = /^(?:parents|prev(?:Until|All))/,\n\n\t// Methods guaranteed to produce a unique set when starting from a unique set\n\tguaranteedUnique = {\n\t\tchildren: true,\n\t\tcontents: true,\n\t\tnext: true,\n\t\tprev: true\n\t};\n\njQuery.fn.extend( {\n\thas: function( target ) {\n\t\tvar targets = jQuery( target, this ),\n\t\t\tl = targets.length;\n\n\t\treturn this.filter( function() {\n\t\t\tvar i = 0;\n\t\t\tfor ( ; i < l; i++ ) {\n\t\t\t\tif ( jQuery.contains( this, targets[ i ] ) ) {\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\t\t\t}\n\t\t} );\n\t},\n\n\tclosest: function( selectors, context ) {\n\t\tvar cur,\n\t\t\ti = 0,\n\t\t\tl = this.length,\n\t\t\tmatched = [],\n\t\t\ttargets = typeof selectors !== \"string\" && jQuery( selectors );\n\n\t\t// Positional selectors never match, since there's no _selection_ context\n\t\tif ( !rneedsContext.test( selectors ) ) {\n\t\t\tfor ( ; i < l; i++ ) {\n\t\t\t\tfor ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) {\n\n\t\t\t\t\t// Always skip document fragments\n\t\t\t\t\tif ( cur.nodeType < 11 && ( targets ?\n\t\t\t\t\t\ttargets.index( cur ) > -1 :\n\n\t\t\t\t\t\t// Don't pass non-elements to Sizzle\n\t\t\t\t\t\tcur.nodeType === 1 &&\n\t\t\t\t\t\t\tjQuery.find.matchesSelector( cur, selectors ) ) ) {\n\n\t\t\t\t\t\tmatched.push( cur );\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn this.pushStack( matched.length > 1 ? jQuery.uniqueSort( matched ) : matched );\n\t},\n\n\t// Determine the position of an element within the set\n\tindex: function( elem ) {\n\n\t\t// No argument, return index in parent\n\t\tif ( !elem ) {\n\t\t\treturn ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1;\n\t\t}\n\n\t\t// Index in selector\n\t\tif ( typeof elem === \"string\" ) {\n\t\t\treturn indexOf.call( jQuery( elem ), this[ 0 ] );\n\t\t}\n\n\t\t// Locate the position of the desired element\n\t\treturn indexOf.call( this,\n\n\t\t\t// If it receives a jQuery object, the first element is used\n\t\t\telem.jquery ? elem[ 0 ] : elem\n\t\t);\n\t},\n\n\tadd: function( selector, context ) {\n\t\treturn this.pushStack(\n\t\t\tjQuery.uniqueSort(\n\t\t\t\tjQuery.merge( this.get(), jQuery( selector, context ) )\n\t\t\t)\n\t\t);\n\t},\n\n\taddBack: function( selector ) {\n\t\treturn this.add( selector == null ?\n\t\t\tthis.prevObject : this.prevObject.filter( selector )\n\t\t);\n\t}\n} );\n\nfunction sibling( cur, dir ) {\n\twhile ( ( cur = cur[ dir ] ) && cur.nodeType !== 1 ) {}\n\treturn cur;\n}\n\njQuery.each( {\n\tparent: function( elem ) {\n\t\tvar parent = elem.parentNode;\n\t\treturn parent && parent.nodeType !== 11 ? parent : null;\n\t},\n\tparents: function( elem ) {\n\t\treturn dir( elem, \"parentNode\" );\n\t},\n\tparentsUntil: function( elem, i, until ) {\n\t\treturn dir( elem, \"parentNode\", until );\n\t},\n\tnext: function( elem ) {\n\t\treturn sibling( elem, \"nextSibling\" );\n\t},\n\tprev: function( elem ) {\n\t\treturn sibling( elem, \"previousSibling\" );\n\t},\n\tnextAll: function( elem ) {\n\t\treturn dir( elem, \"nextSibling\" );\n\t},\n\tprevAll: function( elem ) {\n\t\treturn dir( elem, \"previousSibling\" );\n\t},\n\tnextUntil: function( elem, i, until ) {\n\t\treturn dir( elem, \"nextSibling\", until );\n\t},\n\tprevUntil: function( elem, i, until ) {\n\t\treturn dir( elem, \"previousSibling\", until );\n\t},\n\tsiblings: function( elem ) {\n\t\treturn siblings( ( elem.parentNode || {} ).firstChild, elem );\n\t},\n\tchildren: function( elem ) {\n\t\treturn siblings( elem.firstChild );\n\t},\n\tcontents: function( elem ) {\n        if ( nodeName( elem, \"iframe\" ) ) {\n            return elem.contentDocument;\n        }\n\n        // Support: IE 9 - 11 only, iOS 7 only, Android Browser <=4.3 only\n        // Treat the template element as a regular one in browsers that\n        // don't support it.\n        if ( nodeName( elem, \"template\" ) ) {\n            elem = elem.content || elem;\n        }\n\n        return jQuery.merge( [], elem.childNodes );\n\t}\n}, function( name, fn ) {\n\tjQuery.fn[ name ] = function( until, selector ) {\n\t\tvar matched = jQuery.map( this, fn, until );\n\n\t\tif ( name.slice( -5 ) !== \"Until\" ) {\n\t\t\tselector = until;\n\t\t}\n\n\t\tif ( selector && typeof selector === \"string\" ) {\n\t\t\tmatched = jQuery.filter( selector, matched );\n\t\t}\n\n\t\tif ( this.length > 1 ) {\n\n\t\t\t// Remove duplicates\n\t\t\tif ( !guaranteedUnique[ name ] ) {\n\t\t\t\tjQuery.uniqueSort( matched );\n\t\t\t}\n\n\t\t\t// Reverse order for parents* and prev-derivatives\n\t\t\tif ( rparentsprev.test( name ) ) {\n\t\t\t\tmatched.reverse();\n\t\t\t}\n\t\t}\n\n\t\treturn this.pushStack( matched );\n\t};\n} );\nvar rnothtmlwhite = ( /[^\\x20\\t\\r\\n\\f]+/g );\n\n\n\n// Convert String-formatted options into Object-formatted ones\nfunction createOptions( options ) {\n\tvar object = {};\n\tjQuery.each( options.match( rnothtmlwhite ) || [], function( _, flag ) {\n\t\tobject[ flag ] = true;\n\t} );\n\treturn object;\n}\n\n/*\n * Create a callback list using the following parameters:\n *\n *\toptions: an optional list of space-separated options that will change how\n *\t\t\tthe callback list behaves or a more traditional option object\n *\n * By default a callback list will act like an event callback list and can be\n * \"fired\" multiple times.\n *\n * Possible options:\n *\n *\tonce:\t\t\twill ensure the callback list can only be fired once (like a Deferred)\n *\n *\tmemory:\t\t\twill keep track of previous values and will call any callback added\n *\t\t\t\t\tafter the list has been fired right away with the latest \"memorized\"\n *\t\t\t\t\tvalues (like a Deferred)\n *\n *\tunique:\t\t\twill ensure a callback can only be added once (no duplicate in the list)\n *\n *\tstopOnFalse:\tinterrupt callings when a callback returns false\n *\n */\njQuery.Callbacks = function( options ) {\n\n\t// Convert options from String-formatted to Object-formatted if needed\n\t// (we check in cache first)\n\toptions = typeof options === \"string\" ?\n\t\tcreateOptions( options ) :\n\t\tjQuery.extend( {}, options );\n\n\tvar // Flag to know if list is currently firing\n\t\tfiring,\n\n\t\t// Last fire value for non-forgettable lists\n\t\tmemory,\n\n\t\t// Flag to know if list was already fired\n\t\tfired,\n\n\t\t// Flag to prevent firing\n\t\tlocked,\n\n\t\t// Actual callback list\n\t\tlist = [],\n\n\t\t// Queue of execution data for repeatable lists\n\t\tqueue = [],\n\n\t\t// Index of currently firing callback (modified by add/remove as needed)\n\t\tfiringIndex = -1,\n\n\t\t// Fire callbacks\n\t\tfire = function() {\n\n\t\t\t// Enforce single-firing\n\t\t\tlocked = locked || options.once;\n\n\t\t\t// Execute callbacks for all pending executions,\n\t\t\t// respecting firingIndex overrides and runtime changes\n\t\t\tfired = firing = true;\n\t\t\tfor ( ; queue.length; firingIndex = -1 ) {\n\t\t\t\tmemory = queue.shift();\n\t\t\t\twhile ( ++firingIndex < list.length ) {\n\n\t\t\t\t\t// Run callback and check for early termination\n\t\t\t\t\tif ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false &&\n\t\t\t\t\t\toptions.stopOnFalse ) {\n\n\t\t\t\t\t\t// Jump to end and forget the data so .add doesn't re-fire\n\t\t\t\t\t\tfiringIndex = list.length;\n\t\t\t\t\t\tmemory = false;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Forget the data if we're done with it\n\t\t\tif ( !options.memory ) {\n\t\t\t\tmemory = false;\n\t\t\t}\n\n\t\t\tfiring = false;\n\n\t\t\t// Clean up if we're done firing for good\n\t\t\tif ( locked ) {\n\n\t\t\t\t// Keep an empty list if we have data for future add calls\n\t\t\t\tif ( memory ) {\n\t\t\t\t\tlist = [];\n\n\t\t\t\t// Otherwise, this object is spent\n\t\t\t\t} else {\n\t\t\t\t\tlist = \"\";\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\n\t\t// Actual Callbacks object\n\t\tself = {\n\n\t\t\t// Add a callback or a collection of callbacks to the list\n\t\t\tadd: function() {\n\t\t\t\tif ( list ) {\n\n\t\t\t\t\t// If we have memory from a past run, we should fire after adding\n\t\t\t\t\tif ( memory && !firing ) {\n\t\t\t\t\t\tfiringIndex = list.length - 1;\n\t\t\t\t\t\tqueue.push( memory );\n\t\t\t\t\t}\n\n\t\t\t\t\t( function add( args ) {\n\t\t\t\t\t\tjQuery.each( args, function( _, arg ) {\n\t\t\t\t\t\t\tif ( isFunction( arg ) ) {\n\t\t\t\t\t\t\t\tif ( !options.unique || !self.has( arg ) ) {\n\t\t\t\t\t\t\t\t\tlist.push( arg );\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t} else if ( arg && arg.length && toType( arg ) !== \"string\" ) {\n\n\t\t\t\t\t\t\t\t// Inspect recursively\n\t\t\t\t\t\t\t\tadd( arg );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} );\n\t\t\t\t\t} )( arguments );\n\n\t\t\t\t\tif ( memory && !firing ) {\n\t\t\t\t\t\tfire();\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// Remove a callback from the list\n\t\t\tremove: function() {\n\t\t\t\tjQuery.each( arguments, function( _, arg ) {\n\t\t\t\t\tvar index;\n\t\t\t\t\twhile ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {\n\t\t\t\t\t\tlist.splice( index, 1 );\n\n\t\t\t\t\t\t// Handle firing indexes\n\t\t\t\t\t\tif ( index <= firingIndex ) {\n\t\t\t\t\t\t\tfiringIndex--;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} );\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// Check if a given callback is in the list.\n\t\t\t// If no argument is given, return whether or not list has callbacks attached.\n\t\t\thas: function( fn ) {\n\t\t\t\treturn fn ?\n\t\t\t\t\tjQuery.inArray( fn, list ) > -1 :\n\t\t\t\t\tlist.length > 0;\n\t\t\t},\n\n\t\t\t// Remove all callbacks from the list\n\t\t\tempty: function() {\n\t\t\t\tif ( list ) {\n\t\t\t\t\tlist = [];\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// Disable .fire and .add\n\t\t\t// Abort any current/pending executions\n\t\t\t// Clear all callbacks and values\n\t\t\tdisable: function() {\n\t\t\t\tlocked = queue = [];\n\t\t\t\tlist = memory = \"\";\n\t\t\t\treturn this;\n\t\t\t},\n\t\t\tdisabled: function() {\n\t\t\t\treturn !list;\n\t\t\t},\n\n\t\t\t// Disable .fire\n\t\t\t// Also disable .add unless we have memory (since it would have no effect)\n\t\t\t// Abort any pending executions\n\t\t\tlock: function() {\n\t\t\t\tlocked = queue = [];\n\t\t\t\tif ( !memory && !firing ) {\n\t\t\t\t\tlist = memory = \"\";\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t},\n\t\t\tlocked: function() {\n\t\t\t\treturn !!locked;\n\t\t\t},\n\n\t\t\t// Call all callbacks with the given context and arguments\n\t\t\tfireWith: function( context, args ) {\n\t\t\t\tif ( !locked ) {\n\t\t\t\t\targs = args || [];\n\t\t\t\t\targs = [ context, args.slice ? args.slice() : args ];\n\t\t\t\t\tqueue.push( args );\n\t\t\t\t\tif ( !firing ) {\n\t\t\t\t\t\tfire();\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// Call all the callbacks with the given arguments\n\t\t\tfire: function() {\n\t\t\t\tself.fireWith( this, arguments );\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// To know if the callbacks have already been called at least once\n\t\t\tfired: function() {\n\t\t\t\treturn !!fired;\n\t\t\t}\n\t\t};\n\n\treturn self;\n};\n\n\nfunction Identity( v ) {\n\treturn v;\n}\nfunction Thrower( ex ) {\n\tthrow ex;\n}\n\nfunction adoptValue( value, resolve, reject, noValue ) {\n\tvar method;\n\n\ttry {\n\n\t\t// Check for promise aspect first to privilege synchronous behavior\n\t\tif ( value && isFunction( ( method = value.promise ) ) ) {\n\t\t\tmethod.call( value ).done( resolve ).fail( reject );\n\n\t\t// Other thenables\n\t\t} else if ( value && isFunction( ( method = value.then ) ) ) {\n\t\t\tmethod.call( value, resolve, reject );\n\n\t\t// Other non-thenables\n\t\t} else {\n\n\t\t\t// Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer:\n\t\t\t// * false: [ value ].slice( 0 ) => resolve( value )\n\t\t\t// * true: [ value ].slice( 1 ) => resolve()\n\t\t\tresolve.apply( undefined, [ value ].slice( noValue ) );\n\t\t}\n\n\t// For Promises/A+, convert exceptions into rejections\n\t// Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in\n\t// Deferred#then to conditionally suppress rejection.\n\t} catch ( value ) {\n\n\t\t// Support: Android 4.0 only\n\t\t// Strict mode functions invoked without .call/.apply get global-object context\n\t\treject.apply( undefined, [ value ] );\n\t}\n}\n\njQuery.extend( {\n\n\tDeferred: function( func ) {\n\t\tvar tuples = [\n\n\t\t\t\t// action, add listener, callbacks,\n\t\t\t\t// ... .then handlers, argument index, [final state]\n\t\t\t\t[ \"notify\", \"progress\", jQuery.Callbacks( \"memory\" ),\n\t\t\t\t\tjQuery.Callbacks( \"memory\" ), 2 ],\n\t\t\t\t[ \"resolve\", \"done\", jQuery.Callbacks( \"once memory\" ),\n\t\t\t\t\tjQuery.Callbacks( \"once memory\" ), 0, \"resolved\" ],\n\t\t\t\t[ \"reject\", \"fail\", jQuery.Callbacks( \"once memory\" ),\n\t\t\t\t\tjQuery.Callbacks( \"once memory\" ), 1, \"rejected\" ]\n\t\t\t],\n\t\t\tstate = \"pending\",\n\t\t\tpromise = {\n\t\t\t\tstate: function() {\n\t\t\t\t\treturn state;\n\t\t\t\t},\n\t\t\t\talways: function() {\n\t\t\t\t\tdeferred.done( arguments ).fail( arguments );\n\t\t\t\t\treturn this;\n\t\t\t\t},\n\t\t\t\t\"catch\": function( fn ) {\n\t\t\t\t\treturn promise.then( null, fn );\n\t\t\t\t},\n\n\t\t\t\t// Keep pipe for back-compat\n\t\t\t\tpipe: function( /* fnDone, fnFail, fnProgress */ ) {\n\t\t\t\t\tvar fns = arguments;\n\n\t\t\t\t\treturn jQuery.Deferred( function( newDefer ) {\n\t\t\t\t\t\tjQuery.each( tuples, function( i, tuple ) {\n\n\t\t\t\t\t\t\t// Map tuples (progress, done, fail) to arguments (done, fail, progress)\n\t\t\t\t\t\t\tvar fn = isFunction( fns[ tuple[ 4 ] ] ) && fns[ tuple[ 4 ] ];\n\n\t\t\t\t\t\t\t// deferred.progress(function() { bind to newDefer or newDefer.notify })\n\t\t\t\t\t\t\t// deferred.done(function() { bind to newDefer or newDefer.resolve })\n\t\t\t\t\t\t\t// deferred.fail(function() { bind to newDefer or newDefer.reject })\n\t\t\t\t\t\t\tdeferred[ tuple[ 1 ] ]( function() {\n\t\t\t\t\t\t\t\tvar returned = fn && fn.apply( this, arguments );\n\t\t\t\t\t\t\t\tif ( returned && isFunction( returned.promise ) ) {\n\t\t\t\t\t\t\t\t\treturned.promise()\n\t\t\t\t\t\t\t\t\t\t.progress( newDefer.notify )\n\t\t\t\t\t\t\t\t\t\t.done( newDefer.resolve )\n\t\t\t\t\t\t\t\t\t\t.fail( newDefer.reject );\n\t\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t\tnewDefer[ tuple[ 0 ] + \"With\" ](\n\t\t\t\t\t\t\t\t\t\tthis,\n\t\t\t\t\t\t\t\t\t\tfn ? [ returned ] : arguments\n\t\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t} );\n\t\t\t\t\t\t} );\n\t\t\t\t\t\tfns = null;\n\t\t\t\t\t} ).promise();\n\t\t\t\t},\n\t\t\t\tthen: function( onFulfilled, onRejected, onProgress ) {\n\t\t\t\t\tvar maxDepth = 0;\n\t\t\t\t\tfunction resolve( depth, deferred, handler, special ) {\n\t\t\t\t\t\treturn function() {\n\t\t\t\t\t\t\tvar that = this,\n\t\t\t\t\t\t\t\targs = arguments,\n\t\t\t\t\t\t\t\tmightThrow = function() {\n\t\t\t\t\t\t\t\t\tvar returned, then;\n\n\t\t\t\t\t\t\t\t\t// Support: Promises/A+ section 2.3.3.3.3\n\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-59\n\t\t\t\t\t\t\t\t\t// Ignore double-resolution attempts\n\t\t\t\t\t\t\t\t\tif ( depth < maxDepth ) {\n\t\t\t\t\t\t\t\t\t\treturn;\n\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\treturned = handler.apply( that, args );\n\n\t\t\t\t\t\t\t\t\t// Support: Promises/A+ section 2.3.1\n\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-48\n\t\t\t\t\t\t\t\t\tif ( returned === deferred.promise() ) {\n\t\t\t\t\t\t\t\t\t\tthrow new TypeError( \"Thenable self-resolution\" );\n\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t// Support: Promises/A+ sections 2.3.3.1, 3.5\n\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-54\n\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-75\n\t\t\t\t\t\t\t\t\t// Retrieve `then` only once\n\t\t\t\t\t\t\t\t\tthen = returned &&\n\n\t\t\t\t\t\t\t\t\t\t// Support: Promises/A+ section 2.3.4\n\t\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-64\n\t\t\t\t\t\t\t\t\t\t// Only check objects and functions for thenability\n\t\t\t\t\t\t\t\t\t\t( typeof returned === \"object\" ||\n\t\t\t\t\t\t\t\t\t\t\ttypeof returned === \"function\" ) &&\n\t\t\t\t\t\t\t\t\t\treturned.then;\n\n\t\t\t\t\t\t\t\t\t// Handle a returned thenable\n\t\t\t\t\t\t\t\t\tif ( isFunction( then ) ) {\n\n\t\t\t\t\t\t\t\t\t\t// Special processors (notify) just wait for resolution\n\t\t\t\t\t\t\t\t\t\tif ( special ) {\n\t\t\t\t\t\t\t\t\t\t\tthen.call(\n\t\t\t\t\t\t\t\t\t\t\t\treturned,\n\t\t\t\t\t\t\t\t\t\t\t\tresolve( maxDepth, deferred, Identity, special ),\n\t\t\t\t\t\t\t\t\t\t\t\tresolve( maxDepth, deferred, Thrower, special )\n\t\t\t\t\t\t\t\t\t\t\t);\n\n\t\t\t\t\t\t\t\t\t\t// Normal processors (resolve) also hook into progress\n\t\t\t\t\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t\t\t\t\t// ...and disregard older resolution values\n\t\t\t\t\t\t\t\t\t\t\tmaxDepth++;\n\n\t\t\t\t\t\t\t\t\t\t\tthen.call(\n\t\t\t\t\t\t\t\t\t\t\t\treturned,\n\t\t\t\t\t\t\t\t\t\t\t\tresolve( maxDepth, deferred, Identity, special ),\n\t\t\t\t\t\t\t\t\t\t\t\tresolve( maxDepth, deferred, Thrower, special ),\n\t\t\t\t\t\t\t\t\t\t\t\tresolve( maxDepth, deferred, Identity,\n\t\t\t\t\t\t\t\t\t\t\t\t\tdeferred.notifyWith )\n\t\t\t\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t// Handle all other returned values\n\t\t\t\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t\t\t\t// Only substitute handlers pass on context\n\t\t\t\t\t\t\t\t\t\t// and multiple values (non-spec behavior)\n\t\t\t\t\t\t\t\t\t\tif ( handler !== Identity ) {\n\t\t\t\t\t\t\t\t\t\t\tthat = undefined;\n\t\t\t\t\t\t\t\t\t\t\targs = [ returned ];\n\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t\t// Process the value(s)\n\t\t\t\t\t\t\t\t\t\t// Default process is resolve\n\t\t\t\t\t\t\t\t\t\t( special || deferred.resolveWith )( that, args );\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t},\n\n\t\t\t\t\t\t\t\t// Only normal processors (resolve) catch and reject exceptions\n\t\t\t\t\t\t\t\tprocess = special ?\n\t\t\t\t\t\t\t\t\tmightThrow :\n\t\t\t\t\t\t\t\t\tfunction() {\n\t\t\t\t\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\t\t\t\t\tmightThrow();\n\t\t\t\t\t\t\t\t\t\t} catch ( e ) {\n\n\t\t\t\t\t\t\t\t\t\t\tif ( jQuery.Deferred.exceptionHook ) {\n\t\t\t\t\t\t\t\t\t\t\t\tjQuery.Deferred.exceptionHook( e,\n\t\t\t\t\t\t\t\t\t\t\t\t\tprocess.stackTrace );\n\t\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t\t\t// Support: Promises/A+ section 2.3.3.3.4.1\n\t\t\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-61\n\t\t\t\t\t\t\t\t\t\t\t// Ignore post-resolution exceptions\n\t\t\t\t\t\t\t\t\t\t\tif ( depth + 1 >= maxDepth ) {\n\n\t\t\t\t\t\t\t\t\t\t\t\t// Only substitute handlers pass on context\n\t\t\t\t\t\t\t\t\t\t\t\t// and multiple values (non-spec behavior)\n\t\t\t\t\t\t\t\t\t\t\t\tif ( handler !== Thrower ) {\n\t\t\t\t\t\t\t\t\t\t\t\t\tthat = undefined;\n\t\t\t\t\t\t\t\t\t\t\t\t\targs = [ e ];\n\t\t\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t\t\t\tdeferred.rejectWith( that, args );\n\t\t\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\t};\n\n\t\t\t\t\t\t\t// Support: Promises/A+ section 2.3.3.3.1\n\t\t\t\t\t\t\t// https://promisesaplus.com/#point-57\n\t\t\t\t\t\t\t// Re-resolve promises immediately to dodge false rejection from\n\t\t\t\t\t\t\t// subsequent errors\n\t\t\t\t\t\t\tif ( depth ) {\n\t\t\t\t\t\t\t\tprocess();\n\t\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t\t// Call an optional hook to record the stack, in case of exception\n\t\t\t\t\t\t\t\t// since it's otherwise lost when execution goes async\n\t\t\t\t\t\t\t\tif ( jQuery.Deferred.getStackHook ) {\n\t\t\t\t\t\t\t\t\tprocess.stackTrace = jQuery.Deferred.getStackHook();\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\twindow.setTimeout( process );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t};\n\t\t\t\t\t}\n\n\t\t\t\t\treturn jQuery.Deferred( function( newDefer ) {\n\n\t\t\t\t\t\t// progress_handlers.add( ... )\n\t\t\t\t\t\ttuples[ 0 ][ 3 ].add(\n\t\t\t\t\t\t\tresolve(\n\t\t\t\t\t\t\t\t0,\n\t\t\t\t\t\t\t\tnewDefer,\n\t\t\t\t\t\t\t\tisFunction( onProgress ) ?\n\t\t\t\t\t\t\t\t\tonProgress :\n\t\t\t\t\t\t\t\t\tIdentity,\n\t\t\t\t\t\t\t\tnewDefer.notifyWith\n\t\t\t\t\t\t\t)\n\t\t\t\t\t\t);\n\n\t\t\t\t\t\t// fulfilled_handlers.add( ... )\n\t\t\t\t\t\ttuples[ 1 ][ 3 ].add(\n\t\t\t\t\t\t\tresolve(\n\t\t\t\t\t\t\t\t0,\n\t\t\t\t\t\t\t\tnewDefer,\n\t\t\t\t\t\t\t\tisFunction( onFulfilled ) ?\n\t\t\t\t\t\t\t\t\tonFulfilled :\n\t\t\t\t\t\t\t\t\tIdentity\n\t\t\t\t\t\t\t)\n\t\t\t\t\t\t);\n\n\t\t\t\t\t\t// rejected_handlers.add( ... )\n\t\t\t\t\t\ttuples[ 2 ][ 3 ].add(\n\t\t\t\t\t\t\tresolve(\n\t\t\t\t\t\t\t\t0,\n\t\t\t\t\t\t\t\tnewDefer,\n\t\t\t\t\t\t\t\tisFunction( onRejected ) ?\n\t\t\t\t\t\t\t\t\tonRejected :\n\t\t\t\t\t\t\t\t\tThrower\n\t\t\t\t\t\t\t)\n\t\t\t\t\t\t);\n\t\t\t\t\t} ).promise();\n\t\t\t\t},\n\n\t\t\t\t// Get a promise for this deferred\n\t\t\t\t// If obj is provided, the promise aspect is added to the object\n\t\t\t\tpromise: function( obj ) {\n\t\t\t\t\treturn obj != null ? jQuery.extend( obj, promise ) : promise;\n\t\t\t\t}\n\t\t\t},\n\t\t\tdeferred = {};\n\n\t\t// Add list-specific methods\n\t\tjQuery.each( tuples, function( i, tuple ) {\n\t\t\tvar list = tuple[ 2 ],\n\t\t\t\tstateString = tuple[ 5 ];\n\n\t\t\t// promise.progress = list.add\n\t\t\t// promise.done = list.add\n\t\t\t// promise.fail = list.add\n\t\t\tpromise[ tuple[ 1 ] ] = list.add;\n\n\t\t\t// Handle state\n\t\t\tif ( stateString ) {\n\t\t\t\tlist.add(\n\t\t\t\t\tfunction() {\n\n\t\t\t\t\t\t// state = \"resolved\" (i.e., fulfilled)\n\t\t\t\t\t\t// state = \"rejected\"\n\t\t\t\t\t\tstate = stateString;\n\t\t\t\t\t},\n\n\t\t\t\t\t// rejected_callbacks.disable\n\t\t\t\t\t// fulfilled_callbacks.disable\n\t\t\t\t\ttuples[ 3 - i ][ 2 ].disable,\n\n\t\t\t\t\t// rejected_handlers.disable\n\t\t\t\t\t// fulfilled_handlers.disable\n\t\t\t\t\ttuples[ 3 - i ][ 3 ].disable,\n\n\t\t\t\t\t// progress_callbacks.lock\n\t\t\t\t\ttuples[ 0 ][ 2 ].lock,\n\n\t\t\t\t\t// progress_handlers.lock\n\t\t\t\t\ttuples[ 0 ][ 3 ].lock\n\t\t\t\t);\n\t\t\t}\n\n\t\t\t// progress_handlers.fire\n\t\t\t// fulfilled_handlers.fire\n\t\t\t// rejected_handlers.fire\n\t\t\tlist.add( tuple[ 3 ].fire );\n\n\t\t\t// deferred.notify = function() { deferred.notifyWith(...) }\n\t\t\t// deferred.resolve = function() { deferred.resolveWith(...) }\n\t\t\t// deferred.reject = function() { deferred.rejectWith(...) }\n\t\t\tdeferred[ tuple[ 0 ] ] = function() {\n\t\t\t\tdeferred[ tuple[ 0 ] + \"With\" ]( this === deferred ? undefined : this, arguments );\n\t\t\t\treturn this;\n\t\t\t};\n\n\t\t\t// deferred.notifyWith = list.fireWith\n\t\t\t// deferred.resolveWith = list.fireWith\n\t\t\t// deferred.rejectWith = list.fireWith\n\t\t\tdeferred[ tuple[ 0 ] + \"With\" ] = list.fireWith;\n\t\t} );\n\n\t\t// Make the deferred a promise\n\t\tpromise.promise( deferred );\n\n\t\t// Call given func if any\n\t\tif ( func ) {\n\t\t\tfunc.call( deferred, deferred );\n\t\t}\n\n\t\t// All done!\n\t\treturn deferred;\n\t},\n\n\t// Deferred helper\n\twhen: function( singleValue ) {\n\t\tvar\n\n\t\t\t// count of uncompleted subordinates\n\t\t\tremaining = arguments.length,\n\n\t\t\t// count of unprocessed arguments\n\t\t\ti = remaining,\n\n\t\t\t// subordinate fulfillment data\n\t\t\tresolveContexts = Array( i ),\n\t\t\tresolveValues = slice.call( arguments ),\n\n\t\t\t// the master Deferred\n\t\t\tmaster = jQuery.Deferred(),\n\n\t\t\t// subordinate callback factory\n\t\t\tupdateFunc = function( i ) {\n\t\t\t\treturn function( value ) {\n\t\t\t\t\tresolveContexts[ i ] = this;\n\t\t\t\t\tresolveValues[ i ] = arguments.length > 1 ? slice.call( arguments ) : value;\n\t\t\t\t\tif ( !( --remaining ) ) {\n\t\t\t\t\t\tmaster.resolveWith( resolveContexts, resolveValues );\n\t\t\t\t\t}\n\t\t\t\t};\n\t\t\t};\n\n\t\t// Single- and empty arguments are adopted like Promise.resolve\n\t\tif ( remaining <= 1 ) {\n\t\t\tadoptValue( singleValue, master.done( updateFunc( i ) ).resolve, master.reject,\n\t\t\t\t!remaining );\n\n\t\t\t// Use .then() to unwrap secondary thenables (cf. gh-3000)\n\t\t\tif ( master.state() === \"pending\" ||\n\t\t\t\tisFunction( resolveValues[ i ] && resolveValues[ i ].then ) ) {\n\n\t\t\t\treturn master.then();\n\t\t\t}\n\t\t}\n\n\t\t// Multiple arguments are aggregated like Promise.all array elements\n\t\twhile ( i-- ) {\n\t\t\tadoptValue( resolveValues[ i ], updateFunc( i ), master.reject );\n\t\t}\n\n\t\treturn master.promise();\n\t}\n} );\n\n\n// These usually indicate a programmer mistake during development,\n// warn about them ASAP rather than swallowing them by default.\nvar rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;\n\njQuery.Deferred.exceptionHook = function( error, stack ) {\n\n\t// Support: IE 8 - 9 only\n\t// Console exists when dev tools are open, which can happen at any time\n\tif ( window.console && window.console.warn && error && rerrorNames.test( error.name ) ) {\n\t\twindow.console.warn( \"jQuery.Deferred exception: \" + error.message, error.stack, stack );\n\t}\n};\n\n\n\n\njQuery.readyException = function( error ) {\n\twindow.setTimeout( function() {\n\t\tthrow error;\n\t} );\n};\n\n\n\n\n// The deferred used on DOM ready\nvar readyList = jQuery.Deferred();\n\njQuery.fn.ready = function( fn ) {\n\n\treadyList\n\t\t.then( fn )\n\n\t\t// Wrap jQuery.readyException in a function so that the lookup\n\t\t// happens at the time of error handling instead of callback\n\t\t// registration.\n\t\t.catch( function( error ) {\n\t\t\tjQuery.readyException( error );\n\t\t} );\n\n\treturn this;\n};\n\njQuery.extend( {\n\n\t// Is the DOM ready to be used? Set to true once it occurs.\n\tisReady: false,\n\n\t// A counter to track how many items to wait for before\n\t// the ready event fires. See #6781\n\treadyWait: 1,\n\n\t// Handle when the DOM is ready\n\tready: function( wait ) {\n\n\t\t// Abort if there are pending holds or we're already ready\n\t\tif ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Remember that the DOM is ready\n\t\tjQuery.isReady = true;\n\n\t\t// If a normal DOM Ready event fired, decrement, and wait if need be\n\t\tif ( wait !== true && --jQuery.readyWait > 0 ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// If there are functions bound, to execute\n\t\treadyList.resolveWith( document, [ jQuery ] );\n\t}\n} );\n\njQuery.ready.then = readyList.then;\n\n// The ready event handler and self cleanup method\nfunction completed() {\n\tdocument.removeEventListener( \"DOMContentLoaded\", completed );\n\twindow.removeEventListener( \"load\", completed );\n\tjQuery.ready();\n}\n\n// Catch cases where $(document).ready() is called\n// after the browser event has already occurred.\n// Support: IE <=9 - 10 only\n// Older IE sometimes signals \"interactive\" too soon\nif ( document.readyState === \"complete\" ||\n\t( document.readyState !== \"loading\" && !document.documentElement.doScroll ) ) {\n\n\t// Handle it asynchronously to allow scripts the opportunity to delay ready\n\twindow.setTimeout( jQuery.ready );\n\n} else {\n\n\t// Use the handy event callback\n\tdocument.addEventListener( \"DOMContentLoaded\", completed );\n\n\t// A fallback to window.onload, that will always work\n\twindow.addEventListener( \"load\", completed );\n}\n\n\n\n\n// Multifunctional method to get and set values of a collection\n// The value/s can optionally be executed if it's a function\nvar access = function( elems, fn, key, value, chainable, emptyGet, raw ) {\n\tvar i = 0,\n\t\tlen = elems.length,\n\t\tbulk = key == null;\n\n\t// Sets many values\n\tif ( toType( key ) === \"object\" ) {\n\t\tchainable = true;\n\t\tfor ( i in key ) {\n\t\t\taccess( elems, fn, i, key[ i ], true, emptyGet, raw );\n\t\t}\n\n\t// Sets one value\n\t} else if ( value !== undefined ) {\n\t\tchainable = true;\n\n\t\tif ( !isFunction( value ) ) {\n\t\t\traw = true;\n\t\t}\n\n\t\tif ( bulk ) {\n\n\t\t\t// Bulk operations run against the entire set\n\t\t\tif ( raw ) {\n\t\t\t\tfn.call( elems, value );\n\t\t\t\tfn = null;\n\n\t\t\t// ...except when executing function values\n\t\t\t} else {\n\t\t\t\tbulk = fn;\n\t\t\t\tfn = function( elem, key, value ) {\n\t\t\t\t\treturn bulk.call( jQuery( elem ), value );\n\t\t\t\t};\n\t\t\t}\n\t\t}\n\n\t\tif ( fn ) {\n\t\t\tfor ( ; i < len; i++ ) {\n\t\t\t\tfn(\n\t\t\t\t\telems[ i ], key, raw ?\n\t\t\t\t\tvalue :\n\t\t\t\t\tvalue.call( elems[ i ], i, fn( elems[ i ], key ) )\n\t\t\t\t);\n\t\t\t}\n\t\t}\n\t}\n\n\tif ( chainable ) {\n\t\treturn elems;\n\t}\n\n\t// Gets\n\tif ( bulk ) {\n\t\treturn fn.call( elems );\n\t}\n\n\treturn len ? fn( elems[ 0 ], key ) : emptyGet;\n};\n\n\n// Matches dashed string for camelizing\nvar rmsPrefix = /^-ms-/,\n\trdashAlpha = /-([a-z])/g;\n\n// Used by camelCase as callback to replace()\nfunction fcamelCase( all, letter ) {\n\treturn letter.toUpperCase();\n}\n\n// Convert dashed to camelCase; used by the css and data modules\n// Support: IE <=9 - 11, Edge 12 - 15\n// Microsoft forgot to hump their vendor prefix (#9572)\nfunction camelCase( string ) {\n\treturn string.replace( rmsPrefix, \"ms-\" ).replace( rdashAlpha, fcamelCase );\n}\nvar acceptData = function( owner ) {\n\n\t// Accepts only:\n\t//  - Node\n\t//    - Node.ELEMENT_NODE\n\t//    - Node.DOCUMENT_NODE\n\t//  - Object\n\t//    - Any\n\treturn owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType );\n};\n\n\n\n\nfunction Data() {\n\tthis.expando = jQuery.expando + Data.uid++;\n}\n\nData.uid = 1;\n\nData.prototype = {\n\n\tcache: function( owner ) {\n\n\t\t// Check if the owner object already has a cache\n\t\tvar value = owner[ this.expando ];\n\n\t\t// If not, create one\n\t\tif ( !value ) {\n\t\t\tvalue = {};\n\n\t\t\t// We can accept data for non-element nodes in modern browsers,\n\t\t\t// but we should not, see #8335.\n\t\t\t// Always return an empty object.\n\t\t\tif ( acceptData( owner ) ) {\n\n\t\t\t\t// If it is a node unlikely to be stringify-ed or looped over\n\t\t\t\t// use plain assignment\n\t\t\t\tif ( owner.nodeType ) {\n\t\t\t\t\towner[ this.expando ] = value;\n\n\t\t\t\t// Otherwise secure it in a non-enumerable property\n\t\t\t\t// configurable must be true to allow the property to be\n\t\t\t\t// deleted when data is removed\n\t\t\t\t} else {\n\t\t\t\t\tObject.defineProperty( owner, this.expando, {\n\t\t\t\t\t\tvalue: value,\n\t\t\t\t\t\tconfigurable: true\n\t\t\t\t\t} );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn value;\n\t},\n\tset: function( owner, data, value ) {\n\t\tvar prop,\n\t\t\tcache = this.cache( owner );\n\n\t\t// Handle: [ owner, key, value ] args\n\t\t// Always use camelCase key (gh-2257)\n\t\tif ( typeof data === \"string\" ) {\n\t\t\tcache[ camelCase( data ) ] = value;\n\n\t\t// Handle: [ owner, { properties } ] args\n\t\t} else {\n\n\t\t\t// Copy the properties one-by-one to the cache object\n\t\t\tfor ( prop in data ) {\n\t\t\t\tcache[ camelCase( prop ) ] = data[ prop ];\n\t\t\t}\n\t\t}\n\t\treturn cache;\n\t},\n\tget: function( owner, key ) {\n\t\treturn key === undefined ?\n\t\t\tthis.cache( owner ) :\n\n\t\t\t// Always use camelCase key (gh-2257)\n\t\t\towner[ this.expando ] && owner[ this.expando ][ camelCase( key ) ];\n\t},\n\taccess: function( owner, key, value ) {\n\n\t\t// In cases where either:\n\t\t//\n\t\t//   1. No key was specified\n\t\t//   2. A string key was specified, but no value provided\n\t\t//\n\t\t// Take the \"read\" path and allow the get method to determine\n\t\t// which value to return, respectively either:\n\t\t//\n\t\t//   1. The entire cache object\n\t\t//   2. The data stored at the key\n\t\t//\n\t\tif ( key === undefined ||\n\t\t\t\t( ( key && typeof key === \"string\" ) && value === undefined ) ) {\n\n\t\t\treturn this.get( owner, key );\n\t\t}\n\n\t\t// When the key is not a string, or both a key and value\n\t\t// are specified, set or extend (existing objects) with either:\n\t\t//\n\t\t//   1. An object of properties\n\t\t//   2. A key and value\n\t\t//\n\t\tthis.set( owner, key, value );\n\n\t\t// Since the \"set\" path can have two possible entry points\n\t\t// return the expected data based on which path was taken[*]\n\t\treturn value !== undefined ? value : key;\n\t},\n\tremove: function( owner, key ) {\n\t\tvar i,\n\t\t\tcache = owner[ this.expando ];\n\n\t\tif ( cache === undefined ) {\n\t\t\treturn;\n\t\t}\n\n\t\tif ( key !== undefined ) {\n\n\t\t\t// Support array or space separated string of keys\n\t\t\tif ( Array.isArray( key ) ) {\n\n\t\t\t\t// If key is an array of keys...\n\t\t\t\t// We always set camelCase keys, so remove that.\n\t\t\t\tkey = key.map( camelCase );\n\t\t\t} else {\n\t\t\t\tkey = camelCase( key );\n\n\t\t\t\t// If a key with the spaces exists, use it.\n\t\t\t\t// Otherwise, create an array by matching non-whitespace\n\t\t\t\tkey = key in cache ?\n\t\t\t\t\t[ key ] :\n\t\t\t\t\t( key.match( rnothtmlwhite ) || [] );\n\t\t\t}\n\n\t\t\ti = key.length;\n\n\t\t\twhile ( i-- ) {\n\t\t\t\tdelete cache[ key[ i ] ];\n\t\t\t}\n\t\t}\n\n\t\t// Remove the expando if there's no more data\n\t\tif ( key === undefined || jQuery.isEmptyObject( cache ) ) {\n\n\t\t\t// Support: Chrome <=35 - 45\n\t\t\t// Webkit & Blink performance suffers when deleting properties\n\t\t\t// from DOM nodes, so set to undefined instead\n\t\t\t// https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted)\n\t\t\tif ( owner.nodeType ) {\n\t\t\t\towner[ this.expando ] = undefined;\n\t\t\t} else {\n\t\t\t\tdelete owner[ this.expando ];\n\t\t\t}\n\t\t}\n\t},\n\thasData: function( owner ) {\n\t\tvar cache = owner[ this.expando ];\n\t\treturn cache !== undefined && !jQuery.isEmptyObject( cache );\n\t}\n};\nvar dataPriv = new Data();\n\nvar dataUser = new Data();\n\n\n\n//\tImplementation Summary\n//\n//\t1. Enforce API surface and semantic compatibility with 1.9.x branch\n//\t2. Improve the module's maintainability by reducing the storage\n//\t\tpaths to a single mechanism.\n//\t3. Use the same single mechanism to support \"private\" and \"user\" data.\n//\t4. _Never_ expose \"private\" data to user code (TODO: Drop _data, _removeData)\n//\t5. Avoid exposing implementation details on user objects (eg. expando properties)\n//\t6. Provide a clear path for implementation upgrade to WeakMap in 2014\n\nvar rbrace = /^(?:\\{[\\w\\W]*\\}|\\[[\\w\\W]*\\])$/,\n\trmultiDash = /[A-Z]/g;\n\nfunction getData( data ) {\n\tif ( data === \"true\" ) {\n\t\treturn true;\n\t}\n\n\tif ( data === \"false\" ) {\n\t\treturn false;\n\t}\n\n\tif ( data === \"null\" ) {\n\t\treturn null;\n\t}\n\n\t// Only convert to a number if it doesn't change the string\n\tif ( data === +data + \"\" ) {\n\t\treturn +data;\n\t}\n\n\tif ( rbrace.test( data ) ) {\n\t\treturn JSON.parse( data );\n\t}\n\n\treturn data;\n}\n\nfunction dataAttr( elem, key, data ) {\n\tvar name;\n\n\t// If nothing was found internally, try to fetch any\n\t// data from the HTML5 data-* attribute\n\tif ( data === undefined && elem.nodeType === 1 ) {\n\t\tname = \"data-\" + key.replace( rmultiDash, \"-$&\" ).toLowerCase();\n\t\tdata = elem.getAttribute( name );\n\n\t\tif ( typeof data === \"string\" ) {\n\t\t\ttry {\n\t\t\t\tdata = getData( data );\n\t\t\t} catch ( e ) {}\n\n\t\t\t// Make sure we set the data so it isn't changed later\n\t\t\tdataUser.set( elem, key, data );\n\t\t} else {\n\t\t\tdata = undefined;\n\t\t}\n\t}\n\treturn data;\n}\n\njQuery.extend( {\n\thasData: function( elem ) {\n\t\treturn dataUser.hasData( elem ) || dataPriv.hasData( elem );\n\t},\n\n\tdata: function( elem, name, data ) {\n\t\treturn dataUser.access( elem, name, data );\n\t},\n\n\tremoveData: function( elem, name ) {\n\t\tdataUser.remove( elem, name );\n\t},\n\n\t// TODO: Now that all calls to _data and _removeData have been replaced\n\t// with direct calls to dataPriv methods, these can be deprecated.\n\t_data: function( elem, name, data ) {\n\t\treturn dataPriv.access( elem, name, data );\n\t},\n\n\t_removeData: function( elem, name ) {\n\t\tdataPriv.remove( elem, name );\n\t}\n} );\n\njQuery.fn.extend( {\n\tdata: function( key, value ) {\n\t\tvar i, name, data,\n\t\t\telem = this[ 0 ],\n\t\t\tattrs = elem && elem.attributes;\n\n\t\t// Gets all values\n\t\tif ( key === undefined ) {\n\t\t\tif ( this.length ) {\n\t\t\t\tdata = dataUser.get( elem );\n\n\t\t\t\tif ( elem.nodeType === 1 && !dataPriv.get( elem, \"hasDataAttrs\" ) ) {\n\t\t\t\t\ti = attrs.length;\n\t\t\t\t\twhile ( i-- ) {\n\n\t\t\t\t\t\t// Support: IE 11 only\n\t\t\t\t\t\t// The attrs elements can be null (#14894)\n\t\t\t\t\t\tif ( attrs[ i ] ) {\n\t\t\t\t\t\t\tname = attrs[ i ].name;\n\t\t\t\t\t\t\tif ( name.indexOf( \"data-\" ) === 0 ) {\n\t\t\t\t\t\t\t\tname = camelCase( name.slice( 5 ) );\n\t\t\t\t\t\t\t\tdataAttr( elem, name, data[ name ] );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tdataPriv.set( elem, \"hasDataAttrs\", true );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn data;\n\t\t}\n\n\t\t// Sets multiple values\n\t\tif ( typeof key === \"object\" ) {\n\t\t\treturn this.each( function() {\n\t\t\t\tdataUser.set( this, key );\n\t\t\t} );\n\t\t}\n\n\t\treturn access( this, function( value ) {\n\t\t\tvar data;\n\n\t\t\t// The calling jQuery object (element matches) is not empty\n\t\t\t// (and therefore has an element appears at this[ 0 ]) and the\n\t\t\t// `value` parameter was not undefined. An empty jQuery object\n\t\t\t// will result in `undefined` for elem = this[ 0 ] which will\n\t\t\t// throw an exception if an attempt to read a data cache is made.\n\t\t\tif ( elem && value === undefined ) {\n\n\t\t\t\t// Attempt to get data from the cache\n\t\t\t\t// The key will always be camelCased in Data\n\t\t\t\tdata = dataUser.get( elem, key );\n\t\t\t\tif ( data !== undefined ) {\n\t\t\t\t\treturn data;\n\t\t\t\t}\n\n\t\t\t\t// Attempt to \"discover\" the data in\n\t\t\t\t// HTML5 custom data-* attrs\n\t\t\t\tdata = dataAttr( elem, key );\n\t\t\t\tif ( data !== undefined ) {\n\t\t\t\t\treturn data;\n\t\t\t\t}\n\n\t\t\t\t// We tried really hard, but the data doesn't exist.\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// Set the data...\n\t\t\tthis.each( function() {\n\n\t\t\t\t// We always store the camelCased key\n\t\t\t\tdataUser.set( this, key, value );\n\t\t\t} );\n\t\t}, null, value, arguments.length > 1, null, true );\n\t},\n\n\tremoveData: function( key ) {\n\t\treturn this.each( function() {\n\t\t\tdataUser.remove( this, key );\n\t\t} );\n\t}\n} );\n\n\njQuery.extend( {\n\tqueue: function( elem, type, data ) {\n\t\tvar queue;\n\n\t\tif ( elem ) {\n\t\t\ttype = ( type || \"fx\" ) + \"queue\";\n\t\t\tqueue = dataPriv.get( elem, type );\n\n\t\t\t// Speed up dequeue by getting out quickly if this is just a lookup\n\t\t\tif ( data ) {\n\t\t\t\tif ( !queue || Array.isArray( data ) ) {\n\t\t\t\t\tqueue = dataPriv.access( elem, type, jQuery.makeArray( data ) );\n\t\t\t\t} else {\n\t\t\t\t\tqueue.push( data );\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn queue || [];\n\t\t}\n\t},\n\n\tdequeue: function( elem, type ) {\n\t\ttype = type || \"fx\";\n\n\t\tvar queue = jQuery.queue( elem, type ),\n\t\t\tstartLength = queue.length,\n\t\t\tfn = queue.shift(),\n\t\t\thooks = jQuery._queueHooks( elem, type ),\n\t\t\tnext = function() {\n\t\t\t\tjQuery.dequeue( elem, type );\n\t\t\t};\n\n\t\t// If the fx queue is dequeued, always remove the progress sentinel\n\t\tif ( fn === \"inprogress\" ) {\n\t\t\tfn = queue.shift();\n\t\t\tstartLength--;\n\t\t}\n\n\t\tif ( fn ) {\n\n\t\t\t// Add a progress sentinel to prevent the fx queue from being\n\t\t\t// automatically dequeued\n\t\t\tif ( type === \"fx\" ) {\n\t\t\t\tqueue.unshift( \"inprogress\" );\n\t\t\t}\n\n\t\t\t// Clear up the last queue stop function\n\t\t\tdelete hooks.stop;\n\t\t\tfn.call( elem, next, hooks );\n\t\t}\n\n\t\tif ( !startLength && hooks ) {\n\t\t\thooks.empty.fire();\n\t\t}\n\t},\n\n\t// Not public - generate a queueHooks object, or return the current one\n\t_queueHooks: function( elem, type ) {\n\t\tvar key = type + \"queueHooks\";\n\t\treturn dataPriv.get( elem, key ) || dataPriv.access( elem, key, {\n\t\t\tempty: jQuery.Callbacks( \"once memory\" ).add( function() {\n\t\t\t\tdataPriv.remove( elem, [ type + \"queue\", key ] );\n\t\t\t} )\n\t\t} );\n\t}\n} );\n\njQuery.fn.extend( {\n\tqueue: function( type, data ) {\n\t\tvar setter = 2;\n\n\t\tif ( typeof type !== \"string\" ) {\n\t\t\tdata = type;\n\t\t\ttype = \"fx\";\n\t\t\tsetter--;\n\t\t}\n\n\t\tif ( arguments.length < setter ) {\n\t\t\treturn jQuery.queue( this[ 0 ], type );\n\t\t}\n\n\t\treturn data === undefined ?\n\t\t\tthis :\n\t\t\tthis.each( function() {\n\t\t\t\tvar queue = jQuery.queue( this, type, data );\n\n\t\t\t\t// Ensure a hooks for this queue\n\t\t\t\tjQuery._queueHooks( this, type );\n\n\t\t\t\tif ( type === \"fx\" && queue[ 0 ] !== \"inprogress\" ) {\n\t\t\t\t\tjQuery.dequeue( this, type );\n\t\t\t\t}\n\t\t\t} );\n\t},\n\tdequeue: function( type ) {\n\t\treturn this.each( function() {\n\t\t\tjQuery.dequeue( this, type );\n\t\t} );\n\t},\n\tclearQueue: function( type ) {\n\t\treturn this.queue( type || \"fx\", [] );\n\t},\n\n\t// Get a promise resolved when queues of a certain type\n\t// are emptied (fx is the type by default)\n\tpromise: function( type, obj ) {\n\t\tvar tmp,\n\t\t\tcount = 1,\n\t\t\tdefer = jQuery.Deferred(),\n\t\t\telements = this,\n\t\t\ti = this.length,\n\t\t\tresolve = function() {\n\t\t\t\tif ( !( --count ) ) {\n\t\t\t\t\tdefer.resolveWith( elements, [ elements ] );\n\t\t\t\t}\n\t\t\t};\n\n\t\tif ( typeof type !== \"string\" ) {\n\t\t\tobj = type;\n\t\t\ttype = undefined;\n\t\t}\n\t\ttype = type || \"fx\";\n\n\t\twhile ( i-- ) {\n\t\t\ttmp = dataPriv.get( elements[ i ], type + \"queueHooks\" );\n\t\t\tif ( tmp && tmp.empty ) {\n\t\t\t\tcount++;\n\t\t\t\ttmp.empty.add( resolve );\n\t\t\t}\n\t\t}\n\t\tresolve();\n\t\treturn defer.promise( obj );\n\t}\n} );\nvar pnum = ( /[+-]?(?:\\d*\\.|)\\d+(?:[eE][+-]?\\d+|)/ ).source;\n\nvar rcssNum = new RegExp( \"^(?:([+-])=|)(\" + pnum + \")([a-z%]*)$\", \"i\" );\n\n\nvar cssExpand = [ \"Top\", \"Right\", \"Bottom\", \"Left\" ];\n\nvar isHiddenWithinTree = function( elem, el ) {\n\n\t\t// isHiddenWithinTree might be called from jQuery#filter function;\n\t\t// in that case, element will be second argument\n\t\telem = el || elem;\n\n\t\t// Inline style trumps all\n\t\treturn elem.style.display === \"none\" ||\n\t\t\telem.style.display === \"\" &&\n\n\t\t\t// Otherwise, check computed style\n\t\t\t// Support: Firefox <=43 - 45\n\t\t\t// Disconnected elements can have computed display: none, so first confirm that elem is\n\t\t\t// in the document.\n\t\t\tjQuery.contains( elem.ownerDocument, elem ) &&\n\n\t\t\tjQuery.css( elem, \"display\" ) === \"none\";\n\t};\n\nvar swap = function( elem, options, callback, args ) {\n\tvar ret, name,\n\t\told = {};\n\n\t// Remember the old values, and insert the new ones\n\tfor ( name in options ) {\n\t\told[ name ] = elem.style[ name ];\n\t\telem.style[ name ] = options[ name ];\n\t}\n\n\tret = callback.apply( elem, args || [] );\n\n\t// Revert the old values\n\tfor ( name in options ) {\n\t\telem.style[ name ] = old[ name ];\n\t}\n\n\treturn ret;\n};\n\n\n\n\nfunction adjustCSS( elem, prop, valueParts, tween ) {\n\tvar adjusted, scale,\n\t\tmaxIterations = 20,\n\t\tcurrentValue = tween ?\n\t\t\tfunction() {\n\t\t\t\treturn tween.cur();\n\t\t\t} :\n\t\t\tfunction() {\n\t\t\t\treturn jQuery.css( elem, prop, \"\" );\n\t\t\t},\n\t\tinitial = currentValue(),\n\t\tunit = valueParts && valueParts[ 3 ] || ( jQuery.cssNumber[ prop ] ? \"\" : \"px\" ),\n\n\t\t// Starting value computation is required for potential unit mismatches\n\t\tinitialInUnit = ( jQuery.cssNumber[ prop ] || unit !== \"px\" && +initial ) &&\n\t\t\trcssNum.exec( jQuery.css( elem, prop ) );\n\n\tif ( initialInUnit && initialInUnit[ 3 ] !== unit ) {\n\n\t\t// Support: Firefox <=54\n\t\t// Halve the iteration target value to prevent interference from CSS upper bounds (gh-2144)\n\t\tinitial = initial / 2;\n\n\t\t// Trust units reported by jQuery.css\n\t\tunit = unit || initialInUnit[ 3 ];\n\n\t\t// Iteratively approximate from a nonzero starting point\n\t\tinitialInUnit = +initial || 1;\n\n\t\twhile ( maxIterations-- ) {\n\n\t\t\t// Evaluate and update our best guess (doubling guesses that zero out).\n\t\t\t// Finish if the scale equals or crosses 1 (making the old*new product non-positive).\n\t\t\tjQuery.style( elem, prop, initialInUnit + unit );\n\t\t\tif ( ( 1 - scale ) * ( 1 - ( scale = currentValue() / initial || 0.5 ) ) <= 0 ) {\n\t\t\t\tmaxIterations = 0;\n\t\t\t}\n\t\t\tinitialInUnit = initialInUnit / scale;\n\n\t\t}\n\n\t\tinitialInUnit = initialInUnit * 2;\n\t\tjQuery.style( elem, prop, initialInUnit + unit );\n\n\t\t// Make sure we update the tween properties later on\n\t\tvalueParts = valueParts || [];\n\t}\n\n\tif ( valueParts ) {\n\t\tinitialInUnit = +initialInUnit || +initial || 0;\n\n\t\t// Apply relative offset (+=/-=) if specified\n\t\tadjusted = valueParts[ 1 ] ?\n\t\t\tinitialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] :\n\t\t\t+valueParts[ 2 ];\n\t\tif ( tween ) {\n\t\t\ttween.unit = unit;\n\t\t\ttween.start = initialInUnit;\n\t\t\ttween.end = adjusted;\n\t\t}\n\t}\n\treturn adjusted;\n}\n\n\nvar defaultDisplayMap = {};\n\nfunction getDefaultDisplay( elem ) {\n\tvar temp,\n\t\tdoc = elem.ownerDocument,\n\t\tnodeName = elem.nodeName,\n\t\tdisplay = defaultDisplayMap[ nodeName ];\n\n\tif ( display ) {\n\t\treturn display;\n\t}\n\n\ttemp = doc.body.appendChild( doc.createElement( nodeName ) );\n\tdisplay = jQuery.css( temp, \"display\" );\n\n\ttemp.parentNode.removeChild( temp );\n\n\tif ( display === \"none\" ) {\n\t\tdisplay = \"block\";\n\t}\n\tdefaultDisplayMap[ nodeName ] = display;\n\n\treturn display;\n}\n\nfunction showHide( elements, show ) {\n\tvar display, elem,\n\t\tvalues = [],\n\t\tindex = 0,\n\t\tlength = elements.length;\n\n\t// Determine new display value for elements that need to change\n\tfor ( ; index < length; index++ ) {\n\t\telem = elements[ index ];\n\t\tif ( !elem.style ) {\n\t\t\tcontinue;\n\t\t}\n\n\t\tdisplay = elem.style.display;\n\t\tif ( show ) {\n\n\t\t\t// Since we force visibility upon cascade-hidden elements, an immediate (and slow)\n\t\t\t// check is required in this first loop unless we have a nonempty display value (either\n\t\t\t// inline or about-to-be-restored)\n\t\t\tif ( display === \"none\" ) {\n\t\t\t\tvalues[ index ] = dataPriv.get( elem, \"display\" ) || null;\n\t\t\t\tif ( !values[ index ] ) {\n\t\t\t\t\telem.style.display = \"\";\n\t\t\t\t}\n\t\t\t}\n\t\t\tif ( elem.style.display === \"\" && isHiddenWithinTree( elem ) ) {\n\t\t\t\tvalues[ index ] = getDefaultDisplay( elem );\n\t\t\t}\n\t\t} else {\n\t\t\tif ( display !== \"none\" ) {\n\t\t\t\tvalues[ index ] = \"none\";\n\n\t\t\t\t// Remember what we're overwriting\n\t\t\t\tdataPriv.set( elem, \"display\", display );\n\t\t\t}\n\t\t}\n\t}\n\n\t// Set the display of the elements in a second loop to avoid constant reflow\n\tfor ( index = 0; index < length; index++ ) {\n\t\tif ( values[ index ] != null ) {\n\t\t\telements[ index ].style.display = values[ index ];\n\t\t}\n\t}\n\n\treturn elements;\n}\n\njQuery.fn.extend( {\n\tshow: function() {\n\t\treturn showHide( this, true );\n\t},\n\thide: function() {\n\t\treturn showHide( this );\n\t},\n\ttoggle: function( state ) {\n\t\tif ( typeof state === \"boolean\" ) {\n\t\t\treturn state ? this.show() : this.hide();\n\t\t}\n\n\t\treturn this.each( function() {\n\t\t\tif ( isHiddenWithinTree( this ) ) {\n\t\t\t\tjQuery( this ).show();\n\t\t\t} else {\n\t\t\t\tjQuery( this ).hide();\n\t\t\t}\n\t\t} );\n\t}\n} );\nvar rcheckableType = ( /^(?:checkbox|radio)$/i );\n\nvar rtagName = ( /<([a-z][^\\/\\0>\\x20\\t\\r\\n\\f]+)/i );\n\nvar rscriptType = ( /^$|^module$|\\/(?:java|ecma)script/i );\n\n\n\n// We have to close these tags to support XHTML (#13200)\nvar wrapMap = {\n\n\t// Support: IE <=9 only\n\toption: [ 1, \"<select multiple='multiple'>\", \"</select>\" ],\n\n\t// XHTML parsers do not magically insert elements in the\n\t// same way that tag soup parsers do. So we cannot shorten\n\t// this by omitting <tbody> or other required elements.\n\tthead: [ 1, \"<table>\", \"</table>\" ],\n\tcol: [ 2, \"<table><colgroup>\", \"</colgroup></table>\" ],\n\ttr: [ 2, \"<table><tbody>\", \"</tbody></table>\" ],\n\ttd: [ 3, \"<table><tbody><tr>\", \"</tr></tbody></table>\" ],\n\n\t_default: [ 0, \"\", \"\" ]\n};\n\n// Support: IE <=9 only\nwrapMap.optgroup = wrapMap.option;\n\nwrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;\nwrapMap.th = wrapMap.td;\n\n\nfunction getAll( context, tag ) {\n\n\t// Support: IE <=9 - 11 only\n\t// Use typeof to avoid zero-argument method invocation on host objects (#15151)\n\tvar ret;\n\n\tif ( typeof context.getElementsByTagName !== \"undefined\" ) {\n\t\tret = context.getElementsByTagName( tag || \"*\" );\n\n\t} else if ( typeof context.querySelectorAll !== \"undefined\" ) {\n\t\tret = context.querySelectorAll( tag || \"*\" );\n\n\t} else {\n\t\tret = [];\n\t}\n\n\tif ( tag === undefined || tag && nodeName( context, tag ) ) {\n\t\treturn jQuery.merge( [ context ], ret );\n\t}\n\n\treturn ret;\n}\n\n\n// Mark scripts as having already been evaluated\nfunction setGlobalEval( elems, refElements ) {\n\tvar i = 0,\n\t\tl = elems.length;\n\n\tfor ( ; i < l; i++ ) {\n\t\tdataPriv.set(\n\t\t\telems[ i ],\n\t\t\t\"globalEval\",\n\t\t\t!refElements || dataPriv.get( refElements[ i ], \"globalEval\" )\n\t\t);\n\t}\n}\n\n\nvar rhtml = /<|&#?\\w+;/;\n\nfunction buildFragment( elems, context, scripts, selection, ignored ) {\n\tvar elem, tmp, tag, wrap, contains, j,\n\t\tfragment = context.createDocumentFragment(),\n\t\tnodes = [],\n\t\ti = 0,\n\t\tl = elems.length;\n\n\tfor ( ; i < l; i++ ) {\n\t\telem = elems[ i ];\n\n\t\tif ( elem || elem === 0 ) {\n\n\t\t\t// Add nodes directly\n\t\t\tif ( toType( elem ) === \"object\" ) {\n\n\t\t\t\t// Support: Android <=4.0 only, PhantomJS 1 only\n\t\t\t\t// push.apply(_, arraylike) throws on ancient WebKit\n\t\t\t\tjQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );\n\n\t\t\t// Convert non-html into a text node\n\t\t\t} else if ( !rhtml.test( elem ) ) {\n\t\t\t\tnodes.push( context.createTextNode( elem ) );\n\n\t\t\t// Convert html into DOM nodes\n\t\t\t} else {\n\t\t\t\ttmp = tmp || fragment.appendChild( context.createElement( \"div\" ) );\n\n\t\t\t\t// Deserialize a standard representation\n\t\t\t\ttag = ( rtagName.exec( elem ) || [ \"\", \"\" ] )[ 1 ].toLowerCase();\n\t\t\t\twrap = wrapMap[ tag ] || wrapMap._default;\n\t\t\t\ttmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ];\n\n\t\t\t\t// Descend through wrappers to the right content\n\t\t\t\tj = wrap[ 0 ];\n\t\t\t\twhile ( j-- ) {\n\t\t\t\t\ttmp = tmp.lastChild;\n\t\t\t\t}\n\n\t\t\t\t// Support: Android <=4.0 only, PhantomJS 1 only\n\t\t\t\t// push.apply(_, arraylike) throws on ancient WebKit\n\t\t\t\tjQuery.merge( nodes, tmp.childNodes );\n\n\t\t\t\t// Remember the top-level container\n\t\t\t\ttmp = fragment.firstChild;\n\n\t\t\t\t// Ensure the created nodes are orphaned (#12392)\n\t\t\t\ttmp.textContent = \"\";\n\t\t\t}\n\t\t}\n\t}\n\n\t// Remove wrapper from fragment\n\tfragment.textContent = \"\";\n\n\ti = 0;\n\twhile ( ( elem = nodes[ i++ ] ) ) {\n\n\t\t// Skip elements already in the context collection (trac-4087)\n\t\tif ( selection && jQuery.inArray( elem, selection ) > -1 ) {\n\t\t\tif ( ignored ) {\n\t\t\t\tignored.push( elem );\n\t\t\t}\n\t\t\tcontinue;\n\t\t}\n\n\t\tcontains = jQuery.contains( elem.ownerDocument, elem );\n\n\t\t// Append to fragment\n\t\ttmp = getAll( fragment.appendChild( elem ), \"script\" );\n\n\t\t// Preserve script evaluation history\n\t\tif ( contains ) {\n\t\t\tsetGlobalEval( tmp );\n\t\t}\n\n\t\t// Capture executables\n\t\tif ( scripts ) {\n\t\t\tj = 0;\n\t\t\twhile ( ( elem = tmp[ j++ ] ) ) {\n\t\t\t\tif ( rscriptType.test( elem.type || \"\" ) ) {\n\t\t\t\t\tscripts.push( elem );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn fragment;\n}\n\n\n( function() {\n\tvar fragment = document.createDocumentFragment(),\n\t\tdiv = fragment.appendChild( document.createElement( \"div\" ) ),\n\t\tinput = document.createElement( \"input\" );\n\n\t// Support: Android 4.0 - 4.3 only\n\t// Check state lost if the name is set (#11217)\n\t// Support: Windows Web Apps (WWA)\n\t// `name` and `type` must use .setAttribute for WWA (#14901)\n\tinput.setAttribute( \"type\", \"radio\" );\n\tinput.setAttribute( \"checked\", \"checked\" );\n\tinput.setAttribute( \"name\", \"t\" );\n\n\tdiv.appendChild( input );\n\n\t// Support: Android <=4.1 only\n\t// Older WebKit doesn't clone checked state correctly in fragments\n\tsupport.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked;\n\n\t// Support: IE <=11 only\n\t// Make sure textarea (and checkbox) defaultValue is properly cloned\n\tdiv.innerHTML = \"<textarea>x</textarea>\";\n\tsupport.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue;\n} )();\nvar documentElement = document.documentElement;\n\n\n\nvar\n\trkeyEvent = /^key/,\n\trmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/,\n\trtypenamespace = /^([^.]*)(?:\\.(.+)|)/;\n\nfunction returnTrue() {\n\treturn true;\n}\n\nfunction returnFalse() {\n\treturn false;\n}\n\n// Support: IE <=9 only\n// See #13393 for more info\nfunction safeActiveElement() {\n\ttry {\n\t\treturn document.activeElement;\n\t} catch ( err ) { }\n}\n\nfunction on( elem, types, selector, data, fn, one ) {\n\tvar origFn, type;\n\n\t// Types can be a map of types/handlers\n\tif ( typeof types === \"object\" ) {\n\n\t\t// ( types-Object, selector, data )\n\t\tif ( typeof selector !== \"string\" ) {\n\n\t\t\t// ( types-Object, data )\n\t\t\tdata = data || selector;\n\t\t\tselector = undefined;\n\t\t}\n\t\tfor ( type in types ) {\n\t\t\ton( elem, type, selector, data, types[ type ], one );\n\t\t}\n\t\treturn elem;\n\t}\n\n\tif ( data == null && fn == null ) {\n\n\t\t// ( types, fn )\n\t\tfn = selector;\n\t\tdata = selector = undefined;\n\t} else if ( fn == null ) {\n\t\tif ( typeof selector === \"string\" ) {\n\n\t\t\t// ( types, selector, fn )\n\t\t\tfn = data;\n\t\t\tdata = undefined;\n\t\t} else {\n\n\t\t\t// ( types, data, fn )\n\t\t\tfn = data;\n\t\t\tdata = selector;\n\t\t\tselector = undefined;\n\t\t}\n\t}\n\tif ( fn === false ) {\n\t\tfn = returnFalse;\n\t} else if ( !fn ) {\n\t\treturn elem;\n\t}\n\n\tif ( one === 1 ) {\n\t\torigFn = fn;\n\t\tfn = function( event ) {\n\n\t\t\t// Can use an empty set, since event contains the info\n\t\t\tjQuery().off( event );\n\t\t\treturn origFn.apply( this, arguments );\n\t\t};\n\n\t\t// Use same guid so caller can remove using origFn\n\t\tfn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );\n\t}\n\treturn elem.each( function() {\n\t\tjQuery.event.add( this, types, fn, data, selector );\n\t} );\n}\n\n/*\n * Helper functions for managing events -- not part of the public interface.\n * Props to Dean Edwards' addEvent library for many of the ideas.\n */\njQuery.event = {\n\n\tglobal: {},\n\n\tadd: function( elem, types, handler, data, selector ) {\n\n\t\tvar handleObjIn, eventHandle, tmp,\n\t\t\tevents, t, handleObj,\n\t\t\tspecial, handlers, type, namespaces, origType,\n\t\t\telemData = dataPriv.get( elem );\n\n\t\t// Don't attach events to noData or text/comment nodes (but allow plain objects)\n\t\tif ( !elemData ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Caller can pass in an object of custom data in lieu of the handler\n\t\tif ( handler.handler ) {\n\t\t\thandleObjIn = handler;\n\t\t\thandler = handleObjIn.handler;\n\t\t\tselector = handleObjIn.selector;\n\t\t}\n\n\t\t// Ensure that invalid selectors throw exceptions at attach time\n\t\t// Evaluate against documentElement in case elem is a non-element node (e.g., document)\n\t\tif ( selector ) {\n\t\t\tjQuery.find.matchesSelector( documentElement, selector );\n\t\t}\n\n\t\t// Make sure that the handler has a unique ID, used to find/remove it later\n\t\tif ( !handler.guid ) {\n\t\t\thandler.guid = jQuery.guid++;\n\t\t}\n\n\t\t// Init the element's event structure and main handler, if this is the first\n\t\tif ( !( events = elemData.events ) ) {\n\t\t\tevents = elemData.events = {};\n\t\t}\n\t\tif ( !( eventHandle = elemData.handle ) ) {\n\t\t\teventHandle = elemData.handle = function( e ) {\n\n\t\t\t\t// Discard the second event of a jQuery.event.trigger() and\n\t\t\t\t// when an event is called after a page has unloaded\n\t\t\t\treturn typeof jQuery !== \"undefined\" && jQuery.event.triggered !== e.type ?\n\t\t\t\t\tjQuery.event.dispatch.apply( elem, arguments ) : undefined;\n\t\t\t};\n\t\t}\n\n\t\t// Handle multiple events separated by a space\n\t\ttypes = ( types || \"\" ).match( rnothtmlwhite ) || [ \"\" ];\n\t\tt = types.length;\n\t\twhile ( t-- ) {\n\t\t\ttmp = rtypenamespace.exec( types[ t ] ) || [];\n\t\t\ttype = origType = tmp[ 1 ];\n\t\t\tnamespaces = ( tmp[ 2 ] || \"\" ).split( \".\" ).sort();\n\n\t\t\t// There *must* be a type, no attaching namespace-only handlers\n\t\t\tif ( !type ) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t// If event changes its type, use the special event handlers for the changed type\n\t\t\tspecial = jQuery.event.special[ type ] || {};\n\n\t\t\t// If selector defined, determine special event api type, otherwise given type\n\t\t\ttype = ( selector ? special.delegateType : special.bindType ) || type;\n\n\t\t\t// Update special based on newly reset type\n\t\t\tspecial = jQuery.event.special[ type ] || {};\n\n\t\t\t// handleObj is passed to all event handlers\n\t\t\thandleObj = jQuery.extend( {\n\t\t\t\ttype: type,\n\t\t\t\torigType: origType,\n\t\t\t\tdata: data,\n\t\t\t\thandler: handler,\n\t\t\t\tguid: handler.guid,\n\t\t\t\tselector: selector,\n\t\t\t\tneedsContext: selector && jQuery.expr.match.needsContext.test( selector ),\n\t\t\t\tnamespace: namespaces.join( \".\" )\n\t\t\t}, handleObjIn );\n\n\t\t\t// Init the event handler queue if we're the first\n\t\t\tif ( !( handlers = events[ type ] ) ) {\n\t\t\t\thandlers = events[ type ] = [];\n\t\t\t\thandlers.delegateCount = 0;\n\n\t\t\t\t// Only use addEventListener if the special events handler returns false\n\t\t\t\tif ( !special.setup ||\n\t\t\t\t\tspecial.setup.call( elem, data, namespaces, eventHandle ) === false ) {\n\n\t\t\t\t\tif ( elem.addEventListener ) {\n\t\t\t\t\t\telem.addEventListener( type, eventHandle );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif ( special.add ) {\n\t\t\t\tspecial.add.call( elem, handleObj );\n\n\t\t\t\tif ( !handleObj.handler.guid ) {\n\t\t\t\t\thandleObj.handler.guid = handler.guid;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Add to the element's handler list, delegates in front\n\t\t\tif ( selector ) {\n\t\t\t\thandlers.splice( handlers.delegateCount++, 0, handleObj );\n\t\t\t} else {\n\t\t\t\thandlers.push( handleObj );\n\t\t\t}\n\n\t\t\t// Keep track of which events have ever been used, for event optimization\n\t\t\tjQuery.event.global[ type ] = true;\n\t\t}\n\n\t},\n\n\t// Detach an event or set of events from an element\n\tremove: function( elem, types, handler, selector, mappedTypes ) {\n\n\t\tvar j, origCount, tmp,\n\t\t\tevents, t, handleObj,\n\t\t\tspecial, handlers, type, namespaces, origType,\n\t\t\telemData = dataPriv.hasData( elem ) && dataPriv.get( elem );\n\n\t\tif ( !elemData || !( events = elemData.events ) ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Once for each type.namespace in types; type may be omitted\n\t\ttypes = ( types || \"\" ).match( rnothtmlwhite ) || [ \"\" ];\n\t\tt = types.length;\n\t\twhile ( t-- ) {\n\t\t\ttmp = rtypenamespace.exec( types[ t ] ) || [];\n\t\t\ttype = origType = tmp[ 1 ];\n\t\t\tnamespaces = ( tmp[ 2 ] || \"\" ).split( \".\" ).sort();\n\n\t\t\t// Unbind all events (on this namespace, if provided) for the element\n\t\t\tif ( !type ) {\n\t\t\t\tfor ( type in events ) {\n\t\t\t\t\tjQuery.event.remove( elem, type + types[ t ], handler, selector, true );\n\t\t\t\t}\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tspecial = jQuery.event.special[ type ] || {};\n\t\t\ttype = ( selector ? special.delegateType : special.bindType ) || type;\n\t\t\thandlers = events[ type ] || [];\n\t\t\ttmp = tmp[ 2 ] &&\n\t\t\t\tnew RegExp( \"(^|\\\\.)\" + namespaces.join( \"\\\\.(?:.*\\\\.|)\" ) + \"(\\\\.|$)\" );\n\n\t\t\t// Remove matching events\n\t\t\torigCount = j = handlers.length;\n\t\t\twhile ( j-- ) {\n\t\t\t\thandleObj = handlers[ j ];\n\n\t\t\t\tif ( ( mappedTypes || origType === handleObj.origType ) &&\n\t\t\t\t\t( !handler || handler.guid === handleObj.guid ) &&\n\t\t\t\t\t( !tmp || tmp.test( handleObj.namespace ) ) &&\n\t\t\t\t\t( !selector || selector === handleObj.selector ||\n\t\t\t\t\t\tselector === \"**\" && handleObj.selector ) ) {\n\t\t\t\t\thandlers.splice( j, 1 );\n\n\t\t\t\t\tif ( handleObj.selector ) {\n\t\t\t\t\t\thandlers.delegateCount--;\n\t\t\t\t\t}\n\t\t\t\t\tif ( special.remove ) {\n\t\t\t\t\t\tspecial.remove.call( elem, handleObj );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Remove generic event handler if we removed something and no more handlers exist\n\t\t\t// (avoids potential for endless recursion during removal of special event handlers)\n\t\t\tif ( origCount && !handlers.length ) {\n\t\t\t\tif ( !special.teardown ||\n\t\t\t\t\tspecial.teardown.call( elem, namespaces, elemData.handle ) === false ) {\n\n\t\t\t\t\tjQuery.removeEvent( elem, type, elemData.handle );\n\t\t\t\t}\n\n\t\t\t\tdelete events[ type ];\n\t\t\t}\n\t\t}\n\n\t\t// Remove data and the expando if it's no longer used\n\t\tif ( jQuery.isEmptyObject( events ) ) {\n\t\t\tdataPriv.remove( elem, \"handle events\" );\n\t\t}\n\t},\n\n\tdispatch: function( nativeEvent ) {\n\n\t\t// Make a writable jQuery.Event from the native event object\n\t\tvar event = jQuery.event.fix( nativeEvent );\n\n\t\tvar i, j, ret, matched, handleObj, handlerQueue,\n\t\t\targs = new Array( arguments.length ),\n\t\t\thandlers = ( dataPriv.get( this, \"events\" ) || {} )[ event.type ] || [],\n\t\t\tspecial = jQuery.event.special[ event.type ] || {};\n\n\t\t// Use the fix-ed jQuery.Event rather than the (read-only) native event\n\t\targs[ 0 ] = event;\n\n\t\tfor ( i = 1; i < arguments.length; i++ ) {\n\t\t\targs[ i ] = arguments[ i ];\n\t\t}\n\n\t\tevent.delegateTarget = this;\n\n\t\t// Call the preDispatch hook for the mapped type, and let it bail if desired\n\t\tif ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Determine handlers\n\t\thandlerQueue = jQuery.event.handlers.call( this, event, handlers );\n\n\t\t// Run delegates first; they may want to stop propagation beneath us\n\t\ti = 0;\n\t\twhile ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) {\n\t\t\tevent.currentTarget = matched.elem;\n\n\t\t\tj = 0;\n\t\t\twhile ( ( handleObj = matched.handlers[ j++ ] ) &&\n\t\t\t\t!event.isImmediatePropagationStopped() ) {\n\n\t\t\t\t// Triggered event must either 1) have no namespace, or 2) have namespace(s)\n\t\t\t\t// a subset or equal to those in the bound event (both can have no namespace).\n\t\t\t\tif ( !event.rnamespace || event.rnamespace.test( handleObj.namespace ) ) {\n\n\t\t\t\t\tevent.handleObj = handleObj;\n\t\t\t\t\tevent.data = handleObj.data;\n\n\t\t\t\t\tret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle ||\n\t\t\t\t\t\thandleObj.handler ).apply( matched.elem, args );\n\n\t\t\t\t\tif ( ret !== undefined ) {\n\t\t\t\t\t\tif ( ( event.result = ret ) === false ) {\n\t\t\t\t\t\t\tevent.preventDefault();\n\t\t\t\t\t\t\tevent.stopPropagation();\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Call the postDispatch hook for the mapped type\n\t\tif ( special.postDispatch ) {\n\t\t\tspecial.postDispatch.call( this, event );\n\t\t}\n\n\t\treturn event.result;\n\t},\n\n\thandlers: function( event, handlers ) {\n\t\tvar i, handleObj, sel, matchedHandlers, matchedSelectors,\n\t\t\thandlerQueue = [],\n\t\t\tdelegateCount = handlers.delegateCount,\n\t\t\tcur = event.target;\n\n\t\t// Find delegate handlers\n\t\tif ( delegateCount &&\n\n\t\t\t// Support: IE <=9\n\t\t\t// Black-hole SVG <use> instance trees (trac-13180)\n\t\t\tcur.nodeType &&\n\n\t\t\t// Support: Firefox <=42\n\t\t\t// Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861)\n\t\t\t// https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click\n\t\t\t// Support: IE 11 only\n\t\t\t// ...but not arrow key \"clicks\" of radio inputs, which can have `button` -1 (gh-2343)\n\t\t\t!( event.type === \"click\" && event.button >= 1 ) ) {\n\n\t\t\tfor ( ; cur !== this; cur = cur.parentNode || this ) {\n\n\t\t\t\t// Don't check non-elements (#13208)\n\t\t\t\t// Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)\n\t\t\t\tif ( cur.nodeType === 1 && !( event.type === \"click\" && cur.disabled === true ) ) {\n\t\t\t\t\tmatchedHandlers = [];\n\t\t\t\t\tmatchedSelectors = {};\n\t\t\t\t\tfor ( i = 0; i < delegateCount; i++ ) {\n\t\t\t\t\t\thandleObj = handlers[ i ];\n\n\t\t\t\t\t\t// Don't conflict with Object.prototype properties (#13203)\n\t\t\t\t\t\tsel = handleObj.selector + \" \";\n\n\t\t\t\t\t\tif ( matchedSelectors[ sel ] === undefined ) {\n\t\t\t\t\t\t\tmatchedSelectors[ sel ] = handleObj.needsContext ?\n\t\t\t\t\t\t\t\tjQuery( sel, this ).index( cur ) > -1 :\n\t\t\t\t\t\t\t\tjQuery.find( sel, this, null, [ cur ] ).length;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif ( matchedSelectors[ sel ] ) {\n\t\t\t\t\t\t\tmatchedHandlers.push( handleObj );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tif ( matchedHandlers.length ) {\n\t\t\t\t\t\thandlerQueue.push( { elem: cur, handlers: matchedHandlers } );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Add the remaining (directly-bound) handlers\n\t\tcur = this;\n\t\tif ( delegateCount < handlers.length ) {\n\t\t\thandlerQueue.push( { elem: cur, handlers: handlers.slice( delegateCount ) } );\n\t\t}\n\n\t\treturn handlerQueue;\n\t},\n\n\taddProp: function( name, hook ) {\n\t\tObject.defineProperty( jQuery.Event.prototype, name, {\n\t\t\tenumerable: true,\n\t\t\tconfigurable: true,\n\n\t\t\tget: isFunction( hook ) ?\n\t\t\t\tfunction() {\n\t\t\t\t\tif ( this.originalEvent ) {\n\t\t\t\t\t\t\treturn hook( this.originalEvent );\n\t\t\t\t\t}\n\t\t\t\t} :\n\t\t\t\tfunction() {\n\t\t\t\t\tif ( this.originalEvent ) {\n\t\t\t\t\t\t\treturn this.originalEvent[ name ];\n\t\t\t\t\t}\n\t\t\t\t},\n\n\t\t\tset: function( value ) {\n\t\t\t\tObject.defineProperty( this, name, {\n\t\t\t\t\tenumerable: true,\n\t\t\t\t\tconfigurable: true,\n\t\t\t\t\twritable: true,\n\t\t\t\t\tvalue: value\n\t\t\t\t} );\n\t\t\t}\n\t\t} );\n\t},\n\n\tfix: function( originalEvent ) {\n\t\treturn originalEvent[ jQuery.expando ] ?\n\t\t\toriginalEvent :\n\t\t\tnew jQuery.Event( originalEvent );\n\t},\n\n\tspecial: {\n\t\tload: {\n\n\t\t\t// Prevent triggered image.load events from bubbling to window.load\n\t\t\tnoBubble: true\n\t\t},\n\t\tfocus: {\n\n\t\t\t// Fire native event if possible so blur/focus sequence is correct\n\t\t\ttrigger: function() {\n\t\t\t\tif ( this !== safeActiveElement() && this.focus ) {\n\t\t\t\t\tthis.focus();\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t},\n\t\t\tdelegateType: \"focusin\"\n\t\t},\n\t\tblur: {\n\t\t\ttrigger: function() {\n\t\t\t\tif ( this === safeActiveElement() && this.blur ) {\n\t\t\t\t\tthis.blur();\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t},\n\t\t\tdelegateType: \"focusout\"\n\t\t},\n\t\tclick: {\n\n\t\t\t// For checkbox, fire native event so checked state will be right\n\t\t\ttrigger: function() {\n\t\t\t\tif ( this.type === \"checkbox\" && this.click && nodeName( this, \"input\" ) ) {\n\t\t\t\t\tthis.click();\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t},\n\n\t\t\t// For cross-browser consistency, don't fire native .click() on links\n\t\t\t_default: function( event ) {\n\t\t\t\treturn nodeName( event.target, \"a\" );\n\t\t\t}\n\t\t},\n\n\t\tbeforeunload: {\n\t\t\tpostDispatch: function( event ) {\n\n\t\t\t\t// Support: Firefox 20+\n\t\t\t\t// Firefox doesn't alert if the returnValue field is not set.\n\t\t\t\tif ( event.result !== undefined && event.originalEvent ) {\n\t\t\t\t\tevent.originalEvent.returnValue = event.result;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n};\n\njQuery.removeEvent = function( elem, type, handle ) {\n\n\t// This \"if\" is needed for plain objects\n\tif ( elem.removeEventListener ) {\n\t\telem.removeEventListener( type, handle );\n\t}\n};\n\njQuery.Event = function( src, props ) {\n\n\t// Allow instantiation without the 'new' keyword\n\tif ( !( this instanceof jQuery.Event ) ) {\n\t\treturn new jQuery.Event( src, props );\n\t}\n\n\t// Event object\n\tif ( src && src.type ) {\n\t\tthis.originalEvent = src;\n\t\tthis.type = src.type;\n\n\t\t// Events bubbling up the document may have been marked as prevented\n\t\t// by a handler lower down the tree; reflect the correct value.\n\t\tthis.isDefaultPrevented = src.defaultPrevented ||\n\t\t\t\tsrc.defaultPrevented === undefined &&\n\n\t\t\t\t// Support: Android <=2.3 only\n\t\t\t\tsrc.returnValue === false ?\n\t\t\treturnTrue :\n\t\t\treturnFalse;\n\n\t\t// Create target properties\n\t\t// Support: Safari <=6 - 7 only\n\t\t// Target should not be a text node (#504, #13143)\n\t\tthis.target = ( src.target && src.target.nodeType === 3 ) ?\n\t\t\tsrc.target.parentNode :\n\t\t\tsrc.target;\n\n\t\tthis.currentTarget = src.currentTarget;\n\t\tthis.relatedTarget = src.relatedTarget;\n\n\t// Event type\n\t} else {\n\t\tthis.type = src;\n\t}\n\n\t// Put explicitly provided properties onto the event object\n\tif ( props ) {\n\t\tjQuery.extend( this, props );\n\t}\n\n\t// Create a timestamp if incoming event doesn't have one\n\tthis.timeStamp = src && src.timeStamp || Date.now();\n\n\t// Mark it as fixed\n\tthis[ jQuery.expando ] = true;\n};\n\n// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding\n// https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html\njQuery.Event.prototype = {\n\tconstructor: jQuery.Event,\n\tisDefaultPrevented: returnFalse,\n\tisPropagationStopped: returnFalse,\n\tisImmediatePropagationStopped: returnFalse,\n\tisSimulated: false,\n\n\tpreventDefault: function() {\n\t\tvar e = this.originalEvent;\n\n\t\tthis.isDefaultPrevented = returnTrue;\n\n\t\tif ( e && !this.isSimulated ) {\n\t\t\te.preventDefault();\n\t\t}\n\t},\n\tstopPropagation: function() {\n\t\tvar e = this.originalEvent;\n\n\t\tthis.isPropagationStopped = returnTrue;\n\n\t\tif ( e && !this.isSimulated ) {\n\t\t\te.stopPropagation();\n\t\t}\n\t},\n\tstopImmediatePropagation: function() {\n\t\tvar e = this.originalEvent;\n\n\t\tthis.isImmediatePropagationStopped = returnTrue;\n\n\t\tif ( e && !this.isSimulated ) {\n\t\t\te.stopImmediatePropagation();\n\t\t}\n\n\t\tthis.stopPropagation();\n\t}\n};\n\n// Includes all common event props including KeyEvent and MouseEvent specific props\njQuery.each( {\n\taltKey: true,\n\tbubbles: true,\n\tcancelable: true,\n\tchangedTouches: true,\n\tctrlKey: true,\n\tdetail: true,\n\teventPhase: true,\n\tmetaKey: true,\n\tpageX: true,\n\tpageY: true,\n\tshiftKey: true,\n\tview: true,\n\t\"char\": true,\n\tcharCode: true,\n\tkey: true,\n\tkeyCode: true,\n\tbutton: true,\n\tbuttons: true,\n\tclientX: true,\n\tclientY: true,\n\toffsetX: true,\n\toffsetY: true,\n\tpointerId: true,\n\tpointerType: true,\n\tscreenX: true,\n\tscreenY: true,\n\ttargetTouches: true,\n\ttoElement: true,\n\ttouches: true,\n\n\twhich: function( event ) {\n\t\tvar button = event.button;\n\n\t\t// Add which for key events\n\t\tif ( event.which == null && rkeyEvent.test( event.type ) ) {\n\t\t\treturn event.charCode != null ? event.charCode : event.keyCode;\n\t\t}\n\n\t\t// Add which for click: 1 === left; 2 === middle; 3 === right\n\t\tif ( !event.which && button !== undefined && rmouseEvent.test( event.type ) ) {\n\t\t\tif ( button & 1 ) {\n\t\t\t\treturn 1;\n\t\t\t}\n\n\t\t\tif ( button & 2 ) {\n\t\t\t\treturn 3;\n\t\t\t}\n\n\t\t\tif ( button & 4 ) {\n\t\t\t\treturn 2;\n\t\t\t}\n\n\t\t\treturn 0;\n\t\t}\n\n\t\treturn event.which;\n\t}\n}, jQuery.event.addProp );\n\n// Create mouseenter/leave events using mouseover/out and event-time checks\n// so that event delegation works in jQuery.\n// Do the same for pointerenter/pointerleave and pointerover/pointerout\n//\n// Support: Safari 7 only\n// Safari sends mouseenter too often; see:\n// https://bugs.chromium.org/p/chromium/issues/detail?id=470258\n// for the description of the bug (it existed in older Chrome versions as well).\njQuery.each( {\n\tmouseenter: \"mouseover\",\n\tmouseleave: \"mouseout\",\n\tpointerenter: \"pointerover\",\n\tpointerleave: \"pointerout\"\n}, function( orig, fix ) {\n\tjQuery.event.special[ orig ] = {\n\t\tdelegateType: fix,\n\t\tbindType: fix,\n\n\t\thandle: function( event ) {\n\t\t\tvar ret,\n\t\t\t\ttarget = this,\n\t\t\t\trelated = event.relatedTarget,\n\t\t\t\thandleObj = event.handleObj;\n\n\t\t\t// For mouseenter/leave call the handler if related is outside the target.\n\t\t\t// NB: No relatedTarget if the mouse left/entered the browser window\n\t\t\tif ( !related || ( related !== target && !jQuery.contains( target, related ) ) ) {\n\t\t\t\tevent.type = handleObj.origType;\n\t\t\t\tret = handleObj.handler.apply( this, arguments );\n\t\t\t\tevent.type = fix;\n\t\t\t}\n\t\t\treturn ret;\n\t\t}\n\t};\n} );\n\njQuery.fn.extend( {\n\n\ton: function( types, selector, data, fn ) {\n\t\treturn on( this, types, selector, data, fn );\n\t},\n\tone: function( types, selector, data, fn ) {\n\t\treturn on( this, types, selector, data, fn, 1 );\n\t},\n\toff: function( types, selector, fn ) {\n\t\tvar handleObj, type;\n\t\tif ( types && types.preventDefault && types.handleObj ) {\n\n\t\t\t// ( event )  dispatched jQuery.Event\n\t\t\thandleObj = types.handleObj;\n\t\t\tjQuery( types.delegateTarget ).off(\n\t\t\t\thandleObj.namespace ?\n\t\t\t\t\thandleObj.origType + \".\" + handleObj.namespace :\n\t\t\t\t\thandleObj.origType,\n\t\t\t\thandleObj.selector,\n\t\t\t\thandleObj.handler\n\t\t\t);\n\t\t\treturn this;\n\t\t}\n\t\tif ( typeof types === \"object\" ) {\n\n\t\t\t// ( types-object [, selector] )\n\t\t\tfor ( type in types ) {\n\t\t\t\tthis.off( type, selector, types[ type ] );\n\t\t\t}\n\t\t\treturn this;\n\t\t}\n\t\tif ( selector === false || typeof selector === \"function\" ) {\n\n\t\t\t// ( types [, fn] )\n\t\t\tfn = selector;\n\t\t\tselector = undefined;\n\t\t}\n\t\tif ( fn === false ) {\n\t\t\tfn = returnFalse;\n\t\t}\n\t\treturn this.each( function() {\n\t\t\tjQuery.event.remove( this, types, fn, selector );\n\t\t} );\n\t}\n} );\n\n\nvar\n\n\t/* eslint-disable max-len */\n\n\t// See https://github.com/eslint/eslint/issues/3229\n\trxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([a-z][^\\/\\0>\\x20\\t\\r\\n\\f]*)[^>]*)\\/>/gi,\n\n\t/* eslint-enable */\n\n\t// Support: IE <=10 - 11, Edge 12 - 13 only\n\t// In IE/Edge using regex groups here causes severe slowdowns.\n\t// See https://connect.microsoft.com/IE/feedback/details/1736512/\n\trnoInnerhtml = /<script|<style|<link/i,\n\n\t// checked=\"checked\" or checked\n\trchecked = /checked\\s*(?:[^=]|=\\s*.checked.)/i,\n\trcleanScript = /^\\s*<!(?:\\[CDATA\\[|--)|(?:\\]\\]|--)>\\s*$/g;\n\n// Prefer a tbody over its parent table for containing new rows\nfunction manipulationTarget( elem, content ) {\n\tif ( nodeName( elem, \"table\" ) &&\n\t\tnodeName( content.nodeType !== 11 ? content : content.firstChild, \"tr\" ) ) {\n\n\t\treturn jQuery( elem ).children( \"tbody\" )[ 0 ] || elem;\n\t}\n\n\treturn elem;\n}\n\n// Replace/restore the type attribute of script elements for safe DOM manipulation\nfunction disableScript( elem ) {\n\telem.type = ( elem.getAttribute( \"type\" ) !== null ) + \"/\" + elem.type;\n\treturn elem;\n}\nfunction restoreScript( elem ) {\n\tif ( ( elem.type || \"\" ).slice( 0, 5 ) === \"true/\" ) {\n\t\telem.type = elem.type.slice( 5 );\n\t} else {\n\t\telem.removeAttribute( \"type\" );\n\t}\n\n\treturn elem;\n}\n\nfunction cloneCopyEvent( src, dest ) {\n\tvar i, l, type, pdataOld, pdataCur, udataOld, udataCur, events;\n\n\tif ( dest.nodeType !== 1 ) {\n\t\treturn;\n\t}\n\n\t// 1. Copy private data: events, handlers, etc.\n\tif ( dataPriv.hasData( src ) ) {\n\t\tpdataOld = dataPriv.access( src );\n\t\tpdataCur = dataPriv.set( dest, pdataOld );\n\t\tevents = pdataOld.events;\n\n\t\tif ( events ) {\n\t\t\tdelete pdataCur.handle;\n\t\t\tpdataCur.events = {};\n\n\t\t\tfor ( type in events ) {\n\t\t\t\tfor ( i = 0, l = events[ type ].length; i < l; i++ ) {\n\t\t\t\t\tjQuery.event.add( dest, type, events[ type ][ i ] );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// 2. Copy user data\n\tif ( dataUser.hasData( src ) ) {\n\t\tudataOld = dataUser.access( src );\n\t\tudataCur = jQuery.extend( {}, udataOld );\n\n\t\tdataUser.set( dest, udataCur );\n\t}\n}\n\n// Fix IE bugs, see support tests\nfunction fixInput( src, dest ) {\n\tvar nodeName = dest.nodeName.toLowerCase();\n\n\t// Fails to persist the checked state of a cloned checkbox or radio button.\n\tif ( nodeName === \"input\" && rcheckableType.test( src.type ) ) {\n\t\tdest.checked = src.checked;\n\n\t// Fails to return the selected option to the default selected state when cloning options\n\t} else if ( nodeName === \"input\" || nodeName === \"textarea\" ) {\n\t\tdest.defaultValue = src.defaultValue;\n\t}\n}\n\nfunction domManip( collection, args, callback, ignored ) {\n\n\t// Flatten any nested arrays\n\targs = concat.apply( [], args );\n\n\tvar fragment, first, scripts, hasScripts, node, doc,\n\t\ti = 0,\n\t\tl = collection.length,\n\t\tiNoClone = l - 1,\n\t\tvalue = args[ 0 ],\n\t\tvalueIsFunction = isFunction( value );\n\n\t// We can't cloneNode fragments that contain checked, in WebKit\n\tif ( valueIsFunction ||\n\t\t\t( l > 1 && typeof value === \"string\" &&\n\t\t\t\t!support.checkClone && rchecked.test( value ) ) ) {\n\t\treturn collection.each( function( index ) {\n\t\t\tvar self = collection.eq( index );\n\t\t\tif ( valueIsFunction ) {\n\t\t\t\targs[ 0 ] = value.call( this, index, self.html() );\n\t\t\t}\n\t\t\tdomManip( self, args, callback, ignored );\n\t\t} );\n\t}\n\n\tif ( l ) {\n\t\tfragment = buildFragment( args, collection[ 0 ].ownerDocument, false, collection, ignored );\n\t\tfirst = fragment.firstChild;\n\n\t\tif ( fragment.childNodes.length === 1 ) {\n\t\t\tfragment = first;\n\t\t}\n\n\t\t// Require either new content or an interest in ignored elements to invoke the callback\n\t\tif ( first || ignored ) {\n\t\t\tscripts = jQuery.map( getAll( fragment, \"script\" ), disableScript );\n\t\t\thasScripts = scripts.length;\n\n\t\t\t// Use the original fragment for the last item\n\t\t\t// instead of the first because it can end up\n\t\t\t// being emptied incorrectly in certain situations (#8070).\n\t\t\tfor ( ; i < l; i++ ) {\n\t\t\t\tnode = fragment;\n\n\t\t\t\tif ( i !== iNoClone ) {\n\t\t\t\t\tnode = jQuery.clone( node, true, true );\n\n\t\t\t\t\t// Keep references to cloned scripts for later restoration\n\t\t\t\t\tif ( hasScripts ) {\n\n\t\t\t\t\t\t// Support: Android <=4.0 only, PhantomJS 1 only\n\t\t\t\t\t\t// push.apply(_, arraylike) throws on ancient WebKit\n\t\t\t\t\t\tjQuery.merge( scripts, getAll( node, \"script\" ) );\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tcallback.call( collection[ i ], node, i );\n\t\t\t}\n\n\t\t\tif ( hasScripts ) {\n\t\t\t\tdoc = scripts[ scripts.length - 1 ].ownerDocument;\n\n\t\t\t\t// Reenable scripts\n\t\t\t\tjQuery.map( scripts, restoreScript );\n\n\t\t\t\t// Evaluate executable scripts on first document insertion\n\t\t\t\tfor ( i = 0; i < hasScripts; i++ ) {\n\t\t\t\t\tnode = scripts[ i ];\n\t\t\t\t\tif ( rscriptType.test( node.type || \"\" ) &&\n\t\t\t\t\t\t!dataPriv.access( node, \"globalEval\" ) &&\n\t\t\t\t\t\tjQuery.contains( doc, node ) ) {\n\n\t\t\t\t\t\tif ( node.src && ( node.type || \"\" ).toLowerCase()  !== \"module\" ) {\n\n\t\t\t\t\t\t\t// Optional AJAX dependency, but won't run scripts if not present\n\t\t\t\t\t\t\tif ( jQuery._evalUrl ) {\n\t\t\t\t\t\t\t\tjQuery._evalUrl( node.src );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tDOMEval( node.textContent.replace( rcleanScript, \"\" ), doc, node );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn collection;\n}\n\nfunction remove( elem, selector, keepData ) {\n\tvar node,\n\t\tnodes = selector ? jQuery.filter( selector, elem ) : elem,\n\t\ti = 0;\n\n\tfor ( ; ( node = nodes[ i ] ) != null; i++ ) {\n\t\tif ( !keepData && node.nodeType === 1 ) {\n\t\t\tjQuery.cleanData( getAll( node ) );\n\t\t}\n\n\t\tif ( node.parentNode ) {\n\t\t\tif ( keepData && jQuery.contains( node.ownerDocument, node ) ) {\n\t\t\t\tsetGlobalEval( getAll( node, \"script\" ) );\n\t\t\t}\n\t\t\tnode.parentNode.removeChild( node );\n\t\t}\n\t}\n\n\treturn elem;\n}\n\njQuery.extend( {\n\thtmlPrefilter: function( html ) {\n\t\treturn html.replace( rxhtmlTag, \"<$1></$2>\" );\n\t},\n\n\tclone: function( elem, dataAndEvents, deepDataAndEvents ) {\n\t\tvar i, l, srcElements, destElements,\n\t\t\tclone = elem.cloneNode( true ),\n\t\t\tinPage = jQuery.contains( elem.ownerDocument, elem );\n\n\t\t// Fix IE cloning issues\n\t\tif ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) &&\n\t\t\t\t!jQuery.isXMLDoc( elem ) ) {\n\n\t\t\t// We eschew Sizzle here for performance reasons: https://jsperf.com/getall-vs-sizzle/2\n\t\t\tdestElements = getAll( clone );\n\t\t\tsrcElements = getAll( elem );\n\n\t\t\tfor ( i = 0, l = srcElements.length; i < l; i++ ) {\n\t\t\t\tfixInput( srcElements[ i ], destElements[ i ] );\n\t\t\t}\n\t\t}\n\n\t\t// Copy the events from the original to the clone\n\t\tif ( dataAndEvents ) {\n\t\t\tif ( deepDataAndEvents ) {\n\t\t\t\tsrcElements = srcElements || getAll( elem );\n\t\t\t\tdestElements = destElements || getAll( clone );\n\n\t\t\t\tfor ( i = 0, l = srcElements.length; i < l; i++ ) {\n\t\t\t\t\tcloneCopyEvent( srcElements[ i ], destElements[ i ] );\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tcloneCopyEvent( elem, clone );\n\t\t\t}\n\t\t}\n\n\t\t// Preserve script evaluation history\n\t\tdestElements = getAll( clone, \"script\" );\n\t\tif ( destElements.length > 0 ) {\n\t\t\tsetGlobalEval( destElements, !inPage && getAll( elem, \"script\" ) );\n\t\t}\n\n\t\t// Return the cloned set\n\t\treturn clone;\n\t},\n\n\tcleanData: function( elems ) {\n\t\tvar data, elem, type,\n\t\t\tspecial = jQuery.event.special,\n\t\t\ti = 0;\n\n\t\tfor ( ; ( elem = elems[ i ] ) !== undefined; i++ ) {\n\t\t\tif ( acceptData( elem ) ) {\n\t\t\t\tif ( ( data = elem[ dataPriv.expando ] ) ) {\n\t\t\t\t\tif ( data.events ) {\n\t\t\t\t\t\tfor ( type in data.events ) {\n\t\t\t\t\t\t\tif ( special[ type ] ) {\n\t\t\t\t\t\t\t\tjQuery.event.remove( elem, type );\n\n\t\t\t\t\t\t\t// This is a shortcut to avoid jQuery.event.remove's overhead\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tjQuery.removeEvent( elem, type, data.handle );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Support: Chrome <=35 - 45+\n\t\t\t\t\t// Assign undefined instead of using delete, see Data#remove\n\t\t\t\t\telem[ dataPriv.expando ] = undefined;\n\t\t\t\t}\n\t\t\t\tif ( elem[ dataUser.expando ] ) {\n\n\t\t\t\t\t// Support: Chrome <=35 - 45+\n\t\t\t\t\t// Assign undefined instead of using delete, see Data#remove\n\t\t\t\t\telem[ dataUser.expando ] = undefined;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n} );\n\njQuery.fn.extend( {\n\tdetach: function( selector ) {\n\t\treturn remove( this, selector, true );\n\t},\n\n\tremove: function( selector ) {\n\t\treturn remove( this, selector );\n\t},\n\n\ttext: function( value ) {\n\t\treturn access( this, function( value ) {\n\t\t\treturn value === undefined ?\n\t\t\t\tjQuery.text( this ) :\n\t\t\t\tthis.empty().each( function() {\n\t\t\t\t\tif ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {\n\t\t\t\t\t\tthis.textContent = value;\n\t\t\t\t\t}\n\t\t\t\t} );\n\t\t}, null, value, arguments.length );\n\t},\n\n\tappend: function() {\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tif ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {\n\t\t\t\tvar target = manipulationTarget( this, elem );\n\t\t\t\ttarget.appendChild( elem );\n\t\t\t}\n\t\t} );\n\t},\n\n\tprepend: function() {\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tif ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {\n\t\t\t\tvar target = manipulationTarget( this, elem );\n\t\t\t\ttarget.insertBefore( elem, target.firstChild );\n\t\t\t}\n\t\t} );\n\t},\n\n\tbefore: function() {\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tif ( this.parentNode ) {\n\t\t\t\tthis.parentNode.insertBefore( elem, this );\n\t\t\t}\n\t\t} );\n\t},\n\n\tafter: function() {\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tif ( this.parentNode ) {\n\t\t\t\tthis.parentNode.insertBefore( elem, this.nextSibling );\n\t\t\t}\n\t\t} );\n\t},\n\n\tempty: function() {\n\t\tvar elem,\n\t\t\ti = 0;\n\n\t\tfor ( ; ( elem = this[ i ] ) != null; i++ ) {\n\t\t\tif ( elem.nodeType === 1 ) {\n\n\t\t\t\t// Prevent memory leaks\n\t\t\t\tjQuery.cleanData( getAll( elem, false ) );\n\n\t\t\t\t// Remove any remaining nodes\n\t\t\t\telem.textContent = \"\";\n\t\t\t}\n\t\t}\n\n\t\treturn this;\n\t},\n\n\tclone: function( dataAndEvents, deepDataAndEvents ) {\n\t\tdataAndEvents = dataAndEvents == null ? false : dataAndEvents;\n\t\tdeepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;\n\n\t\treturn this.map( function() {\n\t\t\treturn jQuery.clone( this, dataAndEvents, deepDataAndEvents );\n\t\t} );\n\t},\n\n\thtml: function( value ) {\n\t\treturn access( this, function( value ) {\n\t\t\tvar elem = this[ 0 ] || {},\n\t\t\t\ti = 0,\n\t\t\t\tl = this.length;\n\n\t\t\tif ( value === undefined && elem.nodeType === 1 ) {\n\t\t\t\treturn elem.innerHTML;\n\t\t\t}\n\n\t\t\t// See if we can take a shortcut and just use innerHTML\n\t\t\tif ( typeof value === \"string\" && !rnoInnerhtml.test( value ) &&\n\t\t\t\t!wrapMap[ ( rtagName.exec( value ) || [ \"\", \"\" ] )[ 1 ].toLowerCase() ] ) {\n\n\t\t\t\tvalue = jQuery.htmlPrefilter( value );\n\n\t\t\t\ttry {\n\t\t\t\t\tfor ( ; i < l; i++ ) {\n\t\t\t\t\t\telem = this[ i ] || {};\n\n\t\t\t\t\t\t// Remove element nodes and prevent memory leaks\n\t\t\t\t\t\tif ( elem.nodeType === 1 ) {\n\t\t\t\t\t\t\tjQuery.cleanData( getAll( elem, false ) );\n\t\t\t\t\t\t\telem.innerHTML = value;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\telem = 0;\n\n\t\t\t\t// If using innerHTML throws an exception, use the fallback method\n\t\t\t\t} catch ( e ) {}\n\t\t\t}\n\n\t\t\tif ( elem ) {\n\t\t\t\tthis.empty().append( value );\n\t\t\t}\n\t\t}, null, value, arguments.length );\n\t},\n\n\treplaceWith: function() {\n\t\tvar ignored = [];\n\n\t\t// Make the changes, replacing each non-ignored context element with the new content\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tvar parent = this.parentNode;\n\n\t\t\tif ( jQuery.inArray( this, ignored ) < 0 ) {\n\t\t\t\tjQuery.cleanData( getAll( this ) );\n\t\t\t\tif ( parent ) {\n\t\t\t\t\tparent.replaceChild( elem, this );\n\t\t\t\t}\n\t\t\t}\n\n\t\t// Force callback invocation\n\t\t}, ignored );\n\t}\n} );\n\njQuery.each( {\n\tappendTo: \"append\",\n\tprependTo: \"prepend\",\n\tinsertBefore: \"before\",\n\tinsertAfter: \"after\",\n\treplaceAll: \"replaceWith\"\n}, function( name, original ) {\n\tjQuery.fn[ name ] = function( selector ) {\n\t\tvar elems,\n\t\t\tret = [],\n\t\t\tinsert = jQuery( selector ),\n\t\t\tlast = insert.length - 1,\n\t\t\ti = 0;\n\n\t\tfor ( ; i <= last; i++ ) {\n\t\t\telems = i === last ? this : this.clone( true );\n\t\t\tjQuery( insert[ i ] )[ original ]( elems );\n\n\t\t\t// Support: Android <=4.0 only, PhantomJS 1 only\n\t\t\t// .get() because push.apply(_, arraylike) throws on ancient WebKit\n\t\t\tpush.apply( ret, elems.get() );\n\t\t}\n\n\t\treturn this.pushStack( ret );\n\t};\n} );\nvar rnumnonpx = new RegExp( \"^(\" + pnum + \")(?!px)[a-z%]+$\", \"i\" );\n\nvar getStyles = function( elem ) {\n\n\t\t// Support: IE <=11 only, Firefox <=30 (#15098, #14150)\n\t\t// IE throws on elements created in popups\n\t\t// FF meanwhile throws on frame elements through \"defaultView.getComputedStyle\"\n\t\tvar view = elem.ownerDocument.defaultView;\n\n\t\tif ( !view || !view.opener ) {\n\t\t\tview = window;\n\t\t}\n\n\t\treturn view.getComputedStyle( elem );\n\t};\n\nvar rboxStyle = new RegExp( cssExpand.join( \"|\" ), \"i\" );\n\n\n\n( function() {\n\n\t// Executing both pixelPosition & boxSizingReliable tests require only one layout\n\t// so they're executed at the same time to save the second computation.\n\tfunction computeStyleTests() {\n\n\t\t// This is a singleton, we need to execute it only once\n\t\tif ( !div ) {\n\t\t\treturn;\n\t\t}\n\n\t\tcontainer.style.cssText = \"position:absolute;left:-11111px;width:60px;\" +\n\t\t\t\"margin-top:1px;padding:0;border:0\";\n\t\tdiv.style.cssText =\n\t\t\t\"position:relative;display:block;box-sizing:border-box;overflow:scroll;\" +\n\t\t\t\"margin:auto;border:1px;padding:1px;\" +\n\t\t\t\"width:60%;top:1%\";\n\t\tdocumentElement.appendChild( container ).appendChild( div );\n\n\t\tvar divStyle = window.getComputedStyle( div );\n\t\tpixelPositionVal = divStyle.top !== \"1%\";\n\n\t\t// Support: Android 4.0 - 4.3 only, Firefox <=3 - 44\n\t\treliableMarginLeftVal = roundPixelMeasures( divStyle.marginLeft ) === 12;\n\n\t\t// Support: Android 4.0 - 4.3 only, Safari <=9.1 - 10.1, iOS <=7.0 - 9.3\n\t\t// Some styles come back with percentage values, even though they shouldn't\n\t\tdiv.style.right = \"60%\";\n\t\tpixelBoxStylesVal = roundPixelMeasures( divStyle.right ) === 36;\n\n\t\t// Support: IE 9 - 11 only\n\t\t// Detect misreporting of content dimensions for box-sizing:border-box elements\n\t\tboxSizingReliableVal = roundPixelMeasures( divStyle.width ) === 36;\n\n\t\t// Support: IE 9 only\n\t\t// Detect overflow:scroll screwiness (gh-3699)\n\t\tdiv.style.position = \"absolute\";\n\t\tscrollboxSizeVal = div.offsetWidth === 36 || \"absolute\";\n\n\t\tdocumentElement.removeChild( container );\n\n\t\t// Nullify the div so it wouldn't be stored in the memory and\n\t\t// it will also be a sign that checks already performed\n\t\tdiv = null;\n\t}\n\n\tfunction roundPixelMeasures( measure ) {\n\t\treturn Math.round( parseFloat( measure ) );\n\t}\n\n\tvar pixelPositionVal, boxSizingReliableVal, scrollboxSizeVal, pixelBoxStylesVal,\n\t\treliableMarginLeftVal,\n\t\tcontainer = document.createElement( \"div\" ),\n\t\tdiv = document.createElement( \"div\" );\n\n\t// Finish early in limited (non-browser) environments\n\tif ( !div.style ) {\n\t\treturn;\n\t}\n\n\t// Support: IE <=9 - 11 only\n\t// Style of cloned element affects source element cloned (#8908)\n\tdiv.style.backgroundClip = \"content-box\";\n\tdiv.cloneNode( true ).style.backgroundClip = \"\";\n\tsupport.clearCloneStyle = div.style.backgroundClip === \"content-box\";\n\n\tjQuery.extend( support, {\n\t\tboxSizingReliable: function() {\n\t\t\tcomputeStyleTests();\n\t\t\treturn boxSizingReliableVal;\n\t\t},\n\t\tpixelBoxStyles: function() {\n\t\t\tcomputeStyleTests();\n\t\t\treturn pixelBoxStylesVal;\n\t\t},\n\t\tpixelPosition: function() {\n\t\t\tcomputeStyleTests();\n\t\t\treturn pixelPositionVal;\n\t\t},\n\t\treliableMarginLeft: function() {\n\t\t\tcomputeStyleTests();\n\t\t\treturn reliableMarginLeftVal;\n\t\t},\n\t\tscrollboxSize: function() {\n\t\t\tcomputeStyleTests();\n\t\t\treturn scrollboxSizeVal;\n\t\t}\n\t} );\n} )();\n\n\nfunction curCSS( elem, name, computed ) {\n\tvar width, minWidth, maxWidth, ret,\n\n\t\t// Support: Firefox 51+\n\t\t// Retrieving style before computed somehow\n\t\t// fixes an issue with getting wrong values\n\t\t// on detached elements\n\t\tstyle = elem.style;\n\n\tcomputed = computed || getStyles( elem );\n\n\t// getPropertyValue is needed for:\n\t//   .css('filter') (IE 9 only, #12537)\n\t//   .css('--customProperty) (#3144)\n\tif ( computed ) {\n\t\tret = computed.getPropertyValue( name ) || computed[ name ];\n\n\t\tif ( ret === \"\" && !jQuery.contains( elem.ownerDocument, elem ) ) {\n\t\t\tret = jQuery.style( elem, name );\n\t\t}\n\n\t\t// A tribute to the \"awesome hack by Dean Edwards\"\n\t\t// Android Browser returns percentage for some values,\n\t\t// but width seems to be reliably pixels.\n\t\t// This is against the CSSOM draft spec:\n\t\t// https://drafts.csswg.org/cssom/#resolved-values\n\t\tif ( !support.pixelBoxStyles() && rnumnonpx.test( ret ) && rboxStyle.test( name ) ) {\n\n\t\t\t// Remember the original values\n\t\t\twidth = style.width;\n\t\t\tminWidth = style.minWidth;\n\t\t\tmaxWidth = style.maxWidth;\n\n\t\t\t// Put in the new values to get a computed value out\n\t\t\tstyle.minWidth = style.maxWidth = style.width = ret;\n\t\t\tret = computed.width;\n\n\t\t\t// Revert the changed values\n\t\t\tstyle.width = width;\n\t\t\tstyle.minWidth = minWidth;\n\t\t\tstyle.maxWidth = maxWidth;\n\t\t}\n\t}\n\n\treturn ret !== undefined ?\n\n\t\t// Support: IE <=9 - 11 only\n\t\t// IE returns zIndex value as an integer.\n\t\tret + \"\" :\n\t\tret;\n}\n\n\nfunction addGetHookIf( conditionFn, hookFn ) {\n\n\t// Define the hook, we'll check on the first run if it's really needed.\n\treturn {\n\t\tget: function() {\n\t\t\tif ( conditionFn() ) {\n\n\t\t\t\t// Hook not needed (or it's not possible to use it due\n\t\t\t\t// to missing dependency), remove it.\n\t\t\t\tdelete this.get;\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// Hook needed; redefine it so that the support test is not executed again.\n\t\t\treturn ( this.get = hookFn ).apply( this, arguments );\n\t\t}\n\t};\n}\n\n\nvar\n\n\t// Swappable if display is none or starts with table\n\t// except \"table\", \"table-cell\", or \"table-caption\"\n\t// See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display\n\trdisplayswap = /^(none|table(?!-c[ea]).+)/,\n\trcustomProp = /^--/,\n\tcssShow = { position: \"absolute\", visibility: \"hidden\", display: \"block\" },\n\tcssNormalTransform = {\n\t\tletterSpacing: \"0\",\n\t\tfontWeight: \"400\"\n\t},\n\n\tcssPrefixes = [ \"Webkit\", \"Moz\", \"ms\" ],\n\temptyStyle = document.createElement( \"div\" ).style;\n\n// Return a css property mapped to a potentially vendor prefixed property\nfunction vendorPropName( name ) {\n\n\t// Shortcut for names that are not vendor prefixed\n\tif ( name in emptyStyle ) {\n\t\treturn name;\n\t}\n\n\t// Check for vendor prefixed names\n\tvar capName = name[ 0 ].toUpperCase() + name.slice( 1 ),\n\t\ti = cssPrefixes.length;\n\n\twhile ( i-- ) {\n\t\tname = cssPrefixes[ i ] + capName;\n\t\tif ( name in emptyStyle ) {\n\t\t\treturn name;\n\t\t}\n\t}\n}\n\n// Return a property mapped along what jQuery.cssProps suggests or to\n// a vendor prefixed property.\nfunction finalPropName( name ) {\n\tvar ret = jQuery.cssProps[ name ];\n\tif ( !ret ) {\n\t\tret = jQuery.cssProps[ name ] = vendorPropName( name ) || name;\n\t}\n\treturn ret;\n}\n\nfunction setPositiveNumber( elem, value, subtract ) {\n\n\t// Any relative (+/-) values have already been\n\t// normalized at this point\n\tvar matches = rcssNum.exec( value );\n\treturn matches ?\n\n\t\t// Guard against undefined \"subtract\", e.g., when used as in cssHooks\n\t\tMath.max( 0, matches[ 2 ] - ( subtract || 0 ) ) + ( matches[ 3 ] || \"px\" ) :\n\t\tvalue;\n}\n\nfunction boxModelAdjustment( elem, dimension, box, isBorderBox, styles, computedVal ) {\n\tvar i = dimension === \"width\" ? 1 : 0,\n\t\textra = 0,\n\t\tdelta = 0;\n\n\t// Adjustment may not be necessary\n\tif ( box === ( isBorderBox ? \"border\" : \"content\" ) ) {\n\t\treturn 0;\n\t}\n\n\tfor ( ; i < 4; i += 2 ) {\n\n\t\t// Both box models exclude margin\n\t\tif ( box === \"margin\" ) {\n\t\t\tdelta += jQuery.css( elem, box + cssExpand[ i ], true, styles );\n\t\t}\n\n\t\t// If we get here with a content-box, we're seeking \"padding\" or \"border\" or \"margin\"\n\t\tif ( !isBorderBox ) {\n\n\t\t\t// Add padding\n\t\t\tdelta += jQuery.css( elem, \"padding\" + cssExpand[ i ], true, styles );\n\n\t\t\t// For \"border\" or \"margin\", add border\n\t\t\tif ( box !== \"padding\" ) {\n\t\t\t\tdelta += jQuery.css( elem, \"border\" + cssExpand[ i ] + \"Width\", true, styles );\n\n\t\t\t// But still keep track of it otherwise\n\t\t\t} else {\n\t\t\t\textra += jQuery.css( elem, \"border\" + cssExpand[ i ] + \"Width\", true, styles );\n\t\t\t}\n\n\t\t// If we get here with a border-box (content + padding + border), we're seeking \"content\" or\n\t\t// \"padding\" or \"margin\"\n\t\t} else {\n\n\t\t\t// For \"content\", subtract padding\n\t\t\tif ( box === \"content\" ) {\n\t\t\t\tdelta -= jQuery.css( elem, \"padding\" + cssExpand[ i ], true, styles );\n\t\t\t}\n\n\t\t\t// For \"content\" or \"padding\", subtract border\n\t\t\tif ( box !== \"margin\" ) {\n\t\t\t\tdelta -= jQuery.css( elem, \"border\" + cssExpand[ i ] + \"Width\", true, styles );\n\t\t\t}\n\t\t}\n\t}\n\n\t// Account for positive content-box scroll gutter when requested by providing computedVal\n\tif ( !isBorderBox && computedVal >= 0 ) {\n\n\t\t// offsetWidth/offsetHeight is a rounded sum of content, padding, scroll gutter, and border\n\t\t// Assuming integer scroll gutter, subtract the rest and round down\n\t\tdelta += Math.max( 0, Math.ceil(\n\t\t\telem[ \"offset\" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] -\n\t\t\tcomputedVal -\n\t\t\tdelta -\n\t\t\textra -\n\t\t\t0.5\n\t\t) );\n\t}\n\n\treturn delta;\n}\n\nfunction getWidthOrHeight( elem, dimension, extra ) {\n\n\t// Start with computed style\n\tvar styles = getStyles( elem ),\n\t\tval = curCSS( elem, dimension, styles ),\n\t\tisBorderBox = jQuery.css( elem, \"boxSizing\", false, styles ) === \"border-box\",\n\t\tvalueIsBorderBox = isBorderBox;\n\n\t// Support: Firefox <=54\n\t// Return a confounding non-pixel value or feign ignorance, as appropriate.\n\tif ( rnumnonpx.test( val ) ) {\n\t\tif ( !extra ) {\n\t\t\treturn val;\n\t\t}\n\t\tval = \"auto\";\n\t}\n\n\t// Check for style in case a browser which returns unreliable values\n\t// for getComputedStyle silently falls back to the reliable elem.style\n\tvalueIsBorderBox = valueIsBorderBox &&\n\t\t( support.boxSizingReliable() || val === elem.style[ dimension ] );\n\n\t// Fall back to offsetWidth/offsetHeight when value is \"auto\"\n\t// This happens for inline elements with no explicit setting (gh-3571)\n\t// Support: Android <=4.1 - 4.3 only\n\t// Also use offsetWidth/offsetHeight for misreported inline dimensions (gh-3602)\n\tif ( val === \"auto\" ||\n\t\t!parseFloat( val ) && jQuery.css( elem, \"display\", false, styles ) === \"inline\" ) {\n\n\t\tval = elem[ \"offset\" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ];\n\n\t\t// offsetWidth/offsetHeight provide border-box values\n\t\tvalueIsBorderBox = true;\n\t}\n\n\t// Normalize \"\" and auto\n\tval = parseFloat( val ) || 0;\n\n\t// Adjust for the element's box model\n\treturn ( val +\n\t\tboxModelAdjustment(\n\t\t\telem,\n\t\t\tdimension,\n\t\t\textra || ( isBorderBox ? \"border\" : \"content\" ),\n\t\t\tvalueIsBorderBox,\n\t\t\tstyles,\n\n\t\t\t// Provide the current computed size to request scroll gutter calculation (gh-3589)\n\t\t\tval\n\t\t)\n\t) + \"px\";\n}\n\njQuery.extend( {\n\n\t// Add in style property hooks for overriding the default\n\t// behavior of getting and setting a style property\n\tcssHooks: {\n\t\topacity: {\n\t\t\tget: function( elem, computed ) {\n\t\t\t\tif ( computed ) {\n\n\t\t\t\t\t// We should always get a number back from opacity\n\t\t\t\t\tvar ret = curCSS( elem, \"opacity\" );\n\t\t\t\t\treturn ret === \"\" ? \"1\" : ret;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t},\n\n\t// Don't automatically add \"px\" to these possibly-unitless properties\n\tcssNumber: {\n\t\t\"animationIterationCount\": true,\n\t\t\"columnCount\": true,\n\t\t\"fillOpacity\": true,\n\t\t\"flexGrow\": true,\n\t\t\"flexShrink\": true,\n\t\t\"fontWeight\": true,\n\t\t\"lineHeight\": true,\n\t\t\"opacity\": true,\n\t\t\"order\": true,\n\t\t\"orphans\": true,\n\t\t\"widows\": true,\n\t\t\"zIndex\": true,\n\t\t\"zoom\": true\n\t},\n\n\t// Add in properties whose names you wish to fix before\n\t// setting or getting the value\n\tcssProps: {},\n\n\t// Get and set the style property on a DOM Node\n\tstyle: function( elem, name, value, extra ) {\n\n\t\t// Don't set styles on text and comment nodes\n\t\tif ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Make sure that we're working with the right name\n\t\tvar ret, type, hooks,\n\t\t\torigName = camelCase( name ),\n\t\t\tisCustomProp = rcustomProp.test( name ),\n\t\t\tstyle = elem.style;\n\n\t\t// Make sure that we're working with the right name. We don't\n\t\t// want to query the value if it is a CSS custom property\n\t\t// since they are user-defined.\n\t\tif ( !isCustomProp ) {\n\t\t\tname = finalPropName( origName );\n\t\t}\n\n\t\t// Gets hook for the prefixed version, then unprefixed version\n\t\thooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];\n\n\t\t// Check if we're setting a value\n\t\tif ( value !== undefined ) {\n\t\t\ttype = typeof value;\n\n\t\t\t// Convert \"+=\" or \"-=\" to relative numbers (#7345)\n\t\t\tif ( type === \"string\" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) {\n\t\t\t\tvalue = adjustCSS( elem, name, ret );\n\n\t\t\t\t// Fixes bug #9237\n\t\t\t\ttype = \"number\";\n\t\t\t}\n\n\t\t\t// Make sure that null and NaN values aren't set (#7116)\n\t\t\tif ( value == null || value !== value ) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// If a number was passed in, add the unit (except for certain CSS properties)\n\t\t\tif ( type === \"number\" ) {\n\t\t\t\tvalue += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? \"\" : \"px\" );\n\t\t\t}\n\n\t\t\t// background-* props affect original clone's values\n\t\t\tif ( !support.clearCloneStyle && value === \"\" && name.indexOf( \"background\" ) === 0 ) {\n\t\t\t\tstyle[ name ] = \"inherit\";\n\t\t\t}\n\n\t\t\t// If a hook was provided, use that value, otherwise just set the specified value\n\t\t\tif ( !hooks || !( \"set\" in hooks ) ||\n\t\t\t\t( value = hooks.set( elem, value, extra ) ) !== undefined ) {\n\n\t\t\t\tif ( isCustomProp ) {\n\t\t\t\t\tstyle.setProperty( name, value );\n\t\t\t\t} else {\n\t\t\t\t\tstyle[ name ] = value;\n\t\t\t\t}\n\t\t\t}\n\n\t\t} else {\n\n\t\t\t// If a hook was provided get the non-computed value from there\n\t\t\tif ( hooks && \"get\" in hooks &&\n\t\t\t\t( ret = hooks.get( elem, false, extra ) ) !== undefined ) {\n\n\t\t\t\treturn ret;\n\t\t\t}\n\n\t\t\t// Otherwise just get the value from the style object\n\t\t\treturn style[ name ];\n\t\t}\n\t},\n\n\tcss: function( elem, name, extra, styles ) {\n\t\tvar val, num, hooks,\n\t\t\torigName = camelCase( name ),\n\t\t\tisCustomProp = rcustomProp.test( name );\n\n\t\t// Make sure that we're working with the right name. We don't\n\t\t// want to modify the value if it is a CSS custom property\n\t\t// since they are user-defined.\n\t\tif ( !isCustomProp ) {\n\t\t\tname = finalPropName( origName );\n\t\t}\n\n\t\t// Try prefixed name followed by the unprefixed name\n\t\thooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];\n\n\t\t// If a hook was provided get the computed value from there\n\t\tif ( hooks && \"get\" in hooks ) {\n\t\t\tval = hooks.get( elem, true, extra );\n\t\t}\n\n\t\t// Otherwise, if a way to get the computed value exists, use that\n\t\tif ( val === undefined ) {\n\t\t\tval = curCSS( elem, name, styles );\n\t\t}\n\n\t\t// Convert \"normal\" to computed value\n\t\tif ( val === \"normal\" && name in cssNormalTransform ) {\n\t\t\tval = cssNormalTransform[ name ];\n\t\t}\n\n\t\t// Make numeric if forced or a qualifier was provided and val looks numeric\n\t\tif ( extra === \"\" || extra ) {\n\t\t\tnum = parseFloat( val );\n\t\t\treturn extra === true || isFinite( num ) ? num || 0 : val;\n\t\t}\n\n\t\treturn val;\n\t}\n} );\n\njQuery.each( [ \"height\", \"width\" ], function( i, dimension ) {\n\tjQuery.cssHooks[ dimension ] = {\n\t\tget: function( elem, computed, extra ) {\n\t\t\tif ( computed ) {\n\n\t\t\t\t// Certain elements can have dimension info if we invisibly show them\n\t\t\t\t// but it must have a current display style that would benefit\n\t\t\t\treturn rdisplayswap.test( jQuery.css( elem, \"display\" ) ) &&\n\n\t\t\t\t\t// Support: Safari 8+\n\t\t\t\t\t// Table columns in Safari have non-zero offsetWidth & zero\n\t\t\t\t\t// getBoundingClientRect().width unless display is changed.\n\t\t\t\t\t// Support: IE <=11 only\n\t\t\t\t\t// Running getBoundingClientRect on a disconnected node\n\t\t\t\t\t// in IE throws an error.\n\t\t\t\t\t( !elem.getClientRects().length || !elem.getBoundingClientRect().width ) ?\n\t\t\t\t\t\tswap( elem, cssShow, function() {\n\t\t\t\t\t\t\treturn getWidthOrHeight( elem, dimension, extra );\n\t\t\t\t\t\t} ) :\n\t\t\t\t\t\tgetWidthOrHeight( elem, dimension, extra );\n\t\t\t}\n\t\t},\n\n\t\tset: function( elem, value, extra ) {\n\t\t\tvar matches,\n\t\t\t\tstyles = getStyles( elem ),\n\t\t\t\tisBorderBox = jQuery.css( elem, \"boxSizing\", false, styles ) === \"border-box\",\n\t\t\t\tsubtract = extra && boxModelAdjustment(\n\t\t\t\t\telem,\n\t\t\t\t\tdimension,\n\t\t\t\t\textra,\n\t\t\t\t\tisBorderBox,\n\t\t\t\t\tstyles\n\t\t\t\t);\n\n\t\t\t// Account for unreliable border-box dimensions by comparing offset* to computed and\n\t\t\t// faking a content-box to get border and padding (gh-3699)\n\t\t\tif ( isBorderBox && support.scrollboxSize() === styles.position ) {\n\t\t\t\tsubtract -= Math.ceil(\n\t\t\t\t\telem[ \"offset\" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] -\n\t\t\t\t\tparseFloat( styles[ dimension ] ) -\n\t\t\t\t\tboxModelAdjustment( elem, dimension, \"border\", false, styles ) -\n\t\t\t\t\t0.5\n\t\t\t\t);\n\t\t\t}\n\n\t\t\t// Convert to pixels if value adjustment is needed\n\t\t\tif ( subtract && ( matches = rcssNum.exec( value ) ) &&\n\t\t\t\t( matches[ 3 ] || \"px\" ) !== \"px\" ) {\n\n\t\t\t\telem.style[ dimension ] = value;\n\t\t\t\tvalue = jQuery.css( elem, dimension );\n\t\t\t}\n\n\t\t\treturn setPositiveNumber( elem, value, subtract );\n\t\t}\n\t};\n} );\n\njQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft,\n\tfunction( elem, computed ) {\n\t\tif ( computed ) {\n\t\t\treturn ( parseFloat( curCSS( elem, \"marginLeft\" ) ) ||\n\t\t\t\telem.getBoundingClientRect().left -\n\t\t\t\t\tswap( elem, { marginLeft: 0 }, function() {\n\t\t\t\t\t\treturn elem.getBoundingClientRect().left;\n\t\t\t\t\t} )\n\t\t\t\t) + \"px\";\n\t\t}\n\t}\n);\n\n// These hooks are used by animate to expand properties\njQuery.each( {\n\tmargin: \"\",\n\tpadding: \"\",\n\tborder: \"Width\"\n}, function( prefix, suffix ) {\n\tjQuery.cssHooks[ prefix + suffix ] = {\n\t\texpand: function( value ) {\n\t\t\tvar i = 0,\n\t\t\t\texpanded = {},\n\n\t\t\t\t// Assumes a single number if not a string\n\t\t\t\tparts = typeof value === \"string\" ? value.split( \" \" ) : [ value ];\n\n\t\t\tfor ( ; i < 4; i++ ) {\n\t\t\t\texpanded[ prefix + cssExpand[ i ] + suffix ] =\n\t\t\t\t\tparts[ i ] || parts[ i - 2 ] || parts[ 0 ];\n\t\t\t}\n\n\t\t\treturn expanded;\n\t\t}\n\t};\n\n\tif ( prefix !== \"margin\" ) {\n\t\tjQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber;\n\t}\n} );\n\njQuery.fn.extend( {\n\tcss: function( name, value ) {\n\t\treturn access( this, function( elem, name, value ) {\n\t\t\tvar styles, len,\n\t\t\t\tmap = {},\n\t\t\t\ti = 0;\n\n\t\t\tif ( Array.isArray( name ) ) {\n\t\t\t\tstyles = getStyles( elem );\n\t\t\t\tlen = name.length;\n\n\t\t\t\tfor ( ; i < len; i++ ) {\n\t\t\t\t\tmap[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles );\n\t\t\t\t}\n\n\t\t\t\treturn map;\n\t\t\t}\n\n\t\t\treturn value !== undefined ?\n\t\t\t\tjQuery.style( elem, name, value ) :\n\t\t\t\tjQuery.css( elem, name );\n\t\t}, name, value, arguments.length > 1 );\n\t}\n} );\n\n\nfunction Tween( elem, options, prop, end, easing ) {\n\treturn new Tween.prototype.init( elem, options, prop, end, easing );\n}\njQuery.Tween = Tween;\n\nTween.prototype = {\n\tconstructor: Tween,\n\tinit: function( elem, options, prop, end, easing, unit ) {\n\t\tthis.elem = elem;\n\t\tthis.prop = prop;\n\t\tthis.easing = easing || jQuery.easing._default;\n\t\tthis.options = options;\n\t\tthis.start = this.now = this.cur();\n\t\tthis.end = end;\n\t\tthis.unit = unit || ( jQuery.cssNumber[ prop ] ? \"\" : \"px\" );\n\t},\n\tcur: function() {\n\t\tvar hooks = Tween.propHooks[ this.prop ];\n\n\t\treturn hooks && hooks.get ?\n\t\t\thooks.get( this ) :\n\t\t\tTween.propHooks._default.get( this );\n\t},\n\trun: function( percent ) {\n\t\tvar eased,\n\t\t\thooks = Tween.propHooks[ this.prop ];\n\n\t\tif ( this.options.duration ) {\n\t\t\tthis.pos = eased = jQuery.easing[ this.easing ](\n\t\t\t\tpercent, this.options.duration * percent, 0, 1, this.options.duration\n\t\t\t);\n\t\t} else {\n\t\t\tthis.pos = eased = percent;\n\t\t}\n\t\tthis.now = ( this.end - this.start ) * eased + this.start;\n\n\t\tif ( this.options.step ) {\n\t\t\tthis.options.step.call( this.elem, this.now, this );\n\t\t}\n\n\t\tif ( hooks && hooks.set ) {\n\t\t\thooks.set( this );\n\t\t} else {\n\t\t\tTween.propHooks._default.set( this );\n\t\t}\n\t\treturn this;\n\t}\n};\n\nTween.prototype.init.prototype = Tween.prototype;\n\nTween.propHooks = {\n\t_default: {\n\t\tget: function( tween ) {\n\t\t\tvar result;\n\n\t\t\t// Use a property on the element directly when it is not a DOM element,\n\t\t\t// or when there is no matching style property that exists.\n\t\t\tif ( tween.elem.nodeType !== 1 ||\n\t\t\t\ttween.elem[ tween.prop ] != null && tween.elem.style[ tween.prop ] == null ) {\n\t\t\t\treturn tween.elem[ tween.prop ];\n\t\t\t}\n\n\t\t\t// Passing an empty string as a 3rd parameter to .css will automatically\n\t\t\t// attempt a parseFloat and fallback to a string if the parse fails.\n\t\t\t// Simple values such as \"10px\" are parsed to Float;\n\t\t\t// complex values such as \"rotate(1rad)\" are returned as-is.\n\t\t\tresult = jQuery.css( tween.elem, tween.prop, \"\" );\n\n\t\t\t// Empty strings, null, undefined and \"auto\" are converted to 0.\n\t\t\treturn !result || result === \"auto\" ? 0 : result;\n\t\t},\n\t\tset: function( tween ) {\n\n\t\t\t// Use step hook for back compat.\n\t\t\t// Use cssHook if its there.\n\t\t\t// Use .style if available and use plain properties where available.\n\t\t\tif ( jQuery.fx.step[ tween.prop ] ) {\n\t\t\t\tjQuery.fx.step[ tween.prop ]( tween );\n\t\t\t} else if ( tween.elem.nodeType === 1 &&\n\t\t\t\t( tween.elem.style[ jQuery.cssProps[ tween.prop ] ] != null ||\n\t\t\t\t\tjQuery.cssHooks[ tween.prop ] ) ) {\n\t\t\t\tjQuery.style( tween.elem, tween.prop, tween.now + tween.unit );\n\t\t\t} else {\n\t\t\t\ttween.elem[ tween.prop ] = tween.now;\n\t\t\t}\n\t\t}\n\t}\n};\n\n// Support: IE <=9 only\n// Panic based approach to setting things on disconnected nodes\nTween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {\n\tset: function( tween ) {\n\t\tif ( tween.elem.nodeType && tween.elem.parentNode ) {\n\t\t\ttween.elem[ tween.prop ] = tween.now;\n\t\t}\n\t}\n};\n\njQuery.easing = {\n\tlinear: function( p ) {\n\t\treturn p;\n\t},\n\tswing: function( p ) {\n\t\treturn 0.5 - Math.cos( p * Math.PI ) / 2;\n\t},\n\t_default: \"swing\"\n};\n\njQuery.fx = Tween.prototype.init;\n\n// Back compat <1.8 extension point\njQuery.fx.step = {};\n\n\n\n\nvar\n\tfxNow, inProgress,\n\trfxtypes = /^(?:toggle|show|hide)$/,\n\trrun = /queueHooks$/;\n\nfunction schedule() {\n\tif ( inProgress ) {\n\t\tif ( document.hidden === false && window.requestAnimationFrame ) {\n\t\t\twindow.requestAnimationFrame( schedule );\n\t\t} else {\n\t\t\twindow.setTimeout( schedule, jQuery.fx.interval );\n\t\t}\n\n\t\tjQuery.fx.tick();\n\t}\n}\n\n// Animations created synchronously will run synchronously\nfunction createFxNow() {\n\twindow.setTimeout( function() {\n\t\tfxNow = undefined;\n\t} );\n\treturn ( fxNow = Date.now() );\n}\n\n// Generate parameters to create a standard animation\nfunction genFx( type, includeWidth ) {\n\tvar which,\n\t\ti = 0,\n\t\tattrs = { height: type };\n\n\t// If we include width, step value is 1 to do all cssExpand values,\n\t// otherwise step value is 2 to skip over Left and Right\n\tincludeWidth = includeWidth ? 1 : 0;\n\tfor ( ; i < 4; i += 2 - includeWidth ) {\n\t\twhich = cssExpand[ i ];\n\t\tattrs[ \"margin\" + which ] = attrs[ \"padding\" + which ] = type;\n\t}\n\n\tif ( includeWidth ) {\n\t\tattrs.opacity = attrs.width = type;\n\t}\n\n\treturn attrs;\n}\n\nfunction createTween( value, prop, animation ) {\n\tvar tween,\n\t\tcollection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ \"*\" ] ),\n\t\tindex = 0,\n\t\tlength = collection.length;\n\tfor ( ; index < length; index++ ) {\n\t\tif ( ( tween = collection[ index ].call( animation, prop, value ) ) ) {\n\n\t\t\t// We're done with this property\n\t\t\treturn tween;\n\t\t}\n\t}\n}\n\nfunction defaultPrefilter( elem, props, opts ) {\n\tvar prop, value, toggle, hooks, oldfire, propTween, restoreDisplay, display,\n\t\tisBox = \"width\" in props || \"height\" in props,\n\t\tanim = this,\n\t\torig = {},\n\t\tstyle = elem.style,\n\t\thidden = elem.nodeType && isHiddenWithinTree( elem ),\n\t\tdataShow = dataPriv.get( elem, \"fxshow\" );\n\n\t// Queue-skipping animations hijack the fx hooks\n\tif ( !opts.queue ) {\n\t\thooks = jQuery._queueHooks( elem, \"fx\" );\n\t\tif ( hooks.unqueued == null ) {\n\t\t\thooks.unqueued = 0;\n\t\t\toldfire = hooks.empty.fire;\n\t\t\thooks.empty.fire = function() {\n\t\t\t\tif ( !hooks.unqueued ) {\n\t\t\t\t\toldfire();\n\t\t\t\t}\n\t\t\t};\n\t\t}\n\t\thooks.unqueued++;\n\n\t\tanim.always( function() {\n\n\t\t\t// Ensure the complete handler is called before this completes\n\t\t\tanim.always( function() {\n\t\t\t\thooks.unqueued--;\n\t\t\t\tif ( !jQuery.queue( elem, \"fx\" ).length ) {\n\t\t\t\t\thooks.empty.fire();\n\t\t\t\t}\n\t\t\t} );\n\t\t} );\n\t}\n\n\t// Detect show/hide animations\n\tfor ( prop in props ) {\n\t\tvalue = props[ prop ];\n\t\tif ( rfxtypes.test( value ) ) {\n\t\t\tdelete props[ prop ];\n\t\t\ttoggle = toggle || value === \"toggle\";\n\t\t\tif ( value === ( hidden ? \"hide\" : \"show\" ) ) {\n\n\t\t\t\t// Pretend to be hidden if this is a \"show\" and\n\t\t\t\t// there is still data from a stopped show/hide\n\t\t\t\tif ( value === \"show\" && dataShow && dataShow[ prop ] !== undefined ) {\n\t\t\t\t\thidden = true;\n\n\t\t\t\t// Ignore all other no-op show/hide data\n\t\t\t\t} else {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t}\n\t\t\torig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop );\n\t\t}\n\t}\n\n\t// Bail out if this is a no-op like .hide().hide()\n\tpropTween = !jQuery.isEmptyObject( props );\n\tif ( !propTween && jQuery.isEmptyObject( orig ) ) {\n\t\treturn;\n\t}\n\n\t// Restrict \"overflow\" and \"display\" styles during box animations\n\tif ( isBox && elem.nodeType === 1 ) {\n\n\t\t// Support: IE <=9 - 11, Edge 12 - 15\n\t\t// Record all 3 overflow attributes because IE does not infer the shorthand\n\t\t// from identically-valued overflowX and overflowY and Edge just mirrors\n\t\t// the overflowX value there.\n\t\topts.overflow = [ style.overflow, style.overflowX, style.overflowY ];\n\n\t\t// Identify a display type, preferring old show/hide data over the CSS cascade\n\t\trestoreDisplay = dataShow && dataShow.display;\n\t\tif ( restoreDisplay == null ) {\n\t\t\trestoreDisplay = dataPriv.get( elem, \"display\" );\n\t\t}\n\t\tdisplay = jQuery.css( elem, \"display\" );\n\t\tif ( display === \"none\" ) {\n\t\t\tif ( restoreDisplay ) {\n\t\t\t\tdisplay = restoreDisplay;\n\t\t\t} else {\n\n\t\t\t\t// Get nonempty value(s) by temporarily forcing visibility\n\t\t\t\tshowHide( [ elem ], true );\n\t\t\t\trestoreDisplay = elem.style.display || restoreDisplay;\n\t\t\t\tdisplay = jQuery.css( elem, \"display\" );\n\t\t\t\tshowHide( [ elem ] );\n\t\t\t}\n\t\t}\n\n\t\t// Animate inline elements as inline-block\n\t\tif ( display === \"inline\" || display === \"inline-block\" && restoreDisplay != null ) {\n\t\t\tif ( jQuery.css( elem, \"float\" ) === \"none\" ) {\n\n\t\t\t\t// Restore the original display value at the end of pure show/hide animations\n\t\t\t\tif ( !propTween ) {\n\t\t\t\t\tanim.done( function() {\n\t\t\t\t\t\tstyle.display = restoreDisplay;\n\t\t\t\t\t} );\n\t\t\t\t\tif ( restoreDisplay == null ) {\n\t\t\t\t\t\tdisplay = style.display;\n\t\t\t\t\t\trestoreDisplay = display === \"none\" ? \"\" : display;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tstyle.display = \"inline-block\";\n\t\t\t}\n\t\t}\n\t}\n\n\tif ( opts.overflow ) {\n\t\tstyle.overflow = \"hidden\";\n\t\tanim.always( function() {\n\t\t\tstyle.overflow = opts.overflow[ 0 ];\n\t\t\tstyle.overflowX = opts.overflow[ 1 ];\n\t\t\tstyle.overflowY = opts.overflow[ 2 ];\n\t\t} );\n\t}\n\n\t// Implement show/hide animations\n\tpropTween = false;\n\tfor ( prop in orig ) {\n\n\t\t// General show/hide setup for this element animation\n\t\tif ( !propTween ) {\n\t\t\tif ( dataShow ) {\n\t\t\t\tif ( \"hidden\" in dataShow ) {\n\t\t\t\t\thidden = dataShow.hidden;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tdataShow = dataPriv.access( elem, \"fxshow\", { display: restoreDisplay } );\n\t\t\t}\n\n\t\t\t// Store hidden/visible for toggle so `.stop().toggle()` \"reverses\"\n\t\t\tif ( toggle ) {\n\t\t\t\tdataShow.hidden = !hidden;\n\t\t\t}\n\n\t\t\t// Show elements before animating them\n\t\t\tif ( hidden ) {\n\t\t\t\tshowHide( [ elem ], true );\n\t\t\t}\n\n\t\t\t/* eslint-disable no-loop-func */\n\n\t\t\tanim.done( function() {\n\n\t\t\t/* eslint-enable no-loop-func */\n\n\t\t\t\t// The final step of a \"hide\" animation is actually hiding the element\n\t\t\t\tif ( !hidden ) {\n\t\t\t\t\tshowHide( [ elem ] );\n\t\t\t\t}\n\t\t\t\tdataPriv.remove( elem, \"fxshow\" );\n\t\t\t\tfor ( prop in orig ) {\n\t\t\t\t\tjQuery.style( elem, prop, orig[ prop ] );\n\t\t\t\t}\n\t\t\t} );\n\t\t}\n\n\t\t// Per-property setup\n\t\tpropTween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim );\n\t\tif ( !( prop in dataShow ) ) {\n\t\t\tdataShow[ prop ] = propTween.start;\n\t\t\tif ( hidden ) {\n\t\t\t\tpropTween.end = propTween.start;\n\t\t\t\tpropTween.start = 0;\n\t\t\t}\n\t\t}\n\t}\n}\n\nfunction propFilter( props, specialEasing ) {\n\tvar index, name, easing, value, hooks;\n\n\t// camelCase, specialEasing and expand cssHook pass\n\tfor ( index in props ) {\n\t\tname = camelCase( index );\n\t\teasing = specialEasing[ name ];\n\t\tvalue = props[ index ];\n\t\tif ( Array.isArray( value ) ) {\n\t\t\teasing = value[ 1 ];\n\t\t\tvalue = props[ index ] = value[ 0 ];\n\t\t}\n\n\t\tif ( index !== name ) {\n\t\t\tprops[ name ] = value;\n\t\t\tdelete props[ index ];\n\t\t}\n\n\t\thooks = jQuery.cssHooks[ name ];\n\t\tif ( hooks && \"expand\" in hooks ) {\n\t\t\tvalue = hooks.expand( value );\n\t\t\tdelete props[ name ];\n\n\t\t\t// Not quite $.extend, this won't overwrite existing keys.\n\t\t\t// Reusing 'index' because we have the correct \"name\"\n\t\t\tfor ( index in value ) {\n\t\t\t\tif ( !( index in props ) ) {\n\t\t\t\t\tprops[ index ] = value[ index ];\n\t\t\t\t\tspecialEasing[ index ] = easing;\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tspecialEasing[ name ] = easing;\n\t\t}\n\t}\n}\n\nfunction Animation( elem, properties, options ) {\n\tvar result,\n\t\tstopped,\n\t\tindex = 0,\n\t\tlength = Animation.prefilters.length,\n\t\tdeferred = jQuery.Deferred().always( function() {\n\n\t\t\t// Don't match elem in the :animated selector\n\t\t\tdelete tick.elem;\n\t\t} ),\n\t\ttick = function() {\n\t\t\tif ( stopped ) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t\tvar currentTime = fxNow || createFxNow(),\n\t\t\t\tremaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),\n\n\t\t\t\t// Support: Android 2.3 only\n\t\t\t\t// Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497)\n\t\t\t\ttemp = remaining / animation.duration || 0,\n\t\t\t\tpercent = 1 - temp,\n\t\t\t\tindex = 0,\n\t\t\t\tlength = animation.tweens.length;\n\n\t\t\tfor ( ; index < length; index++ ) {\n\t\t\t\tanimation.tweens[ index ].run( percent );\n\t\t\t}\n\n\t\t\tdeferred.notifyWith( elem, [ animation, percent, remaining ] );\n\n\t\t\t// If there's more to do, yield\n\t\t\tif ( percent < 1 && length ) {\n\t\t\t\treturn remaining;\n\t\t\t}\n\n\t\t\t// If this was an empty animation, synthesize a final progress notification\n\t\t\tif ( !length ) {\n\t\t\t\tdeferred.notifyWith( elem, [ animation, 1, 0 ] );\n\t\t\t}\n\n\t\t\t// Resolve the animation and report its conclusion\n\t\t\tdeferred.resolveWith( elem, [ animation ] );\n\t\t\treturn false;\n\t\t},\n\t\tanimation = deferred.promise( {\n\t\t\telem: elem,\n\t\t\tprops: jQuery.extend( {}, properties ),\n\t\t\topts: jQuery.extend( true, {\n\t\t\t\tspecialEasing: {},\n\t\t\t\teasing: jQuery.easing._default\n\t\t\t}, options ),\n\t\t\toriginalProperties: properties,\n\t\t\toriginalOptions: options,\n\t\t\tstartTime: fxNow || createFxNow(),\n\t\t\tduration: options.duration,\n\t\t\ttweens: [],\n\t\t\tcreateTween: function( prop, end ) {\n\t\t\t\tvar tween = jQuery.Tween( elem, animation.opts, prop, end,\n\t\t\t\t\t\tanimation.opts.specialEasing[ prop ] || animation.opts.easing );\n\t\t\t\tanimation.tweens.push( tween );\n\t\t\t\treturn tween;\n\t\t\t},\n\t\t\tstop: function( gotoEnd ) {\n\t\t\t\tvar index = 0,\n\n\t\t\t\t\t// If we are going to the end, we want to run all the tweens\n\t\t\t\t\t// otherwise we skip this part\n\t\t\t\t\tlength = gotoEnd ? animation.tweens.length : 0;\n\t\t\t\tif ( stopped ) {\n\t\t\t\t\treturn this;\n\t\t\t\t}\n\t\t\t\tstopped = true;\n\t\t\t\tfor ( ; index < length; index++ ) {\n\t\t\t\t\tanimation.tweens[ index ].run( 1 );\n\t\t\t\t}\n\n\t\t\t\t// Resolve when we played the last frame; otherwise, reject\n\t\t\t\tif ( gotoEnd ) {\n\t\t\t\t\tdeferred.notifyWith( elem, [ animation, 1, 0 ] );\n\t\t\t\t\tdeferred.resolveWith( elem, [ animation, gotoEnd ] );\n\t\t\t\t} else {\n\t\t\t\t\tdeferred.rejectWith( elem, [ animation, gotoEnd ] );\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t}\n\t\t} ),\n\t\tprops = animation.props;\n\n\tpropFilter( props, animation.opts.specialEasing );\n\n\tfor ( ; index < length; index++ ) {\n\t\tresult = Animation.prefilters[ index ].call( animation, elem, props, animation.opts );\n\t\tif ( result ) {\n\t\t\tif ( isFunction( result.stop ) ) {\n\t\t\t\tjQuery._queueHooks( animation.elem, animation.opts.queue ).stop =\n\t\t\t\t\tresult.stop.bind( result );\n\t\t\t}\n\t\t\treturn result;\n\t\t}\n\t}\n\n\tjQuery.map( props, createTween, animation );\n\n\tif ( isFunction( animation.opts.start ) ) {\n\t\tanimation.opts.start.call( elem, animation );\n\t}\n\n\t// Attach callbacks from options\n\tanimation\n\t\t.progress( animation.opts.progress )\n\t\t.done( animation.opts.done, animation.opts.complete )\n\t\t.fail( animation.opts.fail )\n\t\t.always( animation.opts.always );\n\n\tjQuery.fx.timer(\n\t\tjQuery.extend( tick, {\n\t\t\telem: elem,\n\t\t\tanim: animation,\n\t\t\tqueue: animation.opts.queue\n\t\t} )\n\t);\n\n\treturn animation;\n}\n\njQuery.Animation = jQuery.extend( Animation, {\n\n\ttweeners: {\n\t\t\"*\": [ function( prop, value ) {\n\t\t\tvar tween = this.createTween( prop, value );\n\t\t\tadjustCSS( tween.elem, prop, rcssNum.exec( value ), tween );\n\t\t\treturn tween;\n\t\t} ]\n\t},\n\n\ttweener: function( props, callback ) {\n\t\tif ( isFunction( props ) ) {\n\t\t\tcallback = props;\n\t\t\tprops = [ \"*\" ];\n\t\t} else {\n\t\t\tprops = props.match( rnothtmlwhite );\n\t\t}\n\n\t\tvar prop,\n\t\t\tindex = 0,\n\t\t\tlength = props.length;\n\n\t\tfor ( ; index < length; index++ ) {\n\t\t\tprop = props[ index ];\n\t\t\tAnimation.tweeners[ prop ] = Animation.tweeners[ prop ] || [];\n\t\t\tAnimation.tweeners[ prop ].unshift( callback );\n\t\t}\n\t},\n\n\tprefilters: [ defaultPrefilter ],\n\n\tprefilter: function( callback, prepend ) {\n\t\tif ( prepend ) {\n\t\t\tAnimation.prefilters.unshift( callback );\n\t\t} else {\n\t\t\tAnimation.prefilters.push( callback );\n\t\t}\n\t}\n} );\n\njQuery.speed = function( speed, easing, fn ) {\n\tvar opt = speed && typeof speed === \"object\" ? jQuery.extend( {}, speed ) : {\n\t\tcomplete: fn || !fn && easing ||\n\t\t\tisFunction( speed ) && speed,\n\t\tduration: speed,\n\t\teasing: fn && easing || easing && !isFunction( easing ) && easing\n\t};\n\n\t// Go to the end state if fx are off\n\tif ( jQuery.fx.off ) {\n\t\topt.duration = 0;\n\n\t} else {\n\t\tif ( typeof opt.duration !== \"number\" ) {\n\t\t\tif ( opt.duration in jQuery.fx.speeds ) {\n\t\t\t\topt.duration = jQuery.fx.speeds[ opt.duration ];\n\n\t\t\t} else {\n\t\t\t\topt.duration = jQuery.fx.speeds._default;\n\t\t\t}\n\t\t}\n\t}\n\n\t// Normalize opt.queue - true/undefined/null -> \"fx\"\n\tif ( opt.queue == null || opt.queue === true ) {\n\t\topt.queue = \"fx\";\n\t}\n\n\t// Queueing\n\topt.old = opt.complete;\n\n\topt.complete = function() {\n\t\tif ( isFunction( opt.old ) ) {\n\t\t\topt.old.call( this );\n\t\t}\n\n\t\tif ( opt.queue ) {\n\t\t\tjQuery.dequeue( this, opt.queue );\n\t\t}\n\t};\n\n\treturn opt;\n};\n\njQuery.fn.extend( {\n\tfadeTo: function( speed, to, easing, callback ) {\n\n\t\t// Show any hidden elements after setting opacity to 0\n\t\treturn this.filter( isHiddenWithinTree ).css( \"opacity\", 0 ).show()\n\n\t\t\t// Animate to the value specified\n\t\t\t.end().animate( { opacity: to }, speed, easing, callback );\n\t},\n\tanimate: function( prop, speed, easing, callback ) {\n\t\tvar empty = jQuery.isEmptyObject( prop ),\n\t\t\toptall = jQuery.speed( speed, easing, callback ),\n\t\t\tdoAnimation = function() {\n\n\t\t\t\t// Operate on a copy of prop so per-property easing won't be lost\n\t\t\t\tvar anim = Animation( this, jQuery.extend( {}, prop ), optall );\n\n\t\t\t\t// Empty animations, or finishing resolves immediately\n\t\t\t\tif ( empty || dataPriv.get( this, \"finish\" ) ) {\n\t\t\t\t\tanim.stop( true );\n\t\t\t\t}\n\t\t\t};\n\t\t\tdoAnimation.finish = doAnimation;\n\n\t\treturn empty || optall.queue === false ?\n\t\t\tthis.each( doAnimation ) :\n\t\t\tthis.queue( optall.queue, doAnimation );\n\t},\n\tstop: function( type, clearQueue, gotoEnd ) {\n\t\tvar stopQueue = function( hooks ) {\n\t\t\tvar stop = hooks.stop;\n\t\t\tdelete hooks.stop;\n\t\t\tstop( gotoEnd );\n\t\t};\n\n\t\tif ( typeof type !== \"string\" ) {\n\t\t\tgotoEnd = clearQueue;\n\t\t\tclearQueue = type;\n\t\t\ttype = undefined;\n\t\t}\n\t\tif ( clearQueue && type !== false ) {\n\t\t\tthis.queue( type || \"fx\", [] );\n\t\t}\n\n\t\treturn this.each( function() {\n\t\t\tvar dequeue = true,\n\t\t\t\tindex = type != null && type + \"queueHooks\",\n\t\t\t\ttimers = jQuery.timers,\n\t\t\t\tdata = dataPriv.get( this );\n\n\t\t\tif ( index ) {\n\t\t\t\tif ( data[ index ] && data[ index ].stop ) {\n\t\t\t\t\tstopQueue( data[ index ] );\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tfor ( index in data ) {\n\t\t\t\t\tif ( data[ index ] && data[ index ].stop && rrun.test( index ) ) {\n\t\t\t\t\t\tstopQueue( data[ index ] );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tfor ( index = timers.length; index--; ) {\n\t\t\t\tif ( timers[ index ].elem === this &&\n\t\t\t\t\t( type == null || timers[ index ].queue === type ) ) {\n\n\t\t\t\t\ttimers[ index ].anim.stop( gotoEnd );\n\t\t\t\t\tdequeue = false;\n\t\t\t\t\ttimers.splice( index, 1 );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Start the next in the queue if the last step wasn't forced.\n\t\t\t// Timers currently will call their complete callbacks, which\n\t\t\t// will dequeue but only if they were gotoEnd.\n\t\t\tif ( dequeue || !gotoEnd ) {\n\t\t\t\tjQuery.dequeue( this, type );\n\t\t\t}\n\t\t} );\n\t},\n\tfinish: function( type ) {\n\t\tif ( type !== false ) {\n\t\t\ttype = type || \"fx\";\n\t\t}\n\t\treturn this.each( function() {\n\t\t\tvar index,\n\t\t\t\tdata = dataPriv.get( this ),\n\t\t\t\tqueue = data[ type + \"queue\" ],\n\t\t\t\thooks = data[ type + \"queueHooks\" ],\n\t\t\t\ttimers = jQuery.timers,\n\t\t\t\tlength = queue ? queue.length : 0;\n\n\t\t\t// Enable finishing flag on private data\n\t\t\tdata.finish = true;\n\n\t\t\t// Empty the queue first\n\t\t\tjQuery.queue( this, type, [] );\n\n\t\t\tif ( hooks && hooks.stop ) {\n\t\t\t\thooks.stop.call( this, true );\n\t\t\t}\n\n\t\t\t// Look for any active animations, and finish them\n\t\t\tfor ( index = timers.length; index--; ) {\n\t\t\t\tif ( timers[ index ].elem === this && timers[ index ].queue === type ) {\n\t\t\t\t\ttimers[ index ].anim.stop( true );\n\t\t\t\t\ttimers.splice( index, 1 );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Look for any animations in the old queue and finish them\n\t\t\tfor ( index = 0; index < length; index++ ) {\n\t\t\t\tif ( queue[ index ] && queue[ index ].finish ) {\n\t\t\t\t\tqueue[ index ].finish.call( this );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Turn off finishing flag\n\t\t\tdelete data.finish;\n\t\t} );\n\t}\n} );\n\njQuery.each( [ \"toggle\", \"show\", \"hide\" ], function( i, name ) {\n\tvar cssFn = jQuery.fn[ name ];\n\tjQuery.fn[ name ] = function( speed, easing, callback ) {\n\t\treturn speed == null || typeof speed === \"boolean\" ?\n\t\t\tcssFn.apply( this, arguments ) :\n\t\t\tthis.animate( genFx( name, true ), speed, easing, callback );\n\t};\n} );\n\n// Generate shortcuts for custom animations\njQuery.each( {\n\tslideDown: genFx( \"show\" ),\n\tslideUp: genFx( \"hide\" ),\n\tslideToggle: genFx( \"toggle\" ),\n\tfadeIn: { opacity: \"show\" },\n\tfadeOut: { opacity: \"hide\" },\n\tfadeToggle: { opacity: \"toggle\" }\n}, function( name, props ) {\n\tjQuery.fn[ name ] = function( speed, easing, callback ) {\n\t\treturn this.animate( props, speed, easing, callback );\n\t};\n} );\n\njQuery.timers = [];\njQuery.fx.tick = function() {\n\tvar timer,\n\t\ti = 0,\n\t\ttimers = jQuery.timers;\n\n\tfxNow = Date.now();\n\n\tfor ( ; i < timers.length; i++ ) {\n\t\ttimer = timers[ i ];\n\n\t\t// Run the timer and safely remove it when done (allowing for external removal)\n\t\tif ( !timer() && timers[ i ] === timer ) {\n\t\t\ttimers.splice( i--, 1 );\n\t\t}\n\t}\n\n\tif ( !timers.length ) {\n\t\tjQuery.fx.stop();\n\t}\n\tfxNow = undefined;\n};\n\njQuery.fx.timer = function( timer ) {\n\tjQuery.timers.push( timer );\n\tjQuery.fx.start();\n};\n\njQuery.fx.interval = 13;\njQuery.fx.start = function() {\n\tif ( inProgress ) {\n\t\treturn;\n\t}\n\n\tinProgress = true;\n\tschedule();\n};\n\njQuery.fx.stop = function() {\n\tinProgress = null;\n};\n\njQuery.fx.speeds = {\n\tslow: 600,\n\tfast: 200,\n\n\t// Default speed\n\t_default: 400\n};\n\n\n// Based off of the plugin by Clint Helfers, with permission.\n// https://web.archive.org/web/20100324014747/http://blindsignals.com/index.php/2009/07/jquery-delay/\njQuery.fn.delay = function( time, type ) {\n\ttime = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;\n\ttype = type || \"fx\";\n\n\treturn this.queue( type, function( next, hooks ) {\n\t\tvar timeout = window.setTimeout( next, time );\n\t\thooks.stop = function() {\n\t\t\twindow.clearTimeout( timeout );\n\t\t};\n\t} );\n};\n\n\n( function() {\n\tvar input = document.createElement( \"input\" ),\n\t\tselect = document.createElement( \"select\" ),\n\t\topt = select.appendChild( document.createElement( \"option\" ) );\n\n\tinput.type = \"checkbox\";\n\n\t// Support: Android <=4.3 only\n\t// Default value for a checkbox should be \"on\"\n\tsupport.checkOn = input.value !== \"\";\n\n\t// Support: IE <=11 only\n\t// Must access selectedIndex to make default options select\n\tsupport.optSelected = opt.selected;\n\n\t// Support: IE <=11 only\n\t// An input loses its value after becoming a radio\n\tinput = document.createElement( \"input\" );\n\tinput.value = \"t\";\n\tinput.type = \"radio\";\n\tsupport.radioValue = input.value === \"t\";\n} )();\n\n\nvar boolHook,\n\tattrHandle = jQuery.expr.attrHandle;\n\njQuery.fn.extend( {\n\tattr: function( name, value ) {\n\t\treturn access( this, jQuery.attr, name, value, arguments.length > 1 );\n\t},\n\n\tremoveAttr: function( name ) {\n\t\treturn this.each( function() {\n\t\t\tjQuery.removeAttr( this, name );\n\t\t} );\n\t}\n} );\n\njQuery.extend( {\n\tattr: function( elem, name, value ) {\n\t\tvar ret, hooks,\n\t\t\tnType = elem.nodeType;\n\n\t\t// Don't get/set attributes on text, comment and attribute nodes\n\t\tif ( nType === 3 || nType === 8 || nType === 2 ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Fallback to prop when attributes are not supported\n\t\tif ( typeof elem.getAttribute === \"undefined\" ) {\n\t\t\treturn jQuery.prop( elem, name, value );\n\t\t}\n\n\t\t// Attribute hooks are determined by the lowercase version\n\t\t// Grab necessary hook if one is defined\n\t\tif ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {\n\t\t\thooks = jQuery.attrHooks[ name.toLowerCase() ] ||\n\t\t\t\t( jQuery.expr.match.bool.test( name ) ? boolHook : undefined );\n\t\t}\n\n\t\tif ( value !== undefined ) {\n\t\t\tif ( value === null ) {\n\t\t\t\tjQuery.removeAttr( elem, name );\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tif ( hooks && \"set\" in hooks &&\n\t\t\t\t( ret = hooks.set( elem, value, name ) ) !== undefined ) {\n\t\t\t\treturn ret;\n\t\t\t}\n\n\t\t\telem.setAttribute( name, value + \"\" );\n\t\t\treturn value;\n\t\t}\n\n\t\tif ( hooks && \"get\" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {\n\t\t\treturn ret;\n\t\t}\n\n\t\tret = jQuery.find.attr( elem, name );\n\n\t\t// Non-existent attributes return null, we normalize to undefined\n\t\treturn ret == null ? undefined : ret;\n\t},\n\n\tattrHooks: {\n\t\ttype: {\n\t\t\tset: function( elem, value ) {\n\t\t\t\tif ( !support.radioValue && value === \"radio\" &&\n\t\t\t\t\tnodeName( elem, \"input\" ) ) {\n\t\t\t\t\tvar val = elem.value;\n\t\t\t\t\telem.setAttribute( \"type\", value );\n\t\t\t\t\tif ( val ) {\n\t\t\t\t\t\telem.value = val;\n\t\t\t\t\t}\n\t\t\t\t\treturn value;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t},\n\n\tremoveAttr: function( elem, value ) {\n\t\tvar name,\n\t\t\ti = 0,\n\n\t\t\t// Attribute names can contain non-HTML whitespace characters\n\t\t\t// https://html.spec.whatwg.org/multipage/syntax.html#attributes-2\n\t\t\tattrNames = value && value.match( rnothtmlwhite );\n\n\t\tif ( attrNames && elem.nodeType === 1 ) {\n\t\t\twhile ( ( name = attrNames[ i++ ] ) ) {\n\t\t\t\telem.removeAttribute( name );\n\t\t\t}\n\t\t}\n\t}\n} );\n\n// Hooks for boolean attributes\nboolHook = {\n\tset: function( elem, value, name ) {\n\t\tif ( value === false ) {\n\n\t\t\t// Remove boolean attributes when set to false\n\t\t\tjQuery.removeAttr( elem, name );\n\t\t} else {\n\t\t\telem.setAttribute( name, name );\n\t\t}\n\t\treturn name;\n\t}\n};\n\njQuery.each( jQuery.expr.match.bool.source.match( /\\w+/g ), function( i, name ) {\n\tvar getter = attrHandle[ name ] || jQuery.find.attr;\n\n\tattrHandle[ name ] = function( elem, name, isXML ) {\n\t\tvar ret, handle,\n\t\t\tlowercaseName = name.toLowerCase();\n\n\t\tif ( !isXML ) {\n\n\t\t\t// Avoid an infinite loop by temporarily removing this function from the getter\n\t\t\thandle = attrHandle[ lowercaseName ];\n\t\t\tattrHandle[ lowercaseName ] = ret;\n\t\t\tret = getter( elem, name, isXML ) != null ?\n\t\t\t\tlowercaseName :\n\t\t\t\tnull;\n\t\t\tattrHandle[ lowercaseName ] = handle;\n\t\t}\n\t\treturn ret;\n\t};\n} );\n\n\n\n\nvar rfocusable = /^(?:input|select|textarea|button)$/i,\n\trclickable = /^(?:a|area)$/i;\n\njQuery.fn.extend( {\n\tprop: function( name, value ) {\n\t\treturn access( this, jQuery.prop, name, value, arguments.length > 1 );\n\t},\n\n\tremoveProp: function( name ) {\n\t\treturn this.each( function() {\n\t\t\tdelete this[ jQuery.propFix[ name ] || name ];\n\t\t} );\n\t}\n} );\n\njQuery.extend( {\n\tprop: function( elem, name, value ) {\n\t\tvar ret, hooks,\n\t\t\tnType = elem.nodeType;\n\n\t\t// Don't get/set properties on text, comment and attribute nodes\n\t\tif ( nType === 3 || nType === 8 || nType === 2 ) {\n\t\t\treturn;\n\t\t}\n\n\t\tif ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {\n\n\t\t\t// Fix name and attach hooks\n\t\t\tname = jQuery.propFix[ name ] || name;\n\t\t\thooks = jQuery.propHooks[ name ];\n\t\t}\n\n\t\tif ( value !== undefined ) {\n\t\t\tif ( hooks && \"set\" in hooks &&\n\t\t\t\t( ret = hooks.set( elem, value, name ) ) !== undefined ) {\n\t\t\t\treturn ret;\n\t\t\t}\n\n\t\t\treturn ( elem[ name ] = value );\n\t\t}\n\n\t\tif ( hooks && \"get\" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {\n\t\t\treturn ret;\n\t\t}\n\n\t\treturn elem[ name ];\n\t},\n\n\tpropHooks: {\n\t\ttabIndex: {\n\t\t\tget: function( elem ) {\n\n\t\t\t\t// Support: IE <=9 - 11 only\n\t\t\t\t// elem.tabIndex doesn't always return the\n\t\t\t\t// correct value when it hasn't been explicitly set\n\t\t\t\t// https://web.archive.org/web/20141116233347/http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/\n\t\t\t\t// Use proper attribute retrieval(#12072)\n\t\t\t\tvar tabindex = jQuery.find.attr( elem, \"tabindex\" );\n\n\t\t\t\tif ( tabindex ) {\n\t\t\t\t\treturn parseInt( tabindex, 10 );\n\t\t\t\t}\n\n\t\t\t\tif (\n\t\t\t\t\trfocusable.test( elem.nodeName ) ||\n\t\t\t\t\trclickable.test( elem.nodeName ) &&\n\t\t\t\t\telem.href\n\t\t\t\t) {\n\t\t\t\t\treturn 0;\n\t\t\t\t}\n\n\t\t\t\treturn -1;\n\t\t\t}\n\t\t}\n\t},\n\n\tpropFix: {\n\t\t\"for\": \"htmlFor\",\n\t\t\"class\": \"className\"\n\t}\n} );\n\n// Support: IE <=11 only\n// Accessing the selectedIndex property\n// forces the browser to respect setting selected\n// on the option\n// The getter ensures a default option is selected\n// when in an optgroup\n// eslint rule \"no-unused-expressions\" is disabled for this code\n// since it considers such accessions noop\nif ( !support.optSelected ) {\n\tjQuery.propHooks.selected = {\n\t\tget: function( elem ) {\n\n\t\t\t/* eslint no-unused-expressions: \"off\" */\n\n\t\t\tvar parent = elem.parentNode;\n\t\t\tif ( parent && parent.parentNode ) {\n\t\t\t\tparent.parentNode.selectedIndex;\n\t\t\t}\n\t\t\treturn null;\n\t\t},\n\t\tset: function( elem ) {\n\n\t\t\t/* eslint no-unused-expressions: \"off\" */\n\n\t\t\tvar parent = elem.parentNode;\n\t\t\tif ( parent ) {\n\t\t\t\tparent.selectedIndex;\n\n\t\t\t\tif ( parent.parentNode ) {\n\t\t\t\t\tparent.parentNode.selectedIndex;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t};\n}\n\njQuery.each( [\n\t\"tabIndex\",\n\t\"readOnly\",\n\t\"maxLength\",\n\t\"cellSpacing\",\n\t\"cellPadding\",\n\t\"rowSpan\",\n\t\"colSpan\",\n\t\"useMap\",\n\t\"frameBorder\",\n\t\"contentEditable\"\n], function() {\n\tjQuery.propFix[ this.toLowerCase() ] = this;\n} );\n\n\n\n\n\t// Strip and collapse whitespace according to HTML spec\n\t// https://infra.spec.whatwg.org/#strip-and-collapse-ascii-whitespace\n\tfunction stripAndCollapse( value ) {\n\t\tvar tokens = value.match( rnothtmlwhite ) || [];\n\t\treturn tokens.join( \" \" );\n\t}\n\n\nfunction getClass( elem ) {\n\treturn elem.getAttribute && elem.getAttribute( \"class\" ) || \"\";\n}\n\nfunction classesToArray( value ) {\n\tif ( Array.isArray( value ) ) {\n\t\treturn value;\n\t}\n\tif ( typeof value === \"string\" ) {\n\t\treturn value.match( rnothtmlwhite ) || [];\n\t}\n\treturn [];\n}\n\njQuery.fn.extend( {\n\taddClass: function( value ) {\n\t\tvar classes, elem, cur, curValue, clazz, j, finalValue,\n\t\t\ti = 0;\n\n\t\tif ( isFunction( value ) ) {\n\t\t\treturn this.each( function( j ) {\n\t\t\t\tjQuery( this ).addClass( value.call( this, j, getClass( this ) ) );\n\t\t\t} );\n\t\t}\n\n\t\tclasses = classesToArray( value );\n\n\t\tif ( classes.length ) {\n\t\t\twhile ( ( elem = this[ i++ ] ) ) {\n\t\t\t\tcurValue = getClass( elem );\n\t\t\t\tcur = elem.nodeType === 1 && ( \" \" + stripAndCollapse( curValue ) + \" \" );\n\n\t\t\t\tif ( cur ) {\n\t\t\t\t\tj = 0;\n\t\t\t\t\twhile ( ( clazz = classes[ j++ ] ) ) {\n\t\t\t\t\t\tif ( cur.indexOf( \" \" + clazz + \" \" ) < 0 ) {\n\t\t\t\t\t\t\tcur += clazz + \" \";\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Only assign if different to avoid unneeded rendering.\n\t\t\t\t\tfinalValue = stripAndCollapse( cur );\n\t\t\t\t\tif ( curValue !== finalValue ) {\n\t\t\t\t\t\telem.setAttribute( \"class\", finalValue );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn this;\n\t},\n\n\tremoveClass: function( value ) {\n\t\tvar classes, elem, cur, curValue, clazz, j, finalValue,\n\t\t\ti = 0;\n\n\t\tif ( isFunction( value ) ) {\n\t\t\treturn this.each( function( j ) {\n\t\t\t\tjQuery( this ).removeClass( value.call( this, j, getClass( this ) ) );\n\t\t\t} );\n\t\t}\n\n\t\tif ( !arguments.length ) {\n\t\t\treturn this.attr( \"class\", \"\" );\n\t\t}\n\n\t\tclasses = classesToArray( value );\n\n\t\tif ( classes.length ) {\n\t\t\twhile ( ( elem = this[ i++ ] ) ) {\n\t\t\t\tcurValue = getClass( elem );\n\n\t\t\t\t// This expression is here for better compressibility (see addClass)\n\t\t\t\tcur = elem.nodeType === 1 && ( \" \" + stripAndCollapse( curValue ) + \" \" );\n\n\t\t\t\tif ( cur ) {\n\t\t\t\t\tj = 0;\n\t\t\t\t\twhile ( ( clazz = classes[ j++ ] ) ) {\n\n\t\t\t\t\t\t// Remove *all* instances\n\t\t\t\t\t\twhile ( cur.indexOf( \" \" + clazz + \" \" ) > -1 ) {\n\t\t\t\t\t\t\tcur = cur.replace( \" \" + clazz + \" \", \" \" );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Only assign if different to avoid unneeded rendering.\n\t\t\t\t\tfinalValue = stripAndCollapse( cur );\n\t\t\t\t\tif ( curValue !== finalValue ) {\n\t\t\t\t\t\telem.setAttribute( \"class\", finalValue );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn this;\n\t},\n\n\ttoggleClass: function( value, stateVal ) {\n\t\tvar type = typeof value,\n\t\t\tisValidValue = type === \"string\" || Array.isArray( value );\n\n\t\tif ( typeof stateVal === \"boolean\" && isValidValue ) {\n\t\t\treturn stateVal ? this.addClass( value ) : this.removeClass( value );\n\t\t}\n\n\t\tif ( isFunction( value ) ) {\n\t\t\treturn this.each( function( i ) {\n\t\t\t\tjQuery( this ).toggleClass(\n\t\t\t\t\tvalue.call( this, i, getClass( this ), stateVal ),\n\t\t\t\t\tstateVal\n\t\t\t\t);\n\t\t\t} );\n\t\t}\n\n\t\treturn this.each( function() {\n\t\t\tvar className, i, self, classNames;\n\n\t\t\tif ( isValidValue ) {\n\n\t\t\t\t// Toggle individual class names\n\t\t\t\ti = 0;\n\t\t\t\tself = jQuery( this );\n\t\t\t\tclassNames = classesToArray( value );\n\n\t\t\t\twhile ( ( className = classNames[ i++ ] ) ) {\n\n\t\t\t\t\t// Check each className given, space separated list\n\t\t\t\t\tif ( self.hasClass( className ) ) {\n\t\t\t\t\t\tself.removeClass( className );\n\t\t\t\t\t} else {\n\t\t\t\t\t\tself.addClass( className );\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t// Toggle whole class name\n\t\t\t} else if ( value === undefined || type === \"boolean\" ) {\n\t\t\t\tclassName = getClass( this );\n\t\t\t\tif ( className ) {\n\n\t\t\t\t\t// Store className if set\n\t\t\t\t\tdataPriv.set( this, \"__className__\", className );\n\t\t\t\t}\n\n\t\t\t\t// If the element has a class name or if we're passed `false`,\n\t\t\t\t// then remove the whole classname (if there was one, the above saved it).\n\t\t\t\t// Otherwise bring back whatever was previously saved (if anything),\n\t\t\t\t// falling back to the empty string if nothing was stored.\n\t\t\t\tif ( this.setAttribute ) {\n\t\t\t\t\tthis.setAttribute( \"class\",\n\t\t\t\t\t\tclassName || value === false ?\n\t\t\t\t\t\t\"\" :\n\t\t\t\t\t\tdataPriv.get( this, \"__className__\" ) || \"\"\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t}\n\t\t} );\n\t},\n\n\thasClass: function( selector ) {\n\t\tvar className, elem,\n\t\t\ti = 0;\n\n\t\tclassName = \" \" + selector + \" \";\n\t\twhile ( ( elem = this[ i++ ] ) ) {\n\t\t\tif ( elem.nodeType === 1 &&\n\t\t\t\t( \" \" + stripAndCollapse( getClass( elem ) ) + \" \" ).indexOf( className ) > -1 ) {\n\t\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\n\t\treturn false;\n\t}\n} );\n\n\n\n\nvar rreturn = /\\r/g;\n\njQuery.fn.extend( {\n\tval: function( value ) {\n\t\tvar hooks, ret, valueIsFunction,\n\t\t\telem = this[ 0 ];\n\n\t\tif ( !arguments.length ) {\n\t\t\tif ( elem ) {\n\t\t\t\thooks = jQuery.valHooks[ elem.type ] ||\n\t\t\t\t\tjQuery.valHooks[ elem.nodeName.toLowerCase() ];\n\n\t\t\t\tif ( hooks &&\n\t\t\t\t\t\"get\" in hooks &&\n\t\t\t\t\t( ret = hooks.get( elem, \"value\" ) ) !== undefined\n\t\t\t\t) {\n\t\t\t\t\treturn ret;\n\t\t\t\t}\n\n\t\t\t\tret = elem.value;\n\n\t\t\t\t// Handle most common string cases\n\t\t\t\tif ( typeof ret === \"string\" ) {\n\t\t\t\t\treturn ret.replace( rreturn, \"\" );\n\t\t\t\t}\n\n\t\t\t\t// Handle cases where value is null/undef or number\n\t\t\t\treturn ret == null ? \"\" : ret;\n\t\t\t}\n\n\t\t\treturn;\n\t\t}\n\n\t\tvalueIsFunction = isFunction( value );\n\n\t\treturn this.each( function( i ) {\n\t\t\tvar val;\n\n\t\t\tif ( this.nodeType !== 1 ) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tif ( valueIsFunction ) {\n\t\t\t\tval = value.call( this, i, jQuery( this ).val() );\n\t\t\t} else {\n\t\t\t\tval = value;\n\t\t\t}\n\n\t\t\t// Treat null/undefined as \"\"; convert numbers to string\n\t\t\tif ( val == null ) {\n\t\t\t\tval = \"\";\n\n\t\t\t} else if ( typeof val === \"number\" ) {\n\t\t\t\tval += \"\";\n\n\t\t\t} else if ( Array.isArray( val ) ) {\n\t\t\t\tval = jQuery.map( val, function( value ) {\n\t\t\t\t\treturn value == null ? \"\" : value + \"\";\n\t\t\t\t} );\n\t\t\t}\n\n\t\t\thooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];\n\n\t\t\t// If set returns undefined, fall back to normal setting\n\t\t\tif ( !hooks || !( \"set\" in hooks ) || hooks.set( this, val, \"value\" ) === undefined ) {\n\t\t\t\tthis.value = val;\n\t\t\t}\n\t\t} );\n\t}\n} );\n\njQuery.extend( {\n\tvalHooks: {\n\t\toption: {\n\t\t\tget: function( elem ) {\n\n\t\t\t\tvar val = jQuery.find.attr( elem, \"value\" );\n\t\t\t\treturn val != null ?\n\t\t\t\t\tval :\n\n\t\t\t\t\t// Support: IE <=10 - 11 only\n\t\t\t\t\t// option.text throws exceptions (#14686, #14858)\n\t\t\t\t\t// Strip and collapse whitespace\n\t\t\t\t\t// https://html.spec.whatwg.org/#strip-and-collapse-whitespace\n\t\t\t\t\tstripAndCollapse( jQuery.text( elem ) );\n\t\t\t}\n\t\t},\n\t\tselect: {\n\t\t\tget: function( elem ) {\n\t\t\t\tvar value, option, i,\n\t\t\t\t\toptions = elem.options,\n\t\t\t\t\tindex = elem.selectedIndex,\n\t\t\t\t\tone = elem.type === \"select-one\",\n\t\t\t\t\tvalues = one ? null : [],\n\t\t\t\t\tmax = one ? index + 1 : options.length;\n\n\t\t\t\tif ( index < 0 ) {\n\t\t\t\t\ti = max;\n\n\t\t\t\t} else {\n\t\t\t\t\ti = one ? index : 0;\n\t\t\t\t}\n\n\t\t\t\t// Loop through all the selected options\n\t\t\t\tfor ( ; i < max; i++ ) {\n\t\t\t\t\toption = options[ i ];\n\n\t\t\t\t\t// Support: IE <=9 only\n\t\t\t\t\t// IE8-9 doesn't update selected after form reset (#2551)\n\t\t\t\t\tif ( ( option.selected || i === index ) &&\n\n\t\t\t\t\t\t\t// Don't return options that are disabled or in a disabled optgroup\n\t\t\t\t\t\t\t!option.disabled &&\n\t\t\t\t\t\t\t( !option.parentNode.disabled ||\n\t\t\t\t\t\t\t\t!nodeName( option.parentNode, \"optgroup\" ) ) ) {\n\n\t\t\t\t\t\t// Get the specific value for the option\n\t\t\t\t\t\tvalue = jQuery( option ).val();\n\n\t\t\t\t\t\t// We don't need an array for one selects\n\t\t\t\t\t\tif ( one ) {\n\t\t\t\t\t\t\treturn value;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Multi-Selects return an array\n\t\t\t\t\t\tvalues.push( value );\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\treturn values;\n\t\t\t},\n\n\t\t\tset: function( elem, value ) {\n\t\t\t\tvar optionSet, option,\n\t\t\t\t\toptions = elem.options,\n\t\t\t\t\tvalues = jQuery.makeArray( value ),\n\t\t\t\t\ti = options.length;\n\n\t\t\t\twhile ( i-- ) {\n\t\t\t\t\toption = options[ i ];\n\n\t\t\t\t\t/* eslint-disable no-cond-assign */\n\n\t\t\t\t\tif ( option.selected =\n\t\t\t\t\t\tjQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -1\n\t\t\t\t\t) {\n\t\t\t\t\t\toptionSet = true;\n\t\t\t\t\t}\n\n\t\t\t\t\t/* eslint-enable no-cond-assign */\n\t\t\t\t}\n\n\t\t\t\t// Force browsers to behave consistently when non-matching value is set\n\t\t\t\tif ( !optionSet ) {\n\t\t\t\t\telem.selectedIndex = -1;\n\t\t\t\t}\n\t\t\t\treturn values;\n\t\t\t}\n\t\t}\n\t}\n} );\n\n// Radios and checkboxes getter/setter\njQuery.each( [ \"radio\", \"checkbox\" ], function() {\n\tjQuery.valHooks[ this ] = {\n\t\tset: function( elem, value ) {\n\t\t\tif ( Array.isArray( value ) ) {\n\t\t\t\treturn ( elem.checked = jQuery.inArray( jQuery( elem ).val(), value ) > -1 );\n\t\t\t}\n\t\t}\n\t};\n\tif ( !support.checkOn ) {\n\t\tjQuery.valHooks[ this ].get = function( elem ) {\n\t\t\treturn elem.getAttribute( \"value\" ) === null ? \"on\" : elem.value;\n\t\t};\n\t}\n} );\n\n\n\n\n// Return jQuery for attributes-only inclusion\n\n\nsupport.focusin = \"onfocusin\" in window;\n\n\nvar rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,\n\tstopPropagationCallback = function( e ) {\n\t\te.stopPropagation();\n\t};\n\njQuery.extend( jQuery.event, {\n\n\ttrigger: function( event, data, elem, onlyHandlers ) {\n\n\t\tvar i, cur, tmp, bubbleType, ontype, handle, special, lastElement,\n\t\t\teventPath = [ elem || document ],\n\t\t\ttype = hasOwn.call( event, \"type\" ) ? event.type : event,\n\t\t\tnamespaces = hasOwn.call( event, \"namespace\" ) ? event.namespace.split( \".\" ) : [];\n\n\t\tcur = lastElement = tmp = elem = elem || document;\n\n\t\t// Don't do events on text and comment nodes\n\t\tif ( elem.nodeType === 3 || elem.nodeType === 8 ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// focus/blur morphs to focusin/out; ensure we're not firing them right now\n\t\tif ( rfocusMorph.test( type + jQuery.event.triggered ) ) {\n\t\t\treturn;\n\t\t}\n\n\t\tif ( type.indexOf( \".\" ) > -1 ) {\n\n\t\t\t// Namespaced trigger; create a regexp to match event type in handle()\n\t\t\tnamespaces = type.split( \".\" );\n\t\t\ttype = namespaces.shift();\n\t\t\tnamespaces.sort();\n\t\t}\n\t\tontype = type.indexOf( \":\" ) < 0 && \"on\" + type;\n\n\t\t// Caller can pass in a jQuery.Event object, Object, or just an event type string\n\t\tevent = event[ jQuery.expando ] ?\n\t\t\tevent :\n\t\t\tnew jQuery.Event( type, typeof event === \"object\" && event );\n\n\t\t// Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)\n\t\tevent.isTrigger = onlyHandlers ? 2 : 3;\n\t\tevent.namespace = namespaces.join( \".\" );\n\t\tevent.rnamespace = event.namespace ?\n\t\t\tnew RegExp( \"(^|\\\\.)\" + namespaces.join( \"\\\\.(?:.*\\\\.|)\" ) + \"(\\\\.|$)\" ) :\n\t\t\tnull;\n\n\t\t// Clean up the event in case it is being reused\n\t\tevent.result = undefined;\n\t\tif ( !event.target ) {\n\t\t\tevent.target = elem;\n\t\t}\n\n\t\t// Clone any incoming data and prepend the event, creating the handler arg list\n\t\tdata = data == null ?\n\t\t\t[ event ] :\n\t\t\tjQuery.makeArray( data, [ event ] );\n\n\t\t// Allow special events to draw outside the lines\n\t\tspecial = jQuery.event.special[ type ] || {};\n\t\tif ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Determine event propagation path in advance, per W3C events spec (#9951)\n\t\t// Bubble up to document, then to window; watch for a global ownerDocument var (#9724)\n\t\tif ( !onlyHandlers && !special.noBubble && !isWindow( elem ) ) {\n\n\t\t\tbubbleType = special.delegateType || type;\n\t\t\tif ( !rfocusMorph.test( bubbleType + type ) ) {\n\t\t\t\tcur = cur.parentNode;\n\t\t\t}\n\t\t\tfor ( ; cur; cur = cur.parentNode ) {\n\t\t\t\teventPath.push( cur );\n\t\t\t\ttmp = cur;\n\t\t\t}\n\n\t\t\t// Only add window if we got to document (e.g., not plain obj or detached DOM)\n\t\t\tif ( tmp === ( elem.ownerDocument || document ) ) {\n\t\t\t\teventPath.push( tmp.defaultView || tmp.parentWindow || window );\n\t\t\t}\n\t\t}\n\n\t\t// Fire handlers on the event path\n\t\ti = 0;\n\t\twhile ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) {\n\t\t\tlastElement = cur;\n\t\t\tevent.type = i > 1 ?\n\t\t\t\tbubbleType :\n\t\t\t\tspecial.bindType || type;\n\n\t\t\t// jQuery handler\n\t\t\thandle = ( dataPriv.get( cur, \"events\" ) || {} )[ event.type ] &&\n\t\t\t\tdataPriv.get( cur, \"handle\" );\n\t\t\tif ( handle ) {\n\t\t\t\thandle.apply( cur, data );\n\t\t\t}\n\n\t\t\t// Native handler\n\t\t\thandle = ontype && cur[ ontype ];\n\t\t\tif ( handle && handle.apply && acceptData( cur ) ) {\n\t\t\t\tevent.result = handle.apply( cur, data );\n\t\t\t\tif ( event.result === false ) {\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tevent.type = type;\n\n\t\t// If nobody prevented the default action, do it now\n\t\tif ( !onlyHandlers && !event.isDefaultPrevented() ) {\n\n\t\t\tif ( ( !special._default ||\n\t\t\t\tspecial._default.apply( eventPath.pop(), data ) === false ) &&\n\t\t\t\tacceptData( elem ) ) {\n\n\t\t\t\t// Call a native DOM method on the target with the same name as the event.\n\t\t\t\t// Don't do default actions on window, that's where global variables be (#6170)\n\t\t\t\tif ( ontype && isFunction( elem[ type ] ) && !isWindow( elem ) ) {\n\n\t\t\t\t\t// Don't re-trigger an onFOO event when we call its FOO() method\n\t\t\t\t\ttmp = elem[ ontype ];\n\n\t\t\t\t\tif ( tmp ) {\n\t\t\t\t\t\telem[ ontype ] = null;\n\t\t\t\t\t}\n\n\t\t\t\t\t// Prevent re-triggering of the same event, since we already bubbled it above\n\t\t\t\t\tjQuery.event.triggered = type;\n\n\t\t\t\t\tif ( event.isPropagationStopped() ) {\n\t\t\t\t\t\tlastElement.addEventListener( type, stopPropagationCallback );\n\t\t\t\t\t}\n\n\t\t\t\t\telem[ type ]();\n\n\t\t\t\t\tif ( event.isPropagationStopped() ) {\n\t\t\t\t\t\tlastElement.removeEventListener( type, stopPropagationCallback );\n\t\t\t\t\t}\n\n\t\t\t\t\tjQuery.event.triggered = undefined;\n\n\t\t\t\t\tif ( tmp ) {\n\t\t\t\t\t\telem[ ontype ] = tmp;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn event.result;\n\t},\n\n\t// Piggyback on a donor event to simulate a different one\n\t// Used only for `focus(in | out)` events\n\tsimulate: function( type, elem, event ) {\n\t\tvar e = jQuery.extend(\n\t\t\tnew jQuery.Event(),\n\t\t\tevent,\n\t\t\t{\n\t\t\t\ttype: type,\n\t\t\t\tisSimulated: true\n\t\t\t}\n\t\t);\n\n\t\tjQuery.event.trigger( e, null, elem );\n\t}\n\n} );\n\njQuery.fn.extend( {\n\n\ttrigger: function( type, data ) {\n\t\treturn this.each( function() {\n\t\t\tjQuery.event.trigger( type, data, this );\n\t\t} );\n\t},\n\ttriggerHandler: function( type, data ) {\n\t\tvar elem = this[ 0 ];\n\t\tif ( elem ) {\n\t\t\treturn jQuery.event.trigger( type, data, elem, true );\n\t\t}\n\t}\n} );\n\n\n// Support: Firefox <=44\n// Firefox doesn't have focus(in | out) events\n// Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787\n//\n// Support: Chrome <=48 - 49, Safari <=9.0 - 9.1\n// focus(in | out) events fire after focus & blur events,\n// which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order\n// Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857\nif ( !support.focusin ) {\n\tjQuery.each( { focus: \"focusin\", blur: \"focusout\" }, function( orig, fix ) {\n\n\t\t// Attach a single capturing handler on the document while someone wants focusin/focusout\n\t\tvar handler = function( event ) {\n\t\t\tjQuery.event.simulate( fix, event.target, jQuery.event.fix( event ) );\n\t\t};\n\n\t\tjQuery.event.special[ fix ] = {\n\t\t\tsetup: function() {\n\t\t\t\tvar doc = this.ownerDocument || this,\n\t\t\t\t\tattaches = dataPriv.access( doc, fix );\n\n\t\t\t\tif ( !attaches ) {\n\t\t\t\t\tdoc.addEventListener( orig, handler, true );\n\t\t\t\t}\n\t\t\t\tdataPriv.access( doc, fix, ( attaches || 0 ) + 1 );\n\t\t\t},\n\t\t\tteardown: function() {\n\t\t\t\tvar doc = this.ownerDocument || this,\n\t\t\t\t\tattaches = dataPriv.access( doc, fix ) - 1;\n\n\t\t\t\tif ( !attaches ) {\n\t\t\t\t\tdoc.removeEventListener( orig, handler, true );\n\t\t\t\t\tdataPriv.remove( doc, fix );\n\n\t\t\t\t} else {\n\t\t\t\t\tdataPriv.access( doc, fix, attaches );\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\t} );\n}\nvar location = window.location;\n\nvar nonce = Date.now();\n\nvar rquery = ( /\\?/ );\n\n\n\n// Cross-browser xml parsing\njQuery.parseXML = function( data ) {\n\tvar xml;\n\tif ( !data || typeof data !== \"string\" ) {\n\t\treturn null;\n\t}\n\n\t// Support: IE 9 - 11 only\n\t// IE throws on parseFromString with invalid input.\n\ttry {\n\t\txml = ( new window.DOMParser() ).parseFromString( data, \"text/xml\" );\n\t} catch ( e ) {\n\t\txml = undefined;\n\t}\n\n\tif ( !xml || xml.getElementsByTagName( \"parsererror\" ).length ) {\n\t\tjQuery.error( \"Invalid XML: \" + data );\n\t}\n\treturn xml;\n};\n\n\nvar\n\trbracket = /\\[\\]$/,\n\trCRLF = /\\r?\\n/g,\n\trsubmitterTypes = /^(?:submit|button|image|reset|file)$/i,\n\trsubmittable = /^(?:input|select|textarea|keygen)/i;\n\nfunction buildParams( prefix, obj, traditional, add ) {\n\tvar name;\n\n\tif ( Array.isArray( obj ) ) {\n\n\t\t// Serialize array item.\n\t\tjQuery.each( obj, function( i, v ) {\n\t\t\tif ( traditional || rbracket.test( prefix ) ) {\n\n\t\t\t\t// Treat each array item as a scalar.\n\t\t\t\tadd( prefix, v );\n\n\t\t\t} else {\n\n\t\t\t\t// Item is non-scalar (array or object), encode its numeric index.\n\t\t\t\tbuildParams(\n\t\t\t\t\tprefix + \"[\" + ( typeof v === \"object\" && v != null ? i : \"\" ) + \"]\",\n\t\t\t\t\tv,\n\t\t\t\t\ttraditional,\n\t\t\t\t\tadd\n\t\t\t\t);\n\t\t\t}\n\t\t} );\n\n\t} else if ( !traditional && toType( obj ) === \"object\" ) {\n\n\t\t// Serialize object item.\n\t\tfor ( name in obj ) {\n\t\t\tbuildParams( prefix + \"[\" + name + \"]\", obj[ name ], traditional, add );\n\t\t}\n\n\t} else {\n\n\t\t// Serialize scalar item.\n\t\tadd( prefix, obj );\n\t}\n}\n\n// Serialize an array of form elements or a set of\n// key/values into a query string\njQuery.param = function( a, traditional ) {\n\tvar prefix,\n\t\ts = [],\n\t\tadd = function( key, valueOrFunction ) {\n\n\t\t\t// If value is a function, invoke it and use its return value\n\t\t\tvar value = isFunction( valueOrFunction ) ?\n\t\t\t\tvalueOrFunction() :\n\t\t\t\tvalueOrFunction;\n\n\t\t\ts[ s.length ] = encodeURIComponent( key ) + \"=\" +\n\t\t\t\tencodeURIComponent( value == null ? \"\" : value );\n\t\t};\n\n\t// If an array was passed in, assume that it is an array of form elements.\n\tif ( Array.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {\n\n\t\t// Serialize the form elements\n\t\tjQuery.each( a, function() {\n\t\t\tadd( this.name, this.value );\n\t\t} );\n\n\t} else {\n\n\t\t// If traditional, encode the \"old\" way (the way 1.3.2 or older\n\t\t// did it), otherwise encode params recursively.\n\t\tfor ( prefix in a ) {\n\t\t\tbuildParams( prefix, a[ prefix ], traditional, add );\n\t\t}\n\t}\n\n\t// Return the resulting serialization\n\treturn s.join( \"&\" );\n};\n\njQuery.fn.extend( {\n\tserialize: function() {\n\t\treturn jQuery.param( this.serializeArray() );\n\t},\n\tserializeArray: function() {\n\t\treturn this.map( function() {\n\n\t\t\t// Can add propHook for \"elements\" to filter or add form elements\n\t\t\tvar elements = jQuery.prop( this, \"elements\" );\n\t\t\treturn elements ? jQuery.makeArray( elements ) : this;\n\t\t} )\n\t\t.filter( function() {\n\t\t\tvar type = this.type;\n\n\t\t\t// Use .is( \":disabled\" ) so that fieldset[disabled] works\n\t\t\treturn this.name && !jQuery( this ).is( \":disabled\" ) &&\n\t\t\t\trsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) &&\n\t\t\t\t( this.checked || !rcheckableType.test( type ) );\n\t\t} )\n\t\t.map( function( i, elem ) {\n\t\t\tvar val = jQuery( this ).val();\n\n\t\t\tif ( val == null ) {\n\t\t\t\treturn null;\n\t\t\t}\n\n\t\t\tif ( Array.isArray( val ) ) {\n\t\t\t\treturn jQuery.map( val, function( val ) {\n\t\t\t\t\treturn { name: elem.name, value: val.replace( rCRLF, \"\\r\\n\" ) };\n\t\t\t\t} );\n\t\t\t}\n\n\t\t\treturn { name: elem.name, value: val.replace( rCRLF, \"\\r\\n\" ) };\n\t\t} ).get();\n\t}\n} );\n\n\nvar\n\tr20 = /%20/g,\n\trhash = /#.*$/,\n\trantiCache = /([?&])_=[^&]*/,\n\trheaders = /^(.*?):[ \\t]*([^\\r\\n]*)$/mg,\n\n\t// #7653, #8125, #8152: local protocol detection\n\trlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,\n\trnoContent = /^(?:GET|HEAD)$/,\n\trprotocol = /^\\/\\//,\n\n\t/* Prefilters\n\t * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)\n\t * 2) These are called:\n\t *    - BEFORE asking for a transport\n\t *    - AFTER param serialization (s.data is a string if s.processData is true)\n\t * 3) key is the dataType\n\t * 4) the catchall symbol \"*\" can be used\n\t * 5) execution will start with transport dataType and THEN continue down to \"*\" if needed\n\t */\n\tprefilters = {},\n\n\t/* Transports bindings\n\t * 1) key is the dataType\n\t * 2) the catchall symbol \"*\" can be used\n\t * 3) selection will start with transport dataType and THEN go to \"*\" if needed\n\t */\n\ttransports = {},\n\n\t// Avoid comment-prolog char sequence (#10098); must appease lint and evade compression\n\tallTypes = \"*/\".concat( \"*\" ),\n\n\t// Anchor tag for parsing the document origin\n\toriginAnchor = document.createElement( \"a\" );\n\toriginAnchor.href = location.href;\n\n// Base \"constructor\" for jQuery.ajaxPrefilter and jQuery.ajaxTransport\nfunction addToPrefiltersOrTransports( structure ) {\n\n\t// dataTypeExpression is optional and defaults to \"*\"\n\treturn function( dataTypeExpression, func ) {\n\n\t\tif ( typeof dataTypeExpression !== \"string\" ) {\n\t\t\tfunc = dataTypeExpression;\n\t\t\tdataTypeExpression = \"*\";\n\t\t}\n\n\t\tvar dataType,\n\t\t\ti = 0,\n\t\t\tdataTypes = dataTypeExpression.toLowerCase().match( rnothtmlwhite ) || [];\n\n\t\tif ( isFunction( func ) ) {\n\n\t\t\t// For each dataType in the dataTypeExpression\n\t\t\twhile ( ( dataType = dataTypes[ i++ ] ) ) {\n\n\t\t\t\t// Prepend if requested\n\t\t\t\tif ( dataType[ 0 ] === \"+\" ) {\n\t\t\t\t\tdataType = dataType.slice( 1 ) || \"*\";\n\t\t\t\t\t( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func );\n\n\t\t\t\t// Otherwise append\n\t\t\t\t} else {\n\t\t\t\t\t( structure[ dataType ] = structure[ dataType ] || [] ).push( func );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t};\n}\n\n// Base inspection function for prefilters and transports\nfunction inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) {\n\n\tvar inspected = {},\n\t\tseekingTransport = ( structure === transports );\n\n\tfunction inspect( dataType ) {\n\t\tvar selected;\n\t\tinspected[ dataType ] = true;\n\t\tjQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) {\n\t\t\tvar dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR );\n\t\t\tif ( typeof dataTypeOrTransport === \"string\" &&\n\t\t\t\t!seekingTransport && !inspected[ dataTypeOrTransport ] ) {\n\n\t\t\t\toptions.dataTypes.unshift( dataTypeOrTransport );\n\t\t\t\tinspect( dataTypeOrTransport );\n\t\t\t\treturn false;\n\t\t\t} else if ( seekingTransport ) {\n\t\t\t\treturn !( selected = dataTypeOrTransport );\n\t\t\t}\n\t\t} );\n\t\treturn selected;\n\t}\n\n\treturn inspect( options.dataTypes[ 0 ] ) || !inspected[ \"*\" ] && inspect( \"*\" );\n}\n\n// A special extend for ajax options\n// that takes \"flat\" options (not to be deep extended)\n// Fixes #9887\nfunction ajaxExtend( target, src ) {\n\tvar key, deep,\n\t\tflatOptions = jQuery.ajaxSettings.flatOptions || {};\n\n\tfor ( key in src ) {\n\t\tif ( src[ key ] !== undefined ) {\n\t\t\t( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ];\n\t\t}\n\t}\n\tif ( deep ) {\n\t\tjQuery.extend( true, target, deep );\n\t}\n\n\treturn target;\n}\n\n/* Handles responses to an ajax request:\n * - finds the right dataType (mediates between content-type and expected dataType)\n * - returns the corresponding response\n */\nfunction ajaxHandleResponses( s, jqXHR, responses ) {\n\n\tvar ct, type, finalDataType, firstDataType,\n\t\tcontents = s.contents,\n\t\tdataTypes = s.dataTypes;\n\n\t// Remove auto dataType and get content-type in the process\n\twhile ( dataTypes[ 0 ] === \"*\" ) {\n\t\tdataTypes.shift();\n\t\tif ( ct === undefined ) {\n\t\t\tct = s.mimeType || jqXHR.getResponseHeader( \"Content-Type\" );\n\t\t}\n\t}\n\n\t// Check if we're dealing with a known content-type\n\tif ( ct ) {\n\t\tfor ( type in contents ) {\n\t\t\tif ( contents[ type ] && contents[ type ].test( ct ) ) {\n\t\t\t\tdataTypes.unshift( type );\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t}\n\n\t// Check to see if we have a response for the expected dataType\n\tif ( dataTypes[ 0 ] in responses ) {\n\t\tfinalDataType = dataTypes[ 0 ];\n\t} else {\n\n\t\t// Try convertible dataTypes\n\t\tfor ( type in responses ) {\n\t\t\tif ( !dataTypes[ 0 ] || s.converters[ type + \" \" + dataTypes[ 0 ] ] ) {\n\t\t\t\tfinalDataType = type;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tif ( !firstDataType ) {\n\t\t\t\tfirstDataType = type;\n\t\t\t}\n\t\t}\n\n\t\t// Or just use first one\n\t\tfinalDataType = finalDataType || firstDataType;\n\t}\n\n\t// If we found a dataType\n\t// We add the dataType to the list if needed\n\t// and return the corresponding response\n\tif ( finalDataType ) {\n\t\tif ( finalDataType !== dataTypes[ 0 ] ) {\n\t\t\tdataTypes.unshift( finalDataType );\n\t\t}\n\t\treturn responses[ finalDataType ];\n\t}\n}\n\n/* Chain conversions given the request and the original response\n * Also sets the responseXXX fields on the jqXHR instance\n */\nfunction ajaxConvert( s, response, jqXHR, isSuccess ) {\n\tvar conv2, current, conv, tmp, prev,\n\t\tconverters = {},\n\n\t\t// Work with a copy of dataTypes in case we need to modify it for conversion\n\t\tdataTypes = s.dataTypes.slice();\n\n\t// Create converters map with lowercased keys\n\tif ( dataTypes[ 1 ] ) {\n\t\tfor ( conv in s.converters ) {\n\t\t\tconverters[ conv.toLowerCase() ] = s.converters[ conv ];\n\t\t}\n\t}\n\n\tcurrent = dataTypes.shift();\n\n\t// Convert to each sequential dataType\n\twhile ( current ) {\n\n\t\tif ( s.responseFields[ current ] ) {\n\t\t\tjqXHR[ s.responseFields[ current ] ] = response;\n\t\t}\n\n\t\t// Apply the dataFilter if provided\n\t\tif ( !prev && isSuccess && s.dataFilter ) {\n\t\t\tresponse = s.dataFilter( response, s.dataType );\n\t\t}\n\n\t\tprev = current;\n\t\tcurrent = dataTypes.shift();\n\n\t\tif ( current ) {\n\n\t\t\t// There's only work to do if current dataType is non-auto\n\t\t\tif ( current === \"*\" ) {\n\n\t\t\t\tcurrent = prev;\n\n\t\t\t// Convert response if prev dataType is non-auto and differs from current\n\t\t\t} else if ( prev !== \"*\" && prev !== current ) {\n\n\t\t\t\t// Seek a direct converter\n\t\t\t\tconv = converters[ prev + \" \" + current ] || converters[ \"* \" + current ];\n\n\t\t\t\t// If none found, seek a pair\n\t\t\t\tif ( !conv ) {\n\t\t\t\t\tfor ( conv2 in converters ) {\n\n\t\t\t\t\t\t// If conv2 outputs current\n\t\t\t\t\t\ttmp = conv2.split( \" \" );\n\t\t\t\t\t\tif ( tmp[ 1 ] === current ) {\n\n\t\t\t\t\t\t\t// If prev can be converted to accepted input\n\t\t\t\t\t\t\tconv = converters[ prev + \" \" + tmp[ 0 ] ] ||\n\t\t\t\t\t\t\t\tconverters[ \"* \" + tmp[ 0 ] ];\n\t\t\t\t\t\t\tif ( conv ) {\n\n\t\t\t\t\t\t\t\t// Condense equivalence converters\n\t\t\t\t\t\t\t\tif ( conv === true ) {\n\t\t\t\t\t\t\t\t\tconv = converters[ conv2 ];\n\n\t\t\t\t\t\t\t\t// Otherwise, insert the intermediate dataType\n\t\t\t\t\t\t\t\t} else if ( converters[ conv2 ] !== true ) {\n\t\t\t\t\t\t\t\t\tcurrent = tmp[ 0 ];\n\t\t\t\t\t\t\t\t\tdataTypes.unshift( tmp[ 1 ] );\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Apply converter (if not an equivalence)\n\t\t\t\tif ( conv !== true ) {\n\n\t\t\t\t\t// Unless errors are allowed to bubble, catch and return them\n\t\t\t\t\tif ( conv && s.throws ) {\n\t\t\t\t\t\tresponse = conv( response );\n\t\t\t\t\t} else {\n\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\tresponse = conv( response );\n\t\t\t\t\t\t} catch ( e ) {\n\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\tstate: \"parsererror\",\n\t\t\t\t\t\t\t\terror: conv ? e : \"No conversion from \" + prev + \" to \" + current\n\t\t\t\t\t\t\t};\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn { state: \"success\", data: response };\n}\n\njQuery.extend( {\n\n\t// Counter for holding the number of active queries\n\tactive: 0,\n\n\t// Last-Modified header cache for next request\n\tlastModified: {},\n\tetag: {},\n\n\tajaxSettings: {\n\t\turl: location.href,\n\t\ttype: \"GET\",\n\t\tisLocal: rlocalProtocol.test( location.protocol ),\n\t\tglobal: true,\n\t\tprocessData: true,\n\t\tasync: true,\n\t\tcontentType: \"application/x-www-form-urlencoded; charset=UTF-8\",\n\n\t\t/*\n\t\ttimeout: 0,\n\t\tdata: null,\n\t\tdataType: null,\n\t\tusername: null,\n\t\tpassword: null,\n\t\tcache: null,\n\t\tthrows: false,\n\t\ttraditional: false,\n\t\theaders: {},\n\t\t*/\n\n\t\taccepts: {\n\t\t\t\"*\": allTypes,\n\t\t\ttext: \"text/plain\",\n\t\t\thtml: \"text/html\",\n\t\t\txml: \"application/xml, text/xml\",\n\t\t\tjson: \"application/json, text/javascript\"\n\t\t},\n\n\t\tcontents: {\n\t\t\txml: /\\bxml\\b/,\n\t\t\thtml: /\\bhtml/,\n\t\t\tjson: /\\bjson\\b/\n\t\t},\n\n\t\tresponseFields: {\n\t\t\txml: \"responseXML\",\n\t\t\ttext: \"responseText\",\n\t\t\tjson: \"responseJSON\"\n\t\t},\n\n\t\t// Data converters\n\t\t// Keys separate source (or catchall \"*\") and destination types with a single space\n\t\tconverters: {\n\n\t\t\t// Convert anything to text\n\t\t\t\"* text\": String,\n\n\t\t\t// Text to html (true = no transformation)\n\t\t\t\"text html\": true,\n\n\t\t\t// Evaluate text as a json expression\n\t\t\t\"text json\": JSON.parse,\n\n\t\t\t// Parse text as xml\n\t\t\t\"text xml\": jQuery.parseXML\n\t\t},\n\n\t\t// For options that shouldn't be deep extended:\n\t\t// you can add your own custom options here if\n\t\t// and when you create one that shouldn't be\n\t\t// deep extended (see ajaxExtend)\n\t\tflatOptions: {\n\t\t\turl: true,\n\t\t\tcontext: true\n\t\t}\n\t},\n\n\t// Creates a full fledged settings object into target\n\t// with both ajaxSettings and settings fields.\n\t// If target is omitted, writes into ajaxSettings.\n\tajaxSetup: function( target, settings ) {\n\t\treturn settings ?\n\n\t\t\t// Building a settings object\n\t\t\tajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) :\n\n\t\t\t// Extending ajaxSettings\n\t\t\tajaxExtend( jQuery.ajaxSettings, target );\n\t},\n\n\tajaxPrefilter: addToPrefiltersOrTransports( prefilters ),\n\tajaxTransport: addToPrefiltersOrTransports( transports ),\n\n\t// Main method\n\tajax: function( url, options ) {\n\n\t\t// If url is an object, simulate pre-1.5 signature\n\t\tif ( typeof url === \"object\" ) {\n\t\t\toptions = url;\n\t\t\turl = undefined;\n\t\t}\n\n\t\t// Force options to be an object\n\t\toptions = options || {};\n\n\t\tvar transport,\n\n\t\t\t// URL without anti-cache param\n\t\t\tcacheURL,\n\n\t\t\t// Response headers\n\t\t\tresponseHeadersString,\n\t\t\tresponseHeaders,\n\n\t\t\t// timeout handle\n\t\t\ttimeoutTimer,\n\n\t\t\t// Url cleanup var\n\t\t\turlAnchor,\n\n\t\t\t// Request state (becomes false upon send and true upon completion)\n\t\t\tcompleted,\n\n\t\t\t// To know if global events are to be dispatched\n\t\t\tfireGlobals,\n\n\t\t\t// Loop variable\n\t\t\ti,\n\n\t\t\t// uncached part of the url\n\t\t\tuncached,\n\n\t\t\t// Create the final options object\n\t\t\ts = jQuery.ajaxSetup( {}, options ),\n\n\t\t\t// Callbacks context\n\t\t\tcallbackContext = s.context || s,\n\n\t\t\t// Context for global events is callbackContext if it is a DOM node or jQuery collection\n\t\t\tglobalEventContext = s.context &&\n\t\t\t\t( callbackContext.nodeType || callbackContext.jquery ) ?\n\t\t\t\t\tjQuery( callbackContext ) :\n\t\t\t\t\tjQuery.event,\n\n\t\t\t// Deferreds\n\t\t\tdeferred = jQuery.Deferred(),\n\t\t\tcompleteDeferred = jQuery.Callbacks( \"once memory\" ),\n\n\t\t\t// Status-dependent callbacks\n\t\t\tstatusCode = s.statusCode || {},\n\n\t\t\t// Headers (they are sent all at once)\n\t\t\trequestHeaders = {},\n\t\t\trequestHeadersNames = {},\n\n\t\t\t// Default abort message\n\t\t\tstrAbort = \"canceled\",\n\n\t\t\t// Fake xhr\n\t\t\tjqXHR = {\n\t\t\t\treadyState: 0,\n\n\t\t\t\t// Builds headers hashtable if needed\n\t\t\t\tgetResponseHeader: function( key ) {\n\t\t\t\t\tvar match;\n\t\t\t\t\tif ( completed ) {\n\t\t\t\t\t\tif ( !responseHeaders ) {\n\t\t\t\t\t\t\tresponseHeaders = {};\n\t\t\t\t\t\t\twhile ( ( match = rheaders.exec( responseHeadersString ) ) ) {\n\t\t\t\t\t\t\t\tresponseHeaders[ match[ 1 ].toLowerCase() ] = match[ 2 ];\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\tmatch = responseHeaders[ key.toLowerCase() ];\n\t\t\t\t\t}\n\t\t\t\t\treturn match == null ? null : match;\n\t\t\t\t},\n\n\t\t\t\t// Raw string\n\t\t\t\tgetAllResponseHeaders: function() {\n\t\t\t\t\treturn completed ? responseHeadersString : null;\n\t\t\t\t},\n\n\t\t\t\t// Caches the header\n\t\t\t\tsetRequestHeader: function( name, value ) {\n\t\t\t\t\tif ( completed == null ) {\n\t\t\t\t\t\tname = requestHeadersNames[ name.toLowerCase() ] =\n\t\t\t\t\t\t\trequestHeadersNames[ name.toLowerCase() ] || name;\n\t\t\t\t\t\trequestHeaders[ name ] = value;\n\t\t\t\t\t}\n\t\t\t\t\treturn this;\n\t\t\t\t},\n\n\t\t\t\t// Overrides response content-type header\n\t\t\t\toverrideMimeType: function( type ) {\n\t\t\t\t\tif ( completed == null ) {\n\t\t\t\t\t\ts.mimeType = type;\n\t\t\t\t\t}\n\t\t\t\t\treturn this;\n\t\t\t\t},\n\n\t\t\t\t// Status-dependent callbacks\n\t\t\t\tstatusCode: function( map ) {\n\t\t\t\t\tvar code;\n\t\t\t\t\tif ( map ) {\n\t\t\t\t\t\tif ( completed ) {\n\n\t\t\t\t\t\t\t// Execute the appropriate callbacks\n\t\t\t\t\t\t\tjqXHR.always( map[ jqXHR.status ] );\n\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t// Lazy-add the new callbacks in a way that preserves old ones\n\t\t\t\t\t\t\tfor ( code in map ) {\n\t\t\t\t\t\t\t\tstatusCode[ code ] = [ statusCode[ code ], map[ code ] ];\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\treturn this;\n\t\t\t\t},\n\n\t\t\t\t// Cancel the request\n\t\t\t\tabort: function( statusText ) {\n\t\t\t\t\tvar finalText = statusText || strAbort;\n\t\t\t\t\tif ( transport ) {\n\t\t\t\t\t\ttransport.abort( finalText );\n\t\t\t\t\t}\n\t\t\t\t\tdone( 0, finalText );\n\t\t\t\t\treturn this;\n\t\t\t\t}\n\t\t\t};\n\n\t\t// Attach deferreds\n\t\tdeferred.promise( jqXHR );\n\n\t\t// Add protocol if not provided (prefilters might expect it)\n\t\t// Handle falsy url in the settings object (#10093: consistency with old signature)\n\t\t// We also use the url parameter if available\n\t\ts.url = ( ( url || s.url || location.href ) + \"\" )\n\t\t\t.replace( rprotocol, location.protocol + \"//\" );\n\n\t\t// Alias method option to type as per ticket #12004\n\t\ts.type = options.method || options.type || s.method || s.type;\n\n\t\t// Extract dataTypes list\n\t\ts.dataTypes = ( s.dataType || \"*\" ).toLowerCase().match( rnothtmlwhite ) || [ \"\" ];\n\n\t\t// A cross-domain request is in order when the origin doesn't match the current origin.\n\t\tif ( s.crossDomain == null ) {\n\t\t\turlAnchor = document.createElement( \"a\" );\n\n\t\t\t// Support: IE <=8 - 11, Edge 12 - 15\n\t\t\t// IE throws exception on accessing the href property if url is malformed,\n\t\t\t// e.g. http://example.com:80x/\n\t\t\ttry {\n\t\t\t\turlAnchor.href = s.url;\n\n\t\t\t\t// Support: IE <=8 - 11 only\n\t\t\t\t// Anchor's host property isn't correctly set when s.url is relative\n\t\t\t\turlAnchor.href = urlAnchor.href;\n\t\t\t\ts.crossDomain = originAnchor.protocol + \"//\" + originAnchor.host !==\n\t\t\t\t\turlAnchor.protocol + \"//\" + urlAnchor.host;\n\t\t\t} catch ( e ) {\n\n\t\t\t\t// If there is an error parsing the URL, assume it is crossDomain,\n\t\t\t\t// it can be rejected by the transport if it is invalid\n\t\t\t\ts.crossDomain = true;\n\t\t\t}\n\t\t}\n\n\t\t// Convert data if not already a string\n\t\tif ( s.data && s.processData && typeof s.data !== \"string\" ) {\n\t\t\ts.data = jQuery.param( s.data, s.traditional );\n\t\t}\n\n\t\t// Apply prefilters\n\t\tinspectPrefiltersOrTransports( prefilters, s, options, jqXHR );\n\n\t\t// If request was aborted inside a prefilter, stop there\n\t\tif ( completed ) {\n\t\t\treturn jqXHR;\n\t\t}\n\n\t\t// We can fire global events as of now if asked to\n\t\t// Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118)\n\t\tfireGlobals = jQuery.event && s.global;\n\n\t\t// Watch for a new set of requests\n\t\tif ( fireGlobals && jQuery.active++ === 0 ) {\n\t\t\tjQuery.event.trigger( \"ajaxStart\" );\n\t\t}\n\n\t\t// Uppercase the type\n\t\ts.type = s.type.toUpperCase();\n\n\t\t// Determine if request has content\n\t\ts.hasContent = !rnoContent.test( s.type );\n\n\t\t// Save the URL in case we're toying with the If-Modified-Since\n\t\t// and/or If-None-Match header later on\n\t\t// Remove hash to simplify url manipulation\n\t\tcacheURL = s.url.replace( rhash, \"\" );\n\n\t\t// More options handling for requests with no content\n\t\tif ( !s.hasContent ) {\n\n\t\t\t// Remember the hash so we can put it back\n\t\t\tuncached = s.url.slice( cacheURL.length );\n\n\t\t\t// If data is available and should be processed, append data to url\n\t\t\tif ( s.data && ( s.processData || typeof s.data === \"string\" ) ) {\n\t\t\t\tcacheURL += ( rquery.test( cacheURL ) ? \"&\" : \"?\" ) + s.data;\n\n\t\t\t\t// #9682: remove data so that it's not used in an eventual retry\n\t\t\t\tdelete s.data;\n\t\t\t}\n\n\t\t\t// Add or update anti-cache param if needed\n\t\t\tif ( s.cache === false ) {\n\t\t\t\tcacheURL = cacheURL.replace( rantiCache, \"$1\" );\n\t\t\t\tuncached = ( rquery.test( cacheURL ) ? \"&\" : \"?\" ) + \"_=\" + ( nonce++ ) + uncached;\n\t\t\t}\n\n\t\t\t// Put hash and anti-cache on the URL that will be requested (gh-1732)\n\t\t\ts.url = cacheURL + uncached;\n\n\t\t// Change '%20' to '+' if this is encoded form body content (gh-2658)\n\t\t} else if ( s.data && s.processData &&\n\t\t\t( s.contentType || \"\" ).indexOf( \"application/x-www-form-urlencoded\" ) === 0 ) {\n\t\t\ts.data = s.data.replace( r20, \"+\" );\n\t\t}\n\n\t\t// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.\n\t\tif ( s.ifModified ) {\n\t\t\tif ( jQuery.lastModified[ cacheURL ] ) {\n\t\t\t\tjqXHR.setRequestHeader( \"If-Modified-Since\", jQuery.lastModified[ cacheURL ] );\n\t\t\t}\n\t\t\tif ( jQuery.etag[ cacheURL ] ) {\n\t\t\t\tjqXHR.setRequestHeader( \"If-None-Match\", jQuery.etag[ cacheURL ] );\n\t\t\t}\n\t\t}\n\n\t\t// Set the correct header, if data is being sent\n\t\tif ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {\n\t\t\tjqXHR.setRequestHeader( \"Content-Type\", s.contentType );\n\t\t}\n\n\t\t// Set the Accepts header for the server, depending on the dataType\n\t\tjqXHR.setRequestHeader(\n\t\t\t\"Accept\",\n\t\t\ts.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ?\n\t\t\t\ts.accepts[ s.dataTypes[ 0 ] ] +\n\t\t\t\t\t( s.dataTypes[ 0 ] !== \"*\" ? \", \" + allTypes + \"; q=0.01\" : \"\" ) :\n\t\t\t\ts.accepts[ \"*\" ]\n\t\t);\n\n\t\t// Check for headers option\n\t\tfor ( i in s.headers ) {\n\t\t\tjqXHR.setRequestHeader( i, s.headers[ i ] );\n\t\t}\n\n\t\t// Allow custom headers/mimetypes and early abort\n\t\tif ( s.beforeSend &&\n\t\t\t( s.beforeSend.call( callbackContext, jqXHR, s ) === false || completed ) ) {\n\n\t\t\t// Abort if not done already and return\n\t\t\treturn jqXHR.abort();\n\t\t}\n\n\t\t// Aborting is no longer a cancellation\n\t\tstrAbort = \"abort\";\n\n\t\t// Install callbacks on deferreds\n\t\tcompleteDeferred.add( s.complete );\n\t\tjqXHR.done( s.success );\n\t\tjqXHR.fail( s.error );\n\n\t\t// Get transport\n\t\ttransport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );\n\n\t\t// If no transport, we auto-abort\n\t\tif ( !transport ) {\n\t\t\tdone( -1, \"No Transport\" );\n\t\t} else {\n\t\t\tjqXHR.readyState = 1;\n\n\t\t\t// Send global event\n\t\t\tif ( fireGlobals ) {\n\t\t\t\tglobalEventContext.trigger( \"ajaxSend\", [ jqXHR, s ] );\n\t\t\t}\n\n\t\t\t// If request was aborted inside ajaxSend, stop there\n\t\t\tif ( completed ) {\n\t\t\t\treturn jqXHR;\n\t\t\t}\n\n\t\t\t// Timeout\n\t\t\tif ( s.async && s.timeout > 0 ) {\n\t\t\t\ttimeoutTimer = window.setTimeout( function() {\n\t\t\t\t\tjqXHR.abort( \"timeout\" );\n\t\t\t\t}, s.timeout );\n\t\t\t}\n\n\t\t\ttry {\n\t\t\t\tcompleted = false;\n\t\t\t\ttransport.send( requestHeaders, done );\n\t\t\t} catch ( e ) {\n\n\t\t\t\t// Rethrow post-completion exceptions\n\t\t\t\tif ( completed ) {\n\t\t\t\t\tthrow e;\n\t\t\t\t}\n\n\t\t\t\t// Propagate others as results\n\t\t\t\tdone( -1, e );\n\t\t\t}\n\t\t}\n\n\t\t// Callback for when everything is done\n\t\tfunction done( status, nativeStatusText, responses, headers ) {\n\t\t\tvar isSuccess, success, error, response, modified,\n\t\t\t\tstatusText = nativeStatusText;\n\n\t\t\t// Ignore repeat invocations\n\t\t\tif ( completed ) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tcompleted = true;\n\n\t\t\t// Clear timeout if it exists\n\t\t\tif ( timeoutTimer ) {\n\t\t\t\twindow.clearTimeout( timeoutTimer );\n\t\t\t}\n\n\t\t\t// Dereference transport for early garbage collection\n\t\t\t// (no matter how long the jqXHR object will be used)\n\t\t\ttransport = undefined;\n\n\t\t\t// Cache response headers\n\t\t\tresponseHeadersString = headers || \"\";\n\n\t\t\t// Set readyState\n\t\t\tjqXHR.readyState = status > 0 ? 4 : 0;\n\n\t\t\t// Determine if successful\n\t\t\tisSuccess = status >= 200 && status < 300 || status === 304;\n\n\t\t\t// Get response data\n\t\t\tif ( responses ) {\n\t\t\t\tresponse = ajaxHandleResponses( s, jqXHR, responses );\n\t\t\t}\n\n\t\t\t// Convert no matter what (that way responseXXX fields are always set)\n\t\t\tresponse = ajaxConvert( s, response, jqXHR, isSuccess );\n\n\t\t\t// If successful, handle type chaining\n\t\t\tif ( isSuccess ) {\n\n\t\t\t\t// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.\n\t\t\t\tif ( s.ifModified ) {\n\t\t\t\t\tmodified = jqXHR.getResponseHeader( \"Last-Modified\" );\n\t\t\t\t\tif ( modified ) {\n\t\t\t\t\t\tjQuery.lastModified[ cacheURL ] = modified;\n\t\t\t\t\t}\n\t\t\t\t\tmodified = jqXHR.getResponseHeader( \"etag\" );\n\t\t\t\t\tif ( modified ) {\n\t\t\t\t\t\tjQuery.etag[ cacheURL ] = modified;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// if no content\n\t\t\t\tif ( status === 204 || s.type === \"HEAD\" ) {\n\t\t\t\t\tstatusText = \"nocontent\";\n\n\t\t\t\t// if not modified\n\t\t\t\t} else if ( status === 304 ) {\n\t\t\t\t\tstatusText = \"notmodified\";\n\n\t\t\t\t// If we have data, let's convert it\n\t\t\t\t} else {\n\t\t\t\t\tstatusText = response.state;\n\t\t\t\t\tsuccess = response.data;\n\t\t\t\t\terror = response.error;\n\t\t\t\t\tisSuccess = !error;\n\t\t\t\t}\n\t\t\t} else {\n\n\t\t\t\t// Extract error from statusText and normalize for non-aborts\n\t\t\t\terror = statusText;\n\t\t\t\tif ( status || !statusText ) {\n\t\t\t\t\tstatusText = \"error\";\n\t\t\t\t\tif ( status < 0 ) {\n\t\t\t\t\t\tstatus = 0;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Set data for the fake xhr object\n\t\t\tjqXHR.status = status;\n\t\t\tjqXHR.statusText = ( nativeStatusText || statusText ) + \"\";\n\n\t\t\t// Success/Error\n\t\t\tif ( isSuccess ) {\n\t\t\t\tdeferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );\n\t\t\t} else {\n\t\t\t\tdeferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );\n\t\t\t}\n\n\t\t\t// Status-dependent callbacks\n\t\t\tjqXHR.statusCode( statusCode );\n\t\t\tstatusCode = undefined;\n\n\t\t\tif ( fireGlobals ) {\n\t\t\t\tglobalEventContext.trigger( isSuccess ? \"ajaxSuccess\" : \"ajaxError\",\n\t\t\t\t\t[ jqXHR, s, isSuccess ? success : error ] );\n\t\t\t}\n\n\t\t\t// Complete\n\t\t\tcompleteDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );\n\n\t\t\tif ( fireGlobals ) {\n\t\t\t\tglobalEventContext.trigger( \"ajaxComplete\", [ jqXHR, s ] );\n\n\t\t\t\t// Handle the global AJAX counter\n\t\t\t\tif ( !( --jQuery.active ) ) {\n\t\t\t\t\tjQuery.event.trigger( \"ajaxStop\" );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn jqXHR;\n\t},\n\n\tgetJSON: function( url, data, callback ) {\n\t\treturn jQuery.get( url, data, callback, \"json\" );\n\t},\n\n\tgetScript: function( url, callback ) {\n\t\treturn jQuery.get( url, undefined, callback, \"script\" );\n\t}\n} );\n\njQuery.each( [ \"get\", \"post\" ], function( i, method ) {\n\tjQuery[ method ] = function( url, data, callback, type ) {\n\n\t\t// Shift arguments if data argument was omitted\n\t\tif ( isFunction( data ) ) {\n\t\t\ttype = type || callback;\n\t\t\tcallback = data;\n\t\t\tdata = undefined;\n\t\t}\n\n\t\t// The url can be an options object (which then must have .url)\n\t\treturn jQuery.ajax( jQuery.extend( {\n\t\t\turl: url,\n\t\t\ttype: method,\n\t\t\tdataType: type,\n\t\t\tdata: data,\n\t\t\tsuccess: callback\n\t\t}, jQuery.isPlainObject( url ) && url ) );\n\t};\n} );\n\n\njQuery._evalUrl = function( url ) {\n\treturn jQuery.ajax( {\n\t\turl: url,\n\n\t\t// Make this explicit, since user can override this through ajaxSetup (#11264)\n\t\ttype: \"GET\",\n\t\tdataType: \"script\",\n\t\tcache: true,\n\t\tasync: false,\n\t\tglobal: false,\n\t\t\"throws\": true\n\t} );\n};\n\n\njQuery.fn.extend( {\n\twrapAll: function( html ) {\n\t\tvar wrap;\n\n\t\tif ( this[ 0 ] ) {\n\t\t\tif ( isFunction( html ) ) {\n\t\t\t\thtml = html.call( this[ 0 ] );\n\t\t\t}\n\n\t\t\t// The elements to wrap the target around\n\t\t\twrap = jQuery( html, this[ 0 ].ownerDocument ).eq( 0 ).clone( true );\n\n\t\t\tif ( this[ 0 ].parentNode ) {\n\t\t\t\twrap.insertBefore( this[ 0 ] );\n\t\t\t}\n\n\t\t\twrap.map( function() {\n\t\t\t\tvar elem = this;\n\n\t\t\t\twhile ( elem.firstElementChild ) {\n\t\t\t\t\telem = elem.firstElementChild;\n\t\t\t\t}\n\n\t\t\t\treturn elem;\n\t\t\t} ).append( this );\n\t\t}\n\n\t\treturn this;\n\t},\n\n\twrapInner: function( html ) {\n\t\tif ( isFunction( html ) ) {\n\t\t\treturn this.each( function( i ) {\n\t\t\t\tjQuery( this ).wrapInner( html.call( this, i ) );\n\t\t\t} );\n\t\t}\n\n\t\treturn this.each( function() {\n\t\t\tvar self = jQuery( this ),\n\t\t\t\tcontents = self.contents();\n\n\t\t\tif ( contents.length ) {\n\t\t\t\tcontents.wrapAll( html );\n\n\t\t\t} else {\n\t\t\t\tself.append( html );\n\t\t\t}\n\t\t} );\n\t},\n\n\twrap: function( html ) {\n\t\tvar htmlIsFunction = isFunction( html );\n\n\t\treturn this.each( function( i ) {\n\t\t\tjQuery( this ).wrapAll( htmlIsFunction ? html.call( this, i ) : html );\n\t\t} );\n\t},\n\n\tunwrap: function( selector ) {\n\t\tthis.parent( selector ).not( \"body\" ).each( function() {\n\t\t\tjQuery( this ).replaceWith( this.childNodes );\n\t\t} );\n\t\treturn this;\n\t}\n} );\n\n\njQuery.expr.pseudos.hidden = function( elem ) {\n\treturn !jQuery.expr.pseudos.visible( elem );\n};\njQuery.expr.pseudos.visible = function( elem ) {\n\treturn !!( elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length );\n};\n\n\n\n\njQuery.ajaxSettings.xhr = function() {\n\ttry {\n\t\treturn new window.XMLHttpRequest();\n\t} catch ( e ) {}\n};\n\nvar xhrSuccessStatus = {\n\n\t\t// File protocol always yields status code 0, assume 200\n\t\t0: 200,\n\n\t\t// Support: IE <=9 only\n\t\t// #1450: sometimes IE returns 1223 when it should be 204\n\t\t1223: 204\n\t},\n\txhrSupported = jQuery.ajaxSettings.xhr();\n\nsupport.cors = !!xhrSupported && ( \"withCredentials\" in xhrSupported );\nsupport.ajax = xhrSupported = !!xhrSupported;\n\njQuery.ajaxTransport( function( options ) {\n\tvar callback, errorCallback;\n\n\t// Cross domain only allowed if supported through XMLHttpRequest\n\tif ( support.cors || xhrSupported && !options.crossDomain ) {\n\t\treturn {\n\t\t\tsend: function( headers, complete ) {\n\t\t\t\tvar i,\n\t\t\t\t\txhr = options.xhr();\n\n\t\t\t\txhr.open(\n\t\t\t\t\toptions.type,\n\t\t\t\t\toptions.url,\n\t\t\t\t\toptions.async,\n\t\t\t\t\toptions.username,\n\t\t\t\t\toptions.password\n\t\t\t\t);\n\n\t\t\t\t// Apply custom fields if provided\n\t\t\t\tif ( options.xhrFields ) {\n\t\t\t\t\tfor ( i in options.xhrFields ) {\n\t\t\t\t\t\txhr[ i ] = options.xhrFields[ i ];\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Override mime type if needed\n\t\t\t\tif ( options.mimeType && xhr.overrideMimeType ) {\n\t\t\t\t\txhr.overrideMimeType( options.mimeType );\n\t\t\t\t}\n\n\t\t\t\t// X-Requested-With header\n\t\t\t\t// For cross-domain requests, seeing as conditions for a preflight are\n\t\t\t\t// akin to a jigsaw puzzle, we simply never set it to be sure.\n\t\t\t\t// (it can always be set on a per-request basis or even using ajaxSetup)\n\t\t\t\t// For same-domain requests, won't change header if already provided.\n\t\t\t\tif ( !options.crossDomain && !headers[ \"X-Requested-With\" ] ) {\n\t\t\t\t\theaders[ \"X-Requested-With\" ] = \"XMLHttpRequest\";\n\t\t\t\t}\n\n\t\t\t\t// Set headers\n\t\t\t\tfor ( i in headers ) {\n\t\t\t\t\txhr.setRequestHeader( i, headers[ i ] );\n\t\t\t\t}\n\n\t\t\t\t// Callback\n\t\t\t\tcallback = function( type ) {\n\t\t\t\t\treturn function() {\n\t\t\t\t\t\tif ( callback ) {\n\t\t\t\t\t\t\tcallback = errorCallback = xhr.onload =\n\t\t\t\t\t\t\t\txhr.onerror = xhr.onabort = xhr.ontimeout =\n\t\t\t\t\t\t\t\t\txhr.onreadystatechange = null;\n\n\t\t\t\t\t\t\tif ( type === \"abort\" ) {\n\t\t\t\t\t\t\t\txhr.abort();\n\t\t\t\t\t\t\t} else if ( type === \"error\" ) {\n\n\t\t\t\t\t\t\t\t// Support: IE <=9 only\n\t\t\t\t\t\t\t\t// On a manual native abort, IE9 throws\n\t\t\t\t\t\t\t\t// errors on any property access that is not readyState\n\t\t\t\t\t\t\t\tif ( typeof xhr.status !== \"number\" ) {\n\t\t\t\t\t\t\t\t\tcomplete( 0, \"error\" );\n\t\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t\tcomplete(\n\n\t\t\t\t\t\t\t\t\t\t// File: protocol always yields status 0; see #8605, #14207\n\t\t\t\t\t\t\t\t\t\txhr.status,\n\t\t\t\t\t\t\t\t\t\txhr.statusText\n\t\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tcomplete(\n\t\t\t\t\t\t\t\t\txhrSuccessStatus[ xhr.status ] || xhr.status,\n\t\t\t\t\t\t\t\t\txhr.statusText,\n\n\t\t\t\t\t\t\t\t\t// Support: IE <=9 only\n\t\t\t\t\t\t\t\t\t// IE9 has no XHR2 but throws on binary (trac-11426)\n\t\t\t\t\t\t\t\t\t// For XHR2 non-text, let the caller handle it (gh-2498)\n\t\t\t\t\t\t\t\t\t( xhr.responseType || \"text\" ) !== \"text\"  ||\n\t\t\t\t\t\t\t\t\ttypeof xhr.responseText !== \"string\" ?\n\t\t\t\t\t\t\t\t\t\t{ binary: xhr.response } :\n\t\t\t\t\t\t\t\t\t\t{ text: xhr.responseText },\n\t\t\t\t\t\t\t\t\txhr.getAllResponseHeaders()\n\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t};\n\t\t\t\t};\n\n\t\t\t\t// Listen to events\n\t\t\t\txhr.onload = callback();\n\t\t\t\terrorCallback = xhr.onerror = xhr.ontimeout = callback( \"error\" );\n\n\t\t\t\t// Support: IE 9 only\n\t\t\t\t// Use onreadystatechange to replace onabort\n\t\t\t\t// to handle uncaught aborts\n\t\t\t\tif ( xhr.onabort !== undefined ) {\n\t\t\t\t\txhr.onabort = errorCallback;\n\t\t\t\t} else {\n\t\t\t\t\txhr.onreadystatechange = function() {\n\n\t\t\t\t\t\t// Check readyState before timeout as it changes\n\t\t\t\t\t\tif ( xhr.readyState === 4 ) {\n\n\t\t\t\t\t\t\t// Allow onerror to be called first,\n\t\t\t\t\t\t\t// but that will not handle a native abort\n\t\t\t\t\t\t\t// Also, save errorCallback to a variable\n\t\t\t\t\t\t\t// as xhr.onerror cannot be accessed\n\t\t\t\t\t\t\twindow.setTimeout( function() {\n\t\t\t\t\t\t\t\tif ( callback ) {\n\t\t\t\t\t\t\t\t\terrorCallback();\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t} );\n\t\t\t\t\t\t}\n\t\t\t\t\t};\n\t\t\t\t}\n\n\t\t\t\t// Create the abort callback\n\t\t\t\tcallback = callback( \"abort\" );\n\n\t\t\t\ttry {\n\n\t\t\t\t\t// Do send the request (this may raise an exception)\n\t\t\t\t\txhr.send( options.hasContent && options.data || null );\n\t\t\t\t} catch ( e ) {\n\n\t\t\t\t\t// #14683: Only rethrow if this hasn't been notified as an error yet\n\t\t\t\t\tif ( callback ) {\n\t\t\t\t\t\tthrow e;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t},\n\n\t\t\tabort: function() {\n\t\t\t\tif ( callback ) {\n\t\t\t\t\tcallback();\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\t}\n} );\n\n\n\n\n// Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432)\njQuery.ajaxPrefilter( function( s ) {\n\tif ( s.crossDomain ) {\n\t\ts.contents.script = false;\n\t}\n} );\n\n// Install script dataType\njQuery.ajaxSetup( {\n\taccepts: {\n\t\tscript: \"text/javascript, application/javascript, \" +\n\t\t\t\"application/ecmascript, application/x-ecmascript\"\n\t},\n\tcontents: {\n\t\tscript: /\\b(?:java|ecma)script\\b/\n\t},\n\tconverters: {\n\t\t\"text script\": function( text ) {\n\t\t\tjQuery.globalEval( text );\n\t\t\treturn text;\n\t\t}\n\t}\n} );\n\n// Handle cache's special case and crossDomain\njQuery.ajaxPrefilter( \"script\", function( s ) {\n\tif ( s.cache === undefined ) {\n\t\ts.cache = false;\n\t}\n\tif ( s.crossDomain ) {\n\t\ts.type = \"GET\";\n\t}\n} );\n\n// Bind script tag hack transport\njQuery.ajaxTransport( \"script\", function( s ) {\n\n\t// This transport only deals with cross domain requests\n\tif ( s.crossDomain ) {\n\t\tvar script, callback;\n\t\treturn {\n\t\t\tsend: function( _, complete ) {\n\t\t\t\tscript = jQuery( \"<script>\" ).prop( {\n\t\t\t\t\tcharset: s.scriptCharset,\n\t\t\t\t\tsrc: s.url\n\t\t\t\t} ).on(\n\t\t\t\t\t\"load error\",\n\t\t\t\t\tcallback = function( evt ) {\n\t\t\t\t\t\tscript.remove();\n\t\t\t\t\t\tcallback = null;\n\t\t\t\t\t\tif ( evt ) {\n\t\t\t\t\t\t\tcomplete( evt.type === \"error\" ? 404 : 200, evt.type );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t);\n\n\t\t\t\t// Use native DOM manipulation to avoid our domManip AJAX trickery\n\t\t\t\tdocument.head.appendChild( script[ 0 ] );\n\t\t\t},\n\t\t\tabort: function() {\n\t\t\t\tif ( callback ) {\n\t\t\t\t\tcallback();\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\t}\n} );\n\n\n\n\nvar oldCallbacks = [],\n\trjsonp = /(=)\\?(?=&|$)|\\?\\?/;\n\n// Default jsonp settings\njQuery.ajaxSetup( {\n\tjsonp: \"callback\",\n\tjsonpCallback: function() {\n\t\tvar callback = oldCallbacks.pop() || ( jQuery.expando + \"_\" + ( nonce++ ) );\n\t\tthis[ callback ] = true;\n\t\treturn callback;\n\t}\n} );\n\n// Detect, normalize options and install callbacks for jsonp requests\njQuery.ajaxPrefilter( \"json jsonp\", function( s, originalSettings, jqXHR ) {\n\n\tvar callbackName, overwritten, responseContainer,\n\t\tjsonProp = s.jsonp !== false && ( rjsonp.test( s.url ) ?\n\t\t\t\"url\" :\n\t\t\ttypeof s.data === \"string\" &&\n\t\t\t\t( s.contentType || \"\" )\n\t\t\t\t\t.indexOf( \"application/x-www-form-urlencoded\" ) === 0 &&\n\t\t\t\trjsonp.test( s.data ) && \"data\"\n\t\t);\n\n\t// Handle iff the expected data type is \"jsonp\" or we have a parameter to set\n\tif ( jsonProp || s.dataTypes[ 0 ] === \"jsonp\" ) {\n\n\t\t// Get callback name, remembering preexisting value associated with it\n\t\tcallbackName = s.jsonpCallback = isFunction( s.jsonpCallback ) ?\n\t\t\ts.jsonpCallback() :\n\t\t\ts.jsonpCallback;\n\n\t\t// Insert callback into url or form data\n\t\tif ( jsonProp ) {\n\t\t\ts[ jsonProp ] = s[ jsonProp ].replace( rjsonp, \"$1\" + callbackName );\n\t\t} else if ( s.jsonp !== false ) {\n\t\t\ts.url += ( rquery.test( s.url ) ? \"&\" : \"?\" ) + s.jsonp + \"=\" + callbackName;\n\t\t}\n\n\t\t// Use data converter to retrieve json after script execution\n\t\ts.converters[ \"script json\" ] = function() {\n\t\t\tif ( !responseContainer ) {\n\t\t\t\tjQuery.error( callbackName + \" was not called\" );\n\t\t\t}\n\t\t\treturn responseContainer[ 0 ];\n\t\t};\n\n\t\t// Force json dataType\n\t\ts.dataTypes[ 0 ] = \"json\";\n\n\t\t// Install callback\n\t\toverwritten = window[ callbackName ];\n\t\twindow[ callbackName ] = function() {\n\t\t\tresponseContainer = arguments;\n\t\t};\n\n\t\t// Clean-up function (fires after converters)\n\t\tjqXHR.always( function() {\n\n\t\t\t// If previous value didn't exist - remove it\n\t\t\tif ( overwritten === undefined ) {\n\t\t\t\tjQuery( window ).removeProp( callbackName );\n\n\t\t\t// Otherwise restore preexisting value\n\t\t\t} else {\n\t\t\t\twindow[ callbackName ] = overwritten;\n\t\t\t}\n\n\t\t\t// Save back as free\n\t\t\tif ( s[ callbackName ] ) {\n\n\t\t\t\t// Make sure that re-using the options doesn't screw things around\n\t\t\t\ts.jsonpCallback = originalSettings.jsonpCallback;\n\n\t\t\t\t// Save the callback name for future use\n\t\t\t\toldCallbacks.push( callbackName );\n\t\t\t}\n\n\t\t\t// Call if it was a function and we have a response\n\t\t\tif ( responseContainer && isFunction( overwritten ) ) {\n\t\t\t\toverwritten( responseContainer[ 0 ] );\n\t\t\t}\n\n\t\t\tresponseContainer = overwritten = undefined;\n\t\t} );\n\n\t\t// Delegate to script\n\t\treturn \"script\";\n\t}\n} );\n\n\n\n\n// Support: Safari 8 only\n// In Safari 8 documents created via document.implementation.createHTMLDocument\n// collapse sibling forms: the second one becomes a child of the first one.\n// Because of that, this security measure has to be disabled in Safari 8.\n// https://bugs.webkit.org/show_bug.cgi?id=137337\nsupport.createHTMLDocument = ( function() {\n\tvar body = document.implementation.createHTMLDocument( \"\" ).body;\n\tbody.innerHTML = \"<form></form><form></form>\";\n\treturn body.childNodes.length === 2;\n} )();\n\n\n// Argument \"data\" should be string of html\n// context (optional): If specified, the fragment will be created in this context,\n// defaults to document\n// keepScripts (optional): If true, will include scripts passed in the html string\njQuery.parseHTML = function( data, context, keepScripts ) {\n\tif ( typeof data !== \"string\" ) {\n\t\treturn [];\n\t}\n\tif ( typeof context === \"boolean\" ) {\n\t\tkeepScripts = context;\n\t\tcontext = false;\n\t}\n\n\tvar base, parsed, scripts;\n\n\tif ( !context ) {\n\n\t\t// Stop scripts or inline event handlers from being executed immediately\n\t\t// by using document.implementation\n\t\tif ( support.createHTMLDocument ) {\n\t\t\tcontext = document.implementation.createHTMLDocument( \"\" );\n\n\t\t\t// Set the base href for the created document\n\t\t\t// so any parsed elements with URLs\n\t\t\t// are based on the document's URL (gh-2965)\n\t\t\tbase = context.createElement( \"base\" );\n\t\t\tbase.href = document.location.href;\n\t\t\tcontext.head.appendChild( base );\n\t\t} else {\n\t\t\tcontext = document;\n\t\t}\n\t}\n\n\tparsed = rsingleTag.exec( data );\n\tscripts = !keepScripts && [];\n\n\t// Single tag\n\tif ( parsed ) {\n\t\treturn [ context.createElement( parsed[ 1 ] ) ];\n\t}\n\n\tparsed = buildFragment( [ data ], context, scripts );\n\n\tif ( scripts && scripts.length ) {\n\t\tjQuery( scripts ).remove();\n\t}\n\n\treturn jQuery.merge( [], parsed.childNodes );\n};\n\n\n/**\n * Load a url into a page\n */\njQuery.fn.load = function( url, params, callback ) {\n\tvar selector, type, response,\n\t\tself = this,\n\t\toff = url.indexOf( \" \" );\n\n\tif ( off > -1 ) {\n\t\tselector = stripAndCollapse( url.slice( off ) );\n\t\turl = url.slice( 0, off );\n\t}\n\n\t// If it's a function\n\tif ( isFunction( params ) ) {\n\n\t\t// We assume that it's the callback\n\t\tcallback = params;\n\t\tparams = undefined;\n\n\t// Otherwise, build a param string\n\t} else if ( params && typeof params === \"object\" ) {\n\t\ttype = \"POST\";\n\t}\n\n\t// If we have elements to modify, make the request\n\tif ( self.length > 0 ) {\n\t\tjQuery.ajax( {\n\t\t\turl: url,\n\n\t\t\t// If \"type\" variable is undefined, then \"GET\" method will be used.\n\t\t\t// Make value of this field explicit since\n\t\t\t// user can override it through ajaxSetup method\n\t\t\ttype: type || \"GET\",\n\t\t\tdataType: \"html\",\n\t\t\tdata: params\n\t\t} ).done( function( responseText ) {\n\n\t\t\t// Save response for use in complete callback\n\t\t\tresponse = arguments;\n\n\t\t\tself.html( selector ?\n\n\t\t\t\t// If a selector was specified, locate the right elements in a dummy div\n\t\t\t\t// Exclude scripts to avoid IE 'Permission Denied' errors\n\t\t\t\tjQuery( \"<div>\" ).append( jQuery.parseHTML( responseText ) ).find( selector ) :\n\n\t\t\t\t// Otherwise use the full result\n\t\t\t\tresponseText );\n\n\t\t// If the request succeeds, this function gets \"data\", \"status\", \"jqXHR\"\n\t\t// but they are ignored because response was set above.\n\t\t// If it fails, this function gets \"jqXHR\", \"status\", \"error\"\n\t\t} ).always( callback && function( jqXHR, status ) {\n\t\t\tself.each( function() {\n\t\t\t\tcallback.apply( this, response || [ jqXHR.responseText, status, jqXHR ] );\n\t\t\t} );\n\t\t} );\n\t}\n\n\treturn this;\n};\n\n\n\n\n// Attach a bunch of functions for handling common AJAX events\njQuery.each( [\n\t\"ajaxStart\",\n\t\"ajaxStop\",\n\t\"ajaxComplete\",\n\t\"ajaxError\",\n\t\"ajaxSuccess\",\n\t\"ajaxSend\"\n], function( i, type ) {\n\tjQuery.fn[ type ] = function( fn ) {\n\t\treturn this.on( type, fn );\n\t};\n} );\n\n\n\n\njQuery.expr.pseudos.animated = function( elem ) {\n\treturn jQuery.grep( jQuery.timers, function( fn ) {\n\t\treturn elem === fn.elem;\n\t} ).length;\n};\n\n\n\n\njQuery.offset = {\n\tsetOffset: function( elem, options, i ) {\n\t\tvar curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition,\n\t\t\tposition = jQuery.css( elem, \"position\" ),\n\t\t\tcurElem = jQuery( elem ),\n\t\t\tprops = {};\n\n\t\t// Set position first, in-case top/left are set even on static elem\n\t\tif ( position === \"static\" ) {\n\t\t\telem.style.position = \"relative\";\n\t\t}\n\n\t\tcurOffset = curElem.offset();\n\t\tcurCSSTop = jQuery.css( elem, \"top\" );\n\t\tcurCSSLeft = jQuery.css( elem, \"left\" );\n\t\tcalculatePosition = ( position === \"absolute\" || position === \"fixed\" ) &&\n\t\t\t( curCSSTop + curCSSLeft ).indexOf( \"auto\" ) > -1;\n\n\t\t// Need to be able to calculate position if either\n\t\t// top or left is auto and position is either absolute or fixed\n\t\tif ( calculatePosition ) {\n\t\t\tcurPosition = curElem.position();\n\t\t\tcurTop = curPosition.top;\n\t\t\tcurLeft = curPosition.left;\n\n\t\t} else {\n\t\t\tcurTop = parseFloat( curCSSTop ) || 0;\n\t\t\tcurLeft = parseFloat( curCSSLeft ) || 0;\n\t\t}\n\n\t\tif ( isFunction( options ) ) {\n\n\t\t\t// Use jQuery.extend here to allow modification of coordinates argument (gh-1848)\n\t\t\toptions = options.call( elem, i, jQuery.extend( {}, curOffset ) );\n\t\t}\n\n\t\tif ( options.top != null ) {\n\t\t\tprops.top = ( options.top - curOffset.top ) + curTop;\n\t\t}\n\t\tif ( options.left != null ) {\n\t\t\tprops.left = ( options.left - curOffset.left ) + curLeft;\n\t\t}\n\n\t\tif ( \"using\" in options ) {\n\t\t\toptions.using.call( elem, props );\n\n\t\t} else {\n\t\t\tcurElem.css( props );\n\t\t}\n\t}\n};\n\njQuery.fn.extend( {\n\n\t// offset() relates an element's border box to the document origin\n\toffset: function( options ) {\n\n\t\t// Preserve chaining for setter\n\t\tif ( arguments.length ) {\n\t\t\treturn options === undefined ?\n\t\t\t\tthis :\n\t\t\t\tthis.each( function( i ) {\n\t\t\t\t\tjQuery.offset.setOffset( this, options, i );\n\t\t\t\t} );\n\t\t}\n\n\t\tvar rect, win,\n\t\t\telem = this[ 0 ];\n\n\t\tif ( !elem ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Return zeros for disconnected and hidden (display: none) elements (gh-2310)\n\t\t// Support: IE <=11 only\n\t\t// Running getBoundingClientRect on a\n\t\t// disconnected node in IE throws an error\n\t\tif ( !elem.getClientRects().length ) {\n\t\t\treturn { top: 0, left: 0 };\n\t\t}\n\n\t\t// Get document-relative position by adding viewport scroll to viewport-relative gBCR\n\t\trect = elem.getBoundingClientRect();\n\t\twin = elem.ownerDocument.defaultView;\n\t\treturn {\n\t\t\ttop: rect.top + win.pageYOffset,\n\t\t\tleft: rect.left + win.pageXOffset\n\t\t};\n\t},\n\n\t// position() relates an element's margin box to its offset parent's padding box\n\t// This corresponds to the behavior of CSS absolute positioning\n\tposition: function() {\n\t\tif ( !this[ 0 ] ) {\n\t\t\treturn;\n\t\t}\n\n\t\tvar offsetParent, offset, doc,\n\t\t\telem = this[ 0 ],\n\t\t\tparentOffset = { top: 0, left: 0 };\n\n\t\t// position:fixed elements are offset from the viewport, which itself always has zero offset\n\t\tif ( jQuery.css( elem, \"position\" ) === \"fixed\" ) {\n\n\t\t\t// Assume position:fixed implies availability of getBoundingClientRect\n\t\t\toffset = elem.getBoundingClientRect();\n\n\t\t} else {\n\t\t\toffset = this.offset();\n\n\t\t\t// Account for the *real* offset parent, which can be the document or its root element\n\t\t\t// when a statically positioned element is identified\n\t\t\tdoc = elem.ownerDocument;\n\t\t\toffsetParent = elem.offsetParent || doc.documentElement;\n\t\t\twhile ( offsetParent &&\n\t\t\t\t( offsetParent === doc.body || offsetParent === doc.documentElement ) &&\n\t\t\t\tjQuery.css( offsetParent, \"position\" ) === \"static\" ) {\n\n\t\t\t\toffsetParent = offsetParent.parentNode;\n\t\t\t}\n\t\t\tif ( offsetParent && offsetParent !== elem && offsetParent.nodeType === 1 ) {\n\n\t\t\t\t// Incorporate borders into its offset, since they are outside its content origin\n\t\t\t\tparentOffset = jQuery( offsetParent ).offset();\n\t\t\t\tparentOffset.top += jQuery.css( offsetParent, \"borderTopWidth\", true );\n\t\t\t\tparentOffset.left += jQuery.css( offsetParent, \"borderLeftWidth\", true );\n\t\t\t}\n\t\t}\n\n\t\t// Subtract parent offsets and element margins\n\t\treturn {\n\t\t\ttop: offset.top - parentOffset.top - jQuery.css( elem, \"marginTop\", true ),\n\t\t\tleft: offset.left - parentOffset.left - jQuery.css( elem, \"marginLeft\", true )\n\t\t};\n\t},\n\n\t// This method will return documentElement in the following cases:\n\t// 1) For the element inside the iframe without offsetParent, this method will return\n\t//    documentElement of the parent window\n\t// 2) For the hidden or detached element\n\t// 3) For body or html element, i.e. in case of the html node - it will return itself\n\t//\n\t// but those exceptions were never presented as a real life use-cases\n\t// and might be considered as more preferable results.\n\t//\n\t// This logic, however, is not guaranteed and can change at any point in the future\n\toffsetParent: function() {\n\t\treturn this.map( function() {\n\t\t\tvar offsetParent = this.offsetParent;\n\n\t\t\twhile ( offsetParent && jQuery.css( offsetParent, \"position\" ) === \"static\" ) {\n\t\t\t\toffsetParent = offsetParent.offsetParent;\n\t\t\t}\n\n\t\t\treturn offsetParent || documentElement;\n\t\t} );\n\t}\n} );\n\n// Create scrollLeft and scrollTop methods\njQuery.each( { scrollLeft: \"pageXOffset\", scrollTop: \"pageYOffset\" }, function( method, prop ) {\n\tvar top = \"pageYOffset\" === prop;\n\n\tjQuery.fn[ method ] = function( val ) {\n\t\treturn access( this, function( elem, method, val ) {\n\n\t\t\t// Coalesce documents and windows\n\t\t\tvar win;\n\t\t\tif ( isWindow( elem ) ) {\n\t\t\t\twin = elem;\n\t\t\t} else if ( elem.nodeType === 9 ) {\n\t\t\t\twin = elem.defaultView;\n\t\t\t}\n\n\t\t\tif ( val === undefined ) {\n\t\t\t\treturn win ? win[ prop ] : elem[ method ];\n\t\t\t}\n\n\t\t\tif ( win ) {\n\t\t\t\twin.scrollTo(\n\t\t\t\t\t!top ? val : win.pageXOffset,\n\t\t\t\t\ttop ? val : win.pageYOffset\n\t\t\t\t);\n\n\t\t\t} else {\n\t\t\t\telem[ method ] = val;\n\t\t\t}\n\t\t}, method, val, arguments.length );\n\t};\n} );\n\n// Support: Safari <=7 - 9.1, Chrome <=37 - 49\n// Add the top/left cssHooks using jQuery.fn.position\n// Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084\n// Blink bug: https://bugs.chromium.org/p/chromium/issues/detail?id=589347\n// getComputedStyle returns percent when specified for top/left/bottom/right;\n// rather than make the css module depend on the offset module, just check for it here\njQuery.each( [ \"top\", \"left\" ], function( i, prop ) {\n\tjQuery.cssHooks[ prop ] = addGetHookIf( support.pixelPosition,\n\t\tfunction( elem, computed ) {\n\t\t\tif ( computed ) {\n\t\t\t\tcomputed = curCSS( elem, prop );\n\n\t\t\t\t// If curCSS returns percentage, fallback to offset\n\t\t\t\treturn rnumnonpx.test( computed ) ?\n\t\t\t\t\tjQuery( elem ).position()[ prop ] + \"px\" :\n\t\t\t\t\tcomputed;\n\t\t\t}\n\t\t}\n\t);\n} );\n\n\n// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods\njQuery.each( { Height: \"height\", Width: \"width\" }, function( name, type ) {\n\tjQuery.each( { padding: \"inner\" + name, content: type, \"\": \"outer\" + name },\n\t\tfunction( defaultExtra, funcName ) {\n\n\t\t// Margin is only for outerHeight, outerWidth\n\t\tjQuery.fn[ funcName ] = function( margin, value ) {\n\t\t\tvar chainable = arguments.length && ( defaultExtra || typeof margin !== \"boolean\" ),\n\t\t\t\textra = defaultExtra || ( margin === true || value === true ? \"margin\" : \"border\" );\n\n\t\t\treturn access( this, function( elem, type, value ) {\n\t\t\t\tvar doc;\n\n\t\t\t\tif ( isWindow( elem ) ) {\n\n\t\t\t\t\t// $( window ).outerWidth/Height return w/h including scrollbars (gh-1729)\n\t\t\t\t\treturn funcName.indexOf( \"outer\" ) === 0 ?\n\t\t\t\t\t\telem[ \"inner\" + name ] :\n\t\t\t\t\t\telem.document.documentElement[ \"client\" + name ];\n\t\t\t\t}\n\n\t\t\t\t// Get document width or height\n\t\t\t\tif ( elem.nodeType === 9 ) {\n\t\t\t\t\tdoc = elem.documentElement;\n\n\t\t\t\t\t// Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height],\n\t\t\t\t\t// whichever is greatest\n\t\t\t\t\treturn Math.max(\n\t\t\t\t\t\telem.body[ \"scroll\" + name ], doc[ \"scroll\" + name ],\n\t\t\t\t\t\telem.body[ \"offset\" + name ], doc[ \"offset\" + name ],\n\t\t\t\t\t\tdoc[ \"client\" + name ]\n\t\t\t\t\t);\n\t\t\t\t}\n\n\t\t\t\treturn value === undefined ?\n\n\t\t\t\t\t// Get width or height on the element, requesting but not forcing parseFloat\n\t\t\t\t\tjQuery.css( elem, type, extra ) :\n\n\t\t\t\t\t// Set width or height on the element\n\t\t\t\t\tjQuery.style( elem, type, value, extra );\n\t\t\t}, type, chainable ? margin : undefined, chainable );\n\t\t};\n\t} );\n} );\n\n\njQuery.each( ( \"blur focus focusin focusout resize scroll click dblclick \" +\n\t\"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave \" +\n\t\"change select submit keydown keypress keyup contextmenu\" ).split( \" \" ),\n\tfunction( i, name ) {\n\n\t// Handle event binding\n\tjQuery.fn[ name ] = function( data, fn ) {\n\t\treturn arguments.length > 0 ?\n\t\t\tthis.on( name, null, data, fn ) :\n\t\t\tthis.trigger( name );\n\t};\n} );\n\njQuery.fn.extend( {\n\thover: function( fnOver, fnOut ) {\n\t\treturn this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );\n\t}\n} );\n\n\n\n\njQuery.fn.extend( {\n\n\tbind: function( types, data, fn ) {\n\t\treturn this.on( types, null, data, fn );\n\t},\n\tunbind: function( types, fn ) {\n\t\treturn this.off( types, null, fn );\n\t},\n\n\tdelegate: function( selector, types, data, fn ) {\n\t\treturn this.on( types, selector, data, fn );\n\t},\n\tundelegate: function( selector, types, fn ) {\n\n\t\t// ( namespace ) or ( selector, types [, fn] )\n\t\treturn arguments.length === 1 ?\n\t\t\tthis.off( selector, \"**\" ) :\n\t\t\tthis.off( types, selector || \"**\", fn );\n\t}\n} );\n\n// Bind a function to a context, optionally partially applying any\n// arguments.\n// jQuery.proxy is deprecated to promote standards (specifically Function#bind)\n// However, it is not slated for removal any time soon\njQuery.proxy = function( fn, context ) {\n\tvar tmp, args, proxy;\n\n\tif ( typeof context === \"string\" ) {\n\t\ttmp = fn[ context ];\n\t\tcontext = fn;\n\t\tfn = tmp;\n\t}\n\n\t// Quick check to determine if target is callable, in the spec\n\t// this throws a TypeError, but we will just return undefined.\n\tif ( !isFunction( fn ) ) {\n\t\treturn undefined;\n\t}\n\n\t// Simulated bind\n\targs = slice.call( arguments, 2 );\n\tproxy = function() {\n\t\treturn fn.apply( context || this, args.concat( slice.call( arguments ) ) );\n\t};\n\n\t// Set the guid of unique handler to the same of original handler, so it can be removed\n\tproxy.guid = fn.guid = fn.guid || jQuery.guid++;\n\n\treturn proxy;\n};\n\njQuery.holdReady = function( hold ) {\n\tif ( hold ) {\n\t\tjQuery.readyWait++;\n\t} else {\n\t\tjQuery.ready( true );\n\t}\n};\njQuery.isArray = Array.isArray;\njQuery.parseJSON = JSON.parse;\njQuery.nodeName = nodeName;\njQuery.isFunction = isFunction;\njQuery.isWindow = isWindow;\njQuery.camelCase = camelCase;\njQuery.type = toType;\n\njQuery.now = Date.now;\n\njQuery.isNumeric = function( obj ) {\n\n\t// As of jQuery 3.0, isNumeric is limited to\n\t// strings and numbers (primitives or objects)\n\t// that can be coerced to finite numbers (gh-2662)\n\tvar type = jQuery.type( obj );\n\treturn ( type === \"number\" || type === \"string\" ) &&\n\n\t\t// parseFloat NaNs numeric-cast false positives (\"\")\n\t\t// ...but misinterprets leading-number strings, particularly hex literals (\"0x...\")\n\t\t// subtraction forces infinities to NaN\n\t\t!isNaN( obj - parseFloat( obj ) );\n};\n\n\n\n\n// Register as a named AMD module, since jQuery can be concatenated with other\n// files that may use define, but not via a proper concatenation script that\n// understands anonymous AMD modules. A named AMD is safest and most robust\n// way to register. Lowercase jquery is used because AMD module names are\n// derived from file names, and jQuery is normally delivered in a lowercase\n// file name. Do this after creating the global so that if an AMD module wants\n// to call noConflict to hide this version of jQuery, it will work.\n\n// Note that for maximum portability, libraries that are not jQuery should\n// declare themselves as anonymous modules, and avoid setting a global if an\n// AMD loader is present. jQuery is a special case. For more information, see\n// https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon\n\nif ( typeof define === \"function\" && define.amd ) {\n\tdefine( \"jquery\", [], function() {\n\t\treturn jQuery;\n\t} );\n}\n\n\n\n\nvar\n\n\t// Map over jQuery in case of overwrite\n\t_jQuery = window.jQuery,\n\n\t// Map over the $ in case of overwrite\n\t_$ = window.$;\n\njQuery.noConflict = function( deep ) {\n\tif ( window.$ === jQuery ) {\n\t\twindow.$ = _$;\n\t}\n\n\tif ( deep && window.jQuery === jQuery ) {\n\t\twindow.jQuery = _jQuery;\n\t}\n\n\treturn jQuery;\n};\n\n// Expose jQuery and $ identifiers, even in AMD\n// (#7102#comment:10, https://github.com/jquery/jquery/pull/557)\n// and CommonJS for browser emulators (#13566)\nif ( !noGlobal ) {\n\twindow.jQuery = window.$ = jQuery;\n}\n\n\n\n\nreturn jQuery;\n} );\n","var baseFlatten = require('../internal/baseFlatten');\n\n/**\n * Recursively flattens a nested array.\n *\n * @static\n * @memberOf _\n * @category Array\n * @param {Array} array The array to recursively flatten.\n * @returns {Array} Returns the new flattened array.\n * @example\n *\n * _.flattenDeep([1, [2, 3, [4]]]);\n * // => [1, 2, 3, 4]\n */\nfunction flattenDeep(array) {\n  var length = array ? array.length : 0;\n  return length ? baseFlatten(array, true) : [];\n}\n\nmodule.exports = flattenDeep;\n","/**\n * Gets the last element of `array`.\n *\n * @static\n * @memberOf _\n * @category Array\n * @param {Array} array The array to query.\n * @returns {*} Returns the last element of `array`.\n * @example\n *\n * _.last([1, 2, 3]);\n * // => 3\n */\nfunction last(array) {\n  var length = array ? array.length : 0;\n  return length ? array[length - 1] : undefined;\n}\n\nmodule.exports = last;\n","var arrayPush = require('../internal/arrayPush'),\n    baseDifference = require('../internal/baseDifference'),\n    baseUniq = require('../internal/baseUniq'),\n    isArrayLike = require('../internal/isArrayLike');\n\n/**\n * Creates an array of unique values that is the [symmetric difference](https://en.wikipedia.org/wiki/Symmetric_difference)\n * of the provided arrays.\n *\n * @static\n * @memberOf _\n * @category Array\n * @param {...Array} [arrays] The arrays to inspect.\n * @returns {Array} Returns the new array of values.\n * @example\n *\n * _.xor([1, 2], [4, 2]);\n * // => [1, 4]\n */\nfunction xor() {\n  var index = -1,\n      length = arguments.length;\n\n  while (++index < length) {\n    var array = arguments[index];\n    if (isArrayLike(array)) {\n      var result = result\n        ? arrayPush(baseDifference(result, array), baseDifference(array, result))\n        : array;\n    }\n  }\n  return result ? baseUniq(result) : [];\n}\n\nmodule.exports = xor;\n","var arrayFilter = require('../internal/arrayFilter'),\n    baseCallback = require('../internal/baseCallback'),\n    baseFilter = require('../internal/baseFilter'),\n    isArray = require('../lang/isArray');\n\n/**\n * Iterates over elements of `collection`, returning an array of all elements\n * `predicate` returns truthy for. The predicate is bound to `thisArg` and\n * invoked with three arguments: (value, index|key, collection).\n *\n * If a property name is provided for `predicate` the created `_.property`\n * style callback returns the property value of the given element.\n *\n * If a value is also provided for `thisArg` the created `_.matchesProperty`\n * style callback returns `true` for elements that have a matching property\n * value, else `false`.\n *\n * If an object is provided for `predicate` the created `_.matches` style\n * callback returns `true` for elements that have the properties of the given\n * object, else `false`.\n *\n * @static\n * @memberOf _\n * @alias select\n * @category Collection\n * @param {Array|Object|string} collection The collection to iterate over.\n * @param {Function|Object|string} [predicate=_.identity] The function invoked\n *  per iteration.\n * @param {*} [thisArg] The `this` binding of `predicate`.\n * @returns {Array} Returns the new filtered array.\n * @example\n *\n * _.filter([4, 5, 6], function(n) {\n *   return n % 2 == 0;\n * });\n * // => [4, 6]\n *\n * var users = [\n *   { 'user': 'barney', 'age': 36, 'active': true },\n *   { 'user': 'fred',   'age': 40, 'active': false }\n * ];\n *\n * // using the `_.matches` callback shorthand\n * _.pluck(_.filter(users, { 'age': 36, 'active': true }), 'user');\n * // => ['barney']\n *\n * // using the `_.matchesProperty` callback shorthand\n * _.pluck(_.filter(users, 'active', false), 'user');\n * // => ['fred']\n *\n * // using the `_.property` callback shorthand\n * _.pluck(_.filter(users, 'active'), 'user');\n * // => ['barney']\n */\nfunction filter(collection, predicate, thisArg) {\n  var func = isArray(collection) ? arrayFilter : baseFilter;\n  predicate = baseCallback(predicate, thisArg, 3);\n  return func(collection, predicate);\n}\n\nmodule.exports = filter;\n","var baseEach = require('../internal/baseEach'),\n    createFind = require('../internal/createFind');\n\n/**\n * Iterates over elements of `collection`, returning the first element\n * `predicate` returns truthy for. The predicate is bound to `thisArg` and\n * invoked with three arguments: (value, index|key, collection).\n *\n * If a property name is provided for `predicate` the created `_.property`\n * style callback returns the property value of the given element.\n *\n * If a value is also provided for `thisArg` the created `_.matchesProperty`\n * style callback returns `true` for elements that have a matching property\n * value, else `false`.\n *\n * If an object is provided for `predicate` the created `_.matches` style\n * callback returns `true` for elements that have the properties of the given\n * object, else `false`.\n *\n * @static\n * @memberOf _\n * @alias detect\n * @category Collection\n * @param {Array|Object|string} collection The collection to search.\n * @param {Function|Object|string} [predicate=_.identity] The function invoked\n *  per iteration.\n * @param {*} [thisArg] The `this` binding of `predicate`.\n * @returns {*} Returns the matched element, else `undefined`.\n * @example\n *\n * var users = [\n *   { 'user': 'barney',  'age': 36, 'active': true },\n *   { 'user': 'fred',    'age': 40, 'active': false },\n *   { 'user': 'pebbles', 'age': 1,  'active': true }\n * ];\n *\n * _.result(_.find(users, function(chr) {\n *   return chr.age < 40;\n * }), 'user');\n * // => 'barney'\n *\n * // using the `_.matches` callback shorthand\n * _.result(_.find(users, { 'age': 1, 'active': true }), 'user');\n * // => 'pebbles'\n *\n * // using the `_.matchesProperty` callback shorthand\n * _.result(_.find(users, 'active', false), 'user');\n * // => 'fred'\n *\n * // using the `_.property` callback shorthand\n * _.result(_.find(users, 'active'), 'user');\n * // => 'barney'\n */\nvar find = createFind(baseEach);\n\nmodule.exports = find;\n","var arrayEach = require('../internal/arrayEach'),\n    baseEach = require('../internal/baseEach'),\n    createForEach = require('../internal/createForEach');\n\n/**\n * Iterates over elements of `collection` invoking `iteratee` for each element.\n * The `iteratee` is bound to `thisArg` and invoked with three arguments:\n * (value, index|key, collection). Iteratee functions may exit iteration early\n * by explicitly returning `false`.\n *\n * **Note:** As with other \"Collections\" methods, objects with a \"length\" property\n * are iterated like arrays. To avoid this behavior `_.forIn` or `_.forOwn`\n * may be used for object iteration.\n *\n * @static\n * @memberOf _\n * @alias each\n * @category Collection\n * @param {Array|Object|string} collection The collection to iterate over.\n * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n * @param {*} [thisArg] The `this` binding of `iteratee`.\n * @returns {Array|Object|string} Returns `collection`.\n * @example\n *\n * _([1, 2]).forEach(function(n) {\n *   console.log(n);\n * }).value();\n * // => logs each value from left to right and returns the array\n *\n * _.forEach({ 'a': 1, 'b': 2 }, function(n, key) {\n *   console.log(n, key);\n * });\n * // => logs each value-key pair and returns the object (iteration order is not guaranteed)\n */\nvar forEach = createForEach(arrayEach, baseEach);\n\nmodule.exports = forEach;\n","var createAggregator = require('../internal/createAggregator');\n\n/**\n * Creates an object composed of keys generated from the results of running\n * each element of `collection` through `iteratee`. The corresponding value\n * of each key is the last element responsible for generating the key. The\n * iteratee function is bound to `thisArg` and invoked with three arguments:\n * (value, index|key, collection).\n *\n * If a property name is provided for `iteratee` the created `_.property`\n * style callback returns the property value of the given element.\n *\n * If a value is also provided for `thisArg` the created `_.matchesProperty`\n * style callback returns `true` for elements that have a matching property\n * value, else `false`.\n *\n * If an object is provided for `iteratee` the created `_.matches` style\n * callback returns `true` for elements that have the properties of the given\n * object, else `false`.\n *\n * @static\n * @memberOf _\n * @category Collection\n * @param {Array|Object|string} collection The collection to iterate over.\n * @param {Function|Object|string} [iteratee=_.identity] The function invoked\n *  per iteration.\n * @param {*} [thisArg] The `this` binding of `iteratee`.\n * @returns {Object} Returns the composed aggregate object.\n * @example\n *\n * var keyData = [\n *   { 'dir': 'left', 'code': 97 },\n *   { 'dir': 'right', 'code': 100 }\n * ];\n *\n * _.indexBy(keyData, 'dir');\n * // => { 'left': { 'dir': 'left', 'code': 97 }, 'right': { 'dir': 'right', 'code': 100 } }\n *\n * _.indexBy(keyData, function(object) {\n *   return String.fromCharCode(object.code);\n * });\n * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } }\n *\n * _.indexBy(keyData, function(object) {\n *   return this.fromCharCode(object.code);\n * }, String);\n * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } }\n */\nvar indexBy = createAggregator(function(result, value, key) {\n  result[key] = value;\n});\n\nmodule.exports = indexBy;\n","var arrayMap = require('../internal/arrayMap'),\n    baseCallback = require('../internal/baseCallback'),\n    baseMap = require('../internal/baseMap'),\n    isArray = require('../lang/isArray');\n\n/**\n * Creates an array of values by running each element in `collection` through\n * `iteratee`. The `iteratee` is bound to `thisArg` and invoked with three\n * arguments: (value, index|key, collection).\n *\n * If a property name is provided for `iteratee` the created `_.property`\n * style callback returns the property value of the given element.\n *\n * If a value is also provided for `thisArg` the created `_.matchesProperty`\n * style callback returns `true` for elements that have a matching property\n * value, else `false`.\n *\n * If an object is provided for `iteratee` the created `_.matches` style\n * callback returns `true` for elements that have the properties of the given\n * object, else `false`.\n *\n * Many lodash methods are guarded to work as iteratees for methods like\n * `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`.\n *\n * The guarded methods are:\n * `ary`, `callback`, `chunk`, `clone`, `create`, `curry`, `curryRight`,\n * `drop`, `dropRight`, `every`, `fill`, `flatten`, `invert`, `max`, `min`,\n * `parseInt`, `slice`, `sortBy`, `take`, `takeRight`, `template`, `trim`,\n * `trimLeft`, `trimRight`, `trunc`, `random`, `range`, `sample`, `some`,\n * `sum`, `uniq`, and `words`\n *\n * @static\n * @memberOf _\n * @alias collect\n * @category Collection\n * @param {Array|Object|string} collection The collection to iterate over.\n * @param {Function|Object|string} [iteratee=_.identity] The function invoked\n *  per iteration.\n * @param {*} [thisArg] The `this` binding of `iteratee`.\n * @returns {Array} Returns the new mapped array.\n * @example\n *\n * function timesThree(n) {\n *   return n * 3;\n * }\n *\n * _.map([1, 2], timesThree);\n * // => [3, 6]\n *\n * _.map({ 'a': 1, 'b': 2 }, timesThree);\n * // => [3, 6] (iteration order is not guaranteed)\n *\n * var users = [\n *   { 'user': 'barney' },\n *   { 'user': 'fred' }\n * ];\n *\n * // using the `_.property` callback shorthand\n * _.map(users, 'user');\n * // => ['barney', 'fred']\n */\nfunction map(collection, iteratee, thisArg) {\n  var func = isArray(collection) ? arrayMap : baseMap;\n  iteratee = baseCallback(iteratee, thisArg, 3);\n  return func(collection, iteratee);\n}\n\nmodule.exports = map;\n","var getNative = require('../internal/getNative');\n\n/* Native method references for those with the same name as other `lodash` methods. */\nvar nativeNow = getNative(Date, 'now');\n\n/**\n * Gets the number of milliseconds that have elapsed since the Unix epoch\n * (1 January 1970 00:00:00 UTC).\n *\n * @static\n * @memberOf _\n * @category Date\n * @example\n *\n * _.defer(function(stamp) {\n *   console.log(_.now() - stamp);\n * }, _.now());\n * // => logs the number of milliseconds it took for the deferred function to be invoked\n */\nvar now = nativeNow || function() {\n  return new Date().getTime();\n};\n\nmodule.exports = now;\n","var isObject = require('../lang/isObject'),\n    now = require('../date/now');\n\n/** Used as the `TypeError` message for \"Functions\" methods. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/* Native method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max;\n\n/**\n * Creates a debounced function that delays invoking `func` until after `wait`\n * milliseconds have elapsed since the last time the debounced function was\n * invoked. The debounced function comes with a `cancel` method to cancel\n * delayed invocations. Provide an options object to indicate that `func`\n * should be invoked on the leading and/or trailing edge of the `wait` timeout.\n * Subsequent calls to the debounced function return the result of the last\n * `func` invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is invoked\n * on the trailing edge of the timeout only if the the debounced function is\n * invoked more than once during the `wait` timeout.\n *\n * See [David Corbacho's article](http://drupalmotion.com/article/debounce-and-throttle-visual-explanation)\n * for details over the differences between `_.debounce` and `_.throttle`.\n *\n * @static\n * @memberOf _\n * @category Function\n * @param {Function} func The function to debounce.\n * @param {number} [wait=0] The number of milliseconds to delay.\n * @param {Object} [options] The options object.\n * @param {boolean} [options.leading=false] Specify invoking on the leading\n *  edge of the timeout.\n * @param {number} [options.maxWait] The maximum time `func` is allowed to be\n *  delayed before it's invoked.\n * @param {boolean} [options.trailing=true] Specify invoking on the trailing\n *  edge of the timeout.\n * @returns {Function} Returns the new debounced function.\n * @example\n *\n * // avoid costly calculations while the window size is in flux\n * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n *\n * // invoke `sendMail` when the click event is fired, debouncing subsequent calls\n * jQuery('#postbox').on('click', _.debounce(sendMail, 300, {\n *   'leading': true,\n *   'trailing': false\n * }));\n *\n * // ensure `batchLog` is invoked once after 1 second of debounced calls\n * var source = new EventSource('/stream');\n * jQuery(source).on('message', _.debounce(batchLog, 250, {\n *   'maxWait': 1000\n * }));\n *\n * // cancel a debounced call\n * var todoChanges = _.debounce(batchLog, 1000);\n * Object.observe(models.todo, todoChanges);\n *\n * Object.observe(models, function(changes) {\n *   if (_.find(changes, { 'user': 'todo', 'type': 'delete'})) {\n *     todoChanges.cancel();\n *   }\n * }, ['delete']);\n *\n * // ...at some point `models.todo` is changed\n * models.todo.completed = true;\n *\n * // ...before 1 second has passed `models.todo` is deleted\n * // which cancels the debounced `todoChanges` call\n * delete models.todo;\n */\nfunction debounce(func, wait, options) {\n  var args,\n      maxTimeoutId,\n      result,\n      stamp,\n      thisArg,\n      timeoutId,\n      trailingCall,\n      lastCalled = 0,\n      maxWait = false,\n      trailing = true;\n\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  wait = wait < 0 ? 0 : (+wait || 0);\n  if (options === true) {\n    var leading = true;\n    trailing = false;\n  } else if (isObject(options)) {\n    leading = !!options.leading;\n    maxWait = 'maxWait' in options && nativeMax(+options.maxWait || 0, wait);\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n\n  function cancel() {\n    if (timeoutId) {\n      clearTimeout(timeoutId);\n    }\n    if (maxTimeoutId) {\n      clearTimeout(maxTimeoutId);\n    }\n    lastCalled = 0;\n    maxTimeoutId = timeoutId = trailingCall = undefined;\n  }\n\n  function complete(isCalled, id) {\n    if (id) {\n      clearTimeout(id);\n    }\n    maxTimeoutId = timeoutId = trailingCall = undefined;\n    if (isCalled) {\n      lastCalled = now();\n      result = func.apply(thisArg, args);\n      if (!timeoutId && !maxTimeoutId) {\n        args = thisArg = undefined;\n      }\n    }\n  }\n\n  function delayed() {\n    var remaining = wait - (now() - stamp);\n    if (remaining <= 0 || remaining > wait) {\n      complete(trailingCall, maxTimeoutId);\n    } else {\n      timeoutId = setTimeout(delayed, remaining);\n    }\n  }\n\n  function maxDelayed() {\n    complete(trailing, timeoutId);\n  }\n\n  function debounced() {\n    args = arguments;\n    stamp = now();\n    thisArg = this;\n    trailingCall = trailing && (timeoutId || !leading);\n\n    if (maxWait === false) {\n      var leadingCall = leading && !timeoutId;\n    } else {\n      if (!maxTimeoutId && !leading) {\n        lastCalled = stamp;\n      }\n      var remaining = maxWait - (stamp - lastCalled),\n          isCalled = remaining <= 0 || remaining > maxWait;\n\n      if (isCalled) {\n        if (maxTimeoutId) {\n          maxTimeoutId = clearTimeout(maxTimeoutId);\n        }\n        lastCalled = stamp;\n        result = func.apply(thisArg, args);\n      }\n      else if (!maxTimeoutId) {\n        maxTimeoutId = setTimeout(maxDelayed, remaining);\n      }\n    }\n    if (isCalled && timeoutId) {\n      timeoutId = clearTimeout(timeoutId);\n    }\n    else if (!timeoutId && wait !== maxWait) {\n      timeoutId = setTimeout(delayed, wait);\n    }\n    if (leadingCall) {\n      isCalled = true;\n      result = func.apply(thisArg, args);\n    }\n    if (isCalled && !timeoutId && !maxTimeoutId) {\n      args = thisArg = undefined;\n    }\n    return result;\n  }\n  debounced.cancel = cancel;\n  return debounced;\n}\n\nmodule.exports = debounce;\n","/** Used as the `TypeError` message for \"Functions\" methods. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/* Native method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max;\n\n/**\n * Creates a function that invokes `func` with the `this` binding of the\n * created function and arguments from `start` and beyond provided as an array.\n *\n * **Note:** This method is based on the [rest parameter](https://developer.mozilla.org/Web/JavaScript/Reference/Functions/rest_parameters).\n *\n * @static\n * @memberOf _\n * @category Function\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @returns {Function} Returns the new function.\n * @example\n *\n * var say = _.restParam(function(what, names) {\n *   return what + ' ' + _.initial(names).join(', ') +\n *     (_.size(names) > 1 ? ', & ' : '') + _.last(names);\n * });\n *\n * say('hello', 'fred', 'barney', 'pebbles');\n * // => 'hello fred, barney, & pebbles'\n */\nfunction restParam(func, start) {\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  start = nativeMax(start === undefined ? (func.length - 1) : (+start || 0), 0);\n  return function() {\n    var args = arguments,\n        index = -1,\n        length = nativeMax(args.length - start, 0),\n        rest = Array(length);\n\n    while (++index < length) {\n      rest[index] = args[start + index];\n    }\n    switch (start) {\n      case 0: return func.call(this, rest);\n      case 1: return func.call(this, args[0], rest);\n      case 2: return func.call(this, args[0], args[1], rest);\n    }\n    var otherArgs = Array(start + 1);\n    index = -1;\n    while (++index < start) {\n      otherArgs[index] = args[index];\n    }\n    otherArgs[start] = rest;\n    return func.apply(this, otherArgs);\n  };\n}\n\nmodule.exports = restParam;\n","var cachePush = require('./cachePush'),\n    getNative = require('./getNative');\n\n/** Native method references. */\nvar Set = getNative(global, 'Set');\n\n/* Native method references for those with the same name as other `lodash` methods. */\nvar nativeCreate = getNative(Object, 'create');\n\n/**\n *\n * Creates a cache object to store unique values.\n *\n * @private\n * @param {Array} [values] The values to cache.\n */\nfunction SetCache(values) {\n  var length = values ? values.length : 0;\n\n  this.data = { 'hash': nativeCreate(null), 'set': new Set };\n  while (length--) {\n    this.push(values[length]);\n  }\n}\n\n// Add functions to the `Set` cache.\nSetCache.prototype.push = cachePush;\n\nmodule.exports = SetCache;\n","/**\n * A specialized version of `_.forEach` for arrays without support for callback\n * shorthands and `this` binding.\n *\n * @private\n * @param {Array} array The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns `array`.\n */\nfunction arrayEach(array, iteratee) {\n  var index = -1,\n      length = array.length;\n\n  while (++index < length) {\n    if (iteratee(array[index], index, array) === false) {\n      break;\n    }\n  }\n  return array;\n}\n\nmodule.exports = arrayEach;\n","/**\n * A specialized version of `_.filter` for arrays without support for callback\n * shorthands and `this` binding.\n *\n * @private\n * @param {Array} array The array to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {Array} Returns the new filtered array.\n */\nfunction arrayFilter(array, predicate) {\n  var index = -1,\n      length = array.length,\n      resIndex = -1,\n      result = [];\n\n  while (++index < length) {\n    var value = array[index];\n    if (predicate(value, index, array)) {\n      result[++resIndex] = value;\n    }\n  }\n  return result;\n}\n\nmodule.exports = arrayFilter;\n","/**\n * A specialized version of `_.map` for arrays without support for callback\n * shorthands and `this` binding.\n *\n * @private\n * @param {Array} array The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the new mapped array.\n */\nfunction arrayMap(array, iteratee) {\n  var index = -1,\n      length = array.length,\n      result = Array(length);\n\n  while (++index < length) {\n    result[index] = iteratee(array[index], index, array);\n  }\n  return result;\n}\n\nmodule.exports = arrayMap;\n","/**\n * Appends the elements of `values` to `array`.\n *\n * @private\n * @param {Array} array The array to modify.\n * @param {Array} values The values to append.\n * @returns {Array} Returns `array`.\n */\nfunction arrayPush(array, values) {\n  var index = -1,\n      length = values.length,\n      offset = array.length;\n\n  while (++index < length) {\n    array[offset + index] = values[index];\n  }\n  return array;\n}\n\nmodule.exports = arrayPush;\n","/**\n * A specialized version of `_.some` for arrays without support for callback\n * shorthands and `this` binding.\n *\n * @private\n * @param {Array} array The array to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {boolean} Returns `true` if any element passes the predicate check,\n *  else `false`.\n */\nfunction arraySome(array, predicate) {\n  var index = -1,\n      length = array.length;\n\n  while (++index < length) {\n    if (predicate(array[index], index, array)) {\n      return true;\n    }\n  }\n  return false;\n}\n\nmodule.exports = arraySome;\n","var keys = require('../object/keys');\n\n/**\n * A specialized version of `_.assign` for customizing assigned values without\n * support for argument juggling, multiple sources, and `this` binding `customizer`\n * functions.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @param {Function} customizer The function to customize assigned values.\n * @returns {Object} Returns `object`.\n */\nfunction assignWith(object, source, customizer) {\n  var index = -1,\n      props = keys(source),\n      length = props.length;\n\n  while (++index < length) {\n    var key = props[index],\n        value = object[key],\n        result = customizer(value, source[key], key, object, source);\n\n    if ((result === result ? (result !== value) : (value === value)) ||\n        (value === undefined && !(key in object))) {\n      object[key] = result;\n    }\n  }\n  return object;\n}\n\nmodule.exports = assignWith;\n","var baseCopy = require('./baseCopy'),\n    keys = require('../object/keys');\n\n/**\n * The base implementation of `_.assign` without support for argument juggling,\n * multiple sources, and `customizer` functions.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @returns {Object} Returns `object`.\n */\nfunction baseAssign(object, source) {\n  return source == null\n    ? object\n    : baseCopy(source, keys(source), object);\n}\n\nmodule.exports = baseAssign;\n","var baseMatches = require('./baseMatches'),\n    baseMatchesProperty = require('./baseMatchesProperty'),\n    bindCallback = require('./bindCallback'),\n    identity = require('../utility/identity'),\n    property = require('../utility/property');\n\n/**\n * The base implementation of `_.callback` which supports specifying the\n * number of arguments to provide to `func`.\n *\n * @private\n * @param {*} [func=_.identity] The value to convert to a callback.\n * @param {*} [thisArg] The `this` binding of `func`.\n * @param {number} [argCount] The number of arguments to provide to `func`.\n * @returns {Function} Returns the callback.\n */\nfunction baseCallback(func, thisArg, argCount) {\n  var type = typeof func;\n  if (type == 'function') {\n    return thisArg === undefined\n      ? func\n      : bindCallback(func, thisArg, argCount);\n  }\n  if (func == null) {\n    return identity;\n  }\n  if (type == 'object') {\n    return baseMatches(func);\n  }\n  return thisArg === undefined\n    ? property(func)\n    : baseMatchesProperty(func, thisArg);\n}\n\nmodule.exports = baseCallback;\n","/**\n * Copies properties of `source` to `object`.\n *\n * @private\n * @param {Object} source The object to copy properties from.\n * @param {Array} props The property names to copy.\n * @param {Object} [object={}] The object to copy properties to.\n * @returns {Object} Returns `object`.\n */\nfunction baseCopy(source, props, object) {\n  object || (object = {});\n\n  var index = -1,\n      length = props.length;\n\n  while (++index < length) {\n    var key = props[index];\n    object[key] = source[key];\n  }\n  return object;\n}\n\nmodule.exports = baseCopy;\n","var isObject = require('../lang/isObject');\n\n/**\n * The base implementation of `_.create` without support for assigning\n * properties to the created object.\n *\n * @private\n * @param {Object} prototype The object to inherit from.\n * @returns {Object} Returns the new object.\n */\nvar baseCreate = (function() {\n  function object() {}\n  return function(prototype) {\n    if (isObject(prototype)) {\n      object.prototype = prototype;\n      var result = new object;\n      object.prototype = undefined;\n    }\n    return result || {};\n  };\n}());\n\nmodule.exports = baseCreate;\n","var baseIndexOf = require('./baseIndexOf'),\n    cacheIndexOf = require('./cacheIndexOf'),\n    createCache = require('./createCache');\n\n/** Used as the size to enable large array optimizations. */\nvar LARGE_ARRAY_SIZE = 200;\n\n/**\n * The base implementation of `_.difference` which accepts a single array\n * of values to exclude.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {Array} values The values to exclude.\n * @returns {Array} Returns the new array of filtered values.\n */\nfunction baseDifference(array, values) {\n  var length = array ? array.length : 0,\n      result = [];\n\n  if (!length) {\n    return result;\n  }\n  var index = -1,\n      indexOf = baseIndexOf,\n      isCommon = true,\n      cache = (isCommon && values.length >= LARGE_ARRAY_SIZE) ? createCache(values) : null,\n      valuesLength = values.length;\n\n  if (cache) {\n    indexOf = cacheIndexOf;\n    isCommon = false;\n    values = cache;\n  }\n  outer:\n  while (++index < length) {\n    var value = array[index];\n\n    if (isCommon && value === value) {\n      var valuesIndex = valuesLength;\n      while (valuesIndex--) {\n        if (values[valuesIndex] === value) {\n          continue outer;\n        }\n      }\n      result.push(value);\n    }\n    else if (indexOf(values, value, 0) < 0) {\n      result.push(value);\n    }\n  }\n  return result;\n}\n\nmodule.exports = baseDifference;\n","var baseForOwn = require('./baseForOwn'),\n    createBaseEach = require('./createBaseEach');\n\n/**\n * The base implementation of `_.forEach` without support for callback\n * shorthands and `this` binding.\n *\n * @private\n * @param {Array|Object|string} collection The collection to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array|Object|string} Returns `collection`.\n */\nvar baseEach = createBaseEach(baseForOwn);\n\nmodule.exports = baseEach;\n","var baseEach = require('./baseEach');\n\n/**\n * The base implementation of `_.filter` without support for callback\n * shorthands and `this` binding.\n *\n * @private\n * @param {Array|Object|string} collection The collection to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {Array} Returns the new filtered array.\n */\nfunction baseFilter(collection, predicate) {\n  var result = [];\n  baseEach(collection, function(value, index, collection) {\n    if (predicate(value, index, collection)) {\n      result.push(value);\n    }\n  });\n  return result;\n}\n\nmodule.exports = baseFilter;\n","/**\n * The base implementation of `_.find`, `_.findLast`, `_.findKey`, and `_.findLastKey`,\n * without support for callback shorthands and `this` binding, which iterates\n * over `collection` using the provided `eachFunc`.\n *\n * @private\n * @param {Array|Object|string} collection The collection to search.\n * @param {Function} predicate The function invoked per iteration.\n * @param {Function} eachFunc The function to iterate over `collection`.\n * @param {boolean} [retKey] Specify returning the key of the found element\n *  instead of the element itself.\n * @returns {*} Returns the found element or its key, else `undefined`.\n */\nfunction baseFind(collection, predicate, eachFunc, retKey) {\n  var result;\n  eachFunc(collection, function(value, key, collection) {\n    if (predicate(value, key, collection)) {\n      result = retKey ? key : value;\n      return false;\n    }\n  });\n  return result;\n}\n\nmodule.exports = baseFind;\n","/**\n * The base implementation of `_.findIndex` and `_.findLastIndex` without\n * support for callback shorthands and `this` binding.\n *\n * @private\n * @param {Array} array The array to search.\n * @param {Function} predicate The function invoked per iteration.\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\nfunction baseFindIndex(array, predicate, fromRight) {\n  var length = array.length,\n      index = fromRight ? length : -1;\n\n  while ((fromRight ? index-- : ++index < length)) {\n    if (predicate(array[index], index, array)) {\n      return index;\n    }\n  }\n  return -1;\n}\n\nmodule.exports = baseFindIndex;\n","var arrayPush = require('./arrayPush'),\n    isArguments = require('../lang/isArguments'),\n    isArray = require('../lang/isArray'),\n    isArrayLike = require('./isArrayLike'),\n    isObjectLike = require('./isObjectLike');\n\n/**\n * The base implementation of `_.flatten` with added support for restricting\n * flattening and specifying the start index.\n *\n * @private\n * @param {Array} array The array to flatten.\n * @param {boolean} [isDeep] Specify a deep flatten.\n * @param {boolean} [isStrict] Restrict flattening to arrays-like objects.\n * @param {Array} [result=[]] The initial result value.\n * @returns {Array} Returns the new flattened array.\n */\nfunction baseFlatten(array, isDeep, isStrict, result) {\n  result || (result = []);\n\n  var index = -1,\n      length = array.length;\n\n  while (++index < length) {\n    var value = array[index];\n    if (isObjectLike(value) && isArrayLike(value) &&\n        (isStrict || isArray(value) || isArguments(value))) {\n      if (isDeep) {\n        // Recursively flatten arrays (susceptible to call stack limits).\n        baseFlatten(value, isDeep, isStrict, result);\n      } else {\n        arrayPush(result, value);\n      }\n    } else if (!isStrict) {\n      result[result.length] = value;\n    }\n  }\n  return result;\n}\n\nmodule.exports = baseFlatten;\n","var createBaseFor = require('./createBaseFor');\n\n/**\n * The base implementation of `baseForIn` and `baseForOwn` which iterates\n * over `object` properties returned by `keysFunc` invoking `iteratee` for\n * each property. Iteratee functions may exit iteration early by explicitly\n * returning `false`.\n *\n * @private\n * @param {Object} object The object to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @returns {Object} Returns `object`.\n */\nvar baseFor = createBaseFor();\n\nmodule.exports = baseFor;\n","var baseFor = require('./baseFor'),\n    keys = require('../object/keys');\n\n/**\n * The base implementation of `_.forOwn` without support for callback\n * shorthands and `this` binding.\n *\n * @private\n * @param {Object} object The object to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Object} Returns `object`.\n */\nfunction baseForOwn(object, iteratee) {\n  return baseFor(object, iteratee, keys);\n}\n\nmodule.exports = baseForOwn;\n","var toObject = require('./toObject');\n\n/**\n * The base implementation of `get` without support for string paths\n * and default values.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Array} path The path of the property to get.\n * @param {string} [pathKey] The key representation of path.\n * @returns {*} Returns the resolved value.\n */\nfunction baseGet(object, path, pathKey) {\n  if (object == null) {\n    return;\n  }\n  if (pathKey !== undefined && pathKey in toObject(object)) {\n    path = [pathKey];\n  }\n  var index = 0,\n      length = path.length;\n\n  while (object != null && index < length) {\n    object = object[path[index++]];\n  }\n  return (index && index == length) ? object : undefined;\n}\n\nmodule.exports = baseGet;\n","var indexOfNaN = require('./indexOfNaN');\n\n/**\n * The base implementation of `_.indexOf` without support for binary searches.\n *\n * @private\n * @param {Array} array The array to search.\n * @param {*} value The value to search for.\n * @param {number} fromIndex The index to search from.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\nfunction baseIndexOf(array, value, fromIndex) {\n  if (value !== value) {\n    return indexOfNaN(array, fromIndex);\n  }\n  var index = fromIndex - 1,\n      length = array.length;\n\n  while (++index < length) {\n    if (array[index] === value) {\n      return index;\n    }\n  }\n  return -1;\n}\n\nmodule.exports = baseIndexOf;\n","var baseIsEqualDeep = require('./baseIsEqualDeep'),\n    isObject = require('../lang/isObject'),\n    isObjectLike = require('./isObjectLike');\n\n/**\n * The base implementation of `_.isEqual` without support for `this` binding\n * `customizer` functions.\n *\n * @private\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @param {Function} [customizer] The function to customize comparing values.\n * @param {boolean} [isLoose] Specify performing partial comparisons.\n * @param {Array} [stackA] Tracks traversed `value` objects.\n * @param {Array} [stackB] Tracks traversed `other` objects.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n */\nfunction baseIsEqual(value, other, customizer, isLoose, stackA, stackB) {\n  if (value === other) {\n    return true;\n  }\n  if (value == null || other == null || (!isObject(value) && !isObjectLike(other))) {\n    return value !== value && other !== other;\n  }\n  return baseIsEqualDeep(value, other, baseIsEqual, customizer, isLoose, stackA, stackB);\n}\n\nmodule.exports = baseIsEqual;\n","var equalArrays = require('./equalArrays'),\n    equalByTag = require('./equalByTag'),\n    equalObjects = require('./equalObjects'),\n    isArray = require('../lang/isArray'),\n    isTypedArray = require('../lang/isTypedArray');\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n    arrayTag = '[object Array]',\n    objectTag = '[object Object]';\n\n/** Used for native method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objToString = objectProto.toString;\n\n/**\n * A specialized version of `baseIsEqual` for arrays and objects which performs\n * deep comparisons and tracks traversed objects enabling objects with circular\n * references to be compared.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Function} [customizer] The function to customize comparing objects.\n * @param {boolean} [isLoose] Specify performing partial comparisons.\n * @param {Array} [stackA=[]] Tracks traversed `value` objects.\n * @param {Array} [stackB=[]] Tracks traversed `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\nfunction baseIsEqualDeep(object, other, equalFunc, customizer, isLoose, stackA, stackB) {\n  var objIsArr = isArray(object),\n      othIsArr = isArray(other),\n      objTag = arrayTag,\n      othTag = arrayTag;\n\n  if (!objIsArr) {\n    objTag = objToString.call(object);\n    if (objTag == argsTag) {\n      objTag = objectTag;\n    } else if (objTag != objectTag) {\n      objIsArr = isTypedArray(object);\n    }\n  }\n  if (!othIsArr) {\n    othTag = objToString.call(other);\n    if (othTag == argsTag) {\n      othTag = objectTag;\n    } else if (othTag != objectTag) {\n      othIsArr = isTypedArray(other);\n    }\n  }\n  var objIsObj = objTag == objectTag,\n      othIsObj = othTag == objectTag,\n      isSameTag = objTag == othTag;\n\n  if (isSameTag && !(objIsArr || objIsObj)) {\n    return equalByTag(object, other, objTag);\n  }\n  if (!isLoose) {\n    var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),\n        othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');\n\n    if (objIsWrapped || othIsWrapped) {\n      return equalFunc(objIsWrapped ? object.value() : object, othIsWrapped ? other.value() : other, customizer, isLoose, stackA, stackB);\n    }\n  }\n  if (!isSameTag) {\n    return false;\n  }\n  // Assume cyclic values are equal.\n  // For more information on detecting circular references see https://es5.github.io/#JO.\n  stackA || (stackA = []);\n  stackB || (stackB = []);\n\n  var length = stackA.length;\n  while (length--) {\n    if (stackA[length] == object) {\n      return stackB[length] == other;\n    }\n  }\n  // Add `object` and `other` to the stack of traversed objects.\n  stackA.push(object);\n  stackB.push(other);\n\n  var result = (objIsArr ? equalArrays : equalObjects)(object, other, equalFunc, customizer, isLoose, stackA, stackB);\n\n  stackA.pop();\n  stackB.pop();\n\n  return result;\n}\n\nmodule.exports = baseIsEqualDeep;\n","var baseIsEqual = require('./baseIsEqual'),\n    toObject = require('./toObject');\n\n/**\n * The base implementation of `_.isMatch` without support for callback\n * shorthands and `this` binding.\n *\n * @private\n * @param {Object} object The object to inspect.\n * @param {Array} matchData The propery names, values, and compare flags to match.\n * @param {Function} [customizer] The function to customize comparing objects.\n * @returns {boolean} Returns `true` if `object` is a match, else `false`.\n */\nfunction baseIsMatch(object, matchData, customizer) {\n  var index = matchData.length,\n      length = index,\n      noCustomizer = !customizer;\n\n  if (object == null) {\n    return !length;\n  }\n  object = toObject(object);\n  while (index--) {\n    var data = matchData[index];\n    if ((noCustomizer && data[2])\n          ? data[1] !== object[data[0]]\n          : !(data[0] in object)\n        ) {\n      return false;\n    }\n  }\n  while (++index < length) {\n    data = matchData[index];\n    var key = data[0],\n        objValue = object[key],\n        srcValue = data[1];\n\n    if (noCustomizer && data[2]) {\n      if (objValue === undefined && !(key in object)) {\n        return false;\n      }\n    } else {\n      var result = customizer ? customizer(objValue, srcValue, key) : undefined;\n      if (!(result === undefined ? baseIsEqual(srcValue, objValue, customizer, true) : result)) {\n        return false;\n      }\n    }\n  }\n  return true;\n}\n\nmodule.exports = baseIsMatch;\n","var baseEach = require('./baseEach'),\n    isArrayLike = require('./isArrayLike');\n\n/**\n * The base implementation of `_.map` without support for callback shorthands\n * and `this` binding.\n *\n * @private\n * @param {Array|Object|string} collection The collection to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the new mapped array.\n */\nfunction baseMap(collection, iteratee) {\n  var index = -1,\n      result = isArrayLike(collection) ? Array(collection.length) : [];\n\n  baseEach(collection, function(value, key, collection) {\n    result[++index] = iteratee(value, key, collection);\n  });\n  return result;\n}\n\nmodule.exports = baseMap;\n","var baseIsMatch = require('./baseIsMatch'),\n    getMatchData = require('./getMatchData'),\n    toObject = require('./toObject');\n\n/**\n * The base implementation of `_.matches` which does not clone `source`.\n *\n * @private\n * @param {Object} source The object of property values to match.\n * @returns {Function} Returns the new function.\n */\nfunction baseMatches(source) {\n  var matchData = getMatchData(source);\n  if (matchData.length == 1 && matchData[0][2]) {\n    var key = matchData[0][0],\n        value = matchData[0][1];\n\n    return function(object) {\n      if (object == null) {\n        return false;\n      }\n      return object[key] === value && (value !== undefined || (key in toObject(object)));\n    };\n  }\n  return function(object) {\n    return baseIsMatch(object, matchData);\n  };\n}\n\nmodule.exports = baseMatches;\n","var baseGet = require('./baseGet'),\n    baseIsEqual = require('./baseIsEqual'),\n    baseSlice = require('./baseSlice'),\n    isArray = require('../lang/isArray'),\n    isKey = require('./isKey'),\n    isStrictComparable = require('./isStrictComparable'),\n    last = require('../array/last'),\n    toObject = require('./toObject'),\n    toPath = require('./toPath');\n\n/**\n * The base implementation of `_.matchesProperty` which does not clone `srcValue`.\n *\n * @private\n * @param {string} path The path of the property to get.\n * @param {*} srcValue The value to compare.\n * @returns {Function} Returns the new function.\n */\nfunction baseMatchesProperty(path, srcValue) {\n  var isArr = isArray(path),\n      isCommon = isKey(path) && isStrictComparable(srcValue),\n      pathKey = (path + '');\n\n  path = toPath(path);\n  return function(object) {\n    if (object == null) {\n      return false;\n    }\n    var key = pathKey;\n    object = toObject(object);\n    if ((isArr || !isCommon) && !(key in object)) {\n      object = path.length == 1 ? object : baseGet(object, baseSlice(path, 0, -1));\n      if (object == null) {\n        return false;\n      }\n      key = last(path);\n      object = toObject(object);\n    }\n    return object[key] === srcValue\n      ? (srcValue !== undefined || (key in object))\n      : baseIsEqual(srcValue, object[key], undefined, true);\n  };\n}\n\nmodule.exports = baseMatchesProperty;\n","/**\n * The base implementation of `_.property` without support for deep paths.\n *\n * @private\n * @param {string} key The key of the property to get.\n * @returns {Function} Returns the new function.\n */\nfunction baseProperty(key) {\n  return function(object) {\n    return object == null ? undefined : object[key];\n  };\n}\n\nmodule.exports = baseProperty;\n","var baseGet = require('./baseGet'),\n    toPath = require('./toPath');\n\n/**\n * A specialized version of `baseProperty` which supports deep paths.\n *\n * @private\n * @param {Array|string} path The path of the property to get.\n * @returns {Function} Returns the new function.\n */\nfunction basePropertyDeep(path) {\n  var pathKey = (path + '');\n  path = toPath(path);\n  return function(object) {\n    return baseGet(object, path, pathKey);\n  };\n}\n\nmodule.exports = basePropertyDeep;\n","/**\n * The base implementation of `_.slice` without an iteratee call guard.\n *\n * @private\n * @param {Array} array The array to slice.\n * @param {number} [start=0] The start position.\n * @param {number} [end=array.length] The end position.\n * @returns {Array} Returns the slice of `array`.\n */\nfunction baseSlice(array, start, end) {\n  var index = -1,\n      length = array.length;\n\n  start = start == null ? 0 : (+start || 0);\n  if (start < 0) {\n    start = -start > length ? 0 : (length + start);\n  }\n  end = (end === undefined || end > length) ? length : (+end || 0);\n  if (end < 0) {\n    end += length;\n  }\n  length = start > end ? 0 : ((end - start) >>> 0);\n  start >>>= 0;\n\n  var result = Array(length);\n  while (++index < length) {\n    result[index] = array[index + start];\n  }\n  return result;\n}\n\nmodule.exports = baseSlice;\n","/**\n * Converts `value` to a string if it's not one. An empty string is returned\n * for `null` or `undefined` values.\n *\n * @private\n * @param {*} value The value to process.\n * @returns {string} Returns the string.\n */\nfunction baseToString(value) {\n  return value == null ? '' : (value + '');\n}\n\nmodule.exports = baseToString;\n","var baseIndexOf = require('./baseIndexOf'),\n    cacheIndexOf = require('./cacheIndexOf'),\n    createCache = require('./createCache');\n\n/** Used as the size to enable large array optimizations. */\nvar LARGE_ARRAY_SIZE = 200;\n\n/**\n * The base implementation of `_.uniq` without support for callback shorthands\n * and `this` binding.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {Function} [iteratee] The function invoked per iteration.\n * @returns {Array} Returns the new duplicate free array.\n */\nfunction baseUniq(array, iteratee) {\n  var index = -1,\n      indexOf = baseIndexOf,\n      length = array.length,\n      isCommon = true,\n      isLarge = isCommon && length >= LARGE_ARRAY_SIZE,\n      seen = isLarge ? createCache() : null,\n      result = [];\n\n  if (seen) {\n    indexOf = cacheIndexOf;\n    isCommon = false;\n  } else {\n    isLarge = false;\n    seen = iteratee ? [] : result;\n  }\n  outer:\n  while (++index < length) {\n    var value = array[index],\n        computed = iteratee ? iteratee(value, index, array) : value;\n\n    if (isCommon && value === value) {\n      var seenIndex = seen.length;\n      while (seenIndex--) {\n        if (seen[seenIndex] === computed) {\n          continue outer;\n        }\n      }\n      if (iteratee) {\n        seen.push(computed);\n      }\n      result.push(value);\n    }\n    else if (indexOf(seen, computed, 0) < 0) {\n      if (iteratee || isLarge) {\n        seen.push(computed);\n      }\n      result.push(value);\n    }\n  }\n  return result;\n}\n\nmodule.exports = baseUniq;\n","/**\n * The base implementation of `_.values` and `_.valuesIn` which creates an\n * array of `object` property values corresponding to the property names\n * of `props`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Array} props The property names to get values for.\n * @returns {Object} Returns the array of property values.\n */\nfunction baseValues(object, props) {\n  var index = -1,\n      length = props.length,\n      result = Array(length);\n\n  while (++index < length) {\n    result[index] = object[props[index]];\n  }\n  return result;\n}\n\nmodule.exports = baseValues;\n","var identity = require('../utility/identity');\n\n/**\n * A specialized version of `baseCallback` which only supports `this` binding\n * and specifying the number of arguments to provide to `func`.\n *\n * @private\n * @param {Function} func The function to bind.\n * @param {*} thisArg The `this` binding of `func`.\n * @param {number} [argCount] The number of arguments to provide to `func`.\n * @returns {Function} Returns the callback.\n */\nfunction bindCallback(func, thisArg, argCount) {\n  if (typeof func != 'function') {\n    return identity;\n  }\n  if (thisArg === undefined) {\n    return func;\n  }\n  switch (argCount) {\n    case 1: return function(value) {\n      return func.call(thisArg, value);\n    };\n    case 3: return function(value, index, collection) {\n      return func.call(thisArg, value, index, collection);\n    };\n    case 4: return function(accumulator, value, index, collection) {\n      return func.call(thisArg, accumulator, value, index, collection);\n    };\n    case 5: return function(value, other, key, object, source) {\n      return func.call(thisArg, value, other, key, object, source);\n    };\n  }\n  return function() {\n    return func.apply(thisArg, arguments);\n  };\n}\n\nmodule.exports = bindCallback;\n","var isObject = require('../lang/isObject');\n\n/**\n * Checks if `value` is in `cache` mimicking the return signature of\n * `_.indexOf` by returning `0` if the value is found, else `-1`.\n *\n * @private\n * @param {Object} cache The cache to search.\n * @param {*} value The value to search for.\n * @returns {number} Returns `0` if `value` is found, else `-1`.\n */\nfunction cacheIndexOf(cache, value) {\n  var data = cache.data,\n      result = (typeof value == 'string' || isObject(value)) ? data.set.has(value) : data.hash[value];\n\n  return result ? 0 : -1;\n}\n\nmodule.exports = cacheIndexOf;\n","var isObject = require('../lang/isObject');\n\n/**\n * Adds `value` to the cache.\n *\n * @private\n * @name push\n * @memberOf SetCache\n * @param {*} value The value to cache.\n */\nfunction cachePush(value) {\n  var data = this.data;\n  if (typeof value == 'string' || isObject(value)) {\n    data.set.add(value);\n  } else {\n    data.hash[value] = true;\n  }\n}\n\nmodule.exports = cachePush;\n","var baseCallback = require('./baseCallback'),\n    baseEach = require('./baseEach'),\n    isArray = require('../lang/isArray');\n\n/**\n * Creates a `_.countBy`, `_.groupBy`, `_.indexBy`, or `_.partition` function.\n *\n * @private\n * @param {Function} setter The function to set keys and values of the accumulator object.\n * @param {Function} [initializer] The function to initialize the accumulator object.\n * @returns {Function} Returns the new aggregator function.\n */\nfunction createAggregator(setter, initializer) {\n  return function(collection, iteratee, thisArg) {\n    var result = initializer ? initializer() : {};\n    iteratee = baseCallback(iteratee, thisArg, 3);\n\n    if (isArray(collection)) {\n      var index = -1,\n          length = collection.length;\n\n      while (++index < length) {\n        var value = collection[index];\n        setter(result, value, iteratee(value, index, collection), collection);\n      }\n    } else {\n      baseEach(collection, function(value, key, collection) {\n        setter(result, value, iteratee(value, key, collection), collection);\n      });\n    }\n    return result;\n  };\n}\n\nmodule.exports = createAggregator;\n","var bindCallback = require('./bindCallback'),\n    isIterateeCall = require('./isIterateeCall'),\n    restParam = require('../function/restParam');\n\n/**\n * Creates a `_.assign`, `_.defaults`, or `_.merge` function.\n *\n * @private\n * @param {Function} assigner The function to assign values.\n * @returns {Function} Returns the new assigner function.\n */\nfunction createAssigner(assigner) {\n  return restParam(function(object, sources) {\n    var index = -1,\n        length = object == null ? 0 : sources.length,\n        customizer = length > 2 ? sources[length - 2] : undefined,\n        guard = length > 2 ? sources[2] : undefined,\n        thisArg = length > 1 ? sources[length - 1] : undefined;\n\n    if (typeof customizer == 'function') {\n      customizer = bindCallback(customizer, thisArg, 5);\n      length -= 2;\n    } else {\n      customizer = typeof thisArg == 'function' ? thisArg : undefined;\n      length -= (customizer ? 1 : 0);\n    }\n    if (guard && isIterateeCall(sources[0], sources[1], guard)) {\n      customizer = length < 3 ? undefined : customizer;\n      length = 1;\n    }\n    while (++index < length) {\n      var source = sources[index];\n      if (source) {\n        assigner(object, source, customizer);\n      }\n    }\n    return object;\n  });\n}\n\nmodule.exports = createAssigner;\n","var getLength = require('./getLength'),\n    isLength = require('./isLength'),\n    toObject = require('./toObject');\n\n/**\n * Creates a `baseEach` or `baseEachRight` function.\n *\n * @private\n * @param {Function} eachFunc The function to iterate over a collection.\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {Function} Returns the new base function.\n */\nfunction createBaseEach(eachFunc, fromRight) {\n  return function(collection, iteratee) {\n    var length = collection ? getLength(collection) : 0;\n    if (!isLength(length)) {\n      return eachFunc(collection, iteratee);\n    }\n    var index = fromRight ? length : -1,\n        iterable = toObject(collection);\n\n    while ((fromRight ? index-- : ++index < length)) {\n      if (iteratee(iterable[index], index, iterable) === false) {\n        break;\n      }\n    }\n    return collection;\n  };\n}\n\nmodule.exports = createBaseEach;\n","var toObject = require('./toObject');\n\n/**\n * Creates a base function for `_.forIn` or `_.forInRight`.\n *\n * @private\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {Function} Returns the new base function.\n */\nfunction createBaseFor(fromRight) {\n  return function(object, iteratee, keysFunc) {\n    var iterable = toObject(object),\n        props = keysFunc(object),\n        length = props.length,\n        index = fromRight ? length : -1;\n\n    while ((fromRight ? index-- : ++index < length)) {\n      var key = props[index];\n      if (iteratee(iterable[key], key, iterable) === false) {\n        break;\n      }\n    }\n    return object;\n  };\n}\n\nmodule.exports = createBaseFor;\n","var SetCache = require('./SetCache'),\n    getNative = require('./getNative');\n\n/** Native method references. */\nvar Set = getNative(global, 'Set');\n\n/* Native method references for those with the same name as other `lodash` methods. */\nvar nativeCreate = getNative(Object, 'create');\n\n/**\n * Creates a `Set` cache object to optimize linear searches of large arrays.\n *\n * @private\n * @param {Array} [values] The values to cache.\n * @returns {null|Object} Returns the new cache object if `Set` is supported, else `null`.\n */\nfunction createCache(values) {\n  return (nativeCreate && Set) ? new SetCache(values) : null;\n}\n\nmodule.exports = createCache;\n","var baseCallback = require('./baseCallback'),\n    baseFind = require('./baseFind'),\n    baseFindIndex = require('./baseFindIndex'),\n    isArray = require('../lang/isArray');\n\n/**\n * Creates a `_.find` or `_.findLast` function.\n *\n * @private\n * @param {Function} eachFunc The function to iterate over a collection.\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {Function} Returns the new find function.\n */\nfunction createFind(eachFunc, fromRight) {\n  return function(collection, predicate, thisArg) {\n    predicate = baseCallback(predicate, thisArg, 3);\n    if (isArray(collection)) {\n      var index = baseFindIndex(collection, predicate, fromRight);\n      return index > -1 ? collection[index] : undefined;\n    }\n    return baseFind(collection, predicate, eachFunc);\n  };\n}\n\nmodule.exports = createFind;\n","var bindCallback = require('./bindCallback'),\n    isArray = require('../lang/isArray');\n\n/**\n * Creates a function for `_.forEach` or `_.forEachRight`.\n *\n * @private\n * @param {Function} arrayFunc The function to iterate over an array.\n * @param {Function} eachFunc The function to iterate over a collection.\n * @returns {Function} Returns the new each function.\n */\nfunction createForEach(arrayFunc, eachFunc) {\n  return function(collection, iteratee, thisArg) {\n    return (typeof iteratee == 'function' && thisArg === undefined && isArray(collection))\n      ? arrayFunc(collection, iteratee)\n      : eachFunc(collection, bindCallback(iteratee, thisArg, 3));\n  };\n}\n\nmodule.exports = createForEach;\n","var arraySome = require('./arraySome');\n\n/**\n * A specialized version of `baseIsEqualDeep` for arrays with support for\n * partial deep comparisons.\n *\n * @private\n * @param {Array} array The array to compare.\n * @param {Array} other The other array to compare.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Function} [customizer] The function to customize comparing arrays.\n * @param {boolean} [isLoose] Specify performing partial comparisons.\n * @param {Array} [stackA] Tracks traversed `value` objects.\n * @param {Array} [stackB] Tracks traversed `other` objects.\n * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.\n */\nfunction equalArrays(array, other, equalFunc, customizer, isLoose, stackA, stackB) {\n  var index = -1,\n      arrLength = array.length,\n      othLength = other.length;\n\n  if (arrLength != othLength && !(isLoose && othLength > arrLength)) {\n    return false;\n  }\n  // Ignore non-index properties.\n  while (++index < arrLength) {\n    var arrValue = array[index],\n        othValue = other[index],\n        result = customizer ? customizer(isLoose ? othValue : arrValue, isLoose ? arrValue : othValue, index) : undefined;\n\n    if (result !== undefined) {\n      if (result) {\n        continue;\n      }\n      return false;\n    }\n    // Recursively compare arrays (susceptible to call stack limits).\n    if (isLoose) {\n      if (!arraySome(other, function(othValue) {\n            return arrValue === othValue || equalFunc(arrValue, othValue, customizer, isLoose, stackA, stackB);\n          })) {\n        return false;\n      }\n    } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, customizer, isLoose, stackA, stackB))) {\n      return false;\n    }\n  }\n  return true;\n}\n\nmodule.exports = equalArrays;\n","/** `Object#toString` result references. */\nvar boolTag = '[object Boolean]',\n    dateTag = '[object Date]',\n    errorTag = '[object Error]',\n    numberTag = '[object Number]',\n    regexpTag = '[object RegExp]',\n    stringTag = '[object String]';\n\n/**\n * A specialized version of `baseIsEqualDeep` for comparing objects of\n * the same `toStringTag`.\n *\n * **Note:** This function only supports comparing values with tags of\n * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {string} tag The `toStringTag` of the objects to compare.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\nfunction equalByTag(object, other, tag) {\n  switch (tag) {\n    case boolTag:\n    case dateTag:\n      // Coerce dates and booleans to numbers, dates to milliseconds and booleans\n      // to `1` or `0` treating invalid dates coerced to `NaN` as not equal.\n      return +object == +other;\n\n    case errorTag:\n      return object.name == other.name && object.message == other.message;\n\n    case numberTag:\n      // Treat `NaN` vs. `NaN` as equal.\n      return (object != +object)\n        ? other != +other\n        : object == +other;\n\n    case regexpTag:\n    case stringTag:\n      // Coerce regexes to strings and treat strings primitives and string\n      // objects as equal. See https://es5.github.io/#x15.10.6.4 for more details.\n      return object == (other + '');\n  }\n  return false;\n}\n\nmodule.exports = equalByTag;\n","var keys = require('../object/keys');\n\n/** Used for native method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * A specialized version of `baseIsEqualDeep` for objects with support for\n * partial deep comparisons.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Function} [customizer] The function to customize comparing values.\n * @param {boolean} [isLoose] Specify performing partial comparisons.\n * @param {Array} [stackA] Tracks traversed `value` objects.\n * @param {Array} [stackB] Tracks traversed `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\nfunction equalObjects(object, other, equalFunc, customizer, isLoose, stackA, stackB) {\n  var objProps = keys(object),\n      objLength = objProps.length,\n      othProps = keys(other),\n      othLength = othProps.length;\n\n  if (objLength != othLength && !isLoose) {\n    return false;\n  }\n  var index = objLength;\n  while (index--) {\n    var key = objProps[index];\n    if (!(isLoose ? key in other : hasOwnProperty.call(other, key))) {\n      return false;\n    }\n  }\n  var skipCtor = isLoose;\n  while (++index < objLength) {\n    key = objProps[index];\n    var objValue = object[key],\n        othValue = other[key],\n        result = customizer ? customizer(isLoose ? othValue : objValue, isLoose? objValue : othValue, key) : undefined;\n\n    // Recursively compare objects (susceptible to call stack limits).\n    if (!(result === undefined ? equalFunc(objValue, othValue, customizer, isLoose, stackA, stackB) : result)) {\n      return false;\n    }\n    skipCtor || (skipCtor = key == 'constructor');\n  }\n  if (!skipCtor) {\n    var objCtor = object.constructor,\n        othCtor = other.constructor;\n\n    // Non `Object` object instances with different constructors are not equal.\n    if (objCtor != othCtor &&\n        ('constructor' in object && 'constructor' in other) &&\n        !(typeof objCtor == 'function' && objCtor instanceof objCtor &&\n          typeof othCtor == 'function' && othCtor instanceof othCtor)) {\n      return false;\n    }\n  }\n  return true;\n}\n\nmodule.exports = equalObjects;\n","var baseProperty = require('./baseProperty');\n\n/**\n * Gets the \"length\" property value of `object`.\n *\n * **Note:** This function is used to avoid a [JIT bug](https://bugs.webkit.org/show_bug.cgi?id=142792)\n * that affects Safari on at least iOS 8.1-8.3 ARM64.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {*} Returns the \"length\" value.\n */\nvar getLength = baseProperty('length');\n\nmodule.exports = getLength;\n","var isStrictComparable = require('./isStrictComparable'),\n    pairs = require('../object/pairs');\n\n/**\n * Gets the propery names, values, and compare flags of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the match data of `object`.\n */\nfunction getMatchData(object) {\n  var result = pairs(object),\n      length = result.length;\n\n  while (length--) {\n    result[length][2] = isStrictComparable(result[length][1]);\n  }\n  return result;\n}\n\nmodule.exports = getMatchData;\n","var isNative = require('../lang/isNative');\n\n/**\n * Gets the native function at `key` of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the method to get.\n * @returns {*} Returns the function if it's native, else `undefined`.\n */\nfunction getNative(object, key) {\n  var value = object == null ? undefined : object[key];\n  return isNative(value) ? value : undefined;\n}\n\nmodule.exports = getNative;\n","/**\n * Gets the index at which the first occurrence of `NaN` is found in `array`.\n *\n * @private\n * @param {Array} array The array to search.\n * @param {number} fromIndex The index to search from.\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {number} Returns the index of the matched `NaN`, else `-1`.\n */\nfunction indexOfNaN(array, fromIndex, fromRight) {\n  var length = array.length,\n      index = fromIndex + (fromRight ? 0 : -1);\n\n  while ((fromRight ? index-- : ++index < length)) {\n    var other = array[index];\n    if (other !== other) {\n      return index;\n    }\n  }\n  return -1;\n}\n\nmodule.exports = indexOfNaN;\n","var getLength = require('./getLength'),\n    isLength = require('./isLength');\n\n/**\n * Checks if `value` is array-like.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n */\nfunction isArrayLike(value) {\n  return value != null && isLength(getLength(value));\n}\n\nmodule.exports = isArrayLike;\n","/** Used to detect unsigned integer values. */\nvar reIsUint = /^\\d+$/;\n\n/**\n * Used as the [maximum length](http://ecma-international.org/ecma-262/6.0/#sec-number.max_safe_integer)\n * of an array-like value.\n */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/**\n * Checks if `value` is a valid array-like index.\n *\n * @private\n * @param {*} value The value to check.\n * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n */\nfunction isIndex(value, length) {\n  value = (typeof value == 'number' || reIsUint.test(value)) ? +value : -1;\n  length = length == null ? MAX_SAFE_INTEGER : length;\n  return value > -1 && value % 1 == 0 && value < length;\n}\n\nmodule.exports = isIndex;\n","var isArrayLike = require('./isArrayLike'),\n    isIndex = require('./isIndex'),\n    isObject = require('../lang/isObject');\n\n/**\n * Checks if the provided arguments are from an iteratee call.\n *\n * @private\n * @param {*} value The potential iteratee value argument.\n * @param {*} index The potential iteratee index or key argument.\n * @param {*} object The potential iteratee object argument.\n * @returns {boolean} Returns `true` if the arguments are from an iteratee call, else `false`.\n */\nfunction isIterateeCall(value, index, object) {\n  if (!isObject(object)) {\n    return false;\n  }\n  var type = typeof index;\n  if (type == 'number'\n      ? (isArrayLike(object) && isIndex(index, object.length))\n      : (type == 'string' && index in object)) {\n    var other = object[index];\n    return value === value ? (value === other) : (other !== other);\n  }\n  return false;\n}\n\nmodule.exports = isIterateeCall;\n","var isArray = require('../lang/isArray'),\n    toObject = require('./toObject');\n\n/** Used to match property names within property paths. */\nvar reIsDeepProp = /\\.|\\[(?:[^[\\]]*|([\"'])(?:(?!\\1)[^\\n\\\\]|\\\\.)*?\\1)\\]/,\n    reIsPlainProp = /^\\w*$/;\n\n/**\n * Checks if `value` is a property name and not a property path.\n *\n * @private\n * @param {*} value The value to check.\n * @param {Object} [object] The object to query keys on.\n * @returns {boolean} Returns `true` if `value` is a property name, else `false`.\n */\nfunction isKey(value, object) {\n  var type = typeof value;\n  if ((type == 'string' && reIsPlainProp.test(value)) || type == 'number') {\n    return true;\n  }\n  if (isArray(value)) {\n    return false;\n  }\n  var result = !reIsDeepProp.test(value);\n  return result || (object != null && value in toObject(object));\n}\n\nmodule.exports = isKey;\n","/**\n * Used as the [maximum length](http://ecma-international.org/ecma-262/6.0/#sec-number.max_safe_integer)\n * of an array-like value.\n */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/**\n * Checks if `value` is a valid array-like length.\n *\n * **Note:** This function is based on [`ToLength`](http://ecma-international.org/ecma-262/6.0/#sec-tolength).\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n */\nfunction isLength(value) {\n  return typeof value == 'number' && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n}\n\nmodule.exports = isLength;\n","/**\n * Checks if `value` is object-like.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n */\nfunction isObjectLike(value) {\n  return !!value && typeof value == 'object';\n}\n\nmodule.exports = isObjectLike;\n","var isObject = require('../lang/isObject');\n\n/**\n * Checks if `value` is suitable for strict equality comparisons, i.e. `===`.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` if suitable for strict\n *  equality comparisons, else `false`.\n */\nfunction isStrictComparable(value) {\n  return value === value && !isObject(value);\n}\n\nmodule.exports = isStrictComparable;\n","var isArguments = require('../lang/isArguments'),\n    isArray = require('../lang/isArray'),\n    isIndex = require('./isIndex'),\n    isLength = require('./isLength'),\n    keysIn = require('../object/keysIn');\n\n/** Used for native method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * A fallback implementation of `Object.keys` which creates an array of the\n * own enumerable property names of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction shimKeys(object) {\n  var props = keysIn(object),\n      propsLength = props.length,\n      length = propsLength && object.length;\n\n  var allowIndexes = !!length && isLength(length) &&\n    (isArray(object) || isArguments(object));\n\n  var index = -1,\n      result = [];\n\n  while (++index < propsLength) {\n    var key = props[index];\n    if ((allowIndexes && isIndex(key, length)) || hasOwnProperty.call(object, key)) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\nmodule.exports = shimKeys;\n","var isObject = require('../lang/isObject');\n\n/**\n * Converts `value` to an object if it's not one.\n *\n * @private\n * @param {*} value The value to process.\n * @returns {Object} Returns the object.\n */\nfunction toObject(value) {\n  return isObject(value) ? value : Object(value);\n}\n\nmodule.exports = toObject;\n","var baseToString = require('./baseToString'),\n    isArray = require('../lang/isArray');\n\n/** Used to match property names within property paths. */\nvar rePropName = /[^.[\\]]+|\\[(?:(-?\\d+(?:\\.\\d+)?)|([\"'])((?:(?!\\2)[^\\n\\\\]|\\\\.)*?)\\2)\\]/g;\n\n/** Used to match backslashes in property paths. */\nvar reEscapeChar = /\\\\(\\\\)?/g;\n\n/**\n * Converts `value` to property path array if it's not one.\n *\n * @private\n * @param {*} value The value to process.\n * @returns {Array} Returns the property path array.\n */\nfunction toPath(value) {\n  if (isArray(value)) {\n    return value;\n  }\n  var result = [];\n  baseToString(value).replace(rePropName, function(match, number, quote, string) {\n    result.push(quote ? string.replace(reEscapeChar, '$1') : (number || match));\n  });\n  return result;\n}\n\nmodule.exports = toPath;\n","var isArrayLike = require('../internal/isArrayLike'),\n    isObjectLike = require('../internal/isObjectLike');\n\n/** Used for native method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Native method references. */\nvar propertyIsEnumerable = objectProto.propertyIsEnumerable;\n\n/**\n * Checks if `value` is classified as an `arguments` object.\n *\n * @static\n * @memberOf _\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.\n * @example\n *\n * _.isArguments(function() { return arguments; }());\n * // => true\n *\n * _.isArguments([1, 2, 3]);\n * // => false\n */\nfunction isArguments(value) {\n  return isObjectLike(value) && isArrayLike(value) &&\n    hasOwnProperty.call(value, 'callee') && !propertyIsEnumerable.call(value, 'callee');\n}\n\nmodule.exports = isArguments;\n","var getNative = require('../internal/getNative'),\n    isLength = require('../internal/isLength'),\n    isObjectLike = require('../internal/isObjectLike');\n\n/** `Object#toString` result references. */\nvar arrayTag = '[object Array]';\n\n/** Used for native method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objToString = objectProto.toString;\n\n/* Native method references for those with the same name as other `lodash` methods. */\nvar nativeIsArray = getNative(Array, 'isArray');\n\n/**\n * Checks if `value` is classified as an `Array` object.\n *\n * @static\n * @memberOf _\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.\n * @example\n *\n * _.isArray([1, 2, 3]);\n * // => true\n *\n * _.isArray(function() { return arguments; }());\n * // => false\n */\nvar isArray = nativeIsArray || function(value) {\n  return isObjectLike(value) && isLength(value.length) && objToString.call(value) == arrayTag;\n};\n\nmodule.exports = isArray;\n","var isArguments = require('./isArguments'),\n    isArray = require('./isArray'),\n    isArrayLike = require('../internal/isArrayLike'),\n    isFunction = require('./isFunction'),\n    isObjectLike = require('../internal/isObjectLike'),\n    isString = require('./isString'),\n    keys = require('../object/keys');\n\n/**\n * Checks if `value` is empty. A value is considered empty unless it's an\n * `arguments` object, array, string, or jQuery-like collection with a length\n * greater than `0` or an object with own enumerable properties.\n *\n * @static\n * @memberOf _\n * @category Lang\n * @param {Array|Object|string} value The value to inspect.\n * @returns {boolean} Returns `true` if `value` is empty, else `false`.\n * @example\n *\n * _.isEmpty(null);\n * // => true\n *\n * _.isEmpty(true);\n * // => true\n *\n * _.isEmpty(1);\n * // => true\n *\n * _.isEmpty([1, 2, 3]);\n * // => false\n *\n * _.isEmpty({ 'a': 1 });\n * // => false\n */\nfunction isEmpty(value) {\n  if (value == null) {\n    return true;\n  }\n  if (isArrayLike(value) && (isArray(value) || isString(value) || isArguments(value) ||\n      (isObjectLike(value) && isFunction(value.splice)))) {\n    return !value.length;\n  }\n  return !keys(value).length;\n}\n\nmodule.exports = isEmpty;\n","var isObject = require('./isObject');\n\n/** `Object#toString` result references. */\nvar funcTag = '[object Function]';\n\n/** Used for native method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objToString = objectProto.toString;\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\nfunction isFunction(value) {\n  // The use of `Object#toString` avoids issues with the `typeof` operator\n  // in older versions of Chrome and Safari which return 'function' for regexes\n  // and Safari 8 which returns 'object' for typed array constructors.\n  return isObject(value) && objToString.call(value) == funcTag;\n}\n\nmodule.exports = isFunction;\n","var isFunction = require('./isFunction'),\n    isObjectLike = require('../internal/isObjectLike');\n\n/** Used to detect host constructors (Safari > 5). */\nvar reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n/** Used for native method references. */\nvar objectProto = Object.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar fnToString = Function.prototype.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Used to detect if a method is native. */\nvar reIsNative = RegExp('^' +\n  fnToString.call(hasOwnProperty).replace(/[\\\\^$.*+?()[\\]{}|]/g, '\\\\$&')\n  .replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$'\n);\n\n/**\n * Checks if `value` is a native function.\n *\n * @static\n * @memberOf _\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a native function, else `false`.\n * @example\n *\n * _.isNative(Array.prototype.push);\n * // => true\n *\n * _.isNative(_);\n * // => false\n */\nfunction isNative(value) {\n  if (value == null) {\n    return false;\n  }\n  if (isFunction(value)) {\n    return reIsNative.test(fnToString.call(value));\n  }\n  return isObjectLike(value) && reIsHostCtor.test(value);\n}\n\nmodule.exports = isNative;\n","/**\n * Checks if `value` is the [language type](https://es5.github.io/#x8) of `Object`.\n * (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(1);\n * // => false\n */\nfunction isObject(value) {\n  // Avoid a V8 JIT bug in Chrome 19-20.\n  // See https://code.google.com/p/v8/issues/detail?id=2291 for more details.\n  var type = typeof value;\n  return !!value && (type == 'object' || type == 'function');\n}\n\nmodule.exports = isObject;\n","var isObjectLike = require('../internal/isObjectLike');\n\n/** `Object#toString` result references. */\nvar stringTag = '[object String]';\n\n/** Used for native method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objToString = objectProto.toString;\n\n/**\n * Checks if `value` is classified as a `String` primitive or object.\n *\n * @static\n * @memberOf _\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.\n * @example\n *\n * _.isString('abc');\n * // => true\n *\n * _.isString(1);\n * // => false\n */\nfunction isString(value) {\n  return typeof value == 'string' || (isObjectLike(value) && objToString.call(value) == stringTag);\n}\n\nmodule.exports = isString;\n","var isLength = require('../internal/isLength'),\n    isObjectLike = require('../internal/isObjectLike');\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n    arrayTag = '[object Array]',\n    boolTag = '[object Boolean]',\n    dateTag = '[object Date]',\n    errorTag = '[object Error]',\n    funcTag = '[object Function]',\n    mapTag = '[object Map]',\n    numberTag = '[object Number]',\n    objectTag = '[object Object]',\n    regexpTag = '[object RegExp]',\n    setTag = '[object Set]',\n    stringTag = '[object String]',\n    weakMapTag = '[object WeakMap]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n    float32Tag = '[object Float32Array]',\n    float64Tag = '[object Float64Array]',\n    int8Tag = '[object Int8Array]',\n    int16Tag = '[object Int16Array]',\n    int32Tag = '[object Int32Array]',\n    uint8Tag = '[object Uint8Array]',\n    uint8ClampedTag = '[object Uint8ClampedArray]',\n    uint16Tag = '[object Uint16Array]',\n    uint32Tag = '[object Uint32Array]';\n\n/** Used to identify `toStringTag` values of typed arrays. */\nvar typedArrayTags = {};\ntypedArrayTags[float32Tag] = typedArrayTags[float64Tag] =\ntypedArrayTags[int8Tag] = typedArrayTags[int16Tag] =\ntypedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =\ntypedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =\ntypedArrayTags[uint32Tag] = true;\ntypedArrayTags[argsTag] = typedArrayTags[arrayTag] =\ntypedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =\ntypedArrayTags[dateTag] = typedArrayTags[errorTag] =\ntypedArrayTags[funcTag] = typedArrayTags[mapTag] =\ntypedArrayTags[numberTag] = typedArrayTags[objectTag] =\ntypedArrayTags[regexpTag] = typedArrayTags[setTag] =\ntypedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;\n\n/** Used for native method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objToString = objectProto.toString;\n\n/**\n * Checks if `value` is classified as a typed array.\n *\n * @static\n * @memberOf _\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.\n * @example\n *\n * _.isTypedArray(new Uint8Array);\n * // => true\n *\n * _.isTypedArray([]);\n * // => false\n */\nfunction isTypedArray(value) {\n  return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[objToString.call(value)];\n}\n\nmodule.exports = isTypedArray;\n","var assignWith = require('../internal/assignWith'),\n    baseAssign = require('../internal/baseAssign'),\n    createAssigner = require('../internal/createAssigner');\n\n/**\n * Assigns own enumerable properties of source object(s) to the destination\n * object. Subsequent sources overwrite property assignments of previous sources.\n * If `customizer` is provided it's invoked to produce the assigned values.\n * The `customizer` is bound to `thisArg` and invoked with five arguments:\n * (objectValue, sourceValue, key, object, source).\n *\n * **Note:** This method mutates `object` and is based on\n * [`Object.assign`](http://ecma-international.org/ecma-262/6.0/#sec-object.assign).\n *\n * @static\n * @memberOf _\n * @alias extend\n * @category Object\n * @param {Object} object The destination object.\n * @param {...Object} [sources] The source objects.\n * @param {Function} [customizer] The function to customize assigned values.\n * @param {*} [thisArg] The `this` binding of `customizer`.\n * @returns {Object} Returns `object`.\n * @example\n *\n * _.assign({ 'user': 'barney' }, { 'age': 40 }, { 'user': 'fred' });\n * // => { 'user': 'fred', 'age': 40 }\n *\n * // using a customizer callback\n * var defaults = _.partialRight(_.assign, function(value, other) {\n *   return _.isUndefined(value) ? other : value;\n * });\n *\n * defaults({ 'user': 'barney' }, { 'age': 36 }, { 'user': 'fred' });\n * // => { 'user': 'barney', 'age': 36 }\n */\nvar assign = createAssigner(function(object, source, customizer) {\n  return customizer\n    ? assignWith(object, source, customizer)\n    : baseAssign(object, source);\n});\n\nmodule.exports = assign;\n","var baseGet = require('../internal/baseGet'),\n    toPath = require('../internal/toPath');\n\n/**\n * Gets the property value at `path` of `object`. If the resolved value is\n * `undefined` the `defaultValue` is used in its place.\n *\n * @static\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @param {Array|string} path The path of the property to get.\n * @param {*} [defaultValue] The value returned if the resolved value is `undefined`.\n * @returns {*} Returns the resolved value.\n * @example\n *\n * var object = { 'a': [{ 'b': { 'c': 3 } }] };\n *\n * _.get(object, 'a[0].b.c');\n * // => 3\n *\n * _.get(object, ['a', '0', 'b', 'c']);\n * // => 3\n *\n * _.get(object, 'a.b.c', 'default');\n * // => 'default'\n */\nfunction get(object, path, defaultValue) {\n  var result = object == null ? undefined : baseGet(object, toPath(path), (path + ''));\n  return result === undefined ? defaultValue : result;\n}\n\nmodule.exports = get;\n","var getNative = require('../internal/getNative'),\n    isArrayLike = require('../internal/isArrayLike'),\n    isObject = require('../lang/isObject'),\n    shimKeys = require('../internal/shimKeys');\n\n/* Native method references for those with the same name as other `lodash` methods. */\nvar nativeKeys = getNative(Object, 'keys');\n\n/**\n * Creates an array of the own enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects. See the\n * [ES spec](http://ecma-international.org/ecma-262/6.0/#sec-object.keys)\n * for more details.\n *\n * @static\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keys(new Foo);\n * // => ['a', 'b'] (iteration order is not guaranteed)\n *\n * _.keys('hi');\n * // => ['0', '1']\n */\nvar keys = !nativeKeys ? shimKeys : function(object) {\n  var Ctor = object == null ? undefined : object.constructor;\n  if ((typeof Ctor == 'function' && Ctor.prototype === object) ||\n      (typeof object != 'function' && isArrayLike(object))) {\n    return shimKeys(object);\n  }\n  return isObject(object) ? nativeKeys(object) : [];\n};\n\nmodule.exports = keys;\n","var isArguments = require('../lang/isArguments'),\n    isArray = require('../lang/isArray'),\n    isIndex = require('../internal/isIndex'),\n    isLength = require('../internal/isLength'),\n    isObject = require('../lang/isObject');\n\n/** Used for native method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Creates an array of the own and inherited enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects.\n *\n * @static\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keysIn(new Foo);\n * // => ['a', 'b', 'c'] (iteration order is not guaranteed)\n */\nfunction keysIn(object) {\n  if (object == null) {\n    return [];\n  }\n  if (!isObject(object)) {\n    object = Object(object);\n  }\n  var length = object.length;\n  length = (length && isLength(length) &&\n    (isArray(object) || isArguments(object)) && length) || 0;\n\n  var Ctor = object.constructor,\n      index = -1,\n      isProto = typeof Ctor == 'function' && Ctor.prototype === object,\n      result = Array(length),\n      skipIndexes = length > 0;\n\n  while (++index < length) {\n    result[index] = (index + '');\n  }\n  for (var key in object) {\n    if (!(skipIndexes && isIndex(key, length)) &&\n        !(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\nmodule.exports = keysIn;\n","var keys = require('./keys'),\n    toObject = require('../internal/toObject');\n\n/**\n * Creates a two dimensional array of the key-value pairs for `object`,\n * e.g. `[[key1, value1], [key2, value2]]`.\n *\n * @static\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the new array of key-value pairs.\n * @example\n *\n * _.pairs({ 'barney': 36, 'fred': 40 });\n * // => [['barney', 36], ['fred', 40]] (iteration order is not guaranteed)\n */\nfunction pairs(object) {\n  object = toObject(object);\n\n  var index = -1,\n      props = keys(object),\n      length = props.length,\n      result = Array(length);\n\n  while (++index < length) {\n    var key = props[index];\n    result[index] = [key, object[key]];\n  }\n  return result;\n}\n\nmodule.exports = pairs;\n","var arrayEach = require('../internal/arrayEach'),\n    baseCallback = require('../internal/baseCallback'),\n    baseCreate = require('../internal/baseCreate'),\n    baseForOwn = require('../internal/baseForOwn'),\n    isArray = require('../lang/isArray'),\n    isFunction = require('../lang/isFunction'),\n    isObject = require('../lang/isObject'),\n    isTypedArray = require('../lang/isTypedArray');\n\n/**\n * An alternative to `_.reduce`; this method transforms `object` to a new\n * `accumulator` object which is the result of running each of its own enumerable\n * properties through `iteratee`, with each invocation potentially mutating\n * the `accumulator` object. The `iteratee` is bound to `thisArg` and invoked\n * with four arguments: (accumulator, value, key, object). Iteratee functions\n * may exit iteration early by explicitly returning `false`.\n *\n * @static\n * @memberOf _\n * @category Object\n * @param {Array|Object} object The object to iterate over.\n * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n * @param {*} [accumulator] The custom accumulator value.\n * @param {*} [thisArg] The `this` binding of `iteratee`.\n * @returns {*} Returns the accumulated value.\n * @example\n *\n * _.transform([2, 3, 4], function(result, n) {\n *   result.push(n *= n);\n *   return n % 2 == 0;\n * });\n * // => [4, 9]\n *\n * _.transform({ 'a': 1, 'b': 2 }, function(result, n, key) {\n *   result[key] = n * 3;\n * });\n * // => { 'a': 3, 'b': 6 }\n */\nfunction transform(object, iteratee, accumulator, thisArg) {\n  var isArr = isArray(object) || isTypedArray(object);\n  iteratee = baseCallback(iteratee, thisArg, 4);\n\n  if (accumulator == null) {\n    if (isArr || isObject(object)) {\n      var Ctor = object.constructor;\n      if (isArr) {\n        accumulator = isArray(object) ? new Ctor : [];\n      } else {\n        accumulator = baseCreate(isFunction(Ctor) ? Ctor.prototype : undefined);\n      }\n    } else {\n      accumulator = {};\n    }\n  }\n  (isArr ? arrayEach : baseForOwn)(object, function(value, index, object) {\n    return iteratee(accumulator, value, index, object);\n  });\n  return accumulator;\n}\n\nmodule.exports = transform;\n","var baseValues = require('../internal/baseValues'),\n    keys = require('./keys');\n\n/**\n * Creates an array of the own enumerable property values of `object`.\n *\n * **Note:** Non-object values are coerced to objects.\n *\n * @static\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property values.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.values(new Foo);\n * // => [1, 2] (iteration order is not guaranteed)\n *\n * _.values('hi');\n * // => ['h', 'i']\n */\nfunction values(object) {\n  return baseValues(object, keys(object));\n}\n\nmodule.exports = values;\n","/**\n * This method returns the first argument provided to it.\n *\n * @static\n * @memberOf _\n * @category Utility\n * @param {*} value Any value.\n * @returns {*} Returns `value`.\n * @example\n *\n * var object = { 'user': 'fred' };\n *\n * _.identity(object) === object;\n * // => true\n */\nfunction identity(value) {\n  return value;\n}\n\nmodule.exports = identity;\n","var baseProperty = require('../internal/baseProperty'),\n    basePropertyDeep = require('../internal/basePropertyDeep'),\n    isKey = require('../internal/isKey');\n\n/**\n * Creates a function that returns the property value at `path` on a\n * given object.\n *\n * @static\n * @memberOf _\n * @category Utility\n * @param {Array|string} path The path of the property to get.\n * @returns {Function} Returns the new function.\n * @example\n *\n * var objects = [\n *   { 'a': { 'b': { 'c': 2 } } },\n *   { 'a': { 'b': { 'c': 1 } } }\n * ];\n *\n * _.map(objects, _.property('a.b.c'));\n * // => [2, 1]\n *\n * _.pluck(_.sortBy(objects, _.property(['a', 'b', 'c'])), 'a.b.c');\n * // => [1, 2]\n */\nfunction property(path) {\n  return isKey(path) ? baseProperty(path) : basePropertyDeep(path);\n}\n\nmodule.exports = property;\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\n/**\n * Flatten array, one level deep.\n *\n * @param {Array<?>} arr\n *\n * @return {Array<?>}\n */\nfunction flatten(arr) {\n  return Array.prototype.concat.apply([], arr);\n}\n\nvar nativeToString = Object.prototype.toString;\nvar nativeHasOwnProperty = Object.prototype.hasOwnProperty;\n\nfunction isUndefined(obj) {\n  return obj === undefined;\n}\n\nfunction isDefined(obj) {\n  return obj !== undefined;\n}\n\nfunction isNil(obj) {\n  return obj == null;\n}\n\nfunction isArray(obj) {\n  return nativeToString.call(obj) === '[object Array]';\n}\n\nfunction isObject(obj) {\n  return nativeToString.call(obj) === '[object Object]';\n}\n\nfunction isNumber(obj) {\n  return nativeToString.call(obj) === '[object Number]';\n}\n\nfunction isFunction(obj) {\n  return nativeToString.call(obj) === '[object Function]';\n}\n\nfunction isString(obj) {\n  return nativeToString.call(obj) === '[object String]';\n}\n\n/**\n * Ensure collection is an array.\n *\n * @param {Object} obj\n */\nfunction ensureArray(obj) {\n\n  if (isArray(obj)) {\n    return;\n  }\n\n  throw new Error('must supply array');\n}\n\n/**\n * Return true, if target owns a property with the given key.\n *\n * @param {Object} target\n * @param {String} key\n *\n * @return {Boolean}\n */\nfunction has(target, key) {\n  return nativeHasOwnProperty.call(target, key);\n}\n\n/**\n * Find element in collection.\n *\n * @param  {Array|Object} collection\n * @param  {Function|Object} matcher\n *\n * @return {Object}\n */\nfunction find(collection, matcher) {\n\n  matcher = toMatcher(matcher);\n\n  var match;\n\n  forEach(collection, function (val, key) {\n    if (matcher(val, key)) {\n      match = val;\n\n      return false;\n    }\n  });\n\n  return match;\n}\n\n/**\n * Find element index in collection.\n *\n * @param  {Array|Object} collection\n * @param  {Function} matcher\n *\n * @return {Object}\n */\nfunction findIndex(collection, matcher) {\n\n  matcher = toMatcher(matcher);\n\n  var idx = isArray(collection) ? -1 : undefined;\n\n  forEach(collection, function (val, key) {\n    if (matcher(val, key)) {\n      idx = key;\n\n      return false;\n    }\n  });\n\n  return idx;\n}\n\n/**\n * Find element in collection.\n *\n * @param  {Array|Object} collection\n * @param  {Function} matcher\n *\n * @return {Array} result\n */\nfunction filter(collection, matcher) {\n\n  var result = [];\n\n  forEach(collection, function (val, key) {\n    if (matcher(val, key)) {\n      result.push(val);\n    }\n  });\n\n  return result;\n}\n\n/**\n * Iterate over collection; returning something\n * (non-undefined) will stop iteration.\n *\n * @param  {Array|Object} collection\n * @param  {Function} iterator\n *\n * @return {Object} return result that stopped the iteration\n */\nfunction forEach(collection, iterator) {\n\n  if (isUndefined(collection)) {\n    return;\n  }\n\n  var convertKey = isArray(collection) ? toNum : identity;\n\n  for (var key in collection) {\n\n    if (has(collection, key)) {\n      var val = collection[key];\n\n      var result = iterator(val, convertKey(key));\n\n      if (result === false) {\n        return;\n      }\n    }\n  }\n}\n\n/**\n * Return collection without element.\n *\n * @param  {Array} arr\n * @param  {Function} matcher\n *\n * @return {Array}\n */\nfunction without(arr, matcher) {\n\n  if (isUndefined(arr)) {\n    return [];\n  }\n\n  ensureArray(arr);\n\n  matcher = toMatcher(matcher);\n\n  return arr.filter(function (el, idx) {\n    return !matcher(el, idx);\n  });\n}\n\n/**\n * Reduce collection, returning a single result.\n *\n * @param  {Object|Array} collection\n * @param  {Function} iterator\n * @param  {Any} result\n *\n * @return {Any} result returned from last iterator\n */\nfunction reduce(collection, iterator, result) {\n\n  forEach(collection, function (value, idx) {\n    result = iterator(result, value, idx);\n  });\n\n  return result;\n}\n\n/**\n * Return true if every element in the collection\n * matches the criteria.\n *\n * @param  {Object|Array} collection\n * @param  {Function} matcher\n *\n * @return {Boolean}\n */\nfunction every(collection, matcher) {\n\n  return reduce(collection, function (matches, val, key) {\n    return matches && matcher(val, key);\n  }, true);\n}\n\n/**\n * Return true if some elements in the collection\n * match the criteria.\n *\n * @param  {Object|Array} collection\n * @param  {Function} matcher\n *\n * @return {Boolean}\n */\nfunction some(collection, matcher) {\n\n  return !!find(collection, matcher);\n}\n\n/**\n * Transform a collection into another collection\n * by piping each member through the given fn.\n *\n * @param  {Object|Array}   collection\n * @param  {Function} fn\n *\n * @return {Array} transformed collection\n */\nfunction map(collection, fn) {\n\n  var result = [];\n\n  forEach(collection, function (val, key) {\n    result.push(fn(val, key));\n  });\n\n  return result;\n}\n\n/**\n * Get the collections keys.\n *\n * @param  {Object|Array} collection\n *\n * @return {Array}\n */\nfunction keys(collection) {\n  return collection && Object.keys(collection) || [];\n}\n\n/**\n * Shorthand for `keys(o).length`.\n *\n * @param  {Object|Array} collection\n *\n * @return {Number}\n */\nfunction size(collection) {\n  return keys(collection).length;\n}\n\n/**\n * Get the values in the collection.\n *\n * @param  {Object|Array} collection\n *\n * @return {Array}\n */\nfunction values(collection) {\n  return map(collection, function (val) {\n    return val;\n  });\n}\n\n/**\n * Group collection members by attribute.\n *\n * @param  {Object|Array} collection\n * @param  {Function} extractor\n *\n * @return {Object} map with { attrValue => [ a, b, c ] }\n */\nfunction groupBy(collection, extractor) {\n  var grouped = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n\n\n  extractor = toExtractor(extractor);\n\n  forEach(collection, function (val) {\n    var discriminator = extractor(val) || '_';\n\n    var group = grouped[discriminator];\n\n    if (!group) {\n      group = grouped[discriminator] = [];\n    }\n\n    group.push(val);\n  });\n\n  return grouped;\n}\n\nfunction uniqueBy(extractor) {\n\n  extractor = toExtractor(extractor);\n\n  var grouped = {};\n\n  for (var _len = arguments.length, collections = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n    collections[_key - 1] = arguments[_key];\n  }\n\n  forEach(collections, function (c) {\n    return groupBy(c, extractor, grouped);\n  });\n\n  var result = map(grouped, function (val, key) {\n    return val[0];\n  });\n\n  return result;\n}\n\nvar unionBy = uniqueBy;\n\n/**\n * Sort collection by criteria.\n *\n * @param  {Object|Array} collection\n * @param  {String|Function} extractor\n *\n * @return {Array}\n */\nfunction sortBy(collection, extractor) {\n\n  extractor = toExtractor(extractor);\n\n  var sorted = [];\n\n  forEach(collection, function (value, key) {\n    var disc = extractor(value, key);\n\n    var entry = {\n      d: disc,\n      v: value\n    };\n\n    for (var idx = 0; idx < sorted.length; idx++) {\n      var d = sorted[idx].d;\n\n\n      if (disc < d) {\n        sorted.splice(idx, 0, entry);\n        return;\n      }\n    }\n\n    // not inserted, append (!)\n    sorted.push(entry);\n  });\n\n  return map(sorted, function (e) {\n    return e.v;\n  });\n}\n\n/**\n * Create an object pattern matcher.\n *\n * @example\n *\n * const matcher = matchPattern({ id: 1 });\n *\n * var element = find(elements, matcher);\n *\n * @param  {Object} pattern\n *\n * @return {Function} matcherFn\n */\nfunction matchPattern(pattern) {\n\n  return function (el) {\n\n    return every(pattern, function (val, key) {\n      return el[key] === val;\n    });\n  };\n}\n\nfunction toExtractor(extractor) {\n  return isFunction(extractor) ? extractor : function (e) {\n    return e[extractor];\n  };\n}\n\nfunction toMatcher(matcher) {\n  return isFunction(matcher) ? matcher : function (e) {\n    return e === matcher;\n  };\n}\n\nfunction identity(arg) {\n  return arg;\n}\n\nfunction toNum(arg) {\n  return Number(arg);\n}\n\n/**\n * Debounce fn, calling it only once if\n * the given time elapsed between calls.\n *\n * @param  {Function} fn\n * @param  {Number} timeout\n *\n * @return {Function} debounced function\n */\nfunction debounce(fn, timeout) {\n\n  var timer;\n\n  var lastArgs;\n  var lastThis;\n\n  var lastNow;\n\n  function fire() {\n\n    var now = Date.now();\n\n    var scheduledDiff = lastNow + timeout - now;\n\n    if (scheduledDiff > 0) {\n      return schedule(scheduledDiff);\n    }\n\n    fn.apply(lastThis, lastArgs);\n\n    timer = lastNow = lastArgs = lastThis = undefined;\n  }\n\n  function schedule(timeout) {\n    timer = setTimeout(fire, timeout);\n  }\n\n  return function () {\n\n    lastNow = Date.now();\n\n    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    lastArgs = args;\n    lastThis = this;\n\n    // ensure an execution is scheduled\n    if (!timer) {\n      schedule(timeout);\n    }\n  };\n}\n\n/**\n * Throttle fn, calling at most once\n * in the given interval.\n *\n * @param  {Function} fn\n * @param  {Number} interval\n *\n * @return {Function} throttled function\n */\nfunction throttle(fn, interval) {\n\n  var throttling = false;\n\n  return function () {\n\n    if (throttling) {\n      return;\n    }\n\n    fn.apply(undefined, arguments);\n    throttling = true;\n\n    setTimeout(function () {\n      throttling = false;\n    }, interval);\n  };\n}\n\n/**\n * Bind function against target <this>.\n *\n * @param  {Function} fn\n * @param  {Object}   target\n *\n * @return {Function} bound function\n */\nfunction bind(fn, target) {\n  return fn.bind(target);\n}\n\nvar _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\n/**\n * Convenience wrapper for `Object.assign`.\n *\n * @param {Object} target\n * @param {...Object} others\n *\n * @return {Object} the target\n */\nfunction assign(target) {\n  for (var _len = arguments.length, others = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n    others[_key - 1] = arguments[_key];\n  }\n\n  return _extends.apply(undefined, [target].concat(others));\n}\n\n/**\n * Pick given properties from the target object.\n *\n * @param {Object} target\n * @param {Array} properties\n *\n * @return {Object} target\n */\nfunction pick(target, properties) {\n\n  var result = {};\n\n  var obj = Object(target);\n\n  forEach(properties, function (prop) {\n\n    if (prop in obj) {\n      result[prop] = target[prop];\n    }\n  });\n\n  return result;\n}\n\n/**\n * Pick all target properties, excluding the given ones.\n *\n * @param {Object} target\n * @param {Array} properties\n *\n * @return {Object} target\n */\nfunction omit(target, properties) {\n\n  var result = {};\n\n  var obj = Object(target);\n\n  forEach(obj, function (prop, key) {\n\n    if (properties.indexOf(key) === -1) {\n      result[key] = prop;\n    }\n  });\n\n  return result;\n}\n\n/**\n * Recursively merge `...sources` into given target.\n *\n * Does support merging objects; does not support merging arrays.\n *\n * @param {Object} target\n * @param {...Object} sources\n *\n * @return {Object} the target\n */\nfunction merge(target) {\n  for (var _len2 = arguments.length, sources = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {\n    sources[_key2 - 1] = arguments[_key2];\n  }\n\n  if (!sources.length) {\n    return target;\n  }\n\n  forEach(sources, function (source) {\n\n    // skip non-obj sources, i.e. null\n    if (!source || !isObject(source)) {\n      return;\n    }\n\n    forEach(source, function (sourceVal, key) {\n\n      var targetVal = target[key];\n\n      if (isObject(sourceVal)) {\n\n        if (!isObject(targetVal)) {\n          // override target[key] with object\n          targetVal = {};\n        }\n\n        target[key] = merge(targetVal, sourceVal);\n      } else {\n        target[key] = sourceVal;\n      }\n    });\n  });\n\n  return target;\n}\n\nexports.flatten = flatten;\nexports.find = find;\nexports.findIndex = findIndex;\nexports.filter = filter;\nexports.forEach = forEach;\nexports.without = without;\nexports.reduce = reduce;\nexports.every = every;\nexports.some = some;\nexports.map = map;\nexports.keys = keys;\nexports.size = size;\nexports.values = values;\nexports.groupBy = groupBy;\nexports.uniqueBy = uniqueBy;\nexports.unionBy = unionBy;\nexports.sortBy = sortBy;\nexports.matchPattern = matchPattern;\nexports.debounce = debounce;\nexports.throttle = throttle;\nexports.bind = bind;\nexports.isUndefined = isUndefined;\nexports.isDefined = isDefined;\nexports.isNil = isNil;\nexports.isArray = isArray;\nexports.isObject = isObject;\nexports.isNumber = isNumber;\nexports.isFunction = isFunction;\nexports.isString = isString;\nexports.ensureArray = ensureArray;\nexports.has = has;\nexports.assign = assign;\nexports.pick = pick;\nexports.omit = omit;\nexports.merge = merge;\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\n/**\n * Set attribute `name` to `val`, or get attr `name`.\n *\n * @param {Element} el\n * @param {String} name\n * @param {String} [val]\n * @api public\n */\nfunction attr(el, name, val) {\n  // get\n  if (arguments.length == 2) {\n    return el.getAttribute(name);\n  }\n\n  // remove\n  if (val === null) {\n    return el.removeAttribute(name);\n  }\n\n  // set\n  el.setAttribute(name, val);\n\n  return el;\n}\n\nvar indexOf = [].indexOf;\n\nvar indexof = function(arr, obj){\n  if (indexOf) return arr.indexOf(obj);\n  for (var i = 0; i < arr.length; ++i) {\n    if (arr[i] === obj) return i;\n  }\n  return -1;\n};\n\n/**\n * Taken from https://github.com/component/classes\n *\n * Without the component bits.\n */\n\n/**\n * Whitespace regexp.\n */\n\nvar re = /\\s+/;\n\n/**\n * toString reference.\n */\n\nvar toString = Object.prototype.toString;\n\n/**\n * Wrap `el` in a `ClassList`.\n *\n * @param {Element} el\n * @return {ClassList}\n * @api public\n */\n\nfunction classes(el) {\n  return new ClassList(el);\n}\n\n/**\n * Initialize a new ClassList for `el`.\n *\n * @param {Element} el\n * @api private\n */\n\nfunction ClassList(el) {\n  if (!el || !el.nodeType) {\n    throw new Error('A DOM element reference is required');\n  }\n  this.el = el;\n  this.list = el.classList;\n}\n\n/**\n * Add class `name` if not already present.\n *\n * @param {String} name\n * @return {ClassList}\n * @api public\n */\n\nClassList.prototype.add = function (name) {\n  // classList\n  if (this.list) {\n    this.list.add(name);\n    return this;\n  }\n\n  // fallback\n  var arr = this.array();\n  var i = indexof(arr, name);\n  if (!~i) arr.push(name);\n  this.el.className = arr.join(' ');\n  return this;\n};\n\n/**\n * Remove class `name` when present, or\n * pass a regular expression to remove\n * any which match.\n *\n * @param {String|RegExp} name\n * @return {ClassList}\n * @api public\n */\n\nClassList.prototype.remove = function (name) {\n  if ('[object RegExp]' == toString.call(name)) {\n    return this.removeMatching(name);\n  }\n\n  // classList\n  if (this.list) {\n    this.list.remove(name);\n    return this;\n  }\n\n  // fallback\n  var arr = this.array();\n  var i = indexof(arr, name);\n  if (~i) arr.splice(i, 1);\n  this.el.className = arr.join(' ');\n  return this;\n};\n\n/**\n * Remove all classes matching `re`.\n *\n * @param {RegExp} re\n * @return {ClassList}\n * @api private\n */\n\nClassList.prototype.removeMatching = function (re) {\n  var arr = this.array();\n  for (var i = 0; i < arr.length; i++) {\n    if (re.test(arr[i])) {\n      this.remove(arr[i]);\n    }\n  }\n  return this;\n};\n\n/**\n * Toggle class `name`, can force state via `force`.\n *\n * For browsers that support classList, but do not support `force` yet,\n * the mistake will be detected and corrected.\n *\n * @param {String} name\n * @param {Boolean} force\n * @return {ClassList}\n * @api public\n */\n\nClassList.prototype.toggle = function (name, force) {\n  // classList\n  if (this.list) {\n    if ('undefined' !== typeof force) {\n      if (force !== this.list.toggle(name, force)) {\n        this.list.toggle(name); // toggle again to correct\n      }\n    } else {\n      this.list.toggle(name);\n    }\n    return this;\n  }\n\n  // fallback\n  if ('undefined' !== typeof force) {\n    if (!force) {\n      this.remove(name);\n    } else {\n      this.add(name);\n    }\n  } else {\n    if (this.has(name)) {\n      this.remove(name);\n    } else {\n      this.add(name);\n    }\n  }\n\n  return this;\n};\n\n/**\n * Return an array of classes.\n *\n * @return {Array}\n * @api public\n */\n\nClassList.prototype.array = function () {\n  var className = this.el.getAttribute('class') || '';\n  var str = className.replace(/^\\s+|\\s+$/g, '');\n  var arr = str.split(re);\n  if ('' === arr[0]) arr.shift();\n  return arr;\n};\n\n/**\n * Check if class `name` is present.\n *\n * @param {String} name\n * @return {ClassList}\n * @api public\n */\n\nClassList.prototype.has = ClassList.prototype.contains = function (name) {\n  return this.list ? this.list.contains(name) : !!~indexof(this.array(), name);\n};\n\n/**\n * Remove all children from the given element.\n */\nfunction clear(el) {\n\n  var c;\n\n  while (el.childNodes.length) {\n    c = el.childNodes[0];\n    el.removeChild(c);\n  }\n\n  return el;\n}\n\n/**\r\n * Element prototype.\r\n */\r\n\r\nvar proto = Element.prototype;\r\n\r\n/**\r\n * Vendor function.\r\n */\r\n\r\nvar vendor = proto.matchesSelector\r\n  || proto.webkitMatchesSelector\r\n  || proto.mozMatchesSelector\r\n  || proto.msMatchesSelector\r\n  || proto.oMatchesSelector;\r\n\r\n/**\r\n * Expose `match()`.\r\n */\r\n\r\nvar matchesSelector = match;\r\n\r\n/**\r\n * Match `el` to `selector`.\r\n *\r\n * @param {Element} el\r\n * @param {String} selector\r\n * @return {Boolean}\r\n * @api public\r\n */\r\n\r\nfunction match(el, selector) {\r\n  if (vendor) return vendor.call(el, selector);\r\n  var nodes = el.parentNode.querySelectorAll(selector);\r\n  for (var i = 0; i < nodes.length; ++i) {\r\n    if (nodes[i] == el) return true;\r\n  }\r\n  return false;\r\n}\n\nvar closest = function (element, selector, checkYoSelf) {\r\n  var parent = checkYoSelf ? element : element.parentNode;\r\n\r\n  while (parent && parent !== document) {\r\n    if (matchesSelector(parent, selector)) return parent;\r\n    parent = parent.parentNode;\r\n  }\r\n};\n\nvar bind = window.addEventListener ? 'addEventListener' : 'attachEvent',\n    unbind = window.removeEventListener ? 'removeEventListener' : 'detachEvent',\n    prefix = bind !== 'addEventListener' ? 'on' : '';\n\n/**\n * Bind `el` event `type` to `fn`.\n *\n * @param {Element} el\n * @param {String} type\n * @param {Function} fn\n * @param {Boolean} capture\n * @return {Function}\n * @api public\n */\n\nvar bind_1 = function(el, type, fn, capture){\n  el[bind](prefix + type, fn, capture || false);\n  return fn;\n};\n\n/**\n * Unbind `el` event `type`'s callback `fn`.\n *\n * @param {Element} el\n * @param {String} type\n * @param {Function} fn\n * @param {Boolean} capture\n * @return {Function}\n * @api public\n */\n\nvar unbind_1 = function(el, type, fn, capture){\n  el[unbind](prefix + type, fn, capture || false);\n  return fn;\n};\n\nvar componentEvent = {\n\tbind: bind_1,\n\tunbind: unbind_1\n};\n\n/**\n * Module dependencies.\n */\n\n\n\n/**\n * Delegate event `type` to `selector`\n * and invoke `fn(e)`. A callback function\n * is returned which may be passed to `.unbind()`.\n *\n * @param {Element} el\n * @param {String} selector\n * @param {String} type\n * @param {Function} fn\n * @param {Boolean} capture\n * @return {Function}\n * @api public\n */\n\n// Some events don't bubble, so we want to bind to the capture phase instead\n// when delegating.\nvar forceCaptureEvents = ['focus', 'blur'];\n\nvar bind$1 = function(el, selector, type, fn, capture){\n  if (forceCaptureEvents.indexOf(type) !== -1) capture = true;\n\n  return componentEvent.bind(el, type, function(e){\n    var target = e.target || e.srcElement;\n    e.delegateTarget = closest(target, selector, true, el);\n    if (e.delegateTarget) fn.call(el, e);\n  }, capture);\n};\n\n/**\n * Unbind event `type`'s callback `fn`.\n *\n * @param {Element} el\n * @param {String} type\n * @param {Function} fn\n * @param {Boolean} capture\n * @api public\n */\n\nvar unbind$1 = function(el, type, fn, capture){\n  if (forceCaptureEvents.indexOf(type) !== -1) capture = true;\n\n  componentEvent.unbind(el, type, fn, capture);\n};\n\nvar delegateEvents = {\n\tbind: bind$1,\n\tunbind: unbind$1\n};\n\n/**\n * Expose `parse`.\n */\n\nvar domify = parse;\n\n/**\n * Tests for browser support.\n */\n\nvar innerHTMLBug = false;\nvar bugTestDiv;\nif (typeof document !== 'undefined') {\n  bugTestDiv = document.createElement('div');\n  // Setup\n  bugTestDiv.innerHTML = '  <link/><table></table><a href=\"/a\">a</a><input type=\"checkbox\"/>';\n  // Make sure that link elements get serialized correctly by innerHTML\n  // This requires a wrapper element in IE\n  innerHTMLBug = !bugTestDiv.getElementsByTagName('link').length;\n  bugTestDiv = undefined;\n}\n\n/**\n * Wrap map from jquery.\n */\n\nvar map = {\n  legend: [1, '<fieldset>', '</fieldset>'],\n  tr: [2, '<table><tbody>', '</tbody></table>'],\n  col: [2, '<table><tbody></tbody><colgroup>', '</colgroup></table>'],\n  // for script/link/style tags to work in IE6-8, you have to wrap\n  // in a div with a non-whitespace character in front, ha!\n  _default: innerHTMLBug ? [1, 'X<div>', '</div>'] : [0, '', '']\n};\n\nmap.td =\nmap.th = [3, '<table><tbody><tr>', '</tr></tbody></table>'];\n\nmap.option =\nmap.optgroup = [1, '<select multiple=\"multiple\">', '</select>'];\n\nmap.thead =\nmap.tbody =\nmap.colgroup =\nmap.caption =\nmap.tfoot = [1, '<table>', '</table>'];\n\nmap.polyline =\nmap.ellipse =\nmap.polygon =\nmap.circle =\nmap.text =\nmap.line =\nmap.path =\nmap.rect =\nmap.g = [1, '<svg xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">','</svg>'];\n\n/**\n * Parse `html` and return a DOM Node instance, which could be a TextNode,\n * HTML DOM Node of some kind (<div> for example), or a DocumentFragment\n * instance, depending on the contents of the `html` string.\n *\n * @param {String} html - HTML string to \"domify\"\n * @param {Document} doc - The `document` instance to create the Node for\n * @return {DOMNode} the TextNode, DOM Node, or DocumentFragment instance\n * @api private\n */\n\nfunction parse(html, doc) {\n  if ('string' != typeof html) throw new TypeError('String expected');\n\n  // default to the global `document` object\n  if (!doc) doc = document;\n\n  // tag name\n  var m = /<([\\w:]+)/.exec(html);\n  if (!m) return doc.createTextNode(html);\n\n  html = html.replace(/^\\s+|\\s+$/g, ''); // Remove leading/trailing whitespace\n\n  var tag = m[1];\n\n  // body support\n  if (tag == 'body') {\n    var el = doc.createElement('html');\n    el.innerHTML = html;\n    return el.removeChild(el.lastChild);\n  }\n\n  // wrap map\n  var wrap = map[tag] || map._default;\n  var depth = wrap[0];\n  var prefix = wrap[1];\n  var suffix = wrap[2];\n  var el = doc.createElement('div');\n  el.innerHTML = prefix + html + suffix;\n  while (depth--) el = el.lastChild;\n\n  // one element\n  if (el.firstChild == el.lastChild) {\n    return el.removeChild(el.firstChild);\n  }\n\n  // several elements\n  var fragment = doc.createDocumentFragment();\n  while (el.firstChild) {\n    fragment.appendChild(el.removeChild(el.firstChild));\n  }\n\n  return fragment;\n}\n\nvar proto$1 = typeof Element !== 'undefined' ? Element.prototype : {};\nvar vendor$1 = proto$1.matches\n  || proto$1.matchesSelector\n  || proto$1.webkitMatchesSelector\n  || proto$1.mozMatchesSelector\n  || proto$1.msMatchesSelector\n  || proto$1.oMatchesSelector;\n\nvar matchesSelector$1 = match$1;\n\n/**\n * Match `el` to `selector`.\n *\n * @param {Element} el\n * @param {String} selector\n * @return {Boolean}\n * @api public\n */\n\nfunction match$1(el, selector) {\n  if (!el || el.nodeType !== 1) return false;\n  if (vendor$1) return vendor$1.call(el, selector);\n  var nodes = el.parentNode.querySelectorAll(selector);\n  for (var i = 0; i < nodes.length; i++) {\n    if (nodes[i] == el) return true;\n  }\n  return false;\n}\n\nfunction query(selector, el) {\n  el = el || document;\n\n  return el.querySelector(selector);\n}\n\nfunction all(selector, el) {\n  el = el || document;\n\n  return el.querySelectorAll(selector);\n}\n\nfunction remove(el) {\n  el.parentNode && el.parentNode.removeChild(el);\n}\n\nexports.attr = attr;\nexports.classes = classes;\nexports.clear = clear;\nexports.closest = closest;\nexports.delegate = delegateEvents;\nexports.domify = domify;\nexports.event = componentEvent;\nexports.matches = matchesSelector$1;\nexports.query = query;\nexports.queryAll = all;\nexports.remove = remove;\n","export {\n  Reader\n} from './lib/read';\n\nexport {\n  Writer\n} from './lib/write';","export function hasLowerCaseAlias(pkg) {\n  return pkg.xml && pkg.xml.tagAlias === 'lowerCase';\n}\n\nexport var DEFAULT_NS_MAP = {\n  'xsi': 'http://www.w3.org/2001/XMLSchema-instance'\n};\n\nexport var XSI_TYPE = 'xsi:type';\n\nfunction serializeFormat(element) {\n  return element.xml && element.xml.serialize;\n}\n\nexport function serializeAsType(element) {\n  return serializeFormat(element) === XSI_TYPE;\n}\n\nexport function serializeAsProperty(element) {\n  return serializeFormat(element) === 'property';\n}","import {\n  forEach,\n  find,\n  assign\n} from 'min-dash';\n\nimport Stack from 'tiny-stack';\n\nimport {\n  Parser as SaxParser\n} from 'saxen';\n\nimport Moddle from 'moddle';\nimport {\n  parseName as parseNameNs\n} from 'moddle/lib/ns';\n\nimport {\n  coerceType,\n  isSimple as isSimpleType\n} from 'moddle/lib/types';\n\nimport {\n  XSI_TYPE,\n  serializeAsType,\n  hasLowerCaseAlias\n} from './common';\n\n\nfunction capitalize(str) {\n  return str.charAt(0).toUpperCase() + str.slice(1);\n}\n\nfunction aliasToName(aliasNs, pkg) {\n\n  if (!hasLowerCaseAlias(pkg)) {\n    return aliasNs.name;\n  }\n\n  return aliasNs.prefix + ':' + capitalize(aliasNs.localName);\n}\n\nfunction prefixedToName(nameNs, pkg) {\n\n  var name = nameNs.name,\n      localName = nameNs.localName;\n\n  var typePrefix = pkg.xml && pkg.xml.typePrefix;\n\n  if (typePrefix && localName.indexOf(typePrefix) === 0) {\n    return nameNs.prefix + ':' + localName.slice(typePrefix.length);\n  } else {\n    return name;\n  }\n}\n\nfunction normalizeXsiTypeName(name, model) {\n\n  var nameNs = parseNameNs(name);\n  var pkg = model.getPackage(nameNs.prefix);\n\n  return prefixedToName(nameNs, pkg);\n}\n\nfunction error(message) {\n  return new Error(message);\n}\n\n/**\n * Get the moddle descriptor for a given instance or type.\n *\n * @param  {ModdleElement|Function} element\n *\n * @return {Object} the moddle descriptor\n */\nfunction getModdleDescriptor(element) {\n  return element.$descriptor;\n}\n\nfunction defer(fn) {\n  setTimeout(fn, 0);\n}\n\n/**\n * A parse context.\n *\n * @class\n *\n * @param {Object} options\n * @param {ElementHandler} options.rootHandler the root handler for parsing a document\n * @param {boolean} [options.lax=false] whether or not to ignore invalid elements\n */\nexport function Context(options) {\n\n  /**\n   * @property {ElementHandler} rootHandler\n   */\n\n  /**\n   * @property {Boolean} lax\n   */\n\n  assign(this, options);\n\n  this.elementsById = {};\n  this.references = [];\n  this.warnings = [];\n\n  /**\n   * Add an unresolved reference.\n   *\n   * @param {Object} reference\n   */\n  this.addReference = function(reference) {\n    this.references.push(reference);\n  };\n\n  /**\n   * Add a processed element.\n   *\n   * @param {ModdleElement} element\n   */\n  this.addElement = function(element) {\n\n    if (!element) {\n      throw error('expected element');\n    }\n\n    var elementsById = this.elementsById;\n\n    var descriptor = getModdleDescriptor(element);\n\n    var idProperty = descriptor.idProperty,\n        id;\n\n    if (idProperty) {\n      id = element.get(idProperty.name);\n\n      if (id) {\n\n        if (elementsById[id]) {\n          throw error('duplicate ID <' + id + '>');\n        }\n\n        elementsById[id] = element;\n      }\n    }\n  };\n\n  /**\n   * Add an import warning.\n   *\n   * @param {Object} warning\n   * @param {String} warning.message\n   * @param {Error} [warning.error]\n   */\n  this.addWarning = function(warning) {\n    this.warnings.push(warning);\n  };\n}\n\nfunction BaseHandler() {}\n\nBaseHandler.prototype.handleEnd = function() {};\nBaseHandler.prototype.handleText = function() {};\nBaseHandler.prototype.handleNode = function() {};\n\n\n/**\n * A simple pass through handler that does nothing except for\n * ignoring all input it receives.\n *\n * This is used to ignore unknown elements and\n * attributes.\n */\nfunction NoopHandler() { }\n\nNoopHandler.prototype = Object.create(BaseHandler.prototype);\n\nNoopHandler.prototype.handleNode = function() {\n  return this;\n};\n\nfunction BodyHandler() {}\n\nBodyHandler.prototype = Object.create(BaseHandler.prototype);\n\nBodyHandler.prototype.handleText = function(text) {\n  this.body = (this.body || '') + text;\n};\n\nfunction ReferenceHandler(property, context) {\n  this.property = property;\n  this.context = context;\n}\n\nReferenceHandler.prototype = Object.create(BodyHandler.prototype);\n\nReferenceHandler.prototype.handleNode = function(node) {\n\n  if (this.element) {\n    throw error('expected no sub nodes');\n  } else {\n    this.element = this.createReference(node);\n  }\n\n  return this;\n};\n\nReferenceHandler.prototype.handleEnd = function() {\n  this.element.id = this.body;\n};\n\nReferenceHandler.prototype.createReference = function(node) {\n  return {\n    property: this.property.ns.name,\n    id: ''\n  };\n};\n\nfunction ValueHandler(propertyDesc, element) {\n  this.element = element;\n  this.propertyDesc = propertyDesc;\n}\n\nValueHandler.prototype = Object.create(BodyHandler.prototype);\n\nValueHandler.prototype.handleEnd = function() {\n\n  var value = this.body || '',\n      element = this.element,\n      propertyDesc = this.propertyDesc;\n\n  value = coerceType(propertyDesc.type, value);\n\n  if (propertyDesc.isMany) {\n    element.get(propertyDesc.name).push(value);\n  } else {\n    element.set(propertyDesc.name, value);\n  }\n};\n\n\nfunction BaseElementHandler() {}\n\nBaseElementHandler.prototype = Object.create(BodyHandler.prototype);\n\nBaseElementHandler.prototype.handleNode = function(node) {\n  var parser = this,\n      element = this.element;\n\n  if (!element) {\n    element = this.element = this.createElement(node);\n\n    this.context.addElement(element);\n  } else {\n    parser = this.handleChild(node);\n  }\n\n  return parser;\n};\n\n/**\n * @class Reader.ElementHandler\n *\n */\nexport function ElementHandler(model, typeName, context) {\n  this.model = model;\n  this.type = model.getType(typeName);\n  this.context = context;\n}\n\nElementHandler.prototype = Object.create(BaseElementHandler.prototype);\n\nElementHandler.prototype.addReference = function(reference) {\n  this.context.addReference(reference);\n};\n\nElementHandler.prototype.handleEnd = function() {\n\n  var value = this.body,\n      element = this.element,\n      descriptor = getModdleDescriptor(element),\n      bodyProperty = descriptor.bodyProperty;\n\n  if (bodyProperty && value !== undefined) {\n    value = coerceType(bodyProperty.type, value);\n    element.set(bodyProperty.name, value);\n  }\n};\n\n/**\n * Create an instance of the model from the given node.\n *\n * @param  {Element} node the xml node\n */\nElementHandler.prototype.createElement = function(node) {\n  var attributes = node.attributes,\n      Type = this.type,\n      descriptor = getModdleDescriptor(Type),\n      context = this.context,\n      instance = new Type({}),\n      model = this.model,\n      propNameNs;\n\n  forEach(attributes, function(value, name) {\n\n    var prop = descriptor.propertiesByName[name],\n        values;\n\n    if (prop && prop.isReference) {\n\n      if (!prop.isMany) {\n        context.addReference({\n          element: instance,\n          property: prop.ns.name,\n          id: value\n        });\n      } else {\n        // IDREFS: parse references as whitespace-separated list\n        values = value.split(' ');\n\n        forEach(values, function(v) {\n          context.addReference({\n            element: instance,\n            property: prop.ns.name,\n            id: v\n          });\n        });\n      }\n\n    } else {\n      if (prop) {\n        value = coerceType(prop.type, value);\n      } else\n      if (name !== 'xmlns') {\n        propNameNs = parseNameNs(name, descriptor.ns.prefix);\n\n        // check whether attribute is defined in a well-known namespace\n        // if that is the case we emit a warning to indicate potential misuse\n        if (model.getPackage(propNameNs.prefix)) {\n\n          context.addWarning({\n            message: 'unknown attribute <' + name + '>',\n            element: instance,\n            property: name,\n            value: value\n          });\n        }\n      }\n\n      instance.set(name, value);\n    }\n  });\n\n  return instance;\n};\n\nElementHandler.prototype.getPropertyForNode = function(node) {\n\n  var name = node.name;\n  var nameNs = parseNameNs(name);\n\n  var type = this.type,\n      model = this.model,\n      descriptor = getModdleDescriptor(type);\n\n  var propertyName = nameNs.name,\n      property = descriptor.propertiesByName[propertyName],\n      elementTypeName,\n      elementType;\n\n  // search for properties by name first\n\n  if (property) {\n\n    if (serializeAsType(property)) {\n      elementTypeName = node.attributes[XSI_TYPE];\n\n      // xsi type is optional, if it does not exists the\n      // default type is assumed\n      if (elementTypeName) {\n\n        // take possible type prefixes from XML\n        // into account, i.e.: xsi:type=\"t{ActualType}\"\n        elementTypeName = normalizeXsiTypeName(elementTypeName, model);\n\n        elementType = model.getType(elementTypeName);\n\n        return assign({}, property, {\n          effectiveType: getModdleDescriptor(elementType).name\n        });\n      }\n    }\n\n    // search for properties by name first\n    return property;\n  }\n\n  var pkg = model.getPackage(nameNs.prefix);\n\n  if (pkg) {\n    elementTypeName = aliasToName(nameNs, pkg);\n    elementType = model.getType(elementTypeName);\n\n    // search for collection members later\n    property = find(descriptor.properties, function(p) {\n      return !p.isVirtual && !p.isReference && !p.isAttribute && elementType.hasType(p.type);\n    });\n\n    if (property) {\n      return assign({}, property, {\n        effectiveType: getModdleDescriptor(elementType).name\n      });\n    }\n  } else {\n    // parse unknown element (maybe extension)\n    property = find(descriptor.properties, function(p) {\n      return !p.isReference && !p.isAttribute && p.type === 'Element';\n    });\n\n    if (property) {\n      return property;\n    }\n  }\n\n  throw error('unrecognized element <' + nameNs.name + '>');\n};\n\nElementHandler.prototype.toString = function() {\n  return 'ElementDescriptor[' + getModdleDescriptor(this.type).name + ']';\n};\n\nElementHandler.prototype.valueHandler = function(propertyDesc, element) {\n  return new ValueHandler(propertyDesc, element);\n};\n\nElementHandler.prototype.referenceHandler = function(propertyDesc) {\n  return new ReferenceHandler(propertyDesc, this.context);\n};\n\nElementHandler.prototype.handler = function(type) {\n  if (type === 'Element') {\n    return new GenericElementHandler(this.model, type, this.context);\n  } else {\n    return new ElementHandler(this.model, type, this.context);\n  }\n};\n\n/**\n * Handle the child element parsing\n *\n * @param  {Element} node the xml node\n */\nElementHandler.prototype.handleChild = function(node) {\n  var propertyDesc, type, element, childHandler;\n\n  propertyDesc = this.getPropertyForNode(node);\n  element = this.element;\n\n  type = propertyDesc.effectiveType || propertyDesc.type;\n\n  if (isSimpleType(type)) {\n    return this.valueHandler(propertyDesc, element);\n  }\n\n  if (propertyDesc.isReference) {\n    childHandler = this.referenceHandler(propertyDesc).handleNode(node);\n  } else {\n    childHandler = this.handler(type).handleNode(node);\n  }\n\n  var newElement = childHandler.element;\n\n  // child handles may decide to skip elements\n  // by not returning anything\n  if (newElement !== undefined) {\n\n    if (propertyDesc.isMany) {\n      element.get(propertyDesc.name).push(newElement);\n    } else {\n      element.set(propertyDesc.name, newElement);\n    }\n\n    if (propertyDesc.isReference) {\n      assign(newElement, {\n        element: element\n      });\n\n      this.context.addReference(newElement);\n    } else {\n      // establish child -> parent relationship\n      newElement.$parent = element;\n    }\n  }\n\n  return childHandler;\n};\n\n/**\n * An element handler that performs special validation\n * to ensure the node it gets initialized with matches\n * the handlers type (namespace wise).\n *\n * @param {Moddle} model\n * @param {String} typeName\n * @param {Context} context\n */\nfunction RootElementHandler(model, typeName, context) {\n  ElementHandler.call(this, model, typeName, context);\n}\n\nRootElementHandler.prototype = Object.create(ElementHandler.prototype);\n\nRootElementHandler.prototype.createElement = function(node) {\n\n  var name = node.name,\n      nameNs = parseNameNs(name),\n      model = this.model,\n      type = this.type,\n      pkg = model.getPackage(nameNs.prefix),\n      typeName = pkg && aliasToName(nameNs, pkg) || name;\n\n  // verify the correct namespace if we parse\n  // the first element in the handler tree\n  //\n  // this ensures we don't mistakenly import wrong namespace elements\n  if (!type.hasType(typeName)) {\n    throw error('unexpected element <' + node.originalName + '>');\n  }\n\n  return ElementHandler.prototype.createElement.call(this, node);\n};\n\n\nfunction GenericElementHandler(model, typeName, context) {\n  this.model = model;\n  this.context = context;\n}\n\nGenericElementHandler.prototype = Object.create(BaseElementHandler.prototype);\n\nGenericElementHandler.prototype.createElement = function(node) {\n\n  var name = node.name,\n      ns = parseNameNs(name),\n      prefix = ns.prefix,\n      uri = node.ns[prefix + '$uri'],\n      attributes = node.attributes;\n\n  return this.model.createAny(name, uri, attributes);\n};\n\nGenericElementHandler.prototype.handleChild = function(node) {\n\n  var handler = new GenericElementHandler(this.model, 'Element', this.context).handleNode(node),\n      element = this.element;\n\n  var newElement = handler.element,\n      children;\n\n  if (newElement !== undefined) {\n    children = element.$children = element.$children || [];\n    children.push(newElement);\n\n    // establish child -> parent relationship\n    newElement.$parent = element;\n  }\n\n  return handler;\n};\n\nGenericElementHandler.prototype.handleText = function(text) {\n  this.body = this.body || '' + text;\n};\n\nGenericElementHandler.prototype.handleEnd = function() {\n  if (this.body) {\n    this.element.$body = this.body;\n  }\n};\n\n/**\n * A reader for a meta-model\n *\n * @param {Object} options\n * @param {Model} options.model used to read xml files\n * @param {Boolean} options.lax whether to make parse errors warnings\n */\nexport function Reader(options) {\n\n  if (options instanceof Moddle) {\n    options = {\n      model: options\n    };\n  }\n\n  assign(this, { lax: false }, options);\n}\n\n\n/**\n * Parse the given XML into a moddle document tree.\n *\n * @param {String} xml\n * @param {ElementHandler|Object} options or rootHandler\n * @param  {Function} done\n */\nReader.prototype.fromXML = function(xml, options, done) {\n\n  var rootHandler = options.rootHandler;\n\n  if (options instanceof ElementHandler) {\n    // root handler passed via (xml, { rootHandler: ElementHandler }, ...)\n    rootHandler = options;\n    options = {};\n  } else {\n    if (typeof options === 'string') {\n      // rootHandler passed via (xml, 'someString', ...)\n      rootHandler = this.handler(options);\n      options = {};\n    } else if (typeof rootHandler === 'string') {\n      // rootHandler passed via (xml, { rootHandler: 'someString' }, ...)\n      rootHandler = this.handler(rootHandler);\n    }\n  }\n\n  var model = this.model,\n      lax = this.lax;\n\n  var context = new Context(assign({}, options, { rootHandler: rootHandler })),\n      parser = new SaxParser({ proxy: true }),\n      stack = new Stack();\n\n  rootHandler.context = context;\n\n  // push root handler\n  stack.push(rootHandler);\n\n\n  /**\n   * Handle error.\n   *\n   * @param  {Error} err\n   * @param  {Function} getContext\n   * @param  {boolean} lax\n   *\n   * @return {boolean} true if handled\n   */\n  function handleError(err, getContext, lax) {\n\n    var ctx = getContext();\n\n    var line = ctx.line,\n        column = ctx.column,\n        data = ctx.data;\n\n    // we receive the full context data here,\n    // for elements trim down the information\n    // to the tag name, only\n    if (data.charAt(0) === '<' && data.indexOf(' ') !== -1) {\n      data = data.slice(0, data.indexOf(' ')) + '>';\n    }\n\n    var message =\n      'unparsable content ' + (data ? data + ' ' : '') + 'detected\\n\\t' +\n        'line: ' + line + '\\n\\t' +\n        'column: ' + column + '\\n\\t' +\n        'nested error: ' + err.message;\n\n    if (lax) {\n      context.addWarning({\n        message: message,\n        error: err\n      });\n\n      console.warn('could not parse node');\n      console.warn(err);\n\n      return true;\n    } else {\n      console.error('could not parse document');\n      console.error(err);\n\n      throw error(message);\n    }\n  }\n\n  function handleWarning(err, getContext) {\n    // just like handling errors in <lax=true> mode\n    return handleError(err, getContext, true);\n  }\n\n  /**\n   * Resolve collected references on parse end.\n   */\n  function resolveReferences() {\n\n    var elementsById = context.elementsById;\n    var references = context.references;\n\n    var i, r;\n\n    for (i = 0; (r = references[i]); i++) {\n      var element = r.element;\n      var reference = elementsById[r.id];\n      var property = getModdleDescriptor(element).propertiesByName[r.property];\n\n      if (!reference) {\n        context.addWarning({\n          message: 'unresolved reference <' + r.id + '>',\n          element: r.element,\n          property: r.property,\n          value: r.id\n        });\n      }\n\n      if (property.isMany) {\n        var collection = element.get(property.name),\n            idx = collection.indexOf(r);\n\n        // we replace an existing place holder (idx != -1) or\n        // append to the collection instead\n        if (idx === -1) {\n          idx = collection.length;\n        }\n\n        if (!reference) {\n          // remove unresolvable reference\n          collection.splice(idx, 1);\n        } else {\n          // add or update reference in collection\n          collection[idx] = reference;\n        }\n      } else {\n        element.set(property.name, reference);\n      }\n    }\n  }\n\n  function handleClose() {\n    stack.pop().handleEnd();\n  }\n\n  var PREAMBLE_START_PATTERN = /^<\\?xml /i;\n\n  var ENCODING_PATTERN = / encoding=\"([^\"]+)\"/i;\n\n  var UTF_8_PATTERN = /^utf-8$/i;\n\n  function handleQuestion(question) {\n\n    if (!PREAMBLE_START_PATTERN.test(question)) {\n      return;\n    }\n\n    var match = ENCODING_PATTERN.exec(question);\n    var encoding = match && match[1];\n\n    if (!encoding || UTF_8_PATTERN.test(encoding)) {\n      return;\n    }\n\n    context.addWarning({\n      message:\n        'unsupported document encoding <' + encoding + '>, ' +\n        'falling back to UTF-8'\n    });\n  }\n\n  function handleOpen(node, getContext) {\n    var handler = stack.peek();\n\n    try {\n      stack.push(handler.handleNode(node));\n    } catch (err) {\n\n      if (handleError(err, getContext, lax)) {\n        stack.push(new NoopHandler());\n      }\n    }\n  }\n\n  function handleCData(text) {\n    stack.peek().handleText(text);\n  }\n\n  function handleText(text) {\n    // strip whitespace only nodes, i.e. before\n    // <!CDATA[ ... ]> sections and in between tags\n    text = text.trim();\n\n    if (!text) {\n      return;\n    }\n\n    stack.peek().handleText(text);\n  }\n\n  var uriMap = model.getPackages().reduce(function(uriMap, p) {\n    uriMap[p.uri] = p.prefix;\n\n    return uriMap;\n  }, {});\n\n  parser\n    .ns(uriMap)\n    .on('openTag', function(obj, decodeStr, selfClosing, getContext) {\n\n      // gracefully handle unparsable attributes (attrs=false)\n      var attrs = obj.attrs || {};\n\n      var decodedAttrs = Object.keys(attrs).reduce(function(d, key) {\n        var value = decodeStr(attrs[key]);\n\n        d[key] = value;\n\n        return d;\n      }, {});\n\n      var node = {\n        name: obj.name,\n        originalName: obj.originalName,\n        attributes: decodedAttrs,\n        ns: obj.ns\n      };\n\n      handleOpen(node, getContext);\n    })\n    .on('question', handleQuestion)\n    .on('closeTag', handleClose)\n    .on('cdata', handleCData)\n    .on('text', function(text, decodeEntities) {\n      handleText(decodeEntities(text));\n    })\n    .on('error', handleError)\n    .on('warn', handleWarning);\n\n  // deferred parse XML to make loading really ascnchronous\n  // this ensures the execution environment (node or browser)\n  // is kept responsive and that certain optimization strategies\n  // can kick in\n  defer(function() {\n    var err;\n\n    try {\n      parser.parse(xml);\n\n      resolveReferences();\n    } catch (e) {\n      err = e;\n    }\n\n    var element = rootHandler.element;\n\n    // handle the situation that we could not extract\n    // the desired root element from the document\n    if (!err && !element) {\n      err = error('failed to parse document as <' + rootHandler.type.$descriptor.name + '>');\n    }\n\n    done(err, err ? undefined : element, context);\n  });\n};\n\nReader.prototype.handler = function(name) {\n  return new RootElementHandler(this.model, name);\n};","import {\n  map,\n  forEach,\n  isString,\n  filter,\n  assign\n} from 'min-dash';\n\nimport {\n  isSimple as isSimpleType\n} from 'moddle/lib/types';\n\nimport {\n  parseName as parseNameNs\n} from 'moddle/lib/ns';\n\nimport {\n  hasLowerCaseAlias,\n  serializeAsType,\n  serializeAsProperty,\n  DEFAULT_NS_MAP,\n  XSI_TYPE\n} from './common';\n\nvar XML_PREAMBLE = '<?xml version=\"1.0\" encoding=\"UTF-8\"?>\\n';\n\nvar ESCAPE_ATTR_CHARS = /<|>|'|\"|&|\\n\\r|\\n/g;\nvar ESCAPE_CHARS =  /<|>|&/g;\n\n\nexport function Namespaces(parent) {\n\n  var prefixMap = {};\n  var uriMap = {};\n  var used = {};\n\n  var wellknown = [];\n  var custom = [];\n\n  // API\n\n  this.byUri = function(uri) {\n    return uriMap[uri] || (\n      parent && parent.byUri(uri)\n    );\n  };\n\n  this.add = function(ns, isWellknown) {\n\n    uriMap[ns.uri] = ns;\n\n    if (isWellknown) {\n      wellknown.push(ns);\n    } else {\n      custom.push(ns);\n    }\n\n    this.mapPrefix(ns.prefix, ns.uri);\n  };\n\n  this.uriByPrefix = function(prefix) {\n    return prefixMap[prefix || 'xmlns'];\n  };\n\n  this.mapPrefix = function(prefix, uri) {\n    prefixMap[prefix || 'xmlns'] = uri;\n  };\n\n  this.logUsed = function(ns) {\n    var uri = ns.uri;\n\n    used[uri] = this.byUri(uri);\n  };\n\n  this.getUsed = function(ns) {\n\n    function isUsed(ns) {\n      return used[ns.uri];\n    }\n\n    var allNs = [].concat(wellknown, custom);\n\n    return allNs.filter(isUsed);\n  };\n\n}\n\nfunction lower(string) {\n  return string.charAt(0).toLowerCase() + string.slice(1);\n}\n\nfunction nameToAlias(name, pkg) {\n  if (hasLowerCaseAlias(pkg)) {\n    return lower(name);\n  } else {\n    return name;\n  }\n}\n\nfunction inherits(ctor, superCtor) {\n  ctor.super_ = superCtor;\n  ctor.prototype = Object.create(superCtor.prototype, {\n    constructor: {\n      value: ctor,\n      enumerable: false,\n      writable: true,\n      configurable: true\n    }\n  });\n}\n\nfunction nsName(ns) {\n  if (isString(ns)) {\n    return ns;\n  } else {\n    return (ns.prefix ? ns.prefix + ':' : '') + ns.localName;\n  }\n}\n\nfunction getNsAttrs(namespaces) {\n\n  return map(namespaces.getUsed(), function(ns) {\n    var name = 'xmlns' + (ns.prefix ? ':' + ns.prefix : '');\n    return { name: name, value: ns.uri };\n  });\n\n}\n\nfunction getElementNs(ns, descriptor) {\n  if (descriptor.isGeneric) {\n    return assign({ localName: descriptor.ns.localName }, ns);\n  } else {\n    return assign({ localName: nameToAlias(descriptor.ns.localName, descriptor.$pkg) }, ns);\n  }\n}\n\nfunction getPropertyNs(ns, descriptor) {\n  return assign({ localName: descriptor.ns.localName }, ns);\n}\n\nfunction getSerializableProperties(element) {\n  var descriptor = element.$descriptor;\n\n  return filter(descriptor.properties, function(p) {\n    var name = p.name;\n\n    if (p.isVirtual) {\n      return false;\n    }\n\n    // do not serialize defaults\n    if (!element.hasOwnProperty(name)) {\n      return false;\n    }\n\n    var value = element[name];\n\n    // do not serialize default equals\n    if (value === p.default) {\n      return false;\n    }\n\n    // do not serialize null properties\n    if (value === null) {\n      return false;\n    }\n\n    return p.isMany ? value.length : true;\n  });\n}\n\nvar ESCAPE_ATTR_MAP = {\n  '\\n': '#10',\n  '\\n\\r': '#10',\n  '\"': '#34',\n  '\\'': '#39',\n  '<': '#60',\n  '>': '#62',\n  '&': '#38'\n};\n\nvar ESCAPE_MAP = {\n  '<': 'lt',\n  '>': 'gt',\n  '&': 'amp'\n};\n\nfunction escape(str, charPattern, replaceMap) {\n\n  // ensure we are handling strings here\n  str = isString(str) ? str : '' + str;\n\n  return str.replace(charPattern, function(s) {\n    return '&' + replaceMap[s] + ';';\n  });\n}\n\n/**\n * Escape a string attribute to not contain any bad values (line breaks, '\"', ...)\n *\n * @param {String} str the string to escape\n * @return {String} the escaped string\n */\nfunction escapeAttr(str) {\n  return escape(str, ESCAPE_ATTR_CHARS, ESCAPE_ATTR_MAP);\n}\n\nfunction escapeBody(str) {\n  return escape(str, ESCAPE_CHARS, ESCAPE_MAP);\n}\n\nfunction filterAttributes(props) {\n  return filter(props, function(p) { return p.isAttr; });\n}\n\nfunction filterContained(props) {\n  return filter(props, function(p) { return !p.isAttr; });\n}\n\n\nfunction ReferenceSerializer(tagName) {\n  this.tagName = tagName;\n}\n\nReferenceSerializer.prototype.build = function(element) {\n  this.element = element;\n  return this;\n};\n\nReferenceSerializer.prototype.serializeTo = function(writer) {\n  writer\n    .appendIndent()\n    .append('<' + this.tagName + '>' + this.element.id + '</' + this.tagName + '>')\n    .appendNewLine();\n};\n\nfunction BodySerializer() {}\n\nBodySerializer.prototype.serializeValue =\nBodySerializer.prototype.serializeTo = function(writer) {\n  writer.append(\n    this.escape\n      ? escapeBody(this.value)\n      : this.value\n  );\n};\n\nBodySerializer.prototype.build = function(prop, value) {\n  this.value = value;\n\n  if (prop.type === 'String' && value.search(ESCAPE_CHARS) !== -1) {\n    this.escape = true;\n  }\n\n  return this;\n};\n\nfunction ValueSerializer(tagName) {\n  this.tagName = tagName;\n}\n\ninherits(ValueSerializer, BodySerializer);\n\nValueSerializer.prototype.serializeTo = function(writer) {\n\n  writer\n    .appendIndent()\n    .append('<' + this.tagName + '>');\n\n  this.serializeValue(writer);\n\n  writer\n    .append('</' + this.tagName + '>')\n    .appendNewLine();\n};\n\nfunction ElementSerializer(parent, propertyDescriptor) {\n  this.body = [];\n  this.attrs = [];\n\n  this.parent = parent;\n  this.propertyDescriptor = propertyDescriptor;\n}\n\nElementSerializer.prototype.build = function(element) {\n  this.element = element;\n\n  var elementDescriptor = element.$descriptor,\n      propertyDescriptor = this.propertyDescriptor;\n\n  var otherAttrs,\n      properties;\n\n  var isGeneric = elementDescriptor.isGeneric;\n\n  if (isGeneric) {\n    otherAttrs = this.parseGeneric(element);\n  } else {\n    otherAttrs = this.parseNsAttributes(element);\n  }\n\n  if (propertyDescriptor) {\n    this.ns = this.nsPropertyTagName(propertyDescriptor);\n  } else {\n    this.ns = this.nsTagName(elementDescriptor);\n  }\n\n  // compute tag name\n  this.tagName = this.addTagName(this.ns);\n\n  if (!isGeneric) {\n    properties = getSerializableProperties(element);\n\n    this.parseAttributes(filterAttributes(properties));\n    this.parseContainments(filterContained(properties));\n  }\n\n  this.parseGenericAttributes(element, otherAttrs);\n\n  return this;\n};\n\nElementSerializer.prototype.nsTagName = function(descriptor) {\n  var effectiveNs = this.logNamespaceUsed(descriptor.ns);\n  return getElementNs(effectiveNs, descriptor);\n};\n\nElementSerializer.prototype.nsPropertyTagName = function(descriptor) {\n  var effectiveNs = this.logNamespaceUsed(descriptor.ns);\n  return getPropertyNs(effectiveNs, descriptor);\n};\n\nElementSerializer.prototype.isLocalNs = function(ns) {\n  return ns.uri === this.ns.uri;\n};\n\n/**\n * Get the actual ns attribute name for the given element.\n *\n * @param {Object} element\n * @param {Boolean} [element.inherited=false]\n *\n * @return {Object} nsName\n */\nElementSerializer.prototype.nsAttributeName = function(element) {\n\n  var ns;\n\n  if (isString(element)) {\n    ns = parseNameNs(element);\n  } else {\n    ns = element.ns;\n  }\n\n  // return just local name for inherited attributes\n  if (element.inherited) {\n    return { localName: ns.localName };\n  }\n\n  // parse + log effective ns\n  var effectiveNs = this.logNamespaceUsed(ns);\n\n  // LOG ACTUAL namespace use\n  this.getNamespaces().logUsed(effectiveNs);\n\n  // strip prefix if same namespace like parent\n  if (this.isLocalNs(effectiveNs)) {\n    return { localName: ns.localName };\n  } else {\n    return assign({ localName: ns.localName }, effectiveNs);\n  }\n};\n\nElementSerializer.prototype.parseGeneric = function(element) {\n\n  var self = this,\n      body = this.body;\n\n  var attributes = [];\n\n  forEach(element, function(val, key) {\n\n    var nonNsAttr;\n\n    if (key === '$body') {\n      body.push(new BodySerializer().build({ type: 'String' }, val));\n    } else\n    if (key === '$children') {\n      forEach(val, function(child) {\n        body.push(new ElementSerializer(self).build(child));\n      });\n    } else\n    if (key.indexOf('$') !== 0) {\n      nonNsAttr = self.parseNsAttribute(element, key, val);\n\n      if (nonNsAttr) {\n        attributes.push({ name: key, value: val });\n      }\n    }\n  });\n\n  return attributes;\n};\n\nElementSerializer.prototype.parseNsAttribute = function(element, name, value) {\n  var model = element.$model;\n\n  var nameNs = parseNameNs(name);\n\n  var ns;\n\n  // parse xmlns:foo=\"http://foo.bar\"\n  if (nameNs.prefix === 'xmlns') {\n    ns = { prefix: nameNs.localName, uri: value };\n  }\n\n  // parse xmlns=\"http://foo.bar\"\n  if (!nameNs.prefix && nameNs.localName === 'xmlns') {\n    ns = { uri: value };\n  }\n\n  if (!ns) {\n    return {\n      name: name,\n      value: value\n    };\n  }\n\n  if (model && model.getPackage(value)) {\n    // register well known namespace\n    this.logNamespace(ns, true, true);\n  } else {\n    // log custom namespace directly as used\n    var actualNs = this.logNamespaceUsed(ns, true);\n\n    this.getNamespaces().logUsed(actualNs);\n  }\n};\n\n\n/**\n * Parse namespaces and return a list of left over generic attributes\n *\n * @param  {Object} element\n * @return {Array<Object>}\n */\nElementSerializer.prototype.parseNsAttributes = function(element, attrs) {\n  var self = this;\n\n  var genericAttrs = element.$attrs;\n\n  var attributes = [];\n\n  // parse namespace attributes first\n  // and log them. push non namespace attributes to a list\n  // and process them later\n  forEach(genericAttrs, function(value, name) {\n\n    var nonNsAttr = self.parseNsAttribute(element, name, value);\n\n    if (nonNsAttr) {\n      attributes.push(nonNsAttr);\n    }\n  });\n\n  return attributes;\n};\n\nElementSerializer.prototype.parseGenericAttributes = function(element, attributes) {\n\n  var self = this;\n\n  forEach(attributes, function(attr) {\n\n    // do not serialize xsi:type attribute\n    // it is set manually based on the actual implementation type\n    if (attr.name === XSI_TYPE) {\n      return;\n    }\n\n    try {\n      self.addAttribute(self.nsAttributeName(attr.name), attr.value);\n    } catch (e) {\n      console.warn(\n        'missing namespace information for ',\n        attr.name, '=', attr.value, 'on', element,\n        e);\n    }\n  });\n};\n\nElementSerializer.prototype.parseContainments = function(properties) {\n\n  var self = this,\n      body = this.body,\n      element = this.element;\n\n  forEach(properties, function(p) {\n    var value = element.get(p.name),\n        isReference = p.isReference,\n        isMany = p.isMany;\n\n    if (!isMany) {\n      value = [ value ];\n    }\n\n    if (p.isBody) {\n      body.push(new BodySerializer().build(p, value[0]));\n    } else\n    if (isSimpleType(p.type)) {\n      forEach(value, function(v) {\n        body.push(new ValueSerializer(self.addTagName(self.nsPropertyTagName(p))).build(p, v));\n      });\n    } else\n    if (isReference) {\n      forEach(value, function(v) {\n        body.push(new ReferenceSerializer(self.addTagName(self.nsPropertyTagName(p))).build(v));\n      });\n    } else {\n      // allow serialization via type\n      // rather than element name\n      var asType = serializeAsType(p),\n          asProperty = serializeAsProperty(p);\n\n      forEach(value, function(v) {\n        var serializer;\n\n        if (asType) {\n          serializer = new TypeSerializer(self, p);\n        } else\n        if (asProperty) {\n          serializer = new ElementSerializer(self, p);\n        } else {\n          serializer = new ElementSerializer(self);\n        }\n\n        body.push(serializer.build(v));\n      });\n    }\n  });\n};\n\nElementSerializer.prototype.getNamespaces = function(local) {\n\n  var namespaces = this.namespaces,\n      parent = this.parent,\n      parentNamespaces;\n\n  if (!namespaces) {\n    parentNamespaces = parent && parent.getNamespaces();\n\n    if (local || !parentNamespaces) {\n      this.namespaces = namespaces = new Namespaces(parentNamespaces);\n    } else {\n      namespaces = parentNamespaces;\n    }\n  }\n\n  return namespaces;\n};\n\nElementSerializer.prototype.logNamespace = function(ns, wellknown, local) {\n  var namespaces = this.getNamespaces(local);\n\n  var nsUri = ns.uri,\n      nsPrefix = ns.prefix;\n\n  var existing = namespaces.byUri(nsUri);\n\n  if (!existing) {\n    namespaces.add(ns, wellknown);\n  }\n\n  namespaces.mapPrefix(nsPrefix, nsUri);\n\n  return ns;\n};\n\nElementSerializer.prototype.logNamespaceUsed = function(ns, local) {\n  var element = this.element,\n      model = element.$model,\n      namespaces = this.getNamespaces(local);\n\n  // ns may be\n  //\n  //   * prefix only\n  //   * prefix:uri\n  //   * localName only\n\n  var prefix = ns.prefix,\n      uri = ns.uri,\n      newPrefix, idx,\n      wellknownUri;\n\n  // handle anonymous namespaces (elementForm=unqualified), cf. #23\n  if (!prefix && !uri) {\n    return { localName: ns.localName };\n  }\n\n  wellknownUri = DEFAULT_NS_MAP[prefix] || model && (model.getPackage(prefix) || {}).uri;\n\n  uri = uri || wellknownUri || namespaces.uriByPrefix(prefix);\n\n  if (!uri) {\n    throw new Error('no namespace uri given for prefix <' + prefix + '>');\n  }\n\n  ns = namespaces.byUri(uri);\n\n  if (!ns) {\n    newPrefix = prefix;\n    idx = 1;\n\n    // find a prefix that is not mapped yet\n    while (namespaces.uriByPrefix(newPrefix)) {\n      newPrefix = prefix + '_' + idx++;\n    }\n\n    ns = this.logNamespace({ prefix: newPrefix, uri: uri }, wellknownUri === uri);\n  }\n\n  if (prefix) {\n    namespaces.mapPrefix(prefix, uri);\n  }\n\n  return ns;\n};\n\nElementSerializer.prototype.parseAttributes = function(properties) {\n  var self = this,\n      element = this.element;\n\n  forEach(properties, function(p) {\n\n    var value = element.get(p.name);\n\n    if (p.isReference) {\n\n      if (!p.isMany) {\n        value = value.id;\n      }\n      else {\n        var values = [];\n        forEach(value, function(v) {\n          values.push(v.id);\n        });\n        // IDREFS is a whitespace-separated list of references.\n        value = values.join(' ');\n      }\n\n    }\n\n    self.addAttribute(self.nsAttributeName(p), value);\n  });\n};\n\nElementSerializer.prototype.addTagName = function(nsTagName) {\n  var actualNs = this.logNamespaceUsed(nsTagName);\n\n  this.getNamespaces().logUsed(actualNs);\n\n  return nsName(nsTagName);\n};\n\nElementSerializer.prototype.addAttribute = function(name, value) {\n  var attrs = this.attrs;\n\n  if (isString(value)) {\n    value = escapeAttr(value);\n  }\n\n  attrs.push({ name: name, value: value });\n};\n\nElementSerializer.prototype.serializeAttributes = function(writer) {\n  var attrs = this.attrs,\n      namespaces = this.namespaces;\n\n  if (namespaces) {\n    attrs = getNsAttrs(namespaces).concat(attrs);\n  }\n\n  forEach(attrs, function(a) {\n    writer\n      .append(' ')\n      .append(nsName(a.name)).append('=\"').append(a.value).append('\"');\n  });\n};\n\nElementSerializer.prototype.serializeTo = function(writer) {\n  var firstBody = this.body[0],\n      indent = firstBody && firstBody.constructor !== BodySerializer;\n\n  writer\n    .appendIndent()\n    .append('<' + this.tagName);\n\n  this.serializeAttributes(writer);\n\n  writer.append(firstBody ? '>' : ' />');\n\n  if (firstBody) {\n\n    if (indent) {\n      writer\n        .appendNewLine()\n        .indent();\n    }\n\n    forEach(this.body, function(b) {\n      b.serializeTo(writer);\n    });\n\n    if (indent) {\n      writer\n        .unindent()\n        .appendIndent();\n    }\n\n    writer.append('</' + this.tagName + '>');\n  }\n\n  writer.appendNewLine();\n};\n\n/**\n * A serializer for types that handles serialization of data types\n */\nfunction TypeSerializer(parent, propertyDescriptor) {\n  ElementSerializer.call(this, parent, propertyDescriptor);\n}\n\ninherits(TypeSerializer, ElementSerializer);\n\nTypeSerializer.prototype.parseNsAttributes = function(element) {\n\n  // extracted attributes\n  var attributes = ElementSerializer.prototype.parseNsAttributes.call(this, element);\n\n  var descriptor = element.$descriptor;\n\n  // only serialize xsi:type if necessary\n  if (descriptor.name === this.propertyDescriptor.type) {\n    return attributes;\n  }\n\n  var typeNs = this.typeNs = this.nsTagName(descriptor);\n  this.getNamespaces().logUsed(this.typeNs);\n\n  // add xsi:type attribute to represent the elements\n  // actual type\n\n  var pkg = element.$model.getPackage(typeNs.uri),\n      typePrefix = (pkg.xml && pkg.xml.typePrefix) || '';\n\n  this.addAttribute(\n    this.nsAttributeName(XSI_TYPE),\n    (typeNs.prefix ? typeNs.prefix + ':' : '') + typePrefix + descriptor.ns.localName\n  );\n\n  return attributes;\n};\n\nTypeSerializer.prototype.isLocalNs = function(ns) {\n  return ns.uri === (this.typeNs || this.ns).uri;\n};\n\nfunction SavingWriter() {\n  this.value = '';\n\n  this.write = function(str) {\n    this.value += str;\n  };\n}\n\nfunction FormatingWriter(out, format) {\n\n  var indent = [''];\n\n  this.append = function(str) {\n    out.write(str);\n\n    return this;\n  };\n\n  this.appendNewLine = function() {\n    if (format) {\n      out.write('\\n');\n    }\n\n    return this;\n  };\n\n  this.appendIndent = function() {\n    if (format) {\n      out.write(indent.join('  '));\n    }\n\n    return this;\n  };\n\n  this.indent = function() {\n    indent.push('');\n    return this;\n  };\n\n  this.unindent = function() {\n    indent.pop();\n    return this;\n  };\n}\n\n/**\n * A writer for meta-model backed document trees\n *\n * @param {Object} options output options to pass into the writer\n */\nexport function Writer(options) {\n\n  options = assign({ format: false, preamble: true }, options || {});\n\n  function toXML(tree, writer) {\n    var internalWriter = writer || new SavingWriter();\n    var formatingWriter = new FormatingWriter(internalWriter, options.format);\n\n    if (options.preamble) {\n      formatingWriter.append(XML_PREAMBLE);\n    }\n\n    new ElementSerializer().build(tree).serializeTo(formatingWriter);\n\n    if (!writer) {\n      return internalWriter.value;\n    }\n  }\n\n  return {\n    toXML: toXML\n  };\n}","export {\n  default\n} from './lib/moddle';","/**\n * Moddle base element.\n */\nexport default function Base() { }\n\nBase.prototype.get = function(name) {\n  return this.$model.properties.get(this, name);\n};\n\nBase.prototype.set = function(name, value) {\n  this.$model.properties.set(this, name, value);\n};","import {\n  pick,\n  assign,\n  forEach,\n  bind\n} from 'min-dash';\n\nimport {\n  parseName as parseNameNs\n} from './ns';\n\n\n/**\n * A utility to build element descriptors.\n */\nexport default function DescriptorBuilder(nameNs) {\n  this.ns = nameNs;\n  this.name = nameNs.name;\n  this.allTypes = [];\n  this.allTypesByName = {};\n  this.properties = [];\n  this.propertiesByName = {};\n}\n\n\nDescriptorBuilder.prototype.build = function() {\n  return pick(this, [\n    'ns',\n    'name',\n    'allTypes',\n    'allTypesByName',\n    'properties',\n    'propertiesByName',\n    'bodyProperty',\n    'idProperty'\n  ]);\n};\n\n/**\n * Add property at given index.\n *\n * @param {Object} p\n * @param {Number} [idx]\n * @param {Boolean} [validate=true]\n */\nDescriptorBuilder.prototype.addProperty = function(p, idx, validate) {\n\n  if (typeof idx === 'boolean') {\n    validate = idx;\n    idx = undefined;\n  }\n\n  this.addNamedProperty(p, validate !== false);\n\n  var properties = this.properties;\n\n  if (idx !== undefined) {\n    properties.splice(idx, 0, p);\n  } else {\n    properties.push(p);\n  }\n};\n\n\nDescriptorBuilder.prototype.replaceProperty = function(oldProperty, newProperty, replace) {\n  var oldNameNs = oldProperty.ns;\n\n  var props = this.properties,\n      propertiesByName = this.propertiesByName,\n      rename = oldProperty.name !== newProperty.name;\n\n  if (oldProperty.isId) {\n    if (!newProperty.isId) {\n      throw new Error(\n        'property <' + newProperty.ns.name + '> must be id property ' +\n        'to refine <' + oldProperty.ns.name + '>');\n    }\n\n    this.setIdProperty(newProperty, false);\n  }\n\n  if (oldProperty.isBody) {\n\n    if (!newProperty.isBody) {\n      throw new Error(\n        'property <' + newProperty.ns.name + '> must be body property ' +\n        'to refine <' + oldProperty.ns.name + '>');\n    }\n\n    // TODO: Check compatibility\n    this.setBodyProperty(newProperty, false);\n  }\n\n  // validate existence and get location of old property\n  var idx = props.indexOf(oldProperty);\n  if (idx === -1) {\n    throw new Error('property <' + oldNameNs.name + '> not found in property list');\n  }\n\n  // remove old property\n  props.splice(idx, 1);\n\n  // replacing the named property is intentional\n  //\n  //  * validate only if this is a \"rename\" operation\n  //  * add at specific index unless we \"replace\"\n  //\n  this.addProperty(newProperty, replace ? undefined : idx, rename);\n\n  // make new property available under old name\n  propertiesByName[oldNameNs.name] = propertiesByName[oldNameNs.localName] = newProperty;\n};\n\n\nDescriptorBuilder.prototype.redefineProperty = function(p, targetPropertyName, replace) {\n\n  var nsPrefix = p.ns.prefix;\n  var parts = targetPropertyName.split('#');\n\n  var name = parseNameNs(parts[0], nsPrefix);\n  var attrName = parseNameNs(parts[1], name.prefix).name;\n\n  var redefinedProperty = this.propertiesByName[attrName];\n  if (!redefinedProperty) {\n    throw new Error('refined property <' + attrName + '> not found');\n  } else {\n    this.replaceProperty(redefinedProperty, p, replace);\n  }\n\n  delete p.redefines;\n};\n\nDescriptorBuilder.prototype.addNamedProperty = function(p, validate) {\n  var ns = p.ns,\n      propsByName = this.propertiesByName;\n\n  if (validate) {\n    this.assertNotDefined(p, ns.name);\n    this.assertNotDefined(p, ns.localName);\n  }\n\n  propsByName[ns.name] = propsByName[ns.localName] = p;\n};\n\nDescriptorBuilder.prototype.removeNamedProperty = function(p) {\n  var ns = p.ns,\n      propsByName = this.propertiesByName;\n\n  delete propsByName[ns.name];\n  delete propsByName[ns.localName];\n};\n\nDescriptorBuilder.prototype.setBodyProperty = function(p, validate) {\n\n  if (validate && this.bodyProperty) {\n    throw new Error(\n      'body property defined multiple times ' +\n      '(<' + this.bodyProperty.ns.name + '>, <' + p.ns.name + '>)');\n  }\n\n  this.bodyProperty = p;\n};\n\nDescriptorBuilder.prototype.setIdProperty = function(p, validate) {\n\n  if (validate && this.idProperty) {\n    throw new Error(\n      'id property defined multiple times ' +\n      '(<' + this.idProperty.ns.name + '>, <' + p.ns.name + '>)');\n  }\n\n  this.idProperty = p;\n};\n\nDescriptorBuilder.prototype.assertNotDefined = function(p, name) {\n  var propertyName = p.name,\n      definedProperty = this.propertiesByName[propertyName];\n\n  if (definedProperty) {\n    throw new Error(\n      'property <' + propertyName + '> already defined; ' +\n      'override of <' + definedProperty.definedBy.ns.name + '#' + definedProperty.ns.name + '> by ' +\n      '<' + p.definedBy.ns.name + '#' + p.ns.name + '> not allowed without redefines');\n  }\n};\n\nDescriptorBuilder.prototype.hasProperty = function(name) {\n  return this.propertiesByName[name];\n};\n\nDescriptorBuilder.prototype.addTrait = function(t, inherited) {\n\n  var typesByName = this.allTypesByName,\n      types = this.allTypes;\n\n  var typeName = t.name;\n\n  if (typeName in typesByName) {\n    return;\n  }\n\n  forEach(t.properties, bind(function(p) {\n\n    // clone property to allow extensions\n    p = assign({}, p, {\n      name: p.ns.localName,\n      inherited: inherited\n    });\n\n    Object.defineProperty(p, 'definedBy', {\n      value: t\n    });\n\n    var replaces = p.replaces,\n        redefines = p.redefines;\n\n    // add replace/redefine support\n    if (replaces || redefines) {\n      this.redefineProperty(p, replaces || redefines, replaces);\n    } else {\n      if (p.isBody) {\n        this.setBodyProperty(p);\n      }\n      if (p.isId) {\n        this.setIdProperty(p);\n      }\n      this.addProperty(p);\n    }\n  }, this));\n\n  types.push(t);\n  typesByName[typeName] = t;\n};","import {\n  forEach,\n  bind\n} from 'min-dash';\n\nimport Base from './base';\n\n/**\n * A model element factory.\n *\n * @param {Moddle} model\n * @param {Properties} properties\n */\nexport default function Factory(model, properties) {\n  this.model = model;\n  this.properties = properties;\n}\n\n\nFactory.prototype.createType = function(descriptor) {\n\n  var model = this.model;\n\n  var props = this.properties,\n      prototype = Object.create(Base.prototype);\n\n  // initialize default values\n  forEach(descriptor.properties, function(p) {\n    if (!p.isMany && p.default !== undefined) {\n      prototype[p.name] = p.default;\n    }\n  });\n\n  props.defineModel(prototype, model);\n  props.defineDescriptor(prototype, descriptor);\n\n  var name = descriptor.ns.name;\n\n  /**\n   * The new type constructor\n   */\n  function ModdleElement(attrs) {\n    props.define(this, '$type', { value: name, enumerable: true });\n    props.define(this, '$attrs', { value: {} });\n    props.define(this, '$parent', { writable: true });\n\n    forEach(attrs, bind(function(val, key) {\n      this.set(key, val);\n    }, this));\n  }\n\n  ModdleElement.prototype = prototype;\n\n  ModdleElement.hasType = prototype.$instanceOf = this.model.hasType;\n\n  // static links\n  props.defineModel(ModdleElement, model);\n  props.defineDescriptor(ModdleElement, descriptor);\n\n  return ModdleElement;\n};","import {\n  isString,\n  isObject,\n  forEach\n} from 'min-dash';\n\nimport Factory from './factory';\nimport Registry from './registry';\nimport Properties from './properties';\n\nimport {\n  parseName as parseNameNs\n} from './ns';\n\n\n//// Moddle implementation /////////////////////////////////////////////////\n\n/**\n * @class Moddle\n *\n * A model that can be used to create elements of a specific type.\n *\n * @example\n *\n * var Moddle = require('moddle');\n *\n * var pkg = {\n *   name: 'mypackage',\n *   prefix: 'my',\n *   types: [\n *     { name: 'Root' }\n *   ]\n * };\n *\n * var moddle = new Moddle([pkg]);\n *\n * @param {Array<Package>} packages the packages to contain\n */\nexport default function Moddle(packages) {\n\n  this.properties = new Properties(this);\n\n  this.factory = new Factory(this, this.properties);\n  this.registry = new Registry(packages, this.properties);\n\n  this.typeCache = {};\n}\n\n\n/**\n * Create an instance of the specified type.\n *\n * @method Moddle#create\n *\n * @example\n *\n * var foo = moddle.create('my:Foo');\n * var bar = moddle.create('my:Bar', { id: 'BAR_1' });\n *\n * @param  {String|Object} descriptor the type descriptor or name know to the model\n * @param  {Object} attrs   a number of attributes to initialize the model instance with\n * @return {Object}         model instance\n */\nModdle.prototype.create = function(descriptor, attrs) {\n  var Type = this.getType(descriptor);\n\n  if (!Type) {\n    throw new Error('unknown type <' + descriptor + '>');\n  }\n\n  return new Type(attrs);\n};\n\n\n/**\n * Returns the type representing a given descriptor\n *\n * @method Moddle#getType\n *\n * @example\n *\n * var Foo = moddle.getType('my:Foo');\n * var foo = new Foo({ 'id' : 'FOO_1' });\n *\n * @param  {String|Object} descriptor the type descriptor or name know to the model\n * @return {Object}         the type representing the descriptor\n */\nModdle.prototype.getType = function(descriptor) {\n\n  var cache = this.typeCache;\n\n  var name = isString(descriptor) ? descriptor : descriptor.ns.name;\n\n  var type = cache[name];\n\n  if (!type) {\n    descriptor = this.registry.getEffectiveDescriptor(name);\n    type = cache[name] = this.factory.createType(descriptor);\n  }\n\n  return type;\n};\n\n\n/**\n * Creates an any-element type to be used within model instances.\n *\n * This can be used to create custom elements that lie outside the meta-model.\n * The created element contains all the meta-data required to serialize it\n * as part of meta-model elements.\n *\n * @method Moddle#createAny\n *\n * @example\n *\n * var foo = moddle.createAny('vendor:Foo', 'http://vendor', {\n *   value: 'bar'\n * });\n *\n * var container = moddle.create('my:Container', 'http://my', {\n *   any: [ foo ]\n * });\n *\n * // go ahead and serialize the stuff\n *\n *\n * @param  {String} name  the name of the element\n * @param  {String} nsUri the namespace uri of the element\n * @param  {Object} [properties] a map of properties to initialize the instance with\n * @return {Object} the any type instance\n */\nModdle.prototype.createAny = function(name, nsUri, properties) {\n\n  var nameNs = parseNameNs(name);\n\n  var element = {\n    $type: name,\n    $instanceOf: function(type) {\n      return type === this.$type;\n    }\n  };\n\n  var descriptor = {\n    name: name,\n    isGeneric: true,\n    ns: {\n      prefix: nameNs.prefix,\n      localName: nameNs.localName,\n      uri: nsUri\n    }\n  };\n\n  this.properties.defineDescriptor(element, descriptor);\n  this.properties.defineModel(element, this);\n  this.properties.define(element, '$parent', { enumerable: false, writable: true });\n\n  forEach(properties, function(a, key) {\n    if (isObject(a) && a.value !== undefined) {\n      element[a.name] = a.value;\n    } else {\n      element[key] = a;\n    }\n  });\n\n  return element;\n};\n\n/**\n * Returns a registered package by uri or prefix\n *\n * @return {Object} the package\n */\nModdle.prototype.getPackage = function(uriOrPrefix) {\n  return this.registry.getPackage(uriOrPrefix);\n};\n\n/**\n * Returns a snapshot of all known packages\n *\n * @return {Object} the package\n */\nModdle.prototype.getPackages = function() {\n  return this.registry.getPackages();\n};\n\n/**\n * Returns the descriptor for an element\n */\nModdle.prototype.getElementDescriptor = function(element) {\n  return element.$descriptor;\n};\n\n/**\n * Returns true if the given descriptor or instance\n * represents the given type.\n *\n * May be applied to this, if element is omitted.\n */\nModdle.prototype.hasType = function(element, type) {\n  if (type === undefined) {\n    type = element;\n    element = this;\n  }\n\n  var descriptor = element.$model.getElementDescriptor(element);\n\n  return (type in descriptor.allTypesByName);\n};\n\n/**\n * Returns the descriptor of an elements named property\n */\nModdle.prototype.getPropertyDescriptor = function(element, property) {\n  return this.getElementDescriptor(element).propertiesByName[property];\n};\n\n/**\n * Returns a mapped type's descriptor\n */\nModdle.prototype.getTypeDescriptor = function(type) {\n  return this.registry.typeMap[type];\n};","/**\n * Parses a namespaced attribute name of the form (ns:)localName to an object,\n * given a default prefix to assume in case no explicit namespace is given.\n *\n * @param {String} name\n * @param {String} [defaultPrefix] the default prefix to take, if none is present.\n *\n * @return {Object} the parsed name\n */\nexport function parseName(name, defaultPrefix) {\n  var parts = name.split(/:/),\n      localName, prefix;\n\n  // no prefix (i.e. only local name)\n  if (parts.length === 1) {\n    localName = name;\n    prefix = defaultPrefix;\n  } else\n  // prefix + local name\n  if (parts.length === 2) {\n    localName = parts[1];\n    prefix = parts[0];\n  } else {\n    throw new Error('expected <prefix:localName> or <localName>, got ' + name);\n  }\n\n  name = (prefix ? prefix + ':' : '') + localName;\n\n  return {\n    name: name,\n    prefix: prefix,\n    localName: localName\n  };\n}","/**\n * A utility that gets and sets properties of model elements.\n *\n * @param {Model} model\n */\nexport default function Properties(model) {\n  this.model = model;\n}\n\n\n/**\n * Sets a named property on the target element.\n * If the value is undefined, the property gets deleted.\n *\n * @param {Object} target\n * @param {String} name\n * @param {Object} value\n */\nProperties.prototype.set = function(target, name, value) {\n\n  var property = this.model.getPropertyDescriptor(target, name);\n\n  var propertyName = property && property.name;\n\n  if (isUndefined(value)) {\n    // unset the property, if the specified value is undefined;\n    // delete from $attrs (for extensions) or the target itself\n    if (property) {\n      delete target[propertyName];\n    } else {\n      delete target.$attrs[name];\n    }\n  } else {\n    // set the property, defining well defined properties on the fly\n    // or simply updating them in target.$attrs (for extensions)\n    if (property) {\n      if (propertyName in target) {\n        target[propertyName] = value;\n      } else {\n        defineProperty(target, property, value);\n      }\n    } else {\n      target.$attrs[name] = value;\n    }\n  }\n};\n\n/**\n * Returns the named property of the given element\n *\n * @param  {Object} target\n * @param  {String} name\n *\n * @return {Object}\n */\nProperties.prototype.get = function(target, name) {\n\n  var property = this.model.getPropertyDescriptor(target, name);\n\n  if (!property) {\n    return target.$attrs[name];\n  }\n\n  var propertyName = property.name;\n\n  // check if access to collection property and lazily initialize it\n  if (!target[propertyName] && property.isMany) {\n    defineProperty(target, property, []);\n  }\n\n  return target[propertyName];\n};\n\n\n/**\n * Define a property on the target element\n *\n * @param  {Object} target\n * @param  {String} name\n * @param  {Object} options\n */\nProperties.prototype.define = function(target, name, options) {\n  Object.defineProperty(target, name, options);\n};\n\n\n/**\n * Define the descriptor for an element\n */\nProperties.prototype.defineDescriptor = function(target, descriptor) {\n  this.define(target, '$descriptor', { value: descriptor });\n};\n\n/**\n * Define the model for an element\n */\nProperties.prototype.defineModel = function(target, model) {\n  this.define(target, '$model', { value: model });\n};\n\n\nfunction isUndefined(val) {\n  return typeof val === 'undefined';\n}\n\nfunction defineProperty(target, property, value) {\n  Object.defineProperty(target, property.name, {\n    enumerable: !property.isReference,\n    writable: true,\n    value: value,\n    configurable: true\n  });\n}","import {\n  assign,\n  forEach,\n  bind\n} from 'min-dash';\n\nimport {\n  isBuiltIn as isBuiltInType\n} from './types';\n\nimport DescriptorBuilder from './descriptor-builder';\n\nimport {\n  parseName as parseNameNs\n} from './ns';\n\n\n/**\n * A registry of Moddle packages.\n *\n * @param {Array<Package>} packages\n * @param {Properties} properties\n */\nexport default function Registry(packages, properties) {\n  this.packageMap = {};\n  this.typeMap = {};\n\n  this.packages = [];\n\n  this.properties = properties;\n\n  forEach(packages, bind(this.registerPackage, this));\n}\n\n\nRegistry.prototype.getPackage = function(uriOrPrefix) {\n  return this.packageMap[uriOrPrefix];\n};\n\nRegistry.prototype.getPackages = function() {\n  return this.packages;\n};\n\n\nRegistry.prototype.registerPackage = function(pkg) {\n\n  // copy package\n  pkg = assign({}, pkg);\n\n  var pkgMap = this.packageMap;\n\n  ensureAvailable(pkgMap, pkg, 'prefix');\n  ensureAvailable(pkgMap, pkg, 'uri');\n\n  // register types\n  forEach(pkg.types, bind(function(descriptor) {\n    this.registerType(descriptor, pkg);\n  }, this));\n\n  pkgMap[pkg.uri] = pkgMap[pkg.prefix] = pkg;\n  this.packages.push(pkg);\n};\n\n\n/**\n * Register a type from a specific package with us\n */\nRegistry.prototype.registerType = function(type, pkg) {\n\n  type = assign({}, type, {\n    superClass: (type.superClass || []).slice(),\n    extends: (type.extends || []).slice(),\n    properties: (type.properties || []).slice(),\n    meta: assign(({}, type.meta || {}))\n  });\n\n  var ns = parseNameNs(type.name, pkg.prefix),\n      name = ns.name,\n      propertiesByName = {};\n\n  // parse properties\n  forEach(type.properties, bind(function(p) {\n\n    // namespace property names\n    var propertyNs = parseNameNs(p.name, ns.prefix),\n        propertyName = propertyNs.name;\n\n    // namespace property types\n    if (!isBuiltInType(p.type)) {\n      p.type = parseNameNs(p.type, propertyNs.prefix).name;\n    }\n\n    assign(p, {\n      ns: propertyNs,\n      name: propertyName\n    });\n\n    propertiesByName[propertyName] = p;\n  }, this));\n\n  // update ns + name\n  assign(type, {\n    ns: ns,\n    name: name,\n    propertiesByName: propertiesByName\n  });\n\n  forEach(type.extends, bind(function(extendsName) {\n    var extended = this.typeMap[extendsName];\n\n    extended.traits = extended.traits || [];\n    extended.traits.push(name);\n  }, this));\n\n  // link to package\n  this.definePackage(type, pkg);\n\n  // register\n  this.typeMap[name] = type;\n};\n\n\n/**\n * Traverse the type hierarchy from bottom to top,\n * calling iterator with (type, inherited) for all elements in\n * the inheritance chain.\n *\n * @param {Object} nsName\n * @param {Function} iterator\n * @param {Boolean} [trait=false]\n */\nRegistry.prototype.mapTypes = function(nsName, iterator, trait) {\n\n  var type = isBuiltInType(nsName.name) ? { name: nsName.name } : this.typeMap[nsName.name];\n\n  var self = this;\n\n  /**\n   * Traverse the selected trait.\n   *\n   * @param {String} cls\n   */\n  function traverseTrait(cls) {\n    return traverseSuper(cls, true);\n  }\n\n  /**\n   * Traverse the selected super type or trait\n   *\n   * @param {String} cls\n   * @param {Boolean} [trait=false]\n   */\n  function traverseSuper(cls, trait) {\n    var parentNs = parseNameNs(cls, isBuiltInType(cls) ? '' : nsName.prefix);\n    self.mapTypes(parentNs, iterator, trait);\n  }\n\n  if (!type) {\n    throw new Error('unknown type <' + nsName.name + '>');\n  }\n\n  forEach(type.superClass, trait ? traverseTrait : traverseSuper);\n\n  // call iterator with (type, inherited=!trait)\n  iterator(type, !trait);\n\n  forEach(type.traits, traverseTrait);\n};\n\n\n/**\n * Returns the effective descriptor for a type.\n *\n * @param  {String} type the namespaced name (ns:localName) of the type\n *\n * @return {Descriptor} the resulting effective descriptor\n */\nRegistry.prototype.getEffectiveDescriptor = function(name) {\n\n  var nsName = parseNameNs(name);\n\n  var builder = new DescriptorBuilder(nsName);\n\n  this.mapTypes(nsName, function(type, inherited) {\n    builder.addTrait(type, inherited);\n  });\n\n  var descriptor = builder.build();\n\n  // define package link\n  this.definePackage(descriptor, descriptor.allTypes[descriptor.allTypes.length - 1].$pkg);\n\n  return descriptor;\n};\n\n\nRegistry.prototype.definePackage = function(target, pkg) {\n  this.properties.define(target, '$pkg', { value: pkg });\n};\n\n\n\n///////// helpers ////////////////////////////\n\nfunction ensureAvailable(packageMap, pkg, identifierKey) {\n\n  var value = pkg[identifierKey];\n\n  if (value in packageMap) {\n    throw new Error('package with ' + identifierKey + ' <' + value + '> already defined');\n  }\n}\n","/**\n * Built-in moddle types\n */\nvar BUILTINS = {\n  String: true,\n  Boolean: true,\n  Integer: true,\n  Real: true,\n  Element: true\n};\n\n/**\n * Converters for built in types from string representations\n */\nvar TYPE_CONVERTERS = {\n  String: function(s) { return s; },\n  Boolean: function(s) { return s === 'true'; },\n  Integer: function(s) { return parseInt(s, 10); },\n  Real: function(s) { return parseFloat(s, 10); }\n};\n\n/**\n * Convert a type to its real representation\n */\nexport function coerceType(type, value) {\n\n  var converter = TYPE_CONVERTERS[type];\n\n  if (converter) {\n    return converter(value);\n  } else {\n    return value;\n  }\n}\n\n/**\n * Return whether the given type is built-in\n */\nexport function isBuiltIn(type) {\n  return !!BUILTINS[type];\n}\n\n/**\n * Return whether the given type is simple\n */\nexport function isSimple(type) {\n  return !!TYPE_CONVERTERS[type];\n}","module.exports = require('./lib/refs');\n\nmodule.exports.Collection = require('./lib/collection');","'use strict';\n\n/**\n * An empty collection stub. Use {@link RefsCollection.extend} to extend a\n * collection with ref semantics.\n *\n * @class RefsCollection\n */\n\n/**\n * Extends a collection with {@link Refs} aware methods\n *\n * @memberof RefsCollection\n * @static\n *\n * @param  {Array<Object>} collection\n * @param  {Refs} refs instance\n * @param  {Object} property represented by the collection\n * @param  {Object} target object the collection is attached to\n *\n * @return {RefsCollection<Object>} the extended array\n */\nfunction extend(collection, refs, property, target) {\n\n  var inverseProperty = property.inverse;\n\n  /**\n   * Removes the given element from the array and returns it.\n   *\n   * @method RefsCollection#remove\n   *\n   * @param {Object} element the element to remove\n   */\n  Object.defineProperty(collection, 'remove', {\n    value: function(element) {\n      var idx = this.indexOf(element);\n      if (idx !== -1) {\n        this.splice(idx, 1);\n\n        // unset inverse\n        refs.unset(element, inverseProperty, target);\n      }\n\n      return element;\n    }\n  });\n\n  /**\n   * Returns true if the collection contains the given element\n   *\n   * @method RefsCollection#contains\n   *\n   * @param {Object} element the element to check for\n   */\n  Object.defineProperty(collection, 'contains', {\n    value: function(element) {\n      return this.indexOf(element) !== -1;\n    }\n  });\n\n  /**\n   * Adds an element to the array, unless it exists already (set semantics).\n   *\n   * @method RefsCollection#add\n   *\n   * @param {Object} element the element to add\n   * @param {Number} optional index to add element to\n   *                 (possibly moving other elements around)\n   */\n  Object.defineProperty(collection, 'add', {\n    value: function(element, idx) {\n\n      var currentIdx = this.indexOf(element);\n\n      if (typeof idx === 'undefined') {\n\n        if (currentIdx !== -1) {\n          // element already in collection (!)\n          return;\n        }\n\n        // add to end of array, as no idx is specified\n        idx = this.length;\n      }\n\n      // handle already in collection\n      if (currentIdx !== -1) {\n\n        // remove element from currentIdx\n        this.splice(currentIdx, 1);\n      }\n\n      // add element at idx\n      this.splice(idx, 0, element);\n\n      if (currentIdx === -1) {\n        // set inverse, unless element was\n        // in collection already\n        refs.set(element, inverseProperty, target);\n      }\n    }\n  });\n\n  // a simple marker, identifying this element\n  // as being a refs collection\n  Object.defineProperty(collection, '__refs_collection', {\n    value: true\n  });\n\n  return collection;\n}\n\n\nfunction isExtended(collection) {\n  return collection.__refs_collection === true;\n}\n\nmodule.exports.extend = extend;\n\nmodule.exports.isExtended = isExtended;","'use strict';\n\nvar Collection = require('./collection');\n\nfunction hasOwnProperty(e, property) {\n  return Object.prototype.hasOwnProperty.call(e, property.name || property);\n}\n\nfunction defineCollectionProperty(ref, property, target) {\n\n  var collection = Collection.extend(target[property.name] || [], ref, property, target);\n\n  Object.defineProperty(target, property.name, {\n    enumerable: property.enumerable,\n    value: collection\n  });\n\n  if (collection.length) {\n\n    collection.forEach(function(o) {\n      ref.set(o, property.inverse, target);\n    });\n  }\n}\n\n\nfunction defineProperty(ref, property, target) {\n\n  var inverseProperty = property.inverse;\n\n  var _value = target[property.name];\n\n  Object.defineProperty(target, property.name, {\n    configurable: property.configurable,\n    enumerable: property.enumerable,\n\n    get: function() {\n      return _value;\n    },\n\n    set: function(value) {\n\n      // return if we already performed all changes\n      if (value === _value) {\n        return;\n      }\n\n      var old = _value;\n\n      // temporary set null\n      _value = null;\n\n      if (old) {\n        ref.unset(old, inverseProperty, target);\n      }\n\n      // set new value\n      _value = value;\n\n      // set inverse value\n      ref.set(_value, inverseProperty, target);\n    }\n  });\n\n}\n\n/**\n * Creates a new references object defining two inversly related\n * attribute descriptors a and b.\n *\n * <p>\n *   When bound to an object using {@link Refs#bind} the references\n *   get activated and ensure that add and remove operations are applied\n *   reversely, too.\n * </p>\n *\n * <p>\n *   For attributes represented as collections {@link Refs} provides the\n *   {@link RefsCollection#add}, {@link RefsCollection#remove} and {@link RefsCollection#contains} extensions\n *   that must be used to properly hook into the inverse change mechanism.\n * </p>\n *\n * @class Refs\n *\n * @classdesc A bi-directional reference between two attributes.\n *\n * @param {Refs.AttributeDescriptor} a property descriptor\n * @param {Refs.AttributeDescriptor} b property descriptor\n *\n * @example\n *\n * var refs = Refs({ name: 'wheels', collection: true, enumerable: true }, { name: 'car' });\n *\n * var car = { name: 'toyota' };\n * var wheels = [{ pos: 'front-left' }, { pos: 'front-right' }];\n *\n * refs.bind(car, 'wheels');\n *\n * car.wheels // []\n * car.wheels.add(wheels[0]);\n * car.wheels.add(wheels[1]);\n *\n * car.wheels // [{ pos: 'front-left' }, { pos: 'front-right' }]\n *\n * wheels[0].car // { name: 'toyota' };\n * car.wheels.remove(wheels[0]);\n *\n * wheels[0].car // undefined\n */\nfunction Refs(a, b) {\n\n  if (!(this instanceof Refs)) {\n    return new Refs(a, b);\n  }\n\n  // link\n  a.inverse = b;\n  b.inverse = a;\n\n  this.props = {};\n  this.props[a.name] = a;\n  this.props[b.name] = b;\n}\n\n/**\n * Binds one side of a bi-directional reference to a\n * target object.\n *\n * @memberOf Refs\n *\n * @param  {Object} target\n * @param  {String} property\n */\nRefs.prototype.bind = function(target, property) {\n  if (typeof property === 'string') {\n    if (!this.props[property]) {\n      throw new Error('no property <' + property + '> in ref');\n    }\n    property = this.props[property];\n  }\n\n  if (property.collection) {\n    defineCollectionProperty(this, property, target);\n  } else {\n    defineProperty(this, property, target);\n  }\n};\n\nRefs.prototype.ensureRefsCollection = function(target, property) {\n\n  var collection = target[property.name];\n\n  if (!Collection.isExtended(collection)) {\n    defineCollectionProperty(this, property, target);\n  }\n\n  return collection;\n};\n\nRefs.prototype.ensureBound = function(target, property) {\n  if (!hasOwnProperty(target, property)) {\n    this.bind(target, property);\n  }\n};\n\nRefs.prototype.unset = function(target, property, value) {\n\n  if (target) {\n    this.ensureBound(target, property);\n\n    if (property.collection) {\n      this.ensureRefsCollection(target, property).remove(value);\n    } else {\n      target[property.name] = undefined;\n    }\n  }\n};\n\nRefs.prototype.set = function(target, property, value) {\n\n  if (target) {\n    this.ensureBound(target, property);\n\n    if (property.collection) {\n      this.ensureRefsCollection(target, property).add(value);\n    } else {\n      target[property.name] = value;\n    }\n  }\n};\n\nmodule.exports = Refs;\n\n\n/**\n * An attribute descriptor to be used specify an attribute in a {@link Refs} instance\n *\n * @typedef {Object} Refs.AttributeDescriptor\n * @property {String} name\n * @property {boolean} [collection=false]\n * @property {boolean} [enumerable=false]\n */","'use strict';\n\n/**\n * This file contains portions that got extraced from Snap.svg (licensed Apache-2.0).\n *\n * @see https://github.com/adobe-webplatform/Snap.svg/blob/master/src/path.js\n */\n\n/* eslint no-fallthrough: \"off\" */\n\nvar has = 'hasOwnProperty',\n    p2s = /,?([a-z]),?/gi,\n    toFloat = parseFloat,\n    math = Math,\n    PI = math.PI,\n    mmin = math.min,\n    mmax = math.max,\n    pow = math.pow,\n    abs = math.abs,\n    pathCommand = /([a-z])[\\s,]*((-?\\d*\\.?\\d*(?:e[-+]?\\d+)?[\\s]*,?[\\s]*)+)/ig,\n    pathValues = /(-?\\d*\\.?\\d*(?:e[-+]?\\\\d+)?)[\\s]*,?[\\s]*/ig;\n\nfunction is(o, type) {\n  type = String.prototype.toLowerCase.call(type);\n\n  if (type == 'finite') {\n    return isFinite(o);\n  }\n\n  if (type == 'array' && (o instanceof Array || Array.isArray && Array.isArray(o))) {\n    return true;\n  }\n\n  return (type == 'null' && o === null) ||\n         (type == typeof o && o !== null) ||\n         (type == 'object' && o === Object(o)) ||\n         Object.prototype.toString.call(o).slice(8, -1).toLowerCase() == type;\n}\n\nfunction clone(obj) {\n\n  if (typeof obj == 'function' || Object(obj) !== obj) {\n    return obj;\n  }\n\n  var res = new obj.constructor;\n\n  for (var key in obj) if (obj[has](key)) {\n    res[key] = clone(obj[key]);\n  }\n\n  return res;\n}\n\nfunction repush(array, item) {\n  for (var i = 0, ii = array.length; i < ii; i++) if (array[i] === item) {\n    return array.push(array.splice(i, 1)[0]);\n  }\n}\n\nfunction cacher(f, scope, postprocessor) {\n\n  function newf() {\n\n    var arg = Array.prototype.slice.call(arguments, 0),\n        args = arg.join('\\u2400'),\n        cache = newf.cache = newf.cache || {},\n        count = newf.count = newf.count || [];\n\n    if (cache[has](args)) {\n      repush(count, args);\n      return postprocessor ? postprocessor(cache[args]) : cache[args];\n    }\n\n    count.length >= 1e3 && delete cache[count.shift()];\n    count.push(args);\n    cache[args] = f.apply(scope, arg);\n\n    return postprocessor ? postprocessor(cache[args]) : cache[args];\n  }\n  return newf;\n}\n\nfunction parsePathString(pathString) {\n\n  if (!pathString) {\n    return null;\n  }\n\n  var pth = paths(pathString);\n\n  if (pth.arr) {\n    return clone(pth.arr);\n  }\n\n  var paramCounts = { a: 7, c: 6, o: 2, h: 1, l: 2, m: 2, r: 4, q: 4, s: 4, t: 2, v: 1, u: 3, z: 0 },\n      data = [];\n\n  if (is(pathString, 'array') && is(pathString[0], 'array')) { // rough assumption\n    data = clone(pathString);\n  }\n\n  if (!data.length) {\n\n    String(pathString).replace(pathCommand, function(a, b, c) {\n      var params = [],\n          name = b.toLowerCase();\n\n      c.replace(pathValues, function(a, b) {\n        b && params.push(+b);\n      });\n\n      if (name == 'm' && params.length > 2) {\n        data.push([b].concat(params.splice(0, 2)));\n        name = 'l';\n        b = b == 'm' ? 'l' : 'L';\n      }\n\n      if (name == 'o' && params.length == 1) {\n        data.push([b, params[0]]);\n      }\n\n      if (name == 'r') {\n        data.push([b].concat(params));\n      } else while (params.length >= paramCounts[name]) {\n        data.push([b].concat(params.splice(0, paramCounts[name])));\n        if (!paramCounts[name]) {\n          break;\n        }\n      }\n    });\n  }\n\n  data.toString = paths.toString;\n  pth.arr = clone(data);\n\n  return data;\n}\n\nfunction paths(ps) {\n  var p = paths.ps = paths.ps || {};\n\n  if (p[ps]) {\n    p[ps].sleep = 100;\n  } else {\n    p[ps] = {\n      sleep: 100\n    };\n  }\n\n  setTimeout(function() {\n    for (var key in p) if (p[has](key) && key != ps) {\n      p[key].sleep--;\n      !p[key].sleep && delete p[key];\n    }\n  });\n\n  return p[ps];\n}\n\nfunction box(x, y, width, height) {\n  if (x == null) {\n    x = y = width = height = 0;\n  }\n\n  if (y == null) {\n    y = x.y;\n    width = x.width;\n    height = x.height;\n    x = x.x;\n  }\n\n  return {\n    x: x,\n    y: y,\n    width: width,\n    w: width,\n    height: height,\n    h: height,\n    x2: x + width,\n    y2: y + height,\n    cx: x + width / 2,\n    cy: y + height / 2,\n    r1: math.min(width, height) / 2,\n    r2: math.max(width, height) / 2,\n    r0: math.sqrt(width * width + height * height) / 2,\n    path: rectPath(x, y, width, height),\n    vb: [x, y, width, height].join(' ')\n  };\n}\n\nfunction pathToString() {\n  return this.join(',').replace(p2s, '$1');\n}\n\nfunction pathClone(pathArray) {\n  var res = clone(pathArray);\n  res.toString = pathToString;\n  return res;\n}\n\nfunction findDotsAtSegment(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, t) {\n  var t1 = 1 - t,\n      t13 = pow(t1, 3),\n      t12 = pow(t1, 2),\n      t2 = t * t,\n      t3 = t2 * t,\n      x = t13 * p1x + t12 * 3 * t * c1x + t1 * 3 * t * t * c2x + t3 * p2x,\n      y = t13 * p1y + t12 * 3 * t * c1y + t1 * 3 * t * t * c2y + t3 * p2y,\n      mx = p1x + 2 * t * (c1x - p1x) + t2 * (c2x - 2 * c1x + p1x),\n      my = p1y + 2 * t * (c1y - p1y) + t2 * (c2y - 2 * c1y + p1y),\n      nx = c1x + 2 * t * (c2x - c1x) + t2 * (p2x - 2 * c2x + c1x),\n      ny = c1y + 2 * t * (c2y - c1y) + t2 * (p2y - 2 * c2y + c1y),\n      ax = t1 * p1x + t * c1x,\n      ay = t1 * p1y + t * c1y,\n      cx = t1 * c2x + t * p2x,\n      cy = t1 * c2y + t * p2y,\n      alpha = (90 - math.atan2(mx - nx, my - ny) * 180 / PI);\n\n  return {\n    x: x,\n    y: y,\n    m: { x: mx, y: my },\n    n: { x: nx, y: ny },\n    start: { x: ax, y: ay },\n    end: { x: cx, y: cy },\n    alpha: alpha\n  };\n}\n\nfunction bezierBBox(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y) {\n\n  if (!is(p1x, 'array')) {\n    p1x = [p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y];\n  }\n\n  var bbox = curveBBox.apply(null, p1x);\n\n  return box(\n    bbox.min.x,\n    bbox.min.y,\n    bbox.max.x - bbox.min.x,\n    bbox.max.y - bbox.min.y\n  );\n}\n\nfunction isPointInsideBBox(bbox, x, y) {\n  return x >= bbox.x &&\n    x <= bbox.x + bbox.width &&\n    y >= bbox.y &&\n    y <= bbox.y + bbox.height;\n}\n\nfunction isBBoxIntersect(bbox1, bbox2) {\n  bbox1 = box(bbox1);\n  bbox2 = box(bbox2);\n  return isPointInsideBBox(bbox2, bbox1.x, bbox1.y)\n    || isPointInsideBBox(bbox2, bbox1.x2, bbox1.y)\n    || isPointInsideBBox(bbox2, bbox1.x, bbox1.y2)\n    || isPointInsideBBox(bbox2, bbox1.x2, bbox1.y2)\n    || isPointInsideBBox(bbox1, bbox2.x, bbox2.y)\n    || isPointInsideBBox(bbox1, bbox2.x2, bbox2.y)\n    || isPointInsideBBox(bbox1, bbox2.x, bbox2.y2)\n    || isPointInsideBBox(bbox1, bbox2.x2, bbox2.y2)\n    || (bbox1.x < bbox2.x2 && bbox1.x > bbox2.x\n        || bbox2.x < bbox1.x2 && bbox2.x > bbox1.x)\n    && (bbox1.y < bbox2.y2 && bbox1.y > bbox2.y\n        || bbox2.y < bbox1.y2 && bbox2.y > bbox1.y);\n}\n\nfunction base3(t, p1, p2, p3, p4) {\n  var t1 = -3 * p1 + 9 * p2 - 9 * p3 + 3 * p4,\n      t2 = t * t1 + 6 * p1 - 12 * p2 + 6 * p3;\n  return t * t2 - 3 * p1 + 3 * p2;\n}\n\nfunction bezlen(x1, y1, x2, y2, x3, y3, x4, y4, z) {\n\n  if (z == null) {\n    z = 1;\n  }\n\n  z = z > 1 ? 1 : z < 0 ? 0 : z;\n\n  var z2 = z / 2,\n      n = 12,\n      Tvalues = [-.1252,.1252,-.3678,.3678,-.5873,.5873,-.7699,.7699,-.9041,.9041,-.9816,.9816],\n      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],\n      sum = 0;\n\n  for (var i = 0; i < n; i++) {\n    var ct = z2 * Tvalues[i] + z2,\n        xbase = base3(ct, x1, x2, x3, x4),\n        ybase = base3(ct, y1, y2, y3, y4),\n        comb = xbase * xbase + ybase * ybase;\n\n    sum += Cvalues[i] * math.sqrt(comb);\n  }\n\n  return z2 * sum;\n}\n\n\nfunction intersectLines(x1, y1, x2, y2, x3, y3, x4, y4) {\n\n  if (\n    mmax(x1, x2) < mmin(x3, x4) ||\n      mmin(x1, x2) > mmax(x3, x4) ||\n      mmax(y1, y2) < mmin(y3, y4) ||\n      mmin(y1, y2) > mmax(y3, y4)\n  ) {\n    return;\n  }\n\n  var nx = (x1 * y2 - y1 * x2) * (x3 - x4) - (x1 - x2) * (x3 * y4 - y3 * x4),\n      ny = (x1 * y2 - y1 * x2) * (y3 - y4) - (y1 - y2) * (x3 * y4 - y3 * x4),\n      denominator = (x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4);\n\n  if (!denominator) {\n    return;\n  }\n\n  var px = nx / denominator,\n      py = ny / denominator,\n      px2 = +px.toFixed(2),\n      py2 = +py.toFixed(2);\n\n  if (\n    px2 < +mmin(x1, x2).toFixed(2) ||\n      px2 > +mmax(x1, x2).toFixed(2) ||\n      px2 < +mmin(x3, x4).toFixed(2) ||\n      px2 > +mmax(x3, x4).toFixed(2) ||\n      py2 < +mmin(y1, y2).toFixed(2) ||\n      py2 > +mmax(y1, y2).toFixed(2) ||\n      py2 < +mmin(y3, y4).toFixed(2) ||\n      py2 > +mmax(y3, y4).toFixed(2)\n  ) {\n    return;\n  }\n\n  return { x: px, y: py };\n}\n\nfunction findBezierIntersections(bez1, bez2, justCount) {\n  var bbox1 = bezierBBox(bez1),\n      bbox2 = bezierBBox(bez2);\n\n  if (!isBBoxIntersect(bbox1, bbox2)) {\n    return justCount ? 0 : [];\n  }\n\n  var l1 = bezlen.apply(0, bez1),\n      l2 = bezlen.apply(0, bez2),\n      n1 = ~~(l1 / 5),\n      n2 = ~~(l2 / 5),\n      dots1 = [],\n      dots2 = [],\n      xy = {},\n      res = justCount ? 0 : [];\n\n  for (var i = 0; i < n1 + 1; i++) {\n    var p = findDotsAtSegment.apply(0, bez1.concat(i / n1));\n    dots1.push({ x: p.x, y: p.y, t: i / n1 });\n  }\n\n  for (i = 0; i < n2 + 1; i++) {\n    p = findDotsAtSegment.apply(0, bez2.concat(i / n2));\n    dots2.push({ x: p.x, y: p.y, t: i / n2 });\n  }\n\n  for (i = 0; i < n1; i++) {\n\n    for (var j = 0; j < n2; j++) {\n      var di = dots1[i],\n          di1 = dots1[i + 1],\n          dj = dots2[j],\n          dj1 = dots2[j + 1],\n          ci = abs(di1.x - di.x) < .01 ? 'y' : 'x',\n          cj = abs(dj1.x - dj.x) < .01 ? 'y' : 'x',\n          is = intersectLines(di.x, di.y, di1.x, di1.y, dj.x, dj.y, dj1.x, dj1.y);\n\n      if (is) {\n\n        if (xy[is.x.toFixed(0)] == is.y.toFixed(0)) {\n          continue;\n        }\n\n        xy[is.x.toFixed(0)] = is.y.toFixed(0);\n\n        var t1 = di.t + abs((is[ci] - di[ci]) / (di1[ci] - di[ci])) * (di1.t - di.t),\n            t2 = dj.t + abs((is[cj] - dj[cj]) / (dj1[cj] - dj[cj])) * (dj1.t - dj.t);\n\n        if (t1 >= 0 && t1 <= 1 && t2 >= 0 && t2 <= 1) {\n\n          if (justCount) {\n            res++;\n          } else {\n            res.push({\n              x: is.x,\n              y: is.y,\n              t1: t1,\n              t2: t2\n            });\n          }\n        }\n      }\n    }\n  }\n\n  return res;\n}\n\n\n/**\n * Find or counts the intersections between two SVG paths.\n *\n * Returns a number in counting mode and a list of intersections otherwise.\n *\n * A single intersection entry contains the intersection coordinates (x, y)\n * as well as additional information regarding the intersecting segments\n * on each path (segment1, segment2) and the relative location of the\n * intersection on these segments (t1, t2).\n *\n * The path may be an SVG path string or a list of path components\n * such as `[ [ 'M', 0, 10 ], [ 'L', 20, 0 ] ]`.\n *\n * @example\n *\n * var intersections = findPathIntersections(\n *   'M0,0L100,100',\n *   [ [ 'M', 0, 100 ], [ 'L', 100, 0 ] ]\n * );\n *\n * // intersections = [\n * //   { x: 50, y: 50, segment1: 1, segment2: 1, t1: 0.5, t2: 0.5 }\n * //\n *\n * @param {String|Array<PathDef>} path1\n * @param {String|Array<PathDef>} path2\n * @param {Boolean} [justCount=false]\n *\n * @return {Array<Intersection>|Number}\n */\nfunction findPathIntersections(path1, path2, justCount) {\n  path1 = pathToCurve(path1);\n  path2 = pathToCurve(path2);\n\n  var x1, y1, x2, y2, x1m, y1m, x2m, y2m, bez1, bez2,\n      res = justCount ? 0 : [];\n\n  for (var i = 0, ii = path1.length; i < ii; i++) {\n    var pi = path1[i];\n\n    if (pi[0] == 'M') {\n      x1 = x1m = pi[1];\n      y1 = y1m = pi[2];\n    } else {\n\n      if (pi[0] == 'C') {\n        bez1 = [x1, y1].concat(pi.slice(1));\n        x1 = bez1[6];\n        y1 = bez1[7];\n      } else {\n        bez1 = [x1, y1, x1, y1, x1m, y1m, x1m, y1m];\n        x1 = x1m;\n        y1 = y1m;\n      }\n\n      for (var j = 0, jj = path2.length; j < jj; j++) {\n        var pj = path2[j];\n\n        if (pj[0] == 'M') {\n          x2 = x2m = pj[1];\n          y2 = y2m = pj[2];\n        } else {\n\n          if (pj[0] == 'C') {\n            bez2 = [x2, y2].concat(pj.slice(1));\n            x2 = bez2[6];\n            y2 = bez2[7];\n          } else {\n            bez2 = [x2, y2, x2, y2, x2m, y2m, x2m, y2m];\n            x2 = x2m;\n            y2 = y2m;\n          }\n\n          var intr = findBezierIntersections(bez1, bez2, justCount);\n\n          if (justCount) {\n            res += intr;\n          } else {\n\n            for (var k = 0, kk = intr.length; k < kk; k++) {\n              intr[k].segment1 = i;\n              intr[k].segment2 = j;\n              intr[k].bez1 = bez1;\n              intr[k].bez2 = bez2;\n            }\n\n            res = res.concat(intr);\n          }\n        }\n      }\n    }\n  }\n\n  return res;\n}\n\n\nfunction rectPath(x, y, w, h, r) {\n  if (r) {\n    return [\n      ['M', +x + (+r), y],\n      ['l', w - r * 2, 0],\n      ['a', r, r, 0, 0, 1, r, r],\n      ['l', 0, h - r * 2],\n      ['a', r, r, 0, 0, 1, -r, r],\n      ['l', r * 2 - w, 0],\n      ['a', r, r, 0, 0, 1, -r, -r],\n      ['l', 0, r * 2 - h],\n      ['a', r, r, 0, 0, 1, r, -r],\n      ['z']\n    ];\n  }\n\n  var res = [['M', x, y], ['l', w, 0], ['l', 0, h], ['l', -w, 0], ['z']];\n  res.toString = pathToString;\n\n  return res;\n}\n\nfunction ellipsePath(x, y, rx, ry, a) {\n  if (a == null && ry == null) {\n    ry = rx;\n  }\n\n  x = +x;\n  y = +y;\n  rx = +rx;\n  ry = +ry;\n\n  if (a != null) {\n    var rad = Math.PI / 180,\n        x1 = x + rx * Math.cos(-ry * rad),\n        x2 = x + rx * Math.cos(-a * rad),\n        y1 = y + rx * Math.sin(-ry * rad),\n        y2 = y + rx * Math.sin(-a * rad),\n        res = [['M', x1, y1], ['A', rx, rx, 0, +(a - ry > 180), 0, x2, y2]];\n  } else {\n    res = [\n      ['M', x, y],\n      ['m', 0, -ry],\n      ['a', rx, ry, 0, 1, 1, 0, 2 * ry],\n      ['a', rx, ry, 0, 1, 1, 0, -2 * ry],\n      ['z']\n    ];\n  }\n\n  res.toString = pathToString;\n\n  return res;\n}\n\n\nfunction pathToAbsolute(pathArray) {\n  var pth = paths(pathArray);\n\n  if (pth.abs) {\n    return pathClone(pth.abs);\n  }\n\n  if (!is(pathArray, 'array') || !is(pathArray && pathArray[0], 'array')) { // rough assumption\n    pathArray = parsePathString(pathArray);\n  }\n\n  if (!pathArray || !pathArray.length) {\n    return [['M', 0, 0]];\n  }\n\n  var res = [],\n      x = 0,\n      y = 0,\n      mx = 0,\n      my = 0,\n      start = 0,\n      pa0;\n\n  if (pathArray[0][0] == 'M') {\n    x = +pathArray[0][1];\n    y = +pathArray[0][2];\n    mx = x;\n    my = y;\n    start++;\n    res[0] = ['M', x, y];\n  }\n\n  var crz = pathArray.length == 3 &&\n      pathArray[0][0] == 'M' &&\n      pathArray[1][0].toUpperCase() == 'R' &&\n      pathArray[2][0].toUpperCase() == 'Z';\n\n  for (var r, pa, i = start, ii = pathArray.length; i < ii; i++) {\n    res.push(r = []);\n    pa = pathArray[i];\n    pa0 = pa[0];\n\n    if (pa0 != pa0.toUpperCase()) {\n      r[0] = pa0.toUpperCase();\n\n      switch (r[0]) {\n      case 'A':\n        r[1] = pa[1];\n        r[2] = pa[2];\n        r[3] = pa[3];\n        r[4] = pa[4];\n        r[5] = pa[5];\n        r[6] = +pa[6] + x;\n        r[7] = +pa[7] + y;\n        break;\n      case 'V':\n        r[1] = +pa[1] + y;\n        break;\n      case 'H':\n        r[1] = +pa[1] + x;\n        break;\n      case 'R':\n        var dots = [x, y].concat(pa.slice(1));\n\n        for (var j = 2, jj = dots.length; j < jj; j++) {\n          dots[j] = +dots[j] + x;\n          dots[++j] = +dots[j] + y;\n        }\n\n        res.pop();\n        res = res.concat(catmulRomToBezier(dots, crz));\n        break;\n      case 'O':\n        res.pop();\n        dots = ellipsePath(x, y, pa[1], pa[2]);\n        dots.push(dots[0]);\n        res = res.concat(dots);\n        break;\n      case 'U':\n        res.pop();\n        res = res.concat(ellipsePath(x, y, pa[1], pa[2], pa[3]));\n        r = ['U'].concat(res[res.length - 1].slice(-2));\n        break;\n      case 'M':\n        mx = +pa[1] + x;\n        my = +pa[2] + y;\n      default:\n\n        for (j = 1, jj = pa.length; j < jj; j++) {\n          r[j] = +pa[j] + ((j % 2) ? x : y);\n        }\n      }\n    } else if (pa0 == 'R') {\n      dots = [x, y].concat(pa.slice(1));\n      res.pop();\n      res = res.concat(catmulRomToBezier(dots, crz));\n      r = ['R'].concat(pa.slice(-2));\n    } else if (pa0 == 'O') {\n      res.pop();\n      dots = ellipsePath(x, y, pa[1], pa[2]);\n      dots.push(dots[0]);\n      res = res.concat(dots);\n    } else if (pa0 == 'U') {\n      res.pop();\n      res = res.concat(ellipsePath(x, y, pa[1], pa[2], pa[3]));\n      r = ['U'].concat(res[res.length - 1].slice(-2));\n    } else {\n\n      for (var k = 0, kk = pa.length; k < kk; k++) {\n        r[k] = pa[k];\n      }\n    }\n    pa0 = pa0.toUpperCase();\n\n    if (pa0 != 'O') {\n      switch (r[0]) {\n      case 'Z':\n        x = +mx;\n        y = +my;\n        break;\n      case 'H':\n        x = r[1];\n        break;\n      case 'V':\n        y = r[1];\n        break;\n      case 'M':\n        mx = r[r.length - 2];\n        my = r[r.length - 1];\n      default:\n        x = r[r.length - 2];\n        y = r[r.length - 1];\n      }\n    }\n  }\n\n  res.toString = pathToString;\n  pth.abs = pathClone(res);\n\n  return res;\n}\n\nfunction lineToCurve(x1, y1, x2, y2) {\n  return [\n    x1, y1, x2,\n    y2, x2, y2\n  ];\n}\n\nfunction qubicToCurve(x1, y1, ax, ay, x2, y2) {\n  var _13 = 1 / 3,\n      _23 = 2 / 3;\n\n  return [\n    _13 * x1 + _23 * ax,\n    _13 * y1 + _23 * ay,\n    _13 * x2 + _23 * ax,\n    _13 * y2 + _23 * ay,\n    x2,\n    y2\n  ];\n}\n\nfunction arcToCurve(x1, y1, rx, ry, angle, large_arc_flag, sweep_flag, x2, y2, recursive) {\n\n  // for more information of where this math came from visit:\n  // http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes\n  var _120 = PI * 120 / 180,\n      rad = PI / 180 * (+angle || 0),\n      res = [],\n      xy,\n      rotate = cacher(function(x, y, rad) {\n        var X = x * math.cos(rad) - y * math.sin(rad),\n            Y = x * math.sin(rad) + y * math.cos(rad);\n\n        return { x: X, y: Y };\n      });\n\n  if (!recursive) {\n    xy = rotate(x1, y1, -rad);\n    x1 = xy.x;\n    y1 = xy.y;\n    xy = rotate(x2, y2, -rad);\n    x2 = xy.x;\n    y2 = xy.y;\n\n    var x = (x1 - x2) / 2,\n        y = (y1 - y2) / 2;\n\n    var h = (x * x) / (rx * rx) + (y * y) / (ry * ry);\n\n    if (h > 1) {\n      h = math.sqrt(h);\n      rx = h * rx;\n      ry = h * ry;\n    }\n\n    var rx2 = rx * rx,\n        ry2 = ry * ry,\n        k = (large_arc_flag == sweep_flag ? -1 : 1) *\n            math.sqrt(abs((rx2 * ry2 - rx2 * y * y - ry2 * x * x) / (rx2 * y * y + ry2 * x * x))),\n        cx = k * rx * y / ry + (x1 + x2) / 2,\n        cy = k * -ry * x / rx + (y1 + y2) / 2,\n        f1 = math.asin(((y1 - cy) / ry).toFixed(9)),\n        f2 = math.asin(((y2 - cy) / ry).toFixed(9));\n\n    f1 = x1 < cx ? PI - f1 : f1;\n    f2 = x2 < cx ? PI - f2 : f2;\n    f1 < 0 && (f1 = PI * 2 + f1);\n    f2 < 0 && (f2 = PI * 2 + f2);\n\n    if (sweep_flag && f1 > f2) {\n      f1 = f1 - PI * 2;\n    }\n    if (!sweep_flag && f2 > f1) {\n      f2 = f2 - PI * 2;\n    }\n  } else {\n    f1 = recursive[0];\n    f2 = recursive[1];\n    cx = recursive[2];\n    cy = recursive[3];\n  }\n\n  var df = f2 - f1;\n\n  if (abs(df) > _120) {\n    var f2old = f2,\n        x2old = x2,\n        y2old = y2;\n\n    f2 = f1 + _120 * (sweep_flag && f2 > f1 ? 1 : -1);\n    x2 = cx + rx * math.cos(f2);\n    y2 = cy + ry * math.sin(f2);\n    res = arcToCurve(x2, y2, rx, ry, angle, 0, sweep_flag, x2old, y2old, [f2, f2old, cx, cy]);\n  }\n\n  df = f2 - f1;\n\n  var c1 = math.cos(f1),\n      s1 = math.sin(f1),\n      c2 = math.cos(f2),\n      s2 = math.sin(f2),\n      t = math.tan(df / 4),\n      hx = 4 / 3 * rx * t,\n      hy = 4 / 3 * ry * t,\n      m1 = [x1, y1],\n      m2 = [x1 + hx * s1, y1 - hy * c1],\n      m3 = [x2 + hx * s2, y2 - hy * c2],\n      m4 = [x2, y2];\n\n  m2[0] = 2 * m1[0] - m2[0];\n  m2[1] = 2 * m1[1] - m2[1];\n\n  if (recursive) {\n    return [m2, m3, m4].concat(res);\n  } else {\n    res = [m2, m3, m4].concat(res).join().split(',');\n    var newres = [];\n\n    for (var i = 0, ii = res.length; i < ii; i++) {\n      newres[i] = i % 2 ? rotate(res[i - 1], res[i], rad).y : rotate(res[i], res[i + 1], rad).x;\n    }\n\n    return newres;\n  }\n}\n\n// http://schepers.cc/getting-to-the-point\nfunction catmulRomToBezier(crp, z) {\n  var d = [];\n\n  for (var i = 0, iLen = crp.length; iLen - 2 * !z > i; i += 2) {\n    var p = [\n      { x: +crp[i - 2], y: +crp[i - 1] },\n      { x: +crp[i], y: +crp[i + 1] },\n      { x: +crp[i + 2], y: +crp[i + 3] },\n      { x: +crp[i + 4], y: +crp[i + 5] }\n    ];\n\n    if (z) {\n\n      if (!i) {\n        p[0] = { x: +crp[iLen - 2], y: +crp[iLen - 1] };\n      } else if (iLen - 4 == i) {\n        p[3] = { x: +crp[0], y: +crp[1] };\n      } else if (iLen - 2 == i) {\n        p[2] = { x: +crp[0], y: +crp[1] };\n        p[3] = { x: +crp[2], y: +crp[3] };\n      }\n\n    } else {\n\n      if (iLen - 4 == i) {\n        p[3] = p[2];\n      } else if (!i) {\n        p[0] = { x: +crp[i], y: +crp[i + 1] };\n      }\n\n    }\n\n    d.push(['C',\n      (-p[0].x + 6 * p[1].x + p[2].x) / 6,\n      (-p[0].y + 6 * p[1].y + p[2].y) / 6,\n      (p[1].x + 6 * p[2].x - p[3].x) / 6,\n      (p[1].y + 6*p[2].y - p[3].y) / 6,\n      p[2].x,\n      p[2].y\n    ]);\n  }\n\n  return d;\n}\n\n// Returns bounding box of cubic bezier curve.\n// Source: http://blog.hackers-cafe.net/2009/06/how-to-calculate-bezier-curves-bounding.html\n// Original version: NISHIO Hirokazu\n// Modifications: https://github.com/timo22345\nfunction curveBBox(x0, y0, x1, y1, x2, y2, x3, y3) {\n  var tvalues = [],\n      bounds = [[], []],\n      a, b, c, t, t1, t2, b2ac, sqrtb2ac;\n\n  for (var i = 0; i < 2; ++i) {\n\n    if (i == 0) {\n      b = 6 * x0 - 12 * x1 + 6 * x2;\n      a = -3 * x0 + 9 * x1 - 9 * x2 + 3 * x3;\n      c = 3 * x1 - 3 * x0;\n    } else {\n      b = 6 * y0 - 12 * y1 + 6 * y2;\n      a = -3 * y0 + 9 * y1 - 9 * y2 + 3 * y3;\n      c = 3 * y1 - 3 * y0;\n    }\n\n    if (abs(a) < 1e-12) {\n\n      if (abs(b) < 1e-12) {\n        continue;\n      }\n\n      t = -c / b;\n\n      if (0 < t && t < 1) {\n        tvalues.push(t);\n      }\n\n      continue;\n    }\n\n    b2ac = b * b - 4 * c * a;\n    sqrtb2ac = math.sqrt(b2ac);\n\n    if (b2ac < 0) {\n      continue;\n    }\n\n    t1 = (-b + sqrtb2ac) / (2 * a);\n\n    if (0 < t1 && t1 < 1) {\n      tvalues.push(t1);\n    }\n\n    t2 = (-b - sqrtb2ac) / (2 * a);\n\n    if (0 < t2 && t2 < 1) {\n      tvalues.push(t2);\n    }\n  }\n\n  var j = tvalues.length,\n      jlen = j,\n      mt;\n\n  while (j--) {\n    t = tvalues[j];\n    mt = 1 - t;\n    bounds[0][j] = (mt * mt * mt * x0) + (3 * mt * mt * t * x1) + (3 * mt * t * t * x2) + (t * t * t * x3);\n    bounds[1][j] = (mt * mt * mt * y0) + (3 * mt * mt * t * y1) + (3 * mt * t * t * y2) + (t * t * t * y3);\n  }\n\n  bounds[0][jlen] = x0;\n  bounds[1][jlen] = y0;\n  bounds[0][jlen + 1] = x3;\n  bounds[1][jlen + 1] = y3;\n  bounds[0].length = bounds[1].length = jlen + 2;\n\n  return {\n    min: { x: mmin.apply(0, bounds[0]), y: mmin.apply(0, bounds[1]) },\n    max: { x: mmax.apply(0, bounds[0]), y: mmax.apply(0, bounds[1]) }\n  };\n}\n\nfunction pathToCurve(path, path2) {\n  var pth = !path2 && paths(path);\n\n  if (!path2 && pth.curve) {\n    return pathClone(pth.curve);\n  }\n\n  var p = pathToAbsolute(path),\n      p2 = path2 && pathToAbsolute(path2),\n      attrs = { x: 0, y: 0, bx: 0, by: 0, X: 0, Y: 0, qx: null, qy: null },\n      attrs2 = { x: 0, y: 0, bx: 0, by: 0, X: 0, Y: 0, qx: null, qy: null },\n      processPath = function(path, d, pcom) {\n        var nx, ny;\n\n        if (!path) {\n          return ['C', d.x, d.y, d.x, d.y, d.x, d.y];\n        }\n\n        !(path[0] in { T: 1, Q: 1 }) && (d.qx = d.qy = null);\n\n        switch (path[0]) {\n        case 'M':\n          d.X = path[1];\n          d.Y = path[2];\n          break;\n        case 'A':\n          path = ['C'].concat(arcToCurve.apply(0, [d.x, d.y].concat(path.slice(1))));\n          break;\n        case 'S':\n          if (pcom == 'C' || pcom == 'S') {\n            // In 'S' case we have to take into account, if the previous command is C/S.\n            nx = d.x * 2 - d.bx;\n            // And reflect the previous\n            ny = d.y * 2 - d.by;\n            // command's control point relative to the current point.\n          }\n          else {\n            // or some else or nothing\n            nx = d.x;\n            ny = d.y;\n          }\n          path = ['C', nx, ny].concat(path.slice(1));\n          break;\n        case 'T':\n          if (pcom == 'Q' || pcom == 'T') {\n            // In 'T' case we have to take into account, if the previous command is Q/T.\n            d.qx = d.x * 2 - d.qx;\n            // And make a reflection similar\n            d.qy = d.y * 2 - d.qy;\n            // to case 'S'.\n          }\n          else {\n            // or something else or nothing\n            d.qx = d.x;\n            d.qy = d.y;\n          }\n          path = ['C'].concat(qubicToCurve(d.x, d.y, d.qx, d.qy, path[1], path[2]));\n          break;\n        case 'Q':\n          d.qx = path[1];\n          d.qy = path[2];\n          path = ['C'].concat(qubicToCurve(d.x, d.y, path[1], path[2], path[3], path[4]));\n          break;\n        case 'L':\n          path = ['C'].concat(lineToCurve(d.x, d.y, path[1], path[2]));\n          break;\n        case 'H':\n          path = ['C'].concat(lineToCurve(d.x, d.y, path[1], d.y));\n          break;\n        case 'V':\n          path = ['C'].concat(lineToCurve(d.x, d.y, d.x, path[1]));\n          break;\n        case 'Z':\n          path = ['C'].concat(lineToCurve(d.x, d.y, d.X, d.Y));\n          break;\n        }\n\n        return path;\n      },\n\n      fixArc = function(pp, i) {\n\n        if (pp[i].length > 7) {\n          pp[i].shift();\n          var pi = pp[i];\n\n          while (pi.length) {\n            pcoms1[i] = 'A'; // if created multiple C:s, their original seg is saved\n            p2 && (pcoms2[i] = 'A'); // the same as above\n            pp.splice(i++, 0, ['C'].concat(pi.splice(0, 6)));\n          }\n\n          pp.splice(i, 1);\n          ii = mmax(p.length, p2 && p2.length || 0);\n        }\n      },\n\n      fixM = function(path1, path2, a1, a2, i) {\n\n        if (path1 && path2 && path1[i][0] == 'M' && path2[i][0] != 'M') {\n          path2.splice(i, 0, ['M', a2.x, a2.y]);\n          a1.bx = 0;\n          a1.by = 0;\n          a1.x = path1[i][1];\n          a1.y = path1[i][2];\n          ii = mmax(p.length, p2 && p2.length || 0);\n        }\n      },\n\n      pcoms1 = [], // path commands of original path p\n      pcoms2 = [], // path commands of original path p2\n      pfirst = '', // temporary holder for original path command\n      pcom = ''; // holder for previous path command of original path\n\n  for (var i = 0, ii = mmax(p.length, p2 && p2.length || 0); i < ii; i++) {\n    p[i] && (pfirst = p[i][0]); // save current path command\n\n    if (pfirst != 'C') // C is not saved yet, because it may be result of conversion\n    {\n      pcoms1[i] = pfirst; // Save current path command\n      i && (pcom = pcoms1[i - 1]); // Get previous path command pcom\n    }\n    p[i] = processPath(p[i], attrs, pcom); // Previous path command is inputted to processPath\n\n    if (pcoms1[i] != 'A' && pfirst == 'C') pcoms1[i] = 'C'; // A is the only command\n    // which may produce multiple C:s\n    // so we have to make sure that C is also C in original path\n\n    fixArc(p, i); // fixArc adds also the right amount of A:s to pcoms1\n\n    if (p2) { // the same procedures is done to p2\n      p2[i] && (pfirst = p2[i][0]);\n\n      if (pfirst != 'C') {\n        pcoms2[i] = pfirst;\n        i && (pcom = pcoms2[i - 1]);\n      }\n\n      p2[i] = processPath(p2[i], attrs2, pcom);\n\n      if (pcoms2[i] != 'A' && pfirst == 'C') {\n        pcoms2[i] = 'C';\n      }\n\n      fixArc(p2, i);\n    }\n\n    fixM(p, p2, attrs, attrs2, i);\n    fixM(p2, p, attrs2, attrs, i);\n\n    var seg = p[i],\n        seg2 = p2 && p2[i],\n        seglen = seg.length,\n        seg2len = p2 && seg2.length;\n\n    attrs.x = seg[seglen - 2];\n    attrs.y = seg[seglen - 1];\n    attrs.bx = toFloat(seg[seglen - 4]) || attrs.x;\n    attrs.by = toFloat(seg[seglen - 3]) || attrs.y;\n    attrs2.bx = p2 && (toFloat(seg2[seg2len - 4]) || attrs2.x);\n    attrs2.by = p2 && (toFloat(seg2[seg2len - 3]) || attrs2.y);\n    attrs2.x = p2 && seg2[seg2len - 2];\n    attrs2.y = p2 && seg2[seg2len - 1];\n  }\n\n  if (!p2) {\n    pth.curve = pathClone(p);\n  }\n\n  return p2 ? [p, p2] : p;\n}\n\nmodule.exports = findPathIntersections;","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar fromCharCode = String.fromCharCode;\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\nvar ENTITY_PATTERN = /&#(\\d+);|&#x([0-9a-f]+);|&(\\w+);/ig;\n\nvar ENTITY_MAPPING = {\n  'amp': '&',\n  'apos': '\\'',\n  'gt': '>',\n  'lt': '<',\n  'quot': '\"'\n};\n\n// map UPPERCASE variants of supported special chars\nObject.keys(ENTITY_MAPPING).forEach(function(k) {\n  ENTITY_MAPPING[k.toUpperCase()] = ENTITY_MAPPING[k];\n});\n\n\nfunction replaceEntities(_, d, x, z) {\n\n  // reserved names, i.e. &nbsp;\n  if (z) {\n    if (hasOwnProperty.call(ENTITY_MAPPING, z)) {\n      return ENTITY_MAPPING[z];\n    } else {\n      // fall back to original value\n      return '&' + z + ';';\n    }\n  }\n\n  // decimal encoded char\n  if (d) {\n    return fromCharCode(d);\n  }\n\n  // hex encoded char\n  return fromCharCode(parseInt(x, 16));\n}\n\n\n/**\n * A basic entity decoder that can decode a minimal\n * sub-set of reserved names (&amp;) as well as\n * hex (&#xaaf;) and decimal (&#1231;) encoded characters.\n *\n * @param {string} str\n *\n * @return {string} decoded string\n */\nfunction decodeEntities(s) {\n  if (s.length > 3 && s.indexOf('&') !== -1) {\n    return s.replace(ENTITY_PATTERN, replaceEntities);\n  }\n\n  return s;\n}\n\nvar XSI_URI = 'http://www.w3.org/2001/XMLSchema-instance';\nvar XSI_PREFIX = 'xsi';\nvar XSI_TYPE = 'xsi:type';\n\nvar NON_WHITESPACE_OUTSIDE_ROOT_NODE = 'non-whitespace outside of root node';\n\nfunction error(msg) {\n  return new Error(msg);\n}\n\nfunction missingNamespaceForPrefix(prefix) {\n  return 'missing namespace for prefix <' + prefix + '>';\n}\n\nfunction getter(getFn) {\n  return {\n    'get': getFn,\n    'enumerable': true\n  };\n}\n\nfunction cloneNsMatrix(nsMatrix) {\n  var clone = {}, key;\n  for (key in nsMatrix) {\n    clone[key] = nsMatrix[key];\n  }\n  return clone;\n}\n\nfunction uriPrefix(prefix) {\n  return prefix + '$uri';\n}\n\nfunction buildNsMatrix(nsUriToPrefix) {\n  var nsMatrix = {},\n      uri,\n      prefix;\n\n  for (uri in nsUriToPrefix) {\n    prefix = nsUriToPrefix[uri];\n    nsMatrix[prefix] = prefix;\n    nsMatrix[uriPrefix(prefix)] = uri;\n  }\n\n  return nsMatrix;\n}\n\nfunction noopGetContext() {\n  return { 'line': 0, 'column': 0 };\n}\n\nfunction throwFunc(err) {\n  throw err;\n}\n\n/**\n * Creates a new parser with the given options.\n *\n * @constructor\n *\n * @param  {!Object<string, ?>=} options\n */\nfunction Parser(options) {\n\n  if (!this) {\n    return new Parser(options);\n  }\n\n  var proxy = options && options['proxy'];\n\n  var onText,\n      onOpenTag,\n      onCloseTag,\n      onCDATA,\n      onError = throwFunc,\n      onWarning,\n      onComment,\n      onQuestion,\n      onAttention;\n\n  var getContext = noopGetContext;\n\n  /**\n   * Do we need to parse the current elements attributes for namespaces?\n   *\n   * @type {boolean}\n   */\n  var maybeNS = false;\n\n  /**\n   * Do we process namespaces at all?\n   *\n   * @type {boolean}\n   */\n  var isNamespace = false;\n\n  /**\n   * The caught error returned on parse end\n   *\n   * @type {Error}\n   */\n  var returnError = null;\n\n  /**\n   * Should we stop parsing?\n   *\n   * @type {boolean}\n   */\n  var parseStop = false;\n\n  /**\n   * A map of { uri: prefix } used by the parser.\n   *\n   * This map will ensure we can normalize prefixes during processing;\n   * for each uri, only one prefix will be exposed to the handlers.\n   *\n   * @type {!Object<string, string>}}\n   */\n  var nsUriToPrefix;\n\n  /**\n   * Handle parse error.\n   *\n   * @param  {string|Error} err\n   */\n  function handleError(err) {\n    if (!(err instanceof Error)) {\n      err = error(err);\n    }\n\n    returnError = err;\n\n    onError(err, getContext);\n  }\n\n  /**\n   * Handle parse error.\n   *\n   * @param  {string|Error} err\n   */\n  function handleWarning(err) {\n\n    if (!onWarning) {\n      return;\n    }\n\n    if (!(err instanceof Error)) {\n      err = error(err);\n    }\n\n    onWarning(err, getContext);\n  }\n\n  /**\n   * Register parse listener.\n   *\n   * @param  {string}   name\n   * @param  {Function} cb\n   *\n   * @return {Parser}\n   */\n  this['on'] = function(name, cb) {\n\n    if (typeof cb !== 'function') {\n      throw error('required args <name, cb>');\n    }\n\n    switch (name) {\n    case 'openTag': onOpenTag = cb; break;\n    case 'text': onText = cb; break;\n    case 'closeTag': onCloseTag = cb; break;\n    case 'error': onError = cb; break;\n    case 'warn': onWarning = cb; break;\n    case 'cdata': onCDATA = cb; break;\n    case 'attention': onAttention = cb; break; // <!XXXXX zzzz=\"eeee\">\n    case 'question': onQuestion = cb; break; // <? ....  ?>\n    case 'comment': onComment = cb; break;\n    default:\n      throw error('unsupported event: ' + name);\n    }\n\n    return this;\n  };\n\n  /**\n   * Set the namespace to prefix mapping.\n   *\n   * @example\n   *\n   * parser.ns({\n   *   'http://foo': 'foo',\n   *   'http://bar': 'bar'\n   * });\n   *\n   * @param  {!Object<string, string>} nsMap\n   *\n   * @return {Parser}\n   */\n  this['ns'] = function(nsMap) {\n\n    if (typeof nsMap === 'undefined') {\n      nsMap = {};\n    }\n\n    if (typeof nsMap !== 'object') {\n      throw error('required args <nsMap={}>');\n    }\n\n    var _nsUriToPrefix = {}, k;\n\n    for (k in nsMap) {\n      _nsUriToPrefix[k] = nsMap[k];\n    }\n\n    // FORCE default mapping for schema instance\n    _nsUriToPrefix[XSI_URI] = XSI_PREFIX;\n\n    isNamespace = true;\n    nsUriToPrefix = _nsUriToPrefix;\n\n    return this;\n  };\n\n  /**\n   * Parse xml string.\n   *\n   * @param  {string} xml\n   *\n   * @return {Error} returnError, if not thrown\n   */\n  this['parse'] = function(xml) {\n    if (typeof xml !== 'string') {\n      throw error('required args <xml=string>');\n    }\n\n    returnError = null;\n\n    parse(xml);\n\n    getContext = noopGetContext;\n    parseStop = false;\n\n    return returnError;\n  };\n\n  /**\n   * Stop parsing.\n   */\n  this['stop'] = function() {\n    parseStop = true;\n  };\n\n  /**\n   * Parse string, invoking configured listeners on element.\n   *\n   * @param  {string} xml\n   */\n  function parse(xml) {\n    var nsMatrixStack = isNamespace ? [] : null,\n        nsMatrix = isNamespace ? buildNsMatrix(nsUriToPrefix) : null,\n        _nsMatrix,\n        nodeStack = [],\n        anonymousNsCount = 0,\n        tagStart = false,\n        tagEnd = false,\n        i = 0, j = 0,\n        x, y, q, w,\n        xmlns,\n        elementName,\n        _elementName,\n        elementProxy\n        ;\n\n    var attrsString = '',\n        attrsStart = 0,\n        cachedAttrs // false = parsed with errors, null = needs parsing\n        ;\n\n    /**\n     * Parse attributes on demand and returns the parsed attributes.\n     *\n     * Return semantics: (1) `false` on attribute parse error,\n     * (2) object hash on extracted attrs.\n     *\n     * @return {boolean|Object}\n     */\n    function getAttrs() {\n      if (cachedAttrs !== null) {\n        return cachedAttrs;\n      }\n\n      var nsUri,\n          nsUriPrefix,\n          nsName,\n          defaultAlias = isNamespace && nsMatrix['xmlns'],\n          attrList = isNamespace && maybeNS ? [] : null,\n          i = attrsStart,\n          s = attrsString,\n          l = s.length,\n          hasNewMatrix,\n          newalias,\n          value,\n          alias,\n          name,\n          attrs = {},\n          seenAttrs = {},\n          skipAttr,\n          w,\n          j;\n\n      parseAttr:\n      for (; i < l; i++) {\n        skipAttr = false;\n        w = s.charCodeAt(i);\n\n        if (w === 32 || (w < 14 && w > 8)) { // WHITESPACE={ \\f\\n\\r\\t\\v}\n          continue;\n        }\n\n        // wait for non whitespace character\n        if (w < 65 || w > 122 || (w > 90 && w < 97)) {\n          if (w !== 95 && w !== 58) { // char 95\"_\" 58\":\"\n            handleWarning('illegal first char attribute name');\n            skipAttr = true;\n          }\n        }\n\n        // parse attribute name\n        for (j = i + 1; j < l; j++) {\n          w = s.charCodeAt(j);\n\n          if (\n            w > 96 && w < 123 ||\n            w > 64 && w < 91 ||\n            w > 47 && w < 59 ||\n            w === 46 || // '.'\n            w === 45 || // '-'\n            w === 95 // '_'\n          ) {\n            continue;\n          }\n\n          // unexpected whitespace\n          if (w === 32 || (w < 14 && w > 8)) { // WHITESPACE\n            handleWarning('missing attribute value');\n            i = j;\n\n            continue parseAttr;\n          }\n\n          // expected \"=\"\n          if (w === 61) { // \"=\" == 61\n            break;\n          }\n\n          handleWarning('illegal attribute name char');\n          skipAttr = true;\n        }\n\n        name = s.substring(i, j);\n\n        if (name === 'xmlns:xmlns') {\n          handleWarning('illegal declaration of xmlns');\n          skipAttr = true;\n        }\n\n        w = s.charCodeAt(j + 1);\n\n        if (w === 34) { // '\"'\n          j = s.indexOf('\"', i = j + 2);\n\n          if (j === -1) {\n            j = s.indexOf('\\'', i);\n\n            if (j !== -1) {\n              handleWarning('attribute value quote missmatch');\n              skipAttr = true;\n            }\n          }\n\n        } else if (w === 39) { // \"'\"\n          j = s.indexOf('\\'', i = j + 2);\n\n          if (j === -1) {\n            j = s.indexOf('\"', i);\n\n            if (j !== -1) {\n              handleWarning('attribute value quote missmatch');\n              skipAttr = true;\n            }\n          }\n\n        } else {\n          handleWarning('missing attribute value quotes');\n          skipAttr = true;\n\n          // skip to next space\n          for (j = j + 1; j < l; j++) {\n            w = s.charCodeAt(j + 1);\n\n            if (w === 32 || (w < 14 && w > 8)) { // WHITESPACE\n              break;\n            }\n          }\n\n        }\n\n        if (j === -1) {\n          handleWarning('missing closing quotes');\n\n          j = l;\n          skipAttr = true;\n        }\n\n        if (!skipAttr) {\n          value = s.substring(i, j);\n        }\n\n        i = j;\n\n        // ensure SPACE follows attribute\n        // skip illegal content otherwise\n        // example a=\"b\"c\n        for (; j + 1 < l; j++) {\n          w = s.charCodeAt(j + 1);\n\n          if (w === 32 || (w < 14 && w > 8)) { // WHITESPACE\n            break;\n          }\n\n          // FIRST ILLEGAL CHAR\n          if (i === j) {\n            handleWarning('illegal character after attribute end');\n            skipAttr = true;\n          }\n        }\n\n        // advance cursor to next attribute\n        i = j + 1;\n\n        if (skipAttr) {\n          continue parseAttr;\n        }\n\n        // check attribute re-declaration\n        if (name in seenAttrs) {\n          handleWarning('attribute <' + name + '> already defined');\n          continue;\n        }\n\n        seenAttrs[name] = true;\n\n        if (!isNamespace) {\n          attrs[name] = value;\n          continue;\n        }\n\n        // try to extract namespace information\n        if (maybeNS) {\n          newalias = (\n            name === 'xmlns'\n              ? 'xmlns'\n              : (name.charCodeAt(0) === 120 && name.substr(0, 6) === 'xmlns:')\n                ? name.substr(6)\n                : null\n          );\n\n          // handle xmlns(:alias) assignment\n          if (newalias !== null) {\n            nsUri = decodeEntities(value);\n            nsUriPrefix = uriPrefix(newalias);\n\n            alias = nsUriToPrefix[nsUri];\n\n            if (!alias) {\n              // no prefix defined or prefix collision\n              if (\n                (newalias === 'xmlns') ||\n                (nsUriPrefix in nsMatrix && nsMatrix[nsUriPrefix] !== nsUri)\n              ) {\n                // alocate free ns prefix\n                do {\n                  alias = 'ns' + (anonymousNsCount++);\n                } while (typeof nsMatrix[alias] !== 'undefined');\n              } else {\n                alias = newalias;\n              }\n\n              nsUriToPrefix[nsUri] = alias;\n            }\n\n            if (nsMatrix[newalias] !== alias) {\n              if (!hasNewMatrix) {\n                nsMatrix = cloneNsMatrix(nsMatrix);\n                hasNewMatrix = true;\n              }\n\n              nsMatrix[newalias] = alias;\n              if (newalias === 'xmlns') {\n                nsMatrix[uriPrefix(alias)] = nsUri;\n                defaultAlias = alias;\n              }\n\n              nsMatrix[nsUriPrefix] = nsUri;\n            }\n\n            // expose xmlns(:asd)=\"...\" in attributes\n            attrs[name] = value;\n            continue;\n          }\n\n          // collect attributes until all namespace\n          // declarations are processed\n          attrList.push(name, value);\n          continue;\n\n        } /** end if (maybeNs) */\n\n        // handle attributes on element without\n        // namespace declarations\n        w = name.indexOf(':');\n        if (w === -1) {\n          attrs[name] = value;\n          continue;\n        }\n\n        // normalize ns attribute name\n        if (!(nsName = nsMatrix[name.substring(0, w)])) {\n          handleWarning(missingNamespaceForPrefix(name.substring(0, w)));\n          continue;\n        }\n\n        name = defaultAlias === nsName\n          ? name.substr(w + 1)\n          : nsName + name.substr(w);\n        // end: normalize ns attribute name\n\n        // normalize xsi:type ns attribute value\n        if (name === XSI_TYPE) {\n          w = value.indexOf(':');\n\n          if (w !== -1) {\n            nsName = value.substring(0, w);\n            // handle default prefixes, i.e. xs:String gracefully\n            nsName = nsMatrix[nsName] || nsName;\n            value = nsName + value.substring(w);\n          } else {\n            value = defaultAlias + ':' + value;\n          }\n        }\n        // end: normalize xsi:type ns attribute value\n\n        attrs[name] = value;\n      }\n\n\n      // handle deferred, possibly namespaced attributes\n      if (maybeNS) {\n\n        // normalize captured attributes\n        for (i = 0, l = attrList.length; i < l; i++) {\n\n          name = attrList[i++];\n          value = attrList[i];\n\n          w = name.indexOf(':');\n\n          if (w !== -1) {\n            // normalize ns attribute name\n            if (!(nsName = nsMatrix[name.substring(0, w)])) {\n              handleWarning(missingNamespaceForPrefix(name.substring(0, w)));\n              continue;\n            }\n\n            name = defaultAlias === nsName\n              ? name.substr(w + 1)\n              : nsName + name.substr(w);\n            // end: normalize ns attribute name\n\n            // normalize xsi:type ns attribute value\n            if (name === XSI_TYPE) {\n              w = value.indexOf(':');\n\n              if (w !== -1) {\n                nsName = value.substring(0, w);\n                // handle default prefixes, i.e. xs:String gracefully\n                nsName = nsMatrix[nsName] || nsName;\n                value = nsName + value.substring(w);\n              } else {\n                value = defaultAlias + ':' + value;\n              }\n            }\n            // end: normalize xsi:type ns attribute value\n          }\n\n          attrs[name] = value;\n        }\n        // end: normalize captured attributes\n      }\n\n      return cachedAttrs = attrs;\n    }\n\n    /**\n     * Extract the parse context { line, column, part }\n     * from the current parser position.\n     *\n     * @return {Object} parse context\n     */\n    function getParseContext() {\n      var splitsRe = /(\\r\\n|\\r|\\n)/g;\n\n      var line = 0;\n      var column = 0;\n      var startOfLine = 0;\n      var endOfLine = j;\n      var match;\n      var data;\n\n      while (i >= startOfLine) {\n\n        match = splitsRe.exec(xml);\n\n        if (!match) {\n          break;\n        }\n\n        // end of line = (break idx + break chars)\n        endOfLine = match[0].length + match.index;\n\n        if (endOfLine > i) {\n          break;\n        }\n\n        // advance to next line\n        line += 1;\n\n        startOfLine = endOfLine;\n      }\n\n      // EOF errors\n      if (i == -1) {\n        column = endOfLine;\n        data = xml.substring(j);\n      } else\n      // start errors\n      if (j === 0) {\n        console.log(i - startOfLine);\n        data = xml.substring(j, i);\n      }\n      // other errors\n      else {\n        column = i - startOfLine;\n        data = (j == -1 ? xml.substring(i) : xml.substring(i, j + 1));\n      }\n\n      return {\n        'data': data,\n        'line': line,\n        'column': column\n      };\n    }\n\n    getContext = getParseContext;\n\n\n    if (proxy) {\n      elementProxy = Object.create({}, {\n        'name': getter(function() {\n          return elementName;\n        }),\n        'originalName': getter(function() {\n          return _elementName;\n        }),\n        'attrs': getter(getAttrs),\n        'ns': getter(function() {\n          return nsMatrix;\n        })\n      });\n    }\n\n    // actual parse logic\n    while (j !== -1) {\n\n      if (xml.charCodeAt(j) === 60) { // \"<\"\n        i = j;\n      } else {\n        i = xml.indexOf('<', j);\n      }\n\n      // parse end\n      if (i === -1) {\n        if (nodeStack.length) {\n          return handleError('unexpected end of file');\n        }\n\n        if (j === 0) {\n          return handleError('missing start tag');\n        }\n\n        if (j < xml.length) {\n          if (xml.substring(j).trim()) {\n            handleWarning(NON_WHITESPACE_OUTSIDE_ROOT_NODE);\n          }\n        }\n\n        return;\n      }\n\n      // parse text\n      if (j !== i) {\n\n        if (nodeStack.length) {\n          if (onText) {\n            onText(xml.substring(j, i), decodeEntities, getContext);\n\n            if (parseStop) {\n              return;\n            }\n          }\n        } else {\n          if (xml.substring(j, i).trim()) {\n            handleWarning(NON_WHITESPACE_OUTSIDE_ROOT_NODE);\n\n            if (parseStop) {\n              return;\n            }\n          }\n        }\n      }\n\n      w = xml.charCodeAt(i+1);\n\n      // parse comments + CDATA\n      if (w === 33) { // \"!\"\n        w = xml.charCodeAt(i+2);\n        if (w === 91 && xml.substr(i + 3, 6) === 'CDATA[') { // 91 == \"[\"\n          j = xml.indexOf(']]>', i);\n          if (j === -1) {\n            return handleError('unclosed cdata');\n          }\n\n          if (onCDATA) {\n            onCDATA(xml.substring(i + 9, j), getContext);\n            if (parseStop) {\n              return;\n            }\n          }\n\n          j += 3;\n          continue;\n        }\n\n\n        if (w === 45 && xml.charCodeAt(i + 3) === 45) { // 45 == \"-\"\n          j = xml.indexOf('-->', i);\n          if (j === -1) {\n            return handleError('unclosed comment');\n          }\n\n\n          if (onComment) {\n            onComment(xml.substring(i + 4, j), decodeEntities, getContext);\n            if (parseStop) {\n              return;\n            }\n          }\n\n          j += 3;\n          continue;\n        }\n\n        j = xml.indexOf('>', i + 1);\n        if (j === -1) {\n          return handleError('unclosed tag');\n        }\n\n        if (onAttention) {\n          onAttention(xml.substring(i, j + 1), decodeEntities, getContext);\n          if (parseStop) {\n            return;\n          }\n        }\n\n        j += 1;\n        continue;\n      }\n\n      if (w === 63) { // \"?\"\n        j = xml.indexOf('?>', i);\n        if (j === -1) {\n          return handleError('unclosed question');\n        }\n\n        if (onQuestion) {\n          onQuestion(xml.substring(i, j + 2), getContext);\n          if (parseStop) {\n            return;\n          }\n        }\n\n        j += 2;\n        continue;\n      }\n\n      j = xml.indexOf('>', i + 1);\n\n      if (j == -1) {\n        return handleError('unclosed tag');\n      }\n\n      // don't process attributes;\n      // there are none\n      cachedAttrs = {};\n\n      // if (xml.charCodeAt(i+1) === 47) { // </...\n      if (w === 47) { // </...\n        tagStart = false;\n        tagEnd = true;\n\n        if (!nodeStack.length) {\n          return handleError('missing open tag');\n        }\n\n        // verify open <-> close tag match\n        x = elementName = nodeStack.pop();\n        q = i + 2 + x.length;\n\n        if (xml.substring(i + 2, q) !== x) {\n          return handleError('closing tag mismatch');\n        }\n\n        // verify chars in close tag\n        for (; q < j; q++) {\n          w = xml.charCodeAt(q);\n\n          if (w === 32 || (w > 8 && w < 14)) { // \\f\\n\\r\\t\\v space\n            continue;\n          }\n\n          return handleError('close tag');\n        }\n\n      } else {\n        if (xml.charCodeAt(j - 1) === 47) { // .../>\n          x = elementName = xml.substring(i + 1, j - 1);\n\n          tagStart = true;\n          tagEnd = true;\n\n        } else {\n          x = elementName = xml.substring(i + 1, j);\n\n          tagStart = true;\n          tagEnd = false;\n        }\n\n        if (!(w > 96 && w < 123 || w > 64 && w < 91 || w === 95 || w === 58)) { // char 95\"_\" 58\":\"\n          return handleError('illegal first char nodeName');\n        }\n\n        for (q = 1, y = x.length; q < y; q++) {\n          w = x.charCodeAt(q);\n\n          if (w > 96 && w < 123 || w > 64 && w < 91 || w > 47 && w < 59 || w === 45 || w === 95 || w == 46) {\n            continue;\n          }\n\n          if (w === 32 || (w < 14 && w > 8)) { // \\f\\n\\r\\t\\v space\n            elementName = x.substring(0, q);\n            // maybe there are attributes\n            cachedAttrs = null;\n            break;\n          }\n\n          return handleError('invalid nodeName');\n        }\n\n        if (!tagEnd) {\n          nodeStack.push(elementName);\n        }\n      }\n\n      if (isNamespace) {\n\n        _nsMatrix = nsMatrix;\n\n        if (tagStart) {\n          // remember old namespace\n          // unless we're self-closing\n          if (!tagEnd) {\n            nsMatrixStack.push(_nsMatrix);\n          }\n\n          if (cachedAttrs === null) {\n            // quick check, whether there may be namespace\n            // declarations on the node; if that is the case\n            // we need to eagerly parse the node attributes\n            if ((maybeNS = x.indexOf('xmlns', q) !== -1)) {\n              attrsStart = q;\n              attrsString = x;\n\n              getAttrs();\n\n              maybeNS = false;\n            }\n          }\n        }\n\n        _elementName = elementName;\n\n        w = elementName.indexOf(':');\n        if (w !== -1) {\n          xmlns = nsMatrix[elementName.substring(0, w)];\n\n          // prefix given; namespace must exist\n          if (!xmlns) {\n            return handleError('missing namespace on <' + _elementName + '>');\n          }\n\n          elementName = elementName.substr(w + 1);\n        } else {\n          xmlns = nsMatrix['xmlns'];\n\n          // if no default namespace is defined,\n          // we'll import the element as anonymous.\n          //\n          // it is up to users to correct that to the document defined\n          // targetNamespace, or whatever their undersanding of the\n          // XML spec mandates.\n        }\n\n        // adjust namespace prefixs as configured\n        if (xmlns) {\n          elementName = xmlns + ':' + elementName;\n        }\n\n      }\n\n      if (tagStart) {\n        attrsStart = q;\n        attrsString = x;\n\n        if (onOpenTag) {\n          if (proxy) {\n            onOpenTag(elementProxy, decodeEntities, tagEnd, getContext);\n          } else {\n            onOpenTag(elementName, getAttrs, decodeEntities, tagEnd, getContext);\n          }\n\n          if (parseStop) {\n            return;\n          }\n        }\n\n      }\n\n      if (tagEnd) {\n\n        if (onCloseTag) {\n          onCloseTag(proxy ? elementProxy : elementName, decodeEntities, tagStart, getContext);\n\n          if (parseStop) {\n            return;\n          }\n        }\n\n        // restore old namespace\n        if (isNamespace) {\n          if (!tagStart) {\n            nsMatrix = nsMatrixStack.pop();\n          } else {\n            nsMatrix = _nsMatrix;\n          }\n        }\n      }\n\n      j += 1;\n    }\n  } /** end parse */\n\n}\n\nexports.Parser = Parser;\nexports.decode = decodeEntities;\n","'use strict';\n\nvar domify = require('min-dom/lib/domify'),\n    domClasses = require('min-dom/lib/classes'),\n    domMatches = require('min-dom/lib/matches'),\n    domDelegate = require('min-dom/lib/delegate'),\n    domQuery = require('min-dom/lib/query'),\n    domEvent = require('min-dom/lib/event'),\n    domAttr = require('min-dom/lib/attr');\n\nvar filter = require('lodash/collection/filter'),\n    assign = require('lodash/object/assign');\n\nvar inherits = require('inherits');\n\nvar EventEmitter = require('events');\n\nvar DEFAULT_OPTIONS = {\n  scrollSymbolLeft: '‹',\n  scrollSymbolRight: '›'\n};\n\n\n/**\n * This component adds the functionality to scroll over a list of tabs.\n *\n * It adds scroll buttons on the left and right side of the tabs container\n * if not all tabs are visible. It also adds a mouse wheel listener on the\n * container.\n *\n * If either a button is clicked or the mouse wheel is used over the tabs,\n * a 'scroll' event is being fired. This event contains the node elements\n * of the new and old active tab, and the direction in which the tab has\n * changed relative to the old active tab.\n *\n * @example:\n * (1) provide a tabs-container:\n *\n * var $el = (\n *   <div>\n *     <!-- button added by scrollTabs -->\n *     <span class=\"scroll-tabs-button scroll-tabs-left\"></span>\n *     <ul class=\"my-tabs-container\">\n *       <li class=\"my-tab i-am-active\"></li>\n *       <li class=\"my-tab\"></li>\n *       <li class=\"my-tab ignore-me\"></li>\n *     </ul>\n *     <!-- button added by scrollTabs -->\n *     <span class=\"scroll-tabs-button scroll-tabs-right\"></span>\n *   </div>\n * );\n *\n *\n * (2) initialize scrollTabs:\n *\n *  var scroller = scrollTabs(tabBarNode, {\n *    selectors: {\n *      tabsContainer: '.my-tabs-container',\n *      tab: '.my-tab',\n *      ignore: '.ignore-me',\n *      active: '.i-am-active'\n *    }\n *  });\n *\n *\n * (3) listen to the scroll event:\n *\n * scroller.on('scroll', function(newActiveNode, oldActiveNode, direction) {\n *   // direction is any of (-1: left, 1: right)\n *   // activate the new active tab\n * });\n *\n *\n * (4) update the scroller if tabs change and or the tab container resizes:\n *\n * scroller.update();\n *\n *\n * @param  {DOMElement} el\n * @param  {Object} options\n * @param  {Object} options.selectors\n * @param  {String} options.selectors.tabsContainer the container all tabs are contained in\n * @param  {String} options.selectors.tab a single tab inside the tab container\n * @param  {String} options.selectors.ignore tabs that should be ignored during scroll left/right\n * @param  {String} options.selectors.active selector for the current active tab\n * @param  {String} [options.scrollSymbolLeft]\n * @param  {String} [options.scrollSymbolRight]\n */\nfunction ScrollTabs($el, options) {\n\n  // we are an event emitter\n  EventEmitter.call(this);\n\n  this.options = options = assign({}, DEFAULT_OPTIONS, options);\n  this.container = $el;\n\n  this._createScrollButtons($el, options);\n\n  this._bindEvents($el);\n}\n\ninherits(ScrollTabs, EventEmitter);\n\n\n/**\n * Create a clickable scroll button\n *\n * @param {Object} options\n * @param {String} options.className\n * @param {String} options.label\n * @param {Number} options.direction\n *\n * @return {DOMElement} The created scroll button node\n */\nScrollTabs.prototype._createButton = function(parentNode, options) {\n\n  var className = options.className,\n      direction = options.direction;\n\n\n  var button = domQuery('.' + className, parentNode);\n\n  if (!button) {\n    button = domify('<span class=\"scroll-tabs-button ' + className + '\">' +\n                                options.label +\n                              '</span>');\n\n    parentNode.insertBefore(button, parentNode.childNodes[0]);\n  }\n\n  domAttr(button, 'data-direction', direction);\n\n  return button;\n};\n\n/**\n * Create both scroll buttons\n *\n * @param  {DOMElement} parentNode\n * @param  {Object} options\n * @param  {String} options.scrollSymbolLeft\n * @param  {String} options.scrollSymbolRight\n */\nScrollTabs.prototype._createScrollButtons = function(parentNode, options) {\n\n  // Create a button that scrolls to the tab left to the currently active tab\n  this._createButton(parentNode, {\n    className: 'scroll-tabs-left',\n    label: options.scrollSymbolLeft,\n    direction: -1\n  });\n\n  // Create a button that scrolls to the tab right to the currently active tab\n  this._createButton(parentNode, {\n    className: 'scroll-tabs-right',\n    label: options.scrollSymbolRight,\n    direction: 1\n  });\n};\n\n/**\n * Get the current active tab\n *\n * @return {DOMElement}\n */\nScrollTabs.prototype.getActiveTabNode = function() {\n  return domQuery(this.options.selectors.active, this.container);\n};\n\n\n/**\n * Get the container all tabs are contained in\n *\n * @return {DOMElement}\n */\nScrollTabs.prototype.getTabsContainerNode = function () {\n  return domQuery(this.options.selectors.tabsContainer, this.container);\n};\n\n\n/**\n * Get all tabs (visible and invisible ones)\n *\n * @return {Array<DOMElement>}\n */\nScrollTabs.prototype.getAllTabNodes = function () {\n  return domQuery.all(this.options.selectors.tab, this.container);\n};\n\n\n/**\n * Gets all tabs that don't have the ignore class set\n *\n * @return {Array<DOMElement>}\n */\nScrollTabs.prototype.getVisibleTabs = function() {\n  var allTabs = this.getAllTabNodes();\n\n  var ignore = this.options.selectors.ignore;\n\n  return filter(allTabs, function(tabNode) {\n    return !domMatches(tabNode, ignore);\n  });\n};\n\n\n/**\n * Get a tab relative to a reference tab.\n *\n * @param  {DOMElement} referenceTabNode\n * @param  {Number} n gets the nth tab next or previous to the reference tab\n *\n * @return {DOMElement}\n *\n * @example:\n * Visible tabs: [ A | B | C | D | E ]\n * Assume tab 'C' is the reference tab:\n * If direction === -1, it returns tab 'B',\n * if direction ===  2, it returns tab 'E'\n */\nScrollTabs.prototype.getAdjacentTab = function(referenceTabNode, n) {\n  var visibleTabs = this.getVisibleTabs();\n\n  var index = visibleTabs.indexOf(referenceTabNode);\n\n  return visibleTabs[index + n];\n};\n\nScrollTabs.prototype._bindEvents = function(node) {\n  this._bindWheelEvent(node);\n  this._bindTabClickEvents(node);\n  this._bindScrollButtonEvents(node);\n};\n\n/**\n *  Bind a click listener to a DOM node.\n *  Make sure a tab link is entirely visible after onClick.\n *\n * @param {DOMElement} node\n */\nScrollTabs.prototype._bindTabClickEvents = function(node) {\n  var selector = this.options.selectors.tab;\n\n  var self = this;\n\n  domDelegate.bind(node, selector, 'click', function onClick(event) {\n    self.scrollToTabNode(event.delegateTarget);\n  });\n};\n\n\n/**\n * Bind the wheel event listener to a DOM node\n *\n * @param {DOMElement} node\n */\nScrollTabs.prototype._bindWheelEvent = function(node) {\n  var self = this;\n\n  domEvent.bind(node, 'wheel', function(e) {\n\n    // scroll direction (-1: left, 1: right)\n    var direction = Math.sign(e.deltaY);\n\n    var oldActiveTab = self.getActiveTabNode();\n\n    var newActiveTab = self.getAdjacentTab(oldActiveTab, direction);\n\n    if (newActiveTab) {\n      self.scrollToTabNode(newActiveTab);\n      self.emit('scroll', newActiveTab, oldActiveTab, direction);\n    }\n\n    e.preventDefault();\n  });\n};\n\n/**\n * Bind scroll button events to a DOM node\n *\n * @param  {DOMElement} node\n */\nScrollTabs.prototype._bindScrollButtonEvents = function(node) {\n\n  var self = this;\n\n  domDelegate.bind(node, '.scroll-tabs-button', 'click', function(event) {\n\n    var target = event.delegateTarget;\n\n    // data-direction is either -1 or 1\n    var direction = parseInt(domAttr(target, 'data-direction'), 10);\n\n    var oldActiveTabNode = self.getActiveTabNode();\n\n    var newActiveTabNode = self.getAdjacentTab(oldActiveTabNode, direction);\n\n    if (newActiveTabNode) {\n      self.scrollToTabNode(newActiveTabNode);\n      self.emit('scroll', newActiveTabNode, oldActiveTabNode, direction);\n    }\n\n    event.preventDefault();\n  });\n};\n\n\n/**\n* Scroll to a tab if it is not entirely visible\n*\n* @param  {DOMElement} tabNode tab node to scroll to\n*/\nScrollTabs.prototype.scrollToTabNode = function(tabNode) {\n  if (!tabNode) {\n    return;\n  }\n\n  var tabsContainerNode = tabNode.parentNode;\n\n  var tabWidth = tabNode.offsetWidth,\n      tabOffsetLeft = tabNode.offsetLeft,\n      tabOffsetRight = tabOffsetLeft + tabWidth,\n      containerWidth = tabsContainerNode.offsetWidth,\n      containerScrollLeft = tabsContainerNode.scrollLeft;\n\n  if (containerScrollLeft > tabOffsetLeft) {\n    // scroll to the left, if the tab is overflowing on the left side\n    tabsContainerNode.scrollLeft = 0;\n  } else if (tabOffsetRight > containerWidth) {\n    // scroll to the right, if the tab is overflowing on the right side\n    tabsContainerNode.scrollLeft = tabOffsetRight - containerWidth;\n  }\n};\n\n\n/**\n * React on tab changes from outside (resize/show/hide/add/remove),\n * update scroll button visibility.\n */\nScrollTabs.prototype.update = function() {\n\n  var tabsContainerNode = this.getTabsContainerNode();\n\n  // check if tabs fit in container\n  var overflow = tabsContainerNode.scrollWidth > tabsContainerNode.offsetWidth;\n\n  // TODO(nikku): distinguish overflow left / overflow right?\n  var overflowClass = 'scroll-tabs-overflow';\n\n  domClasses(this.container).toggle(overflowClass, overflow);\n\n  if (overflow) {\n    // make sure the current active tab is always visible\n    this.scrollToTabNode(this.getActiveTabNode());\n  }\n};\n\n\n////// module exports /////////////////////////////////////////\n\n/**\n * Create a scrollTabs instance on the given element.\n *\n * @param {DOMElement} $el\n * @param {Object} options\n *\n * @return {ScrollTabs}\n */\nfunction create($el, options) {\n\n  var scrollTabs = get($el);\n\n  if (!scrollTabs) {\n    scrollTabs = new ScrollTabs($el, options);\n\n    $el.__scrollTabs = scrollTabs;\n  }\n\n  return scrollTabs;\n}\n\n/**\n * Factory function to get or create a new scroll tabs instance.\n */\nmodule.exports = create;\n\n\n/**\n * Return the scrollTabs instance that has been previously\n * initialized on the element.\n *\n * @param {DOMElement} $el\n * @return {ScrollTabs}\n */\nfunction get($el) {\n  return $el.__scrollTabs;\n}\n\n/**\n * Getter to retrieve an already initialized scroll tabs instance.\n */\nmodule.exports.get = get;","module.exports = require('component-event');","'use strict';\n\n/**\n * Calculate the selection update for the given\n * current and new input values.\n *\n * @param {Object} currentSelection as {start, end}\n * @param {String} currentValue\n * @param {String} newValue\n *\n * @return {Object} newSelection as {start, end}\n */\nfunction calculateUpdate(currentSelection, currentValue, newValue) {\n\n  var currentCursor = currentSelection.start,\n      newCursor = currentCursor,\n      diff = newValue.length - currentValue.length,\n      idx;\n\n  var lengthDelta = newValue.length - currentValue.length;\n\n  var currentTail = currentValue.substring(currentCursor);\n\n  // check if we can remove common ending from the equation\n  // to be able to properly detect a selection change for\n  // the following scenarios:\n  //\n  //  * (AAATTT|TF) => (AAAT|TF)\n  //  * (AAAT|TF) =>  (AAATTT|TF)\n  //\n  if (newValue.lastIndexOf(currentTail) === newValue.length - currentTail.length) {\n    currentValue = currentValue.substring(0, currentValue.length - currentTail.length);\n    newValue = newValue.substring(0, newValue.length - currentTail.length);\n  }\n\n  // diff\n  var diff = createDiff(currentValue, newValue);\n\n  if (diff) {\n    if (diff.type === 'remove') {\n      newCursor = diff.newStart;\n    } else {\n      newCursor = diff.newEnd;\n    }\n  }\n\n  return range(newCursor);\n}\n\nmodule.exports = calculateUpdate;\n\n\nfunction createDiff(currentValue, newValue) {\n\n  var insert;\n\n  var l_str, l_char, l_idx = 0,\n      s_str, s_char, s_idx = 0;\n\n  if (newValue.length > currentValue.length) {\n    l_str = newValue;\n    s_str = currentValue;\n  } else {\n    l_str = currentValue;\n    s_str = newValue;\n  }\n\n  // assume there will be only one insert / remove and\n  // detect that _first_ edit operation only\n  while (l_idx < l_str.length) {\n\n    l_char = l_str.charAt(l_idx);\n    s_char = s_str.charAt(s_idx);\n\n    // chars no not equal\n    if (l_char !== s_char) {\n\n      if (!insert) {\n        insert = {\n          l_start: l_idx,\n          s_start: s_idx\n        };\n      }\n\n      l_idx++;\n    }\n\n    // chars equal (again?)\n    else {\n\n      if (insert && !insert.complete) {\n        insert.l_end = l_idx;\n        insert.s_end = s_idx;\n        insert.complete = true;\n      }\n\n      s_idx++;\n      l_idx++;\n    }\n  }\n\n  if (insert && !insert.complete) {\n    insert.complete = true;\n    insert.s_end = s_str.length;\n    insert.l_end = l_str.length;\n  }\n\n  // no diff\n  if (!insert) {\n    return;\n  }\n\n  if (newValue.length > currentValue.length) {\n    return {\n      newStart: insert.l_start,\n      newEnd: insert.l_end,\n      type: 'add'\n    };\n  } else {\n    return {\n      newStart: insert.s_start,\n      newEnd: insert.s_end,\n      type: newValue.length < currentValue.length ? 'remove' : 'replace'\n    };\n  }\n}\n\n/**\n * Utility method for creating a new selection range {start, end} object.\n *\n * @param {Number} start\n * @param {Number} [end]\n *\n * @return {Object} selection range as {start, end}\n */\nfunction range(start, end) {\n  return {\n    start: start,\n    end: end === undefined ? start : end\n  };\n}\n\nmodule.exports.range = range;\n\n\nfunction splitStr(str, position) {\n  return {\n    before: str.substring(0, position),\n    after: str.substring(position)\n  };\n}","\"use strict\";\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n/**\n * Tiny stack for browser or server\n *\n * @author Jason Mulligan <jason.mulligan@avoidwork.com>\n * @copyright 2018\n * @license BSD-3-Clause\n * @link http://avoidwork.github.io/tiny-stack\n * @version 1.1.0\n */\n(function (global) {\n\t\"use strict\";\n\n\tvar TinyStack = function () {\n\t\tfunction TinyStack() {\n\t\t\t_classCallCheck(this, TinyStack);\n\n\t\t\tfor (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {\n\t\t\t\targs[_key] = arguments[_key];\n\t\t\t}\n\n\t\t\tthis.data = [null].concat(args);\n\t\t\tthis.top = this.data.length - 1;\n\t\t}\n\n\t\t_createClass(TinyStack, [{\n\t\t\tkey: \"clear\",\n\t\t\tvalue: function clear() {\n\t\t\t\tthis.data.length = 1;\n\t\t\t\tthis.top = 0;\n\n\t\t\t\treturn this;\n\t\t\t}\n\t\t}, {\n\t\t\tkey: \"empty\",\n\t\t\tvalue: function empty() {\n\t\t\t\treturn this.top === 0;\n\t\t\t}\n\t\t}, {\n\t\t\tkey: \"length\",\n\t\t\tvalue: function length() {\n\t\t\t\treturn this.top;\n\t\t\t}\n\t\t}, {\n\t\t\tkey: \"peek\",\n\t\t\tvalue: function peek() {\n\t\t\t\treturn this.data[this.top];\n\t\t\t}\n\t\t}, {\n\t\t\tkey: \"pop\",\n\t\t\tvalue: function pop() {\n\t\t\t\tvar result = void 0;\n\n\t\t\t\tif (this.top > 0) {\n\t\t\t\t\tresult = this.data.pop();\n\t\t\t\t\tthis.top--;\n\t\t\t\t}\n\n\t\t\t\treturn result;\n\t\t\t}\n\t\t}, {\n\t\t\tkey: \"push\",\n\t\t\tvalue: function push(arg) {\n\t\t\t\tthis.data[++this.top] = arg;\n\n\t\t\t\treturn this;\n\t\t\t}\n\t\t}, {\n\t\t\tkey: \"search\",\n\t\t\tvalue: function search(arg) {\n\t\t\t\tvar index = this.data.indexOf(arg);\n\n\t\t\t\treturn index === -1 ? -1 : this.data.length - index;\n\t\t\t}\n\t\t}]);\n\n\t\treturn TinyStack;\n\t}();\n\n\tfunction factory() {\n\t\tfor (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n\t\t\targs[_key2] = arguments[_key2];\n\t\t}\n\n\t\treturn new (Function.prototype.bind.apply(TinyStack, [null].concat(args)))();\n\t}\n\n\t// Node, AMD & window supported\n\tif (typeof exports !== \"undefined\") {\n\t\tmodule.exports = factory;\n\t} else if (typeof define === \"function\" && define.amd !== void 0) {\n\t\tdefine(function () {\n\t\t\treturn factory;\n\t\t});\n\t} else {\n\t\tglobal.stack = factory;\n\t}\n})(typeof window !== \"undefined\" ? window : global);\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nfunction ensureImported(element, target) {\n\n  if (element.ownerDocument !== target.ownerDocument) {\n    try {\n      // may fail on webkit\n      return target.ownerDocument.importNode(element, true);\n    } catch (e) {\n      // ignore\n    }\n  }\n\n  return element;\n}\n\n/**\n * appendTo utility\n */\n\n/**\n * Append a node to a target element and return the appended node.\n *\n * @param  {SVGElement} element\n * @param  {SVGElement} target\n *\n * @return {SVGElement} the appended node\n */\nfunction appendTo(element, target) {\n  return target.appendChild(ensureImported(element, target));\n}\n\n/**\n * append utility\n */\n\n/**\n * Append a node to an element\n *\n * @param  {SVGElement} element\n * @param  {SVGElement} node\n *\n * @return {SVGElement} the element\n */\nfunction append(target, node) {\n  appendTo(node, target);\n  return target;\n}\n\n/**\n * attribute accessor utility\n */\n\nvar LENGTH_ATTR = 2;\n\nvar CSS_PROPERTIES = {\n  'alignment-baseline': 1,\n  'baseline-shift': 1,\n  'clip': 1,\n  'clip-path': 1,\n  'clip-rule': 1,\n  'color': 1,\n  'color-interpolation': 1,\n  'color-interpolation-filters': 1,\n  'color-profile': 1,\n  'color-rendering': 1,\n  'cursor': 1,\n  'direction': 1,\n  'display': 1,\n  'dominant-baseline': 1,\n  'enable-background': 1,\n  'fill': 1,\n  'fill-opacity': 1,\n  'fill-rule': 1,\n  'filter': 1,\n  'flood-color': 1,\n  'flood-opacity': 1,\n  'font': 1,\n  'font-family': 1,\n  'font-size': LENGTH_ATTR,\n  'font-size-adjust': 1,\n  'font-stretch': 1,\n  'font-style': 1,\n  'font-variant': 1,\n  'font-weight': 1,\n  'glyph-orientation-horizontal': 1,\n  'glyph-orientation-vertical': 1,\n  'image-rendering': 1,\n  'kerning': 1,\n  'letter-spacing': 1,\n  'lighting-color': 1,\n  'marker': 1,\n  'marker-end': 1,\n  'marker-mid': 1,\n  'marker-start': 1,\n  'mask': 1,\n  'opacity': 1,\n  'overflow': 1,\n  'pointer-events': 1,\n  'shape-rendering': 1,\n  'stop-color': 1,\n  'stop-opacity': 1,\n  'stroke': 1,\n  'stroke-dasharray': 1,\n  'stroke-dashoffset': 1,\n  'stroke-linecap': 1,\n  'stroke-linejoin': 1,\n  'stroke-miterlimit': 1,\n  'stroke-opacity': 1,\n  'stroke-width': LENGTH_ATTR,\n  'text-anchor': 1,\n  'text-decoration': 1,\n  'text-rendering': 1,\n  'unicode-bidi': 1,\n  'visibility': 1,\n  'word-spacing': 1,\n  'writing-mode': 1\n};\n\n\nfunction getAttribute(node, name) {\n  if (CSS_PROPERTIES[name]) {\n    return node.style[name];\n  } else {\n    return node.getAttributeNS(null, name);\n  }\n}\n\nfunction setAttribute(node, name, value) {\n  var hyphenated = name.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();\n\n  var type = CSS_PROPERTIES[hyphenated];\n\n  if (type) {\n    // append pixel unit, unless present\n    if (type === LENGTH_ATTR && typeof value === 'number') {\n      value = String(value) + 'px';\n    }\n\n    node.style[hyphenated] = value;\n  } else {\n    node.setAttributeNS(null, name, value);\n  }\n}\n\nfunction setAttributes(node, attrs) {\n\n  var names = Object.keys(attrs), i, name;\n\n  for (i = 0, name; (name = names[i]); i++) {\n    setAttribute(node, name, attrs[name]);\n  }\n}\n\n/**\n * Gets or sets raw attributes on a node.\n *\n * @param  {SVGElement} node\n * @param  {Object} [attrs]\n * @param  {String} [name]\n * @param  {String} [value]\n *\n * @return {String}\n */\nfunction attr(node, name, value) {\n  if (typeof name === 'string') {\n    if (value !== undefined) {\n      setAttribute(node, name, value);\n    } else {\n      return getAttribute(node, name);\n    }\n  } else {\n    setAttributes(node, name);\n  }\n\n  return node;\n}\n\n/**\r\n * Clear utility\r\n */\r\nfunction index(arr, obj) {\r\n  if (arr.indexOf) {\r\n    return arr.indexOf(obj);\r\n  }\r\n\r\n\r\n  for (var i = 0; i < arr.length; ++i) {\r\n    if (arr[i] === obj) {\r\n      return i;\r\n    }\r\n  }\r\n\r\n  return -1;\r\n}\r\n\r\nvar re = /\\s+/;\r\n\r\nvar toString = Object.prototype.toString;\r\n\r\nfunction defined(o) {\r\n  return typeof o !== 'undefined';\r\n}\r\n\r\n/**\r\n * Wrap `el` in a `ClassList`.\r\n *\r\n * @param {Element} el\r\n * @return {ClassList}\r\n * @api public\r\n */\r\n\r\nfunction classes(el) {\r\n  return new ClassList(el);\r\n}\r\n\r\nfunction ClassList(el) {\r\n  if (!el || !el.nodeType) {\r\n    throw new Error('A DOM element reference is required');\r\n  }\r\n  this.el = el;\r\n  this.list = el.classList;\r\n}\r\n\r\n/**\r\n * Add class `name` if not already present.\r\n *\r\n * @param {String} name\r\n * @return {ClassList}\r\n * @api public\r\n */\r\n\r\nClassList.prototype.add = function(name) {\r\n\r\n  // classList\r\n  if (this.list) {\r\n    this.list.add(name);\r\n    return this;\r\n  }\r\n\r\n  // fallback\r\n  var arr = this.array();\r\n  var i = index(arr, name);\r\n  if (!~i) {\r\n    arr.push(name);\r\n  }\r\n\r\n  if (defined(this.el.className.baseVal)) {\r\n    this.el.className.baseVal = arr.join(' ');\r\n  } else {\r\n    this.el.className = arr.join(' ');\r\n  }\r\n\r\n  return this;\r\n};\r\n\r\n/**\r\n * Remove class `name` when present, or\r\n * pass a regular expression to remove\r\n * any which match.\r\n *\r\n * @param {String|RegExp} name\r\n * @return {ClassList}\r\n * @api public\r\n */\r\n\r\nClassList.prototype.remove = function(name) {\r\n  if ('[object RegExp]' === toString.call(name)) {\r\n    return this.removeMatching(name);\r\n  }\r\n\r\n  // classList\r\n  if (this.list) {\r\n    this.list.remove(name);\r\n    return this;\r\n  }\r\n\r\n  // fallback\r\n  var arr = this.array();\r\n  var i = index(arr, name);\r\n  if (~i) {\r\n    arr.splice(i, 1);\r\n  }\r\n  this.el.className.baseVal = arr.join(' ');\r\n  return this;\r\n};\r\n\r\n/**\r\n * Remove all classes matching `re`.\r\n *\r\n * @param {RegExp} re\r\n * @return {ClassList}\r\n * @api private\r\n */\r\n\r\nClassList.prototype.removeMatching = function(re) {\r\n  var arr = this.array();\r\n  for (var i = 0; i < arr.length; i++) {\r\n    if (re.test(arr[i])) {\r\n      this.remove(arr[i]);\r\n    }\r\n  }\r\n  return this;\r\n};\r\n\r\n/**\r\n * Toggle class `name`, can force state via `force`.\r\n *\r\n * For browsers that support classList, but do not support `force` yet,\r\n * the mistake will be detected and corrected.\r\n *\r\n * @param {String} name\r\n * @param {Boolean} force\r\n * @return {ClassList}\r\n * @api public\r\n */\r\n\r\nClassList.prototype.toggle = function(name, force) {\r\n  // classList\r\n  if (this.list) {\r\n    if (defined(force)) {\r\n      if (force !== this.list.toggle(name, force)) {\r\n        this.list.toggle(name); // toggle again to correct\r\n      }\r\n    } else {\r\n      this.list.toggle(name);\r\n    }\r\n    return this;\r\n  }\r\n\r\n  // fallback\r\n  if (defined(force)) {\r\n    if (!force) {\r\n      this.remove(name);\r\n    } else {\r\n      this.add(name);\r\n    }\r\n  } else {\r\n    if (this.has(name)) {\r\n      this.remove(name);\r\n    } else {\r\n      this.add(name);\r\n    }\r\n  }\r\n\r\n  return this;\r\n};\r\n\r\n/**\r\n * Return an array of classes.\r\n *\r\n * @return {Array}\r\n * @api public\r\n */\r\n\r\nClassList.prototype.array = function() {\r\n  var className = this.el.getAttribute('class') || '';\r\n  var str = className.replace(/^\\s+|\\s+$/g, '');\r\n  var arr = str.split(re);\r\n  if ('' === arr[0]) {\r\n    arr.shift();\r\n  }\r\n  return arr;\r\n};\r\n\r\n/**\r\n * Check if class `name` is present.\r\n *\r\n * @param {String} name\r\n * @return {ClassList}\r\n * @api public\r\n */\r\n\r\nClassList.prototype.has =\r\nClassList.prototype.contains = function(name) {\r\n  return (\r\n    this.list ?\r\n      this.list.contains(name) :\r\n      !! ~index(this.array(), name)\r\n  );\r\n};\n\nfunction remove(element) {\n  var parent = element.parentNode;\n\n  if (parent) {\n    parent.removeChild(element);\n  }\n\n  return element;\n}\n\n/**\n * Clear utility\n */\n\n/**\n * Removes all children from the given element\n *\n * @param  {DOMElement} element\n * @return {DOMElement} the element (for chaining)\n */\nfunction clear(element) {\n  var child;\n\n  while ((child = element.firstChild)) {\n    remove(child);\n  }\n\n  return element;\n}\n\nfunction clone(element) {\n  return element.cloneNode(true);\n}\n\nvar ns = {\n  svg: 'http://www.w3.org/2000/svg'\n};\n\n/**\n * DOM parsing utility\n */\n\nvar SVG_START = '<svg xmlns=\"' + ns.svg + '\"';\n\nfunction parse(svg) {\n\n  var unwrap = false;\n\n  // ensure we import a valid svg document\n  if (svg.substring(0, 4) === '<svg') {\n    if (svg.indexOf(ns.svg) === -1) {\n      svg = SVG_START + svg.substring(4);\n    }\n  } else {\n    // namespace svg\n    svg = SVG_START + '>' + svg + '</svg>';\n    unwrap = true;\n  }\n\n  var parsed = parseDocument(svg);\n\n  if (!unwrap) {\n    return parsed;\n  }\n\n  var fragment = document.createDocumentFragment();\n\n  var parent = parsed.firstChild;\n\n  while (parent.firstChild) {\n    fragment.appendChild(parent.firstChild);\n  }\n\n  return fragment;\n}\n\nfunction parseDocument(svg) {\n\n  var parser;\n\n  // parse\n  parser = new DOMParser();\n  parser.async = false;\n\n  return parser.parseFromString(svg, 'text/xml');\n}\n\n/**\n * Create utility for SVG elements\n */\n\n\n/**\n * Create a specific type from name or SVG markup.\n *\n * @param {String} name the name or markup of the element\n * @param {Object} [attrs] attributes to set on the element\n *\n * @returns {SVGElement}\n */\nfunction create(name, attrs) {\n  var element;\n\n  if (name.charAt(0) === '<') {\n    element = parse(name).firstChild;\n    element = document.importNode(element, true);\n  } else {\n    element = document.createElementNS(ns.svg, name);\n  }\n\n  if (attrs) {\n    attr(element, attrs);\n  }\n\n  return element;\n}\n\n/**\n * Events handling utility\n */\n\nfunction on(node, event, listener, useCapture) {\n  node.addEventListener(event, listener, useCapture);\n}\n\nfunction off(node, event, listener, useCapture) {\n  node.removeEventListener(event, listener, useCapture);\n}\n\n/**\n * Geometry helpers\n */\n\n// fake node used to instantiate svg geometry elements\nvar node = create('svg');\n\nfunction extend(object, props) {\n  var i, k, keys = Object.keys(props);\n\n  for (i = 0; (k = keys[i]); i++) {\n    object[k] = props[k];\n  }\n\n  return object;\n}\n\n\nfunction createPoint(x, y) {\n  var point = node.createSVGPoint();\n\n  switch (arguments.length) {\n  case 0:\n    return point;\n  case 2:\n    x = {\n      x: x,\n      y: y\n    };\n    break;\n  }\n\n  return extend(point, x);\n}\n\nfunction createMatrix(a, b, c, d, e, f) {\n  var matrix = node.createSVGMatrix();\n\n  switch (arguments.length) {\n  case 0:\n    return matrix;\n  case 6:\n    a = {\n      a: a,\n      b: b,\n      c: c,\n      d: d,\n      e: e,\n      f: f\n    };\n    break;\n  }\n\n  return extend(matrix, a);\n}\n\nfunction createTransform(matrix) {\n  if (matrix) {\n    return node.createSVGTransformFromMatrix(matrix);\n  } else {\n    return node.createSVGTransform();\n  }\n}\n\n/**\n * Serialization util\n */\n\nvar TEXT_ENTITIES = /([&<>]{1})/g;\nvar ATTR_ENTITIES = /([\\n\\r\"]{1})/g;\n\nvar ENTITY_REPLACEMENT = {\n  '&': '&amp;',\n  '<': '&lt;',\n  '>': '&gt;',\n  '\"': '\\''\n};\n\nfunction escape(str, pattern) {\n\n  function replaceFn(match, entity) {\n    return ENTITY_REPLACEMENT[entity] || entity;\n  }\n\n  return str.replace(pattern, replaceFn);\n}\n\nfunction serialize(node, output) {\n\n  var i, len, attrMap, attrNode, childNodes;\n\n  switch (node.nodeType) {\n  // TEXT\n  case 3:\n    // replace special XML characters\n    output.push(escape(node.textContent, TEXT_ENTITIES));\n    break;\n\n  // ELEMENT\n  case 1:\n    output.push('<', node.tagName);\n\n    if (node.hasAttributes()) {\n      attrMap = node.attributes;\n      for (i = 0, len = attrMap.length; i < len; ++i) {\n        attrNode = attrMap.item(i);\n        output.push(' ', attrNode.name, '=\"', escape(attrNode.value, ATTR_ENTITIES), '\"');\n      }\n    }\n\n    if (node.hasChildNodes()) {\n      output.push('>');\n      childNodes = node.childNodes;\n      for (i = 0, len = childNodes.length; i < len; ++i) {\n        serialize(childNodes.item(i), output);\n      }\n      output.push('</', node.tagName, '>');\n    } else {\n      output.push('/>');\n    }\n    break;\n\n  // COMMENT\n  case 8:\n    output.push('<!--', escape(node.nodeValue, TEXT_ENTITIES), '-->');\n    break;\n\n  // CDATA\n  case 4:\n    output.push('<![CDATA[', node.nodeValue, ']]>');\n    break;\n\n  default:\n    throw new Error('unable to handle node ' + node.nodeType);\n  }\n\n  return output;\n}\n\n/**\n * innerHTML like functionality for SVG elements.\n * based on innerSVG (https://code.google.com/p/innersvg)\n */\n\n\nfunction set(element, svg) {\n\n  var parsed = parse(svg);\n\n  // clear element contents\n  clear(element);\n\n  if (!svg) {\n    return;\n  }\n\n  if (!isFragment(parsed)) {\n    // extract <svg> from parsed document\n    parsed = parsed.documentElement;\n  }\n\n  var nodes = slice(parsed.childNodes);\n\n  // import + append each node\n  for (var i = 0; i < nodes.length; i++) {\n    appendTo(nodes[i], element);\n  }\n\n}\n\nfunction get(element) {\n  var child = element.firstChild,\n      output = [];\n\n  while (child) {\n    serialize(child, output);\n    child = child.nextSibling;\n  }\n\n  return output.join('');\n}\n\nfunction isFragment(node) {\n  return node.nodeName === '#document-fragment';\n}\n\nfunction innerSVG(element, svg) {\n\n  if (svg !== undefined) {\n\n    try {\n      set(element, svg);\n    } catch (e) {\n      throw new Error('error parsing SVG: ' + e.message);\n    }\n\n    return element;\n  } else {\n    return get(element);\n  }\n}\n\n\nfunction slice(arr) {\n  return Array.prototype.slice.call(arr);\n}\n\n/**\n * Selection utilities\n */\n\nfunction select(node, selector) {\n  return node.querySelector(selector);\n}\n\nfunction selectAll(node, selector) {\n  var nodes = node.querySelectorAll(selector);\n\n  return [].map.call(nodes, function(element) {\n    return element;\n  });\n}\n\n/**\n * prependTo utility\n */\n\n/**\n * Prepend a node to a target element and return the prepended node.\n *\n * @param  {SVGElement} node\n * @param  {SVGElement} target\n *\n * @return {SVGElement} the prepended node\n */\nfunction prependTo(node, target) {\n  return target.insertBefore(ensureImported(node, target), target.firstChild || null);\n}\n\n/**\n * prepend utility\n */\n\n/**\n * Prepend a node to a target element\n *\n * @param  {SVGElement} target\n * @param  {SVGElement} node\n *\n * @return {SVGElement} the target element\n */\nfunction prepend(target, node) {\n  prependTo(node, target);\n  return target;\n}\n\n/**\n * Replace utility\n */\n\nfunction replace(element, replacement) {\n  element.parentNode.replaceChild(ensureImported(replacement, element), element);\n  return replacement;\n}\n\n/**\n * transform accessor utility\n */\n\nfunction wrapMatrix(transformList, transform) {\n  if (transform instanceof SVGMatrix) {\n    return transformList.createSVGTransformFromMatrix(transform);\n  } else {\n    return transform;\n  }\n}\n\nfunction setTransforms(transformList, transforms) {\n  var i, t;\n\n  transformList.clear();\n\n  for (i = 0; (t = transforms[i]); i++) {\n    transformList.appendItem(wrapMatrix(transformList, t));\n  }\n\n  transformList.consolidate();\n}\n\nfunction transform(node, transforms) {\n  var transformList = node.transform.baseVal;\n\n  if (arguments.length === 1) {\n    return transformList.consolidate();\n  } else {\n    if (transforms.length) {\n      setTransforms(transformList, transforms);\n    } else {\n      transformList.initialize(wrapMatrix(transformList, transforms));\n    }\n  }\n}\n\nexports.append = append;\nexports.appendTo = appendTo;\nexports.attr = attr;\nexports.classes = classes;\nexports.clear = clear;\nexports.clone = clone;\nexports.create = create;\nexports.innerSVG = innerSVG;\nexports.prepend = prepend;\nexports.prependTo = prependTo;\nexports.remove = remove;\nexports.replace = replace;\nexports.transform = transform;\nexports.on = on;\nexports.off = off;\nexports.createPoint = createPoint;\nexports.createMatrix = createMatrix;\nexports.createTransform = createTransform;\nexports.select = select;\nexports.selectAll = selectAll;\n","module.exports = \"<?xml version=\\\"1.0\\\" encoding=\\\"UTF-8\\\"?>\\r\\n<bpmn2:definitions xmlns:xsi=\\\"http://www.w3.org/2001/XMLSchema-instance\\\" xmlns:bpmn2=\\\"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\\\" xmlns:di=\\\"http://www.omg.org/spec/DD/20100524/DI\\\" xsi:schemaLocation=\\\"http://www.omg.org/spec/BPMN/20100524/MODEL BPMN20.xsd\\\" id=\\\"sample-diagram\\\" targetNamespace=\\\"http://bpmn.io/schema/bpmn\\\">\\r\\n  <bpmn2:process id=\\\"Process_1\\\" isExecutable=\\\"false\\\">\\r\\n    <bpmn2:startEvent id=\\\"StartEvent_1\\\"/>\\r\\n  </bpmn2:process>\\r\\n  <bpmndi:BPMNDiagram id=\\\"BPMNDiagram_1\\\">\\r\\n    <bpmndi:BPMNPlane id=\\\"BPMNPlane_1\\\" bpmnElement=\\\"Process_1\\\">\\r\\n      <bpmndi:BPMNShape id=\\\"_BPMNShape_StartEvent_2\\\" bpmnElement=\\\"StartEvent_1\\\">\\r\\n        <dc:Bounds height=\\\"36.0\\\" width=\\\"36.0\\\" x=\\\"412.0\\\" y=\\\"240.0\\\"/>\\r\\n      </bpmndi:BPMNShape>\\r\\n    </bpmndi:BPMNPlane>\\r\\n  </bpmndi:BPMNDiagram>\\r\\n</bpmn2:definitions>\";\n"]}