xref: /plugin/bpmnioeditor/vendor/bpmnio-js/bpmn-modeler.development.js

/*!
 * bpmn-js - bpmn-modeler v8.8.2
 *
 * Copyright (c) 2014-present, camunda Services GmbH
 *
 * Released under the bpmn.io license
 * http://bpmn.io/license
 *
 * Source Code: https://github.com/bpmn-io/bpmn-js
 *
 * Date: 2021-10-20
 */
(function (global, factory) {
	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
	typeof define === 'function' && define.amd ? define(factory) :
	(global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.BpmnJS = factory());
}(this, (function () { 'use strict';

	var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};

	var inherits_browser = {exports: {}};

	if (typeof Object.create === 'function') {
	  // implementation from standard node.js 'util' module
	  inherits_browser.exports = function inherits(ctor, superCtor) {
	    if (superCtor) {
	      ctor.super_ = superCtor;
	      ctor.prototype = Object.create(superCtor.prototype, {
	        constructor: {
	          value: ctor,
	          enumerable: false,
	          writable: true,
	          configurable: true
	        }
	      });
	    }
	  };
	} else {
	  // old school shim for old browsers
	  inherits_browser.exports = function inherits(ctor, superCtor) {
	    if (superCtor) {
	      ctor.super_ = superCtor;
	      var TempCtor = function () {};
	      TempCtor.prototype = superCtor.prototype;
	      ctor.prototype = new TempCtor();
	      ctor.prototype.constructor = ctor;
	    }
	  };
	}

	var inherits$1 = inherits_browser.exports;

	function createCommonjsModule(fn, module) {
		return module = { exports: {} }, fn(module, module.exports), module.exports;
	}

	var hat_1 = createCommonjsModule(function (module) {
	var hat = module.exports = function (bits, base) {
	    if (!base) base = 16;
	    if (bits === undefined) bits = 128;
	    if (bits <= 0) return '0';

	    var digits = Math.log(Math.pow(2, bits)) / Math.log(base);
	    for (var i = 2; digits === Infinity; i *= 2) {
	        digits = Math.log(Math.pow(2, bits / i)) / Math.log(base) * i;
	    }

	    var rem = digits - Math.floor(digits);

	    var res = '';

	    for (var i = 0; i < Math.floor(digits); i++) {
	        var x = Math.floor(Math.random() * base).toString(base);
	        res = x + res;
	    }

	    if (rem) {
	        var b = Math.pow(base, rem);
	        var x = Math.floor(Math.random() * b).toString(base);
	        res = x + res;
	    }

	    var parsed = parseInt(res, base);
	    if (parsed !== Infinity && parsed >= Math.pow(2, bits)) {
	        return hat(bits, base)
	    }
	    else return res;
	};

	hat.rack = function (bits, base, expandBy) {
	    var fn = function (data) {
	        var iters = 0;
	        do {
	            if (iters ++ > 10) {
	                if (expandBy) bits += expandBy;
	                else throw new Error('too many ID collisions, use more bits')
	            }

	            var id = hat(bits, base);
	        } while (Object.hasOwnProperty.call(hats, id));

	        hats[id] = data;
	        return id;
	    };
	    var hats = fn.hats = {};

	    fn.get = function (id) {
	        return fn.hats[id];
	    };

	    fn.set = function (id, value) {
	        fn.hats[id] = value;
	        return fn;
	    };

	    fn.bits = bits || 128;
	    fn.base = base || 16;
	    return fn;
	};
	});

	/**
	 * 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_1.rack(seed[0], seed[1], seed[2]) : seed;
	}
	/**
	 * Generate a next id.
	 *
	 * @param {Object} [element] element to bind the id to
	 *
	 * @return {String} id
	 */

	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);
	  }
	};

	/**
	 * 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$1(obj) {
	  return obj === undefined;
	}
	function isDefined(obj) {
	  return obj !== undefined;
	}
	function isNil(obj) {
	  return obj == null;
	}
	function isArray$2(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) {
	  var tag = nativeToString.call(obj);
	  return tag === '[object Function]' || tag === '[object AsyncFunction]' || tag === '[object GeneratorFunction]' || tag === '[object AsyncGeneratorFunction]' || tag === '[object Proxy]';
	}
	function isString(obj) {
	  return nativeToString.call(obj) === '[object String]';
	}
	/**
	 * Ensure collection is an array.
	 *
	 * @param {Object} obj
	 */

	function ensureArray(obj) {
	  if (isArray$2(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$2(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) {
	  var val, result;

	  if (isUndefined$1(collection)) {
	    return;
	  }

	  var convertKey = isArray$2(collection) ? toNum : identity;

	  for (var key in collection) {
	    if (has(collection, key)) {
	      val = collection[key];
	      result = iterator(val, convertKey(key));

	      if (result === false) {
	        return val;
	      }
	    }
	  }
	}
	/**
	 * Return collection without element.
	 *
	 * @param  {Array} arr
	 * @param  {Function} matcher
	 *
	 * @return {Array}
	 */

	function without(arr, matcher) {
	  if (isUndefined$1(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$1(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$1(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 = new 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$1(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$1(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 = new Array(_len), _key = 0; _key < _len; _key++) {
	      args[_key] = arguments[_key];
	    }

	    lastArgs = args;
	    lastThis = this; // ensure an execution is scheduled

	    if (!timer) {
	      schedule(timeout);
	    }
	  };
	}
	/**
	 * Bind function against target <this>.
	 *
	 * @param  {Function} fn
	 * @param  {Object}   target
	 *
	 * @return {Function} bound function
	 */

	function bind$2(fn, target) {
	  return fn.bind(target);
	}

	function _extends() {
	  _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;
	  };

	  return _extends.apply(this, arguments);
	}

	/**
	 * Convenience wrapper for `Object.assign`.
	 *
	 * @param {Object} target
	 * @param {...Object} others
	 *
	 * @return {Object} the target
	 */

	function assign(target) {
	  for (var _len = arguments.length, others = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
	    others[_key - 1] = arguments[_key];
	  }

	  return _extends.apply(void 0, [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;
	}

	/**
	 * Set attribute `name` to `val`, or get attr `name`.
	 *
	 * @param {Element} el
	 * @param {String} name
	 * @param {String} [val]
	 * @api public
	 */
	function attr$1(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$1 = [].indexOf;

	var indexof = function(arr, obj){
	  if (indexOf$1) return arr.indexOf(obj);
	  for (var i = 0; i < arr.length; ++i) {
	    if (arr[i] === obj) return i;
	  }
	  return -1;
	};

	/**
	 * Taken from https://github.com/component/classes
	 *
	 * Without the component bits.
	 */

	/**
	 * Whitespace regexp.
	 */

	var re$1 = /\s+/;

	/**
	 * toString reference.
	 */

	var toString$1 = Object.prototype.toString;

	/**
	 * Wrap `el` in a `ClassList`.
	 *
	 * @param {Element} el
	 * @return {ClassList}
	 * @api public
	 */

	function classes$1(el) {
	  return new ClassList$1(el);
	}

	/**
	 * Initialize a new ClassList for `el`.
	 *
	 * @param {Element} el
	 * @api private
	 */

	function ClassList$1(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$1.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$1.prototype.remove = function (name) {
	  if ('[object RegExp]' == toString$1.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$1.prototype.removeMatching = function (re) {
	  var arr = this.array();
	  for (var i = 0; i < arr.length; i++) {
	    if (re.test(arr[i])) {
	      this.remove(arr[i]);
	    }
	  }
	  return this;
	};

	/**
	 * 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$1.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$1.prototype.array = function () {
	  var className = this.el.getAttribute('class') || '';
	  var str = className.replace(/^\s+|\s+$/g, '');
	  var arr = str.split(re$1);
	  if ('' === arr[0]) arr.shift();
	  return arr;
	};

	/**
	 * Check if class `name` is present.
	 *
	 * @param {String} name
	 * @return {ClassList}
	 * @api public
	 */

	ClassList$1.prototype.has = ClassList$1.prototype.contains = function (name) {
	  return this.list ? this.list.contains(name) : !!~indexof(this.array(), name);
	};

	/**
	 * Remove all children from the given element.
	 */
	function clear$1(el) {

	  var c;

	  while (el.childNodes.length) {
	    c = el.childNodes[0];
	    el.removeChild(c);
	  }

	  return el;
	}

	var proto = typeof Element !== 'undefined' ? Element.prototype : {};
	var vendor = proto.matches
	  || proto.matchesSelector
	  || proto.webkitMatchesSelector
	  || proto.mozMatchesSelector
	  || proto.msMatchesSelector
	  || proto.oMatchesSelector;

	var matchesSelector = 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 = el.parentNode.querySelectorAll(selector);
	  for (var i = 0; i < nodes.length; i++) {
	    if (nodes[i] == el) return true;
	  }
	  return false;
	}

	/**
	 * Closest
	 *
	 * @param {Element} el
	 * @param {String} selector
	 * @param {Boolean} checkYourSelf (optional)
	 */
	function closest (element, selector, checkYourSelf) {
	  var currentElem = checkYourSelf ? element : element.parentNode;

	  while (currentElem && currentElem.nodeType !== document.DOCUMENT_NODE && currentElem.nodeType !== document.DOCUMENT_FRAGMENT_NODE) {

	    if (matchesSelector(currentElem, selector)) {
	      return currentElem;
	    }

	    currentElem = currentElem.parentNode;
	  }

	  return matchesSelector(currentElem, selector) ? currentElem : null;
	}

	var bind = window.addEventListener ? 'addEventListener' : 'attachEvent',
	    unbind = window.removeEventListener ? 'removeEventListener' : 'detachEvent',
	    prefix$6 = 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(el, type, fn, capture){
	  el[bind](prefix$6 + 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(el, type, fn, capture){
	  el[unbind](prefix$6 + 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'];

	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);
	    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
	 */
	function unbind$1(el, type, fn, capture) {
	  if (forceCaptureEvents.indexOf(type) !== -1) {
	    capture = true;
	  }

	  return componentEvent.unbind(el, type, fn, capture);
	}

	var delegate = {
	  bind: bind$1,
	  unbind: unbind$1
	};

	/**
	 * Expose `parse`.
	 */

	var domify = parse$1;

	/**
	 * 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$1(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;
	}

	function query(selector, el) {
	  el = el || document;

	  return el.querySelector(selector);
	}

	function all(selector, el) {
	  el = el || document;

	  return el.querySelectorAll(selector);
	}

	function remove$2(el) {
	  el.parentNode && el.parentNode.removeChild(el);
	}

	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$1(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$1(child);
	  }

	  return element;
	}

	function clone$1(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$1(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;
	}

	/**
	 * Geometry helpers
	 */

	// fake node used to instantiate svg geometry elements
	var node = create$1('svg');

	function extend$1(object, props) {
	  var i, k, keys = Object.keys(props);

	  for (i = 0; (k = keys[i]); i++) {
	    object[k] = props[k];
	  }

	  return object;
	}

	/**
	 * Create matrix via args.
	 *
	 * @example
	 *
	 * createMatrix({ a: 1, b: 1 });
	 * createMatrix();
	 * createMatrix(1, 2, 0, 0, 30, 20);
	 *
	 * @return {SVGMatrix}
	 */
	function createMatrix(a, b, c, d, e, f) {
	  var matrix = node.createSVGMatrix();

	  switch (arguments.length) {
	  case 0:
	    return matrix;
	  case 1:
	    return extend$1(matrix, a);
	  case 6:
	    return extend$1(matrix, {
	      a: a,
	      b: b,
	      c: c,
	      d: d,
	      e: e,
	      f: f
	    });
	  }
	}

	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$1(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$1(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$1(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$1(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$1(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$1(parsed.childNodes);

	  // import + append each node
	  for (var i = 0; i < nodes.length; i++) {
	    appendTo(nodes[i], element);
	  }

	}

	function get$1(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$1(element, svg);
	    } catch (e) {
	      throw new Error('error parsing SVG: ' + e.message);
	    }

	    return element;
	  } else {
	    return get$1(element);
	  }
	}


	function slice$1(arr) {
	  return Array.prototype.slice.call(arr);
	}

	/**
	 * transform accessor utility
	 */

	function wrapMatrix(transformList, transform) {
	  if (transform instanceof SVGMatrix) {
	    return transformList.createSVGTransformFromMatrix(transform);
	  }

	  return transform;
	}


	function setTransforms(transformList, transforms) {
	  var i, t;

	  transformList.clear();

	  for (i = 0; (t = transforms[i]); i++) {
	    transformList.appendItem(wrapMatrix(transformList, t));
	  }
	}

	/**
	 * Get or set the transforms on the given node.
	 *
	 * @param {SVGElement} node
	 * @param  {SVGTransform|SVGMatrix|Array<SVGTransform|SVGMatrix>} [transforms]
	 *
	 * @return {SVGTransform} the consolidated transform
	 */
	function transform$1(node, transforms) {
	  var transformList = node.transform.baseVal;

	  if (transforms) {

	    if (!Array.isArray(transforms)) {
	      transforms = [ transforms ];
	    }

	    setTransforms(transformList, transforms);
	  }

	  return transformList.consolidate();
	}

	var CLASS_PATTERN = /^class /;

	function isClass(fn) {
	  return CLASS_PATTERN.test(fn.toString());
	}

	function isArray$1(obj) {
	  return Object.prototype.toString.call(obj) === '[object Array]';
	}

	function hasOwnProp(obj, prop) {
	  return Object.prototype.hasOwnProperty.call(obj, prop);
	}

	function annotate() {
	  var args = Array.prototype.slice.call(arguments);

	  if (args.length === 1 && isArray$1(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 = /^(?:async )?(?:function\s*)?[^(]*\(\s*([^)]*)\)/m;
	var FN_ARG = /\/\*([^*]*)\*\//m;

	function parseAnnotations(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);
	  };

	}

	function Injector(modules, parent) {
	  parent = parent || {
	    get: function(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(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(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 (hasOwnProp(instances, name)) {
	      return instances[name];
	    }

	    if (hasOwnProp(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(fn, locals) {

	    if (typeof locals === 'undefined') {
	      locals = {};
	    }

	    if (typeof fn !== 'function') {
	      if (isArray$1(fn)) {
	        fn = annotate(fn.slice());
	      } else {
	        throw new Error('Cannot invoke "' + fn + '". Expected a function!');
	      }
	    }

	    var inject = fn.$inject || parseAnnotations(fn);
	    var dependencies = inject.map(function(dep) {
	      if (hasOwnProp(locals, dep)) {
	        return locals[dep];
	      } else {
	        return get(dep);
	      }
	    });

	    return {
	      fn: fn,
	      dependencies: dependencies
	    };
	  };

	  var instantiate = function(Type) {
	    var def = fnDef(Type);

	    var fn = def.fn,
	        dependencies = def.dependencies;

	    // instantiate var args constructor
	    var Constructor = Function.prototype.bind.apply(fn, [ null ].concat(dependencies));

	    return new Constructor();
	  };

	  var invoke = function(func, context, locals) {
	    var def = fnDef(func, locals);

	    var fn = def.fn,
	        dependencies = def.dependencies;

	    return fn.apply(context, dependencies);
	  };


	  var createPrivateInjectorFactory = function(privateChildInjector) {
	    return annotate(function(key) {
	      return privateChildInjector.get(key);
	    });
	  };

	  var createChild = function(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) {
	      return value;
	    }
	  };

	  modules.forEach(function(module) {

	    function arrayUnwrap(type, value) {
	      if (type !== 'value' && isArray$1(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 === '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;
	}

	var DEFAULT_RENDER_PRIORITY$1 = 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$1;

	  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() {};

	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 = create$1('polyline');
	  attr(line, { points: toSVGPoints(points) });

	  if (attrs) {
	    attr(line, attrs);
	  }

	  return line;
	}

	function updateLine(gfx, points) {
	  attr(gfx, { points: toSVGPoints(points) });

	  return gfx;
	}

	/**
	 * Get parent elements.
	 *
	 * @param {Array<djs.model.base>} elements
	 *
	 * @returns {Array<djs.model.Base>}
	 */
	function getParents$1(elements) {

	  // find elements that are not children of any other elements
	  return filter(elements, function(element) {
	    return !find(elements, function(e) {
	      return e !== element && getParent$1(element, e);
	    });
	  });
	}


	function getParent$1(element, parent) {
	  if (!parent) {
	    return;
	  }

	  if (element === parent) {
	    return parent;
	  }

	  if (!element.parent) {
	    return;
	  }

	  return getParent$1(element.parent, parent);
	}


	/**
	 * Adds an element to a collection and returns true if the
	 * element was added.
	 *
	 * @param {Array<Object>} elements
	 * @param {Object} e
	 * @param {boolean} unique
	 */
	function add$1(elements, e, unique) {
	  var canAdd = !unique || elements.indexOf(e) === -1;

	  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 (!isArray$2(elements)) {
	    elements = [ elements ];
	  }

	  forEach(elements, function(s, i) {
	    var filter = fn(s, i, depth);

	    if (isArray$2(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$1(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$1(processedChildren, children, unique)) {
	        return children;
	      }
	    }
	  });

	  return result;
	}


	/**
	 * 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 (isUndefined$1(isTopLevel)) {
	    isTopLevel = true;
	  }

	  if (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 && 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
	      forEach(element.incoming, handleConnection);

	      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 (!isArray$2(elements)) {
	    elements = [elements];
	  }

	  var minX,
	      minY,
	      maxX,
	      maxY;

	  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 = {};

	  forEach(elements, function(element) {

	    var e = element;

	    if (e.waypoints) {
	      e = getBBox(e);
	    }

	    if (!isNumber(bbox.y) && (e.x > bbox.x)) {
	      filteredElements[element.id] = element;
	    }
	    if (!isNumber(bbox.x) && (e.y > bbox.y)) {
	      filteredElements[element.id] = element;
	    }
	    if (e.x > bbox.x && e.y > bbox.y) {
	      if (isNumber(bbox.width) && isNumber(bbox.height) &&
	          e.width + e.x < bbox.width + bbox.x &&
	          e.height + e.y < bbox.height + bbox.y) {

	        filteredElements[element.id] = element;
	      } else if (!isNumber(bbox.width) || !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';
	}

	function isFrameElement$1(element) {

	  return !!(element && element.isFrame);
	}

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

	function copyObject(src1, src2) {
	  return assign({}, src1 || {}, src2 || {});
	}

	// 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) {

	  //
	  BaseRenderer.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 });
	  this.FRAME_STYLE = styles.style([ 'no-fill' ], { stroke: 'fuchsia', strokeDasharray: 4, strokeWidth: 2 });
	}

	inherits$1(DefaultRenderer, BaseRenderer);


	DefaultRenderer.prototype.canRender = function() {
	  return true;
	};

	DefaultRenderer.prototype.drawShape = function drawShape(visuals, element) {
	  var rect = create$1('rect');

	  attr(rect, {
	    x: 0,
	    y: 0,
	    width: element.width || 0,
	    height: element.height || 0
	  });

	  if (isFrameElement$1(element)) {
	    attr(rect, this.FRAME_STYLE);
	  } else {
	    attr(rect, this.SHAPE_STYLE);
	  }

	  append(visuals, rect);

	  return rect;
	};

	DefaultRenderer.prototype.drawConnection = function drawConnection(visuals, connection) {

	  var line = createLine(connection.waypoints, this.CONNECTION_STYLE);
	  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 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 componentsToPath(connectionPath);
	};


	DefaultRenderer.$inject = [ 'eventBus', 'styles' ];

	/**
	 * 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 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 (!isArray$2(traits) && !additionalAttrs) {
	      additionalAttrs = traits;
	      traits = [];
	    }

	    var attrs = reduce(traits, function(attrs, t) {
	      return assign(attrs, defaultTraits[t] || {});
	    }, {});

	    return additionalAttrs ? assign(attrs, additionalAttrs) : attrs;
	  };

	  this.computeStyle = function(custom, traits, defaultStyles) {
	    if (!isArray$2(traits)) {
	      defaultStyles = traits;
	      traits = [];
	    }

	    return self.style(traits || [], assign({}, defaultStyles, custom || {}));
	  };
	}

	var DrawModule$1 = {
	  __init__: [ 'defaultRenderer' ],
	  defaultRenderer: [ 'type', DefaultRenderer ],
	  styles: [ 'type', Styles ]
	};

	/**
	 * 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);
	}

	/**
	 * 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;

	/**
	 * Check whether two points are horizontally or vertically aligned.
	 *
	 * @param {Array<Point>|Point}
	 * @param {Point}
	 *
	 * @return {string|boolean}
	 */
	function pointsAligned(a, b) {
	  var points;

	  if (isArray$2(a)) {
	    points = a;
	  } else {
	    points = [ a, b ];
	  }

	  if (pointsAlignedHorizontally(points)) {
	    return 'h';
	  }

	  if (pointsAlignedVertically(points)) {
	    return 'v';
	  }

	  return false;
	}

	function pointsAlignedHorizontally(a, b) {
	  var points;

	  if (isArray$2(a)) {
	    points = a;
	  } else {
	    points = [ a, b ];
	  }

	  var firstPoint = points.slice().shift();

	  return every(points, function(point) {
	    return Math.abs(firstPoint.y - point.y) <= ALIGNED_THRESHOLD;
	  });
	}

	function pointsAlignedVertically(a, b) {
	  var points;

	  if (isArray$2(a)) {
	    points = a;
	  } else {
	    points = [ a, b ];
	  }

	  var firstPoint = points.slice().shift();

	  return every(points, function(point) {
	    return Math.abs(firstPoint.x - point.x) <= ALIGNED_THRESHOLD;
	  });
	}



	/**
	 * 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))
	  };
	}

	/**
	 * This file contains source code adapted from Snap.svg (licensed Apache-2.0).
	 *
	 * @see https://github.com/adobe-webplatform/Snap.svg/blob/master/src/path.js
	 */

	/* eslint no-fallthrough: "off" */

	var p2s = /,?([a-z]),?/gi,
	    toFloat = parseFloat,
	    math = Math,
	    PI = math.PI,
	    mmin = math.min,
	    mmax = math.max,
	    pow = math.pow,
	    abs$7 = math.abs,
	    pathCommand = /([a-z])[\s,]*((-?\d*\.?\d*(?:e[-+]?\d+)?[\s]*,?[\s]*)+)/ig,
	    pathValues = /(-?\d*\.?\d*(?:e[-+]?\d+)?)[\s]*,?[\s]*/ig;

	var isArray = Array.isArray || function(o) { return o instanceof Array; };

	function hasProperty(obj, property) {
	  return Object.prototype.hasOwnProperty.call(obj, property);
	}

	function clone(obj) {

	  if (typeof obj == 'function' || Object(obj) !== obj) {
	    return obj;
	  }

	  var res = new obj.constructor;

	  for (var key in obj) {
	    if (hasProperty(obj, 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) {

	  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 (hasProperty(cache, args)) {
	      repush(count, args);
	      return cache[args];
	    }

	    count.length >= 1e3 && delete cache[count.shift()];
	    count.push(args);
	    cache[args] = f.apply(0, arg);

	    return 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, h: 1, l: 2, m: 2, q: 4, s: 4, t: 2, v: 1, z: 0 },
	      data = [];

	  if (isArray(pathString) && isArray(pathString[0])) { // 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';
	      }

	      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 (hasProperty(p, key) && key != ps) {
	        p[key].sleep--;
	        !p[key].sleep && delete p[key];
	      }
	    }
	  });

	  return p[ps];
	}

	function rectBBox(x, y, width, height) {

	  if (arguments.length === 1) {
	    y = x.y;
	    width = x.width;
	    height = x.height;
	    x = x.x;
	  }

	  return {
	    x: x,
	    y: y,
	    width: width,
	    height: height,
	    x2: x + width,
	    y2: y + height
	  };
	}

	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;

	  return {
	    x: fixError(x),
	    y: fixError(y)
	  };
	}

	function bezierBBox(points) {

	  var bbox = curveBBox.apply(null, points);

	  return rectBBox(
	    bbox.x0,
	    bbox.y0,
	    bbox.x1 - bbox.x0,
	    bbox.y1 - bbox.y0
	  );
	}

	function isPointInsideBBox$2(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 = rectBBox(bbox1);
	  bbox2 = rectBBox(bbox2);
	  return isPointInsideBBox$2(bbox2, bbox1.x, bbox1.y)
	    || isPointInsideBBox$2(bbox2, bbox1.x2, bbox1.y)
	    || isPointInsideBBox$2(bbox2, bbox1.x, bbox1.y2)
	    || isPointInsideBBox$2(bbox2, bbox1.x2, bbox1.y2)
	    || isPointInsideBBox$2(bbox1, bbox2.x, bbox2.y)
	    || isPointInsideBBox$2(bbox1, bbox2.x2, bbox2.y)
	    || isPointInsideBBox$2(bbox1, bbox2.x, bbox2.y2)
	    || isPointInsideBBox$2(bbox1, bbox2.x2, bbox2.y2)
	    || (bbox1.x < bbox2.x2 && bbox1.x > bbox2.x
	        || bbox2.x < bbox1.x2 && bbox2.x > bbox1.x)
	    && (bbox1.y < bbox2.y2 && bbox1.y > bbox2.y
	        || bbox2.y < bbox1.y2 && bbox2.y > bbox1.y);
	}

	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 = fixError(nx / denominator),
	      py = fixError(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 fixError(number) {
	  return Math.round(number * 100000000000) / 100000000000;
	}

	function findBezierIntersections(bez1, bez2, justCount) {
	  var bbox1 = bezierBBox(bez1),
	      bbox2 = bezierBBox(bez2);

	  if (!isBBoxIntersect(bbox1, bbox2)) {
	    return justCount ? 0 : [];
	  }

	  // As an optimization, lines will have only 1 segment

	  var l1 = bezlen.apply(0, bez1),
	      l2 = bezlen.apply(0, bez2),
	      n1 = isLine(bez1) ? 1 : ~~(l1 / 5) || 1,
	      n2 = isLine(bez2) ? 1 : ~~(l2 / 5) || 1,
	      dots1 = [],
	      dots2 = [],
	      xy = {},
	      res = justCount ? 0 : [];

	  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$7(di1.x - di.x) < .01 ? 'y' : 'x',
	          cj = abs$7(dj1.x - dj.x) < .01 ? 'y' : 'x',
	          is = intersectLines(di.x, di.y, di1.x, di1.y, dj.x, dj.y, dj1.x, dj1.y),
	          key;

	      if (is) {
	        key = is.x.toFixed(9) + '#' + is.y.toFixed(9);

	        if (xy[key]) {
	          continue;
	        }

	        xy[key] = true;

	        var t1 = di.t + abs$7((is[ci] - di[ci]) / (di1[ci] - di[ci])) * (di1.t - di.t),
	            t2 = dj.t + abs$7((is[cj] - dj[cj]) / (dj1[cj] - dj[cj])) * (dj1.t - dj.t);

	        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 pathToAbsolute(pathArray) {
	  var pth = paths(pathArray);

	  if (pth.abs) {
	    return pathClone(pth.abs);
	  }

	  if (!isArray(pathArray) || !isArray(pathArray && pathArray[0])) { // 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];
	  }

	  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 'M':
	        mx = +pa[1] + x;
	        my = +pa[2] + y;
	      default:
	        for (var j = 1, jj = pa.length; j < jj; j++) {
	          r[j] = +pa[j] + ((j % 2) ? x : y);
	        }
	      }
	    } else {
	      for (var k = 0, kk = pa.length; k < kk; k++) {
	        r[k] = pa[k];
	      }
	    }
	    pa0 = pa0.toUpperCase();

	    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 isLine(bez) {
	  return (
	    bez[0] === bez[2] &&
	    bez[1] === bez[3] &&
	    bez[4] === bez[6] &&
	    bez[5] === bez[7]
	  );
	}

	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$7((rx2 * ry2 - rx2 * y * y - ry2 * x * x) / (rx2 * y * y + ry2 * x * x))),
	        cx = k * rx * y / ry + (x1 + x2) / 2,
	        cy = k * -ry * x / rx + (y1 + y2) / 2,
	        f1 = math.asin(((y1 - cy) / ry).toFixed(9)),
	        f2 = math.asin(((y2 - cy) / ry).toFixed(9));

	    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$7(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;
	  }
	}

	// 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$7(a) < 1e-12) {

	      if (abs$7(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 {
	    x0: mmin.apply(0, bounds[0]),
	    y0: mmin.apply(0, bounds[1]),
	    x1: mmax.apply(0, bounds[0]),
	    y1: mmax.apply(0, bounds[1])
	  };
	}

	function pathToCurve(path) {

	  var pth = paths(path);

	  // return cached curve, if existing
	  if (pth.curve) {
	    return pathClone(pth.curve);
	  }

	  var curvedPath = pathToAbsolute(path),
	      attrs = { x: 0, y: 0, bx: 0, by: 0, X: 0, Y: 0, qx: null, qy: null },
	      processPath = function(path, d, pathCommand) {
	        var nx, ny;

	        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 (pathCommand == 'C' || pathCommand == '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 (pathCommand == 'Q' || pathCommand == '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(pp, i) {

	        if (pp[i].length > 7) {
	          pp[i].shift();
	          var pi = pp[i];

	          while (pi.length) {
	            pathCommands[i] = 'A'; // if created multiple C:s, their original seg is saved
	            pp.splice(i++, 0, ['C'].concat(pi.splice(0, 6)));
	          }

	          pp.splice(i, 1);
	          ii = curvedPath.length;
	        }
	      },

	      pathCommands = [], // path commands of original path p
	      pfirst = '', // temporary holder for original path command
	      pathCommand = ''; // holder for previous path command of original path

	  for (var i = 0, ii = curvedPath.length; i < ii; i++) {
	    curvedPath[i] && (pfirst = curvedPath[i][0]); // save current path command

	    if (pfirst != 'C') // C is not saved yet, because it may be result of conversion
	    {
	      pathCommands[i] = pfirst; // Save current path command
	      i && (pathCommand = pathCommands[i - 1]); // Get previous path command pathCommand
	    }
	    curvedPath[i] = processPath(curvedPath[i], attrs, pathCommand); // Previous path command is inputted to processPath

	    if (pathCommands[i] != 'A' && pfirst == 'C') pathCommands[i] = 'C'; // A is the only command
	    // which may produce multiple C:s
	    // so we have to make sure that C is also C in original path

	    fixArc(curvedPath, i); // fixArc adds also the right amount of A:s to pathCommands