text: /*!
   * bpmn-js - bpmn-viewer v0.11.0
  
   * Copyright 2014, 2015 camunda Services GmbH and other contributors
   *
   * Released under the bpmn.io license
   * http://bpmn.io/license
   *
   * Source Code: https://github.com/bpmn-io/bpmn-js
   *
   * Date: 2015-08-06
   */
  !function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var f;"undefined"!=typeof window?f=window:"undefined"!=typeof global?f=global:"undefined"!=typeof self&&(f=self),f.BpmnJS=e()}}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(_dereq_,module,exports){
  'use strict';
  
  var assign = _dereq_(168),
      omit = _dereq_(172),
      isString = _dereq_(165),
      isNumber = _dereq_(162);
  
  var domify = _dereq_(181),
      domQuery = _dereq_(182),
      domRemove = _dereq_(183);
  
  var Diagram = _dereq_(35),
      BpmnModdle = _dereq_(14);
  
  var Importer = _dereq_(8);
  
  
  function initListeners(diagram, listeners) {
    var events = diagram.get('eventBus');
  
    listeners.forEach(function(l) {
      events.on(l.event, l.handler);
    });
  }
  
  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;
  }
  
  var DEFAULT_OPTIONS = {
    width: '100%',
    height: '100%',
    position: 'relative',
    container: 'body'
  };
  
  
  /**
   * Ensure the passed argument is a proper unit (defaulting to px)
   */
  function ensureUnit(val) {
    return val + (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) {
  
    this.options = options = assign({}, DEFAULT_OPTIONS, options || {});
  
    var parent = options.container;
  
    // support jquery element
    // unwrap it if passed
    if (parent.get) {
      parent = parent.get(0);
    }
  
    // support selector
    if (isString(parent)) {
      parent = domQuery(parent);
    }
  
    var container = this.container = domify('<div class="bjs-container"></div>');
    parent.appendChild(container);
  
    assign(container.style, {
      width: ensureUnit(options.width),
      height: ensureUnit(options.height),
      position: options.position
    });
  
    /**
     * The code in the <project-logo></project-logo> area
     * must not be changed, see http://bpmn.io/license for more information
     *
     * <project-logo>
     */
  
    /* jshint -W101 */
  
    // inlined ../resources/bpmnjs.png
    var logoData = 'iVBORw0KGgoAAAANSUhEUgAAADQAAAA0CAMAAADypuvZAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAADBQTFRFiMte9PrwldFwfcZPqtqN0+zEyOe1XLgjvuKncsJAZ70y6fXh3vDT////UrQV////G2zN+AAAABB0Uk5T////////////////////AOAjXRkAAAHDSURBVHjavJZJkoUgDEBJmAX8979tM8u3E6x20VlYJfFFMoL4vBDxATxZcakIOJTWSmxvKWVIkJ8jHvlRv1F2LFrVISCZI+tCtQx+XfewgVTfyY3plPiQEAzI3zWy+kR6NBhFBYeBuscJLOUuA2WVLpCjVIaFzrNQZArxAZKUQm6gsj37L9Cb7dnIBUKxENaaMJQqMpDXvSL+ktxdGRm2IsKgJGGPg7atwUG5CcFUEuSv+CwQqizTrvDTNXdMU2bMiDWZd8d7QIySWVRsb2vBBioxOFt4OinPBapL+neAb5KL5IJ8szOza2/DYoipUCx+CjO0Bpsv0V6mktNZ+k8rlABlWG0FrOpKYVo8DT3dBeLEjUBAj7moDogVii7nSS9QzZnFcOVBp1g2PyBQ3Vr5aIapN91VJy33HTJLC1iX2FY6F8gRdaAeIEfVONgtFCzZTmoLEdOjBDfsIOA6128gw3eu1shAajdZNAORxuQDJN5A5PbEG6gNIu24QJD5iNyRMZIr6bsHbCtCU/OaOaSvgkUyDMdDa1BXGf5HJ1To+/Ym6mCKT02Y+/Sa126ZKyd3jxhzpc1r8zVL6YM1Qy/kR4ABAFJ6iQUnivhAAAAAAElFTkSuQmCC';
  
    /* jshint +W101 */
  
    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 src="data:image/png;base64,' + logoData + '">' +
          '</a>';
  
    container.appendChild(domify(linkMarkup));
  
    /* </project-logo> */
  }
  
  Viewer.prototype.importXML = function(xml, done) {
  
    var self = this;
  
    this.moddle = this.createModdle();
  
    this.moddle.fromXML(xml, 'bpmn:Definitions', function(err, definitions, context) {
  
      if (err) {
        err = checkValidationError(err);
        return done(err);
      }
  
      var parseWarnings = context.warnings;
  
      self.importDefinitions(definitions, function(err, importWarnings) {
        if (err) {
          return done(err);
        }
  
        done(null, parseWarnings.concat(importWarnings || []));
      });
    });
  };
  
  Viewer.prototype.saveXML = function(options, done) {
  
    if (!done) {
      done = options;
      options = {};
    }
  
    var definitions = this.definitions;
  
    if (!definitions) {
      return done(new Error('no definitions loaded'));
    }
  
    this.moddle.toXML(definitions, options, done);
  };
  
  Viewer.prototype.createModdle = function() {
    return new BpmnModdle(this.options.moddleExtensions);
  };
  
  Viewer.prototype.saveSVG = function(options, done) {
  
    if (!done) {
      done = options;
      options = {};
    }
  
    var canvas = this.get('canvas');
  
    var contentNode = canvas.getDefaultLayer(),
        defsNode = canvas._svg.select('defs');
  
    var contents = contentNode.innerSVG(),
        defs = (defsNode && defsNode.outerSVG()) || '';
  
    var bbox = contentNode.getBBox();
  
    var 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>';
  
    done(null, svg);
  };
  
  Viewer.prototype.get = function(name) {
  
    if (!this.diagram) {
      throw new Error('no diagram loaded');
    }
  
    return this.diagram.get(name);
  };
  
  Viewer.prototype.invoke = function(fn) {
  
    if (!this.diagram) {
      throw new Error('no diagram loaded');
    }
  
    return this.diagram.invoke(fn);
  };
  
  Viewer.prototype.importDefinitions = function(definitions, done) {
  
    // use try/catch to not swallow synchronous exceptions
    // that may be raised during model parsing
    try {
      if (this.diagram) {
        this.clear();
      }
  
      this.definitions = definitions;
  
      var diagram = this.diagram = this._createDiagram(this.options);
  
      this._init(diagram);
  
      Importer.importBpmnDiagram(diagram, definitions, done);
    } catch (e) {
      done(e);
    }
  };
  
  Viewer.prototype._init = function(diagram) {
    initListeners(diagram, this.__listeners || []);
  };
  
  Viewer.prototype._createDiagram = function(options) {
  
    var modules = [].concat(options.modules || this.getModules(), options.additionalModules || []);
  
    // add self as an available service
    modules.unshift({
      bpmnjs: [ 'value', this ],
      moddle: [ 'value', this.moddle ]
    });
  
    options = omit(options, 'additionalModules');
  
    options = assign(options, {
      canvas: { container: this.container },
      modules: modules
    });
  
    return new Diagram(options);
  };
  
  
  Viewer.prototype.getModules = function() {
    return this._modules;
  };
  
  /**
   * Remove all drawn elements from the viewer.
   *
   * After calling this method the viewer can still
   * be reused for opening another diagram.
   */
  Viewer.prototype.clear = function() {
    var diagram = this.diagram;
  
    if (diagram) {
      diagram.destroy();
    }
  };
  
  /**
   * Destroy the viewer instance and remove all its remainders
   * from the document tree.
   */
  Viewer.prototype.destroy = function() {
    // clear underlying diagram
    this.clear();
  
    // remove container
    domRemove(this.container);
  };
  
  /**
   * Register an event listener on the viewer
   *
   * @param {String} event
   * @param {Function} handler
   */
  Viewer.prototype.on = function(event, handler) {
    var diagram = this.diagram,
        listeners = this.__listeners = this.__listeners || [];
  
    listeners.push({ event: event, handler: handler });
  
    if (diagram) {
      diagram.get('eventBus').on(event, handler);
    }
  };
  
  // modules the viewer is composed of
  Viewer.prototype._modules = [
    _dereq_(2),
    _dereq_(55),
    _dereq_(51)
  ];
  
  module.exports = Viewer;
  
  },{"14":14,"162":162,"165":165,"168":168,"172":172,"181":181,"182":182,"183":183,"2":2,"35":35,"51":51,"55":55,"8":8}],2:[function(_dereq_,module,exports){
  module.exports = {
    __depends__: [
      _dereq_(5),
      _dereq_(10)
    ]
  };
  },{"10":10,"5":5}],3:[function(_dereq_,module,exports){
  'use strict';
  
  var inherits = _dereq_(72),
      isArray = _dereq_(159),
      isObject = _dereq_(163),
      assign = _dereq_(168),
      forEach = _dereq_(77),
      every = _dereq_(74),
      includes = _dereq_(79),
      some = _dereq_(82);
  
  var DefaultRenderer = _dereq_(43),
      TextUtil = _dereq_(64),
      DiUtil = _dereq_(11);
  
  var createLine = DefaultRenderer.createLine;
  
  
  function BpmnRenderer(events, styles, pathMap) {
  
    DefaultRenderer.call(this, styles);
  
    var TASK_BORDER_RADIUS = 10;
    var INNER_OUTER_DIST = 3;
  
    var LABEL_STYLE = {
      fontFamily: 'Arial, sans-serif',
      fontSize: '12px'
    };
  
    var textUtil = new TextUtil({
      style: LABEL_STYLE,
      size: { width: 100 }
    });
  
    var markers = {};
  
    function addMarker(id, element) {
      markers[id] = element;
    }
  
    function marker(id) {
      return markers[id];
    }
  
    function initMarkers(svg) {
  
      function createMarker(id, options) {
        var attrs = 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 = options.element
                       .attr(attrs)
                       .marker(0, 0, 20, 20, ref.x, ref.y)
                       .attr({
                         markerWidth: 20 * scale,
                         markerHeight: 20 * scale
                       });
  
        return addMarker(id, marker);
      }
  
  
      createMarker('sequenceflow-end', {
        element: svg.path('M 1 5 L 11 10 L 1 15 Z'),
        ref: { x: 11, y: 10 },
        scale: 0.5
      });
  
      createMarker('messageflow-start', {
        element: svg.circle(6, 6, 3.5),
        attrs: {
          fill: 'white',
          stroke: 'black'
        },
        ref: { x: 6, y: 6 }
      });
  
      createMarker('messageflow-end', {
        element: svg.path('m 1 5 l 0 -3 l 7 3 l -7 3 z'),
        attrs: {
          fill: 'white',
          stroke: 'black',
          strokeLinecap: 'butt'
        },
        ref: { x: 8.5, y: 5 }
      });
  
      createMarker('data-association-end', {
        element: svg.path('M 1 5 L 11 10 L 1 15'),
        attrs: {
          fill: 'white',
          stroke: 'black'
        },
        ref: { x: 11, y: 10 },
        scale: 0.5
      });
  
      createMarker('conditional-flow-marker', {
        element: svg.path('M 0 10 L 8 6 L 16 10 L 8 14 Z'),
        attrs: {
          fill: 'white',
          stroke: 'black'
        },
        ref: { x: -1, y: 10 },
        scale: 0.5
      });
  
      createMarker('conditional-default-flow-marker', {
        element: svg.path('M 1 4 L 5 16'),
        attrs: {
          stroke: 'black'
        },
        ref: { x: -5, y: 10 },
        scale: 0.5
      });
    }
  
    function computeStyle(custom, traits, defaultStyles) {
      if (!isArray(traits)) {
        defaultStyles = traits;
        traits = [];
      }
  
      return styles.style(traits || [], assign(defaultStyles, custom || {}));
    }
  
    function drawCircle(p, width, height, offset, attrs) {
  
      if (isObject(offset)) {
        attrs = offset;
        offset = 0;
      }
  
      offset = offset || 0;
  
      attrs = computeStyle(attrs, {
        stroke: 'black',
        strokeWidth: 2,
        fill: 'white'
      });
  
      var cx = width / 2,
          cy = height / 2;
  
      return p.circle(cx, cy, Math.round((width + height) / 4 - offset)).attr(attrs);
    }
  
    function drawRect(p, width, height, r, offset, attrs) {
  
      if (isObject(offset)) {
        attrs = offset;
        offset = 0;
      }
  
      offset = offset || 0;
  
      attrs = computeStyle(attrs, {
        stroke: 'black',
        strokeWidth: 2,
        fill: 'white'
      });
  
      return p.rect(offset, offset, width - offset * 2, height - offset * 2, r).attr(attrs);
    }
  
    function drawDiamond(p, width, height, attrs) {
  
      var x_2 = width / 2;
      var y_2 = height / 2;
  
      var points = [x_2, 0, width, y_2, x_2, height, 0, y_2 ];
  
      attrs = computeStyle(attrs, {
        stroke: 'black',
        strokeWidth: 2,
        fill: 'white'
      });
  
      return p.polygon(points).attr(attrs);
    }
  
    function drawLine(p, waypoints, attrs) {
      attrs = computeStyle(attrs, [ 'no-fill' ], {
        stroke: 'black',
        strokeWidth: 2,
        fill: 'none'
      });
  
      return createLine(waypoints, attrs).appendTo(p);
    }
  
    function drawPath(p, d, attrs) {
  
      attrs = computeStyle(attrs, [ 'no-fill' ], {
        strokeWidth: 2,
        stroke: 'black'
      });
  
      return p.path(d).attr(attrs);
    }
  
    function as(type) {
      return function(p, element) {
        return handlers[type](p, element);
      };
    }
  
    function renderer(type) {
      return handlers[type];
    }
  
    function renderEventContent(element, p) {
  
      var event = getSemantic(element);
      var isThrowing = isThrowEvent(event);
  
      if (isTypedEvent(event, 'bpmn:MessageEventDefinition')) {
        return renderer('bpmn:MessageEventDefinition')(p, element, isThrowing);
      }
  
      if (isTypedEvent(event, 'bpmn:TimerEventDefinition')) {
        return renderer('bpmn:TimerEventDefinition')(p, element, isThrowing);
      }
  
      if (isTypedEvent(event, 'bpmn:ConditionalEventDefinition')) {
        return renderer('bpmn:ConditionalEventDefinition')(p, element);
      }
  
      if (isTypedEvent(event, 'bpmn:SignalEventDefinition')) {
        return renderer('bpmn:SignalEventDefinition')(p, element, isThrowing);
      }
  
      if (isTypedEvent(event, 'bpmn:CancelEventDefinition') &&
        isTypedEvent(event, 'bpmn:TerminateEventDefinition', { parallelMultiple: false })) {
        return renderer('bpmn:MultipleEventDefinition')(p, element, isThrowing);
      }
  
      if (isTypedEvent(event, 'bpmn:CancelEventDefinition') &&
        isTypedEvent(event, 'bpmn:TerminateEventDefinition', { parallelMultiple: true })) {
        return renderer('bpmn:ParallelMultipleEventDefinition')(p, element, isThrowing);
      }
  
      if (isTypedEvent(event, 'bpmn:EscalationEventDefinition')) {
        return renderer('bpmn:EscalationEventDefinition')(p, element, isThrowing);
      }
  
      if (isTypedEvent(event, 'bpmn:LinkEventDefinition')) {
        return renderer('bpmn:LinkEventDefinition')(p, element, isThrowing);
      }
  
      if (isTypedEvent(event, 'bpmn:ErrorEventDefinition')) {
        return renderer('bpmn:ErrorEventDefinition')(p, element, isThrowing);
      }
  
      if (isTypedEvent(event, 'bpmn:CancelEventDefinition')) {
        return renderer('bpmn:CancelEventDefinition')(p, element, isThrowing);
      }
  
      if (isTypedEvent(event, 'bpmn:CompensateEventDefinition')) {
        return renderer('bpmn:CompensateEventDefinition')(p, element, isThrowing);
      }
  
      if (isTypedEvent(event, 'bpmn:TerminateEventDefinition')) {
        return renderer('bpmn:TerminateEventDefinition')(p, element, isThrowing);
      }
  
      return null;
    }
  
    function renderLabel(p, label, options) {
      return textUtil.createText(p, label || '', options).addClass('djs-label');
    }
  
    function renderEmbeddedLabel(p, element, align) {
      var semantic = getSemantic(element);
      return renderLabel(p, semantic.name, { box: element, align: align, padding: 5 });
    }
  
    function renderExternalLabel(p, element, align) {
      var semantic = getSemantic(element);
  
      if (!semantic.name) {
        element.hidden = true;
      }
  
      return renderLabel(p, semantic.name, { box: element, align: align, style: { fontSize: '11px' } });
    }
  
    function renderLaneLabel(p, text, element) {
      var textBox = renderLabel(p, text, {
        box: { height: 30, width: element.height },
        align: 'center-middle'
      });
  
      var top = -1 * element.height;
      textBox.transform(
        'rotate(270) ' +
        'translate(' + top + ',' + 0 + ')'
      );
    }
  
    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 = {
      'bpmn:Event': function(p, element, attrs) {
        return drawCircle(p, element.width, element.height,  attrs);
      },
      'bpmn:StartEvent': function(p, element) {
        var attrs = {};
        var semantic = getSemantic(element);
  
        if (!semantic.isInterrupting) {
          attrs = {
            strokeDasharray: '6',
            strokeLinecap: 'round'
          };
        }
  
        var circle = renderer('bpmn:Event')(p, element, attrs);
  
        renderEventContent(element, p);
  
        return circle;
      },
      'bpmn:MessageEventDefinition': function(p, 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 ? 'black' : 'white';
        var stroke = isThrowing ? 'white' : 'black';
  
        var messagePath = drawPath(p, pathData, {
          strokeWidth: 1,
          fill: fill,
          stroke: stroke
        });
  
        return messagePath;
      },
      'bpmn:TimerEventDefinition': function(p, element) {
  
        var circle = drawCircle(p, element.width, element.height, 0.2 * element.height, {
          strokeWidth: 2
        });
  
        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(p, pathData, {
          strokeWidth: 2,
          strokeLinecap: 'square'
        });
  
        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(p, linePathData, {
            strokeWidth: 1,
            strokeLinecap: 'square',
            transform: 'rotate(' + (i * 30) + ',' + height + ',' + width + ')'
          });
        }
  
        return circle;
      },
      'bpmn:EscalationEventDefinition': function(p, event, isThrowing) {
        var pathData = pathMap.getScaledPath('EVENT_ESCALATION', {
          xScaleFactor: 1,
          yScaleFactor: 1,
          containerWidth: event.width,
          containerHeight: event.height,
          position: {
            mx: 0.5,
            my: 0.555
          }
        });
  
        var fill = isThrowing ? 'black' : 'none';
  
        return drawPath(p, pathData, {
          strokeWidth: 1,
          fill: fill
        });
      },
      'bpmn:ConditionalEventDefinition': function(p, 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(p, pathData, {
          strokeWidth: 1
        });
      },
      'bpmn:LinkEventDefinition': function(p, 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 ? 'black' : 'none';
  
        return drawPath(p, pathData, {
          strokeWidth: 1,
          fill: fill
        });
      },
      'bpmn:ErrorEventDefinition': function(p, 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 ? 'black' : 'none';
  
        return drawPath(p, pathData, {
          strokeWidth: 1,
          fill: fill
        });
      },
      'bpmn:CancelEventDefinition': function(p, 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 ? 'black' : 'none';
  
        return drawPath(p, pathData, {
          strokeWidth: 1,
          fill: fill
        }).transform('rotate(45)');
      },
      'bpmn:CompensateEventDefinition': function(p, event, isThrowing) {
        var pathData = pathMap.getScaledPath('EVENT_COMPENSATION', {
          xScaleFactor: 1,
          yScaleFactor: 1,
          containerWidth: event.width,
          containerHeight: event.height,
          position: {
            mx: 0.201,
            my: 0.472
          }
        });
  
        var fill = isThrowing ? 'black' : 'none';
  
        return drawPath(p, pathData, {
          strokeWidth: 1,
          fill: fill
        });
      },
      'bpmn:SignalEventDefinition': function(p, 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 ? 'black' : 'none';
  
        return drawPath(p, pathData, {
          strokeWidth: 1,
          fill: fill
        });
      },
      'bpmn:MultipleEventDefinition': function(p, 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 ? 'black' : 'none';
  
        return drawPath(p, pathData, {
          strokeWidth: 1,
          fill: fill
        });
      },
      'bpmn:ParallelMultipleEventDefinition': function(p, 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(p, pathData, {
          strokeWidth: 1
        });
      },
      'bpmn:EndEvent': function(p, element) {
        var circle = renderer('bpmn:Event')(p, element, {
          strokeWidth: 4
        });
  
        renderEventContent(element, p, true);
  
        return circle;
      },
      'bpmn:TerminateEventDefinition': function(p, element) {
        var circle = drawCircle(p, element.width, element.height, 8, {
          strokeWidth: 4,
          fill: 'black'
        });
  
        return circle;
      },
      'bpmn:IntermediateEvent': function(p, element) {
        var outer = renderer('bpmn:Event')(p, element, { strokeWidth: 1 });
        /* inner */ drawCircle(p, element.width, element.height, INNER_OUTER_DIST, { strokeWidth: 1, fill: 'none' });
  
        renderEventContent(element, p);
  
        return outer;
      },
      'bpmn:IntermediateCatchEvent': as('bpmn:IntermediateEvent'),
      'bpmn:IntermediateThrowEvent': as('bpmn:IntermediateEvent'),
  
      'bpmn:Activity': function(p, element, attrs) {
        return drawRect(p, element.width, element.height, TASK_BORDER_RADIUS, attrs);
      },
  
      'bpmn:Task': function(p, element, attrs) {
        var rect = renderer('bpmn:Activity')(p, element, attrs);
        renderEmbeddedLabel(p, element, 'center-middle');
        attachTaskMarkers(p, element);
        return rect;
      },
      'bpmn:ServiceTask': function(p, element) {
        var task = renderer('bpmn:Task')(p, element);
  
        var pathDataBG = pathMap.getScaledPath('TASK_TYPE_SERVICE', {
          abspos: {
            x: 12,
            y: 18
          }
        });
  
        /* service bg */ drawPath(p, pathDataBG, {
          strokeWidth: 1,
          fill: 'none'
        });
  
        var fillPathData = pathMap.getScaledPath('TASK_TYPE_SERVICE_FILL', {
          abspos: {
            x: 17.2,
            y: 18
          }
        });
  
        /* service fill */ drawPath(p, fillPathData, {
          strokeWidth: 0,
          stroke: 'none',
          fill: 'white'
        });
  
        var pathData = pathMap.getScaledPath('TASK_TYPE_SERVICE', {
          abspos: {
            x: 17,
            y: 22
          }
        });
  
        /* service */ drawPath(p, pathData, {
          strokeWidth: 1,
          fill: 'white'
        });
  
        return task;
      },
      'bpmn:UserTask': function(p, element) {
        var task = renderer('bpmn:Task')(p, element);
  
        var x = 15;
        var y = 12;
  
        var pathData = pathMap.getScaledPath('TASK_TYPE_USER_1', {
          abspos: {
            x: x,
            y: y
          }
        });
  
        /* user path */ drawPath(p, pathData, {
          strokeWidth: 0.5,
          fill: 'none'
        });
  
        var pathData2 = pathMap.getScaledPath('TASK_TYPE_USER_2', {
          abspos: {
            x: x,
            y: y
          }
        });
  
        /* user2 path */ drawPath(p, pathData2, {
          strokeWidth: 0.5,
          fill: 'none'
        });
  
        var pathData3 = pathMap.getScaledPath('TASK_TYPE_USER_3', {
          abspos: {
            x: x,
            y: y
          }
        });
  
        /* user3 path */ drawPath(p, pathData3, {
          strokeWidth: 0.5,
          fill: 'black'
        });
  
        return task;
      },
      'bpmn:ManualTask': function(p, element) {
        var task = renderer('bpmn:Task')(p, element);
  
        var pathData = pathMap.getScaledPath('TASK_TYPE_MANUAL', {
          abspos: {
            x: 17,
            y: 15
          }
        });
  
        /* manual path */ drawPath(p, pathData, {
          strokeWidth: 0.25,
          fill: 'white',
          stroke: 'black'
        });
  
        return task;
      },
      'bpmn:SendTask': function(p, element) {
        var task = renderer('bpmn:Task')(p, 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(p, pathData, {
          strokeWidth: 1,
          fill: 'black',
          stroke: 'white'
        });
  
        return task;
      },
      'bpmn:ReceiveTask' : function(p, element) {
        var semantic = getSemantic(element);
  
        var task = renderer('bpmn:Task')(p, element);
        var pathData;
  
        if (semantic.instantiate) {
          drawCircle(p, 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(p, pathData, {
          strokeWidth: 1
        });
  
        return task;
      },
      'bpmn:ScriptTask': function(p, element) {
        var task = renderer('bpmn:Task')(p, element);
  
        var pathData = pathMap.getScaledPath('TASK_TYPE_SCRIPT', {
          abspos: {
            x: 15,
            y: 20
          }
        });
  
        /* script path */ drawPath(p, pathData, {
          strokeWidth: 1
        });
  
        return task;
      },
      'bpmn:BusinessRuleTask': function(p, element) {
        var task = renderer('bpmn:Task')(p, element);
  
        var headerPathData = pathMap.getScaledPath('TASK_TYPE_BUSINESS_RULE_HEADER', {
          abspos: {
            x: 8,
            y: 8
          }
        });
  
        var businessHeaderPath = drawPath(p, headerPathData);
        businessHeaderPath.attr({
          strokeWidth: 1,
          fill: 'AAA'
        });
  
        var headerData = pathMap.getScaledPath('TASK_TYPE_BUSINESS_RULE_MAIN', {
          abspos: {
            x: 8,
            y: 8
          }
        });
  
        var businessPath = drawPath(p, headerData);
        businessPath.attr({
          strokeWidth: 1
        });
  
        return task;
      },
      'bpmn:SubProcess': function(p, element, attrs) {
        var rect = renderer('bpmn:Activity')(p, element, attrs);
  
        var semantic = getSemantic(element);
  
        var expanded = DiUtil.isExpanded(semantic);
  
        var isEventSubProcess = !!semantic.triggeredByEvent;
        if (isEventSubProcess) {
          rect.attr({
            strokeDasharray: '1,2'
          });
        }
  
        renderEmbeddedLabel(p, element, expanded ? 'center-top' : 'center-middle');
  
        if (expanded) {
          attachTaskMarkers(p, element);
        } else {
          attachTaskMarkers(p, element, ['SubProcessMarker']);
        }
  
        return rect;
      },
      'bpmn:AdHocSubProcess': function(p, element) {
        return renderer('bpmn:SubProcess')(p, element);
      },
      'bpmn:Transaction': function(p, element) {
        var outer = renderer('bpmn:SubProcess')(p, element);
  
        var innerAttrs = styles.style([ 'no-fill', 'no-events' ]);
  
        /* inner path */ drawRect(p, element.width, element.height, TASK_BORDER_RADIUS - 2, INNER_OUTER_DIST, innerAttrs);
  
        return outer;
      },
      'bpmn:CallActivity': function(p, element) {
        return renderer('bpmn:Task')(p, element, {
          strokeWidth: 5
        });
      },
      'bpmn:Participant': function(p, element) {
  
        var lane = renderer('bpmn:Lane')(p, element, {
          fill: 'White'
        });
  
        var expandedPool = DiUtil.isExpanded(element);
  
        if (expandedPool) {
          drawLine(p, [
            { x: 30, y: 0 },
            { x: 30, y: element.height }
          ]);
          var text = getSemantic(element).name;
          renderLaneLabel(p, text, element);
        } else {
          // Collapsed pool draw text inline
          var text2 = getSemantic(element).name;
          renderLabel(p, text2, { box: element, align: 'center-middle' });
        }
  
        var participantMultiplicity = !!(getSemantic(element).participantMultiplicity);
  
        if(participantMultiplicity) {
          renderer('ParticipantMultiplicityMarker')(p, element);
        }
  
        return lane;
      },
      'bpmn:Lane': function(p, element, attrs) {
        var rect = drawRect(p, element.width, element.height, 0, attrs || {
          fill: 'none'
        });
  
        var semantic = getSemantic(element);
  
        if (semantic.$type === 'bpmn:Lane') {
          var text = semantic.name;
          renderLaneLabel(p, text, element);
        }
  
        return rect;
      },
      'bpmn:InclusiveGateway': function(p, element) {
        var diamond = drawDiamond(p, element.width, element.height);
  
        /* circle path */
        drawCircle(p, element.width, element.height, element.height * 0.24, {
          strokeWidth: 2.5,
          fill: 'none'
        });
  
        return diamond;
      },
      'bpmn:ExclusiveGateway': function(p, element) {
        var diamond = drawDiamond(p, element.width, element.height);
  
        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 (!!(getDi(element).isMarkerVisible)) {
          drawPath(p, pathData, {
            strokeWidth: 1,
            fill: 'black'
          });
        }
  
        return diamond;
      },
      'bpmn:ComplexGateway': function(p, element) {
        var diamond = drawDiamond(p, element.width, element.height);
  
        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(p, pathData, {
          strokeWidth: 1,
          fill: 'black'
        });
  
        return diamond;
      },
      'bpmn:ParallelGateway': function(p, element) {
        var diamond = drawDiamond(p, element.width, element.height);
  
        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(p, pathData, {
          strokeWidth: 1,
          fill: 'black'
        });
  
        return diamond;
      },
      'bpmn:EventBasedGateway': function(p, element) {
  
        var semantic = getSemantic(element);
  
        var diamond = drawDiamond(p, element.width, element.height);
  
        /* outer circle path */ drawCircle(p, element.width, element.height, element.height * 0.20, {
          strokeWidth: 1,
          fill: 'none'
        });
  
        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
            }
          });
  
          /* event path */ drawPath(p, pathData, {
            strokeWidth: 2,
            fill: 'none'
          });
        }
  
        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(p, pathData);
          parallelPath.attr({
            strokeWidth: 1,
            fill: 'none'
          });
        } else if (type === 'Exclusive') {
  
          if (!instantiate) {
            var innerCircle = drawCircle(p, element.width, element.height, element.height * 0.26);
            innerCircle.attr({
              strokeWidth: 1,
              fill: 'none'
            });
          }
  
          drawEvent();
        }
  
  
        return diamond;
      },
      'bpmn:Gateway': function(p, element) {
        return drawDiamond(p, element.width, element.height);
      },
      'bpmn:SequenceFlow': function(p, element) {
        var pathData = createPathFromConnection(element);
        var path = drawPath(p, pathData, {
          strokeLinejoin: 'round',
          markerEnd: marker('sequenceflow-end')
        });
  
        var sequenceFlow = getSemantic(element);
        var source = element.source.businessObject;
  
        // conditional flow marker
        if (sequenceFlow.conditionExpression && source.$instanceOf('bpmn:Task')) {
          path.attr({
            markerStart: marker('conditional-flow-marker')
          });
        }
  
        // default marker
        if (source.default && source.$instanceOf('bpmn:Gateway') && source.default === sequenceFlow) {
          path.attr({
            markerStart: marker('conditional-default-flow-marker')
          });
        }
  
        return path;
      },
      'bpmn:Association': function(p, element, attrs) {
  
        attrs = assign({
          strokeDasharray: '1,6',
          strokeLinecap: 'round',
          strokeLinejoin: 'round'
        }, attrs || {});
  
        // TODO(nre): style according to directed state
        return drawLine(p, element.waypoints, attrs);
      },
      'bpmn:DataInputAssociation': function(p, element) {
        return renderer('bpmn:Association')(p, element, {
          markerEnd: marker('data-association-end')
        });
      },
      'bpmn:DataOutputAssociation': function(p, element) {
        return renderer('bpmn:Association')(p, element, {
          markerEnd: marker('data-association-end')
        });
      },
      'bpmn:MessageFlow': function(p, element) {
  
        var semantic = getSemantic(element),
            di = getDi(element);
  
        var pathData = createPathFromConnection(element);
        var path = drawPath(p, pathData, {
          markerEnd: marker('messageflow-end'),
          markerStart: marker('messageflow-start'),
          strokeDasharray: '10, 12',
          strokeLinecap: 'round',
          strokeLinejoin: 'round',
          strokeWidth: '1.5px'
        });
  
        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(p, markerPathData, messageAttrs);
        }
  
        return path;
      },
      'bpmn:DataObject': function(p, 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(p, pathData, { fill: 'white' });
  
        var semantic = getSemantic(element);
  
        if (isCollection(semantic)) {
          renderDataItemCollection(p, element);
        }
  
        return elementObject;
      },
      'bpmn:DataObjectReference': as('bpmn:DataObject'),
      'bpmn:DataInput': function(p, element) {
  
        var arrowPathData = pathMap.getRawPath('DATA_ARROW');
  
        // page
        var elementObject = renderer('bpmn:DataObject')(p, element);
  
        /* input arrow path */ drawPath(p, arrowPathData, { strokeWidth: 1 });
  
        return elementObject;
      },
      'bpmn:DataOutput': function(p, element) {
        var arrowPathData = pathMap.getRawPath('DATA_ARROW');
  
        // page
        var elementObject = renderer('bpmn:DataObject')(p, element);
  
        /* output arrow path */ drawPath(p, arrowPathData, {
          strokeWidth: 1,
          fill: 'black'
        });
  
        return elementObject;
      },
      'bpmn:DataStoreReference': function(p, 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(p, DATA_STORE_PATH, {
          strokeWidth: 2,
          fill: 'white'
        });
  
        return elementStore;
      },
      'bpmn:BoundaryEvent': function(p, element) {
  
        var semantic = getSemantic(element),
            cancel = semantic.cancelActivity;
  
        var attrs = {
          strokeWidth: 1
        };
  
        if (!cancel) {
          attrs.strokeDasharray = '6';
          attrs.strokeLinecap = 'round';
        }
  
        var outer = renderer('bpmn:Event')(p, element, attrs);
        /* inner path */ drawCircle(p, element.width, element.height, INNER_OUTER_DIST, assign(attrs, { fill: 'none' }));
  
        renderEventContent(element, p);
  
        return outer;
      },
      'bpmn:Group': function(p, element) {
        return drawRect(p, element.width, element.height, TASK_BORDER_RADIUS, {
          strokeWidth: 1,
          strokeDasharray: '8,3,1,3',
          fill: 'none',
          pointerEvents: 'none'
        });
      },
      'label': function(p, element) {
        return renderExternalLabel(p, element, '');
      },
      'bpmn:TextAnnotation': function(p, element) {
        var style = {
          'fill': 'none',
          'stroke': 'none'
        };
        var textElement = drawRect(p, 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(p, textPathData);
  
        var text = getSemantic(element).text || '';
        renderLabel(p, text, { box: element, align: 'left-middle', padding: 5 });
  
        return textElement;
      },
      'ParticipantMultiplicityMarker': function(p, element) {
        var subProcessPath = 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
          }
        });
  
        drawPath(p, subProcessPath);
      },
      'SubProcessMarker': function(p, element) {
        var markerRect = drawRect(p, 14, 14, 0, {
          strokeWidth: 1
        });
  
        // Process marker is placed in the middle of the box
        // therefore fixed values can be used here
        markerRect.transform('translate(' + (element.width / 2 - 7.5) + ',' + (element.height - 20) + ')');
  
        var subProcessPath = 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
          }
        });
  
        drawPath(p, subProcessPath);
      },
      'ParallelMarker': function(p, element, position) {
        var subProcessPath = 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
          }
        });
        drawPath(p, subProcessPath);
      },
      'SequentialMarker': function(p, element, position) {
        var sequentialPath = 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
          }
        });
        drawPath(p, sequentialPath);
      },
      'CompensationMarker': function(p, element, position) {
        var compensationPath = 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
          }
        });
        drawPath(p, compensationPath, { strokeWidth: 1 });
      },
      'LoopMarker': function(p, element, position) {
        var loopPath = 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
          }
        });
  
        drawPath(p, loopPath, {
          strokeWidth: 1,
          fill: 'none',
          strokeLinecap: 'round',
          strokeMiterlimit: 0.5
        });
      },
      'AdhocMarker': function(p, element, position) {
        var loopPath = 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
          }
        });
  
        drawPath(p, loopPath, {
          strokeWidth: 1,
          fill: 'black'
        });
      }
    };
  
    function attachTaskMarkers(p, element, taskMarkers) {
      var obj = getSemantic(element);
  
      var subprocess = includes(taskMarkers, 'SubProcessMarker');
      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
        };
      }
  
      forEach(taskMarkers, function(marker) {
        renderer(marker)(p, element, position);
      });
  
      if (obj.$type === 'bpmn:AdHocSubProcess') {
        renderer('AdhocMarker')(p, element, position);
      }
      if (obj.loopCharacteristics && obj.loopCharacteristics.isSequential === undefined) {
        renderer('LoopMarker')(p, element, position);
        return;
      }
      if (obj.loopCharacteristics &&
        obj.loopCharacteristics.isSequential !== undefined &&
        !obj.loopCharacteristics.isSequential) {
        renderer('ParallelMarker')(p, element, position);
      }
      if (obj.loopCharacteristics && !!obj.loopCharacteristics.isSequential) {
        renderer('SequentialMarker')(p, element, position);
      }
      if (!!obj.isForCompensation) {
        renderer('CompensationMarker')(p, element, position);
      }
    }
  
    function drawShape(parent, element) {
      var type = element.type;
      var h = handlers[type];
  
      /* jshint -W040 */
      if (!h) {
        return DefaultRenderer.prototype.drawShape.apply(this, [ parent, element ]);
      } else {
        return h(parent, element);
      }
    }
  
    function drawConnection(parent, element) {
      var type = element.type;
      var h = handlers[type];
  
      /* jshint -W040 */
      if (!h) {
        return DefaultRenderer.prototype.drawConnection.apply(this, [ parent, element ]);
      } else {
        return h(parent, element);
      }
    }
  
    function renderDataItemCollection(p, 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(p, pathData, {
        strokeWidth: 2
      });
    }
  
    function isCollection(element, filter) {
      return element.isCollection ||
             (element.elementObjectRef && element.elementObjectRef.isCollection);
    }
  
    function getDi(element) {
      return element.businessObject.di;
    }
  
    function getSemantic(element) {
      return element.businessObject;
    }
  
    /**
     * 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 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 some(event.eventDefinitions, function(definition) {
        return definition.$type === eventDefinitionType && matches(event, filter);
      });
    }
  
    function isThrowEvent(event) {
      return (event.$type === 'bpmn:IntermediateThrowEvent') || (event.$type === 'bpmn:EndEvent');
    }
  
  
    /////// cropping path customizations /////////////////////////
  
    function componentsToPath(elements) {
      return elements.join(',').replace(/,?([A-z]),?/g, '$1');
    }
  
    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 componentsToPath(circlePath);
    }
  
    function getRoundRectPath(shape) {
  
      var radius = TASK_BORDER_RADIUS,
          x = shape.x,
          y = shape.y,
          width = shape.width,
          height = shape.height;
  
      var roundRectPath = [
        ['M', x + radius, y],
        ['l', width - radius * 2, 0],
        ['a', radius, radius, 0, 0, 1, radius, radius],
        ['l', 0, height - radius * 2],
        ['a', radius, radius, 0, 0, 1, -radius, radius],
        ['l', radius * 2 - width, 0],
        ['a', radius, radius, 0, 0, 1, -radius, -radius],
        ['l', 0, radius * 2 - height],
        ['a', radius, radius, 0, 0, 1, radius, -radius],
        ['z']
      ];
  
      return 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 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 componentsToPath(rectPath);
    }
  
    function getShapePath(element) {
      var obj = getSemantic(element);
  
      if (obj.$instanceOf('bpmn:Event')) {
        return getCirclePath(element);
      }
  
      if (obj.$instanceOf('bpmn:Activity')) {
        return getRoundRectPath(element);
      }
  
      if (obj.$instanceOf('bpmn:Gateway')) {
        return getDiamondPath(element);
      }
  
      return getRectPath(element);
    }
  
  
    // hook onto canvas init event to initialize
    // connection start/end markers on svg
    events.on('canvas.init', function(event) {
      initMarkers(event.svg);
    });
  
    this.drawShape = drawShape;
    this.drawConnection = drawConnection;
  
    this.getShapePath = getShapePath;
  }
  
  inherits(BpmnRenderer, DefaultRenderer);
  
  
  BpmnRenderer.$inject = [ 'eventBus', 'styles', 'pathMap' ];
  
  module.exports = BpmnRenderer;
  
  },{"11":11,"159":159,"163":163,"168":168,"43":43,"64":64,"72":72,"74":74,"77":77,"79":79,"82":82}],4:[function(_dereq_,module,exports){
  'use strict';
  
  var Snap = _dereq_(67);
  
  /**
   * 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} c -{e.x1},{e.y0} -{e.x3},{e.y1} -{e.x5},{e.y4} {e.x1},-{e.y3} {e.x3},-{e.y5} {e.x5},-{e.y6} ' +
          '{e.x0},{e.y3} {e.x2},{e.y5} {e.x4},{e.y6} -{e.x0},-{e.y0} -{e.x2},-{e.y1} -{e.x4},-{e.y4} z',
        height: 36,
        width: 36,
        heightElements: [2.382, 4.764, 4.926, 6.589333, 7.146, 13.178667, 19.768],
        widthElements: [2.463, 2.808, 4.926, 5.616, 7.389, 8.424]
      },
      '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.x0},0 {e.x0},-{e.y0} 0,{e.y1} z',
        height: 36,
        width: 36,
        heightElements: [5, 10],
        widthElements: [10]
      },
      '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} 8,-5 0,10 z m 9,0 8,-5 0,10 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 = Snap.format(
        rawPath.d, {
          mx: mx,
          my: my,
          e: coordinates
        }
      );
      return path;
    };
  }
  
  module.exports = PathMap;
  
  },{"67":67}],5:[function(_dereq_,module,exports){
  module.exports = {
    renderer: [ 'type', _dereq_(3) ],
    pathMap: [ 'type', _dereq_(4) ]
  };
  },{"3":3,"4":4}],6:[function(_dereq_,module,exports){
  'use strict';
  
  var assign = _dereq_(168),
      map = _dereq_(80);
  
  var LabelUtil = _dereq_(12);
  
  var is = _dereq_(13).is;
  
  var hasExternalLabel = LabelUtil.hasExternalLabel,
      getExternalLabelBounds = LabelUtil.getExternalLabelBounds,
      isExpanded = _dereq_(11).isExpanded,
      elementToString = _dereq_(9).elementToString;
  
  
  function elementData(semantic, attrs) {
    return assign({
      id: semantic.id,
      type: semantic.$type,
      businessObject: semantic
    }, attrs);
  }
  
  function collectWaypoints(waypoints) {
    return map(waypoints, function(p) {
      return { x: p.x, y: p.y };
    });
  }
  
  function notYetDrawn(semantic, refSemantic, property) {
    return new Error(
        'element ' + elementToString(refSemantic) + ' referenced by ' +
        elementToString(semantic) + '#' + property + ' not yet drawn');
  }
  
  /**
   * An importer that adds bpmn elements to the canvas
   *
   * @param {EventBus} eventBus
   * @param {Canvas} canvas
   * @param {ElementFactory} elementFactory
   * @param {ElementRegistry} elementRegistry
   */
  function BpmnImporter(eventBus, canvas, elementFactory, elementRegistry) {
    this._eventBus = eventBus;
    this._canvas = canvas;
  
    this._elementFactory = elementFactory;
    this._elementRegistry = elementRegistry;
  }
  
  BpmnImporter.$inject = [ 'eventBus', 'canvas', 'elementFactory', 'elementRegistry' ];
  
  module.exports = BpmnImporter;
  
  
  /**
   * Add bpmn element (semantic) to the canvas onto the
   * specified parent shape.
   */
  BpmnImporter.prototype.add = function(semantic, parentElement) {
  
    var di = semantic.di,
        element;
  
    // ROOT ELEMENT
    // handle the special case that we deal with a
    // invisible root element (process or collaboration)
    if (di.$instanceOf('bpmndi:BPMNPlane')) {
  
      // add a virtual element (not being drawn)
      element = this._elementFactory.createRoot(elementData(semantic));
  
      this._canvas.setRootElement(element);
    }
  
    // SHAPE
    else if (di.$instanceOf('bpmndi:BPMNShape')) {
  
      var collapsed = !isExpanded(semantic);
      var 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 (is(semantic, 'bpmn:BoundaryEvent')) {
        this._attachBoundary(semantic, element);
      }
  
      this._canvas.addShape(element, parentElement);
    }
  
    // CONNECTION
    else if (di.$instanceOf('bpmndi:BPMNEdge')) {
  
      var source = this._getSource(semantic),
          target = this._getTarget(semantic);
  
      element = this._elementFactory.createConnection(elementData(semantic, {
        source: source,
        target: target,
        waypoints: collectWaypoints(semantic.di.waypoint)
      }));
  
      this._canvas.addConnection(element, parentElement);
    } else {
      throw new Error('unknown di ' + elementToString(di) + ' for element ' + elementToString(semantic));
    }
  
    // (optional) LABEL
    if (hasExternalLabel(semantic)) {
      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 hostSemantic = boundarySemantic.attachedToRef;
  
    if (!hostSemantic) {
      throw new Error('missing ' + elementToString(boundarySemantic) + '#attachedToRef');
    }
  
    var host = this._elementRegistry.get(hostSemantic.id),
        attachers = host && host.attachers;
  
    if (!host) {
      throw notYetDrawn(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 = getExternalLabelBounds(semantic, element);
  
    var label = this._elementFactory.createLabel(elementData(semantic, {
      id: semantic.id + '_label',
      labelTarget: element,
      type: 'label',
      hidden: element.hidden,
      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;
  
    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(semantic, refSemantic, side + 'Ref');
    } else {
      throw new Error(elementToString(semantic) + '#' + side + 'Ref not specified');
    }
  };
  
  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);
  };
  },{"11":11,"12":12,"13":13,"168":168,"80":80,"9":9}],7:[function(_dereq_,module,exports){
  'use strict';
  
  var filter = _dereq_(75),
      find = _dereq_(76),
      forEach = _dereq_(77);
  
  var Refs = _dereq_(192);
  
  var elementToString = _dereq_(9).elementToString;
  
  var diRefs = new Refs({ name: 'bpmnElement', enumerable: true }, { name: 'di' });
  
  /**
   * 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 find(definitions.rootElements, function(e) {
      return is(e, 'bpmn:Process') || is(e, 'bpmn:Collaboration');
    });
  }
  
  
  function BpmnTreeWalker(handler) {
  
    // list of containers already walked
    var handledProcesses = [];
  
    // 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 visit(element, ctx) {
  
      var gfx = element.gfx;
  
      // avoid multiple rendering of elements
      if (gfx) {
        throw new Error('already rendered ' + elementToString(element));
      }
  
      // call handler
      return handler.element(element, ctx);
    }
  
    function visitRoot(element, diagram) {
      return handler.root(element, diagram);
    }
  
    function visitIfDi(element, ctx) {
      try {
        return element.di && visit(element, ctx);
      } catch (e) {
        logError(e.message, { element: element, error: e });
  
        console.error('failed to import ' + 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('multiple DI elements defined for ' + elementToString(bpmnElement), { element: bpmnElement });
        } else {
          diRefs.bind(bpmnElement, 'di');
          bpmnElement.di = di;
        }
      } else {
        logError('no bpmnElement referenced in ' + elementToString(di), { element: di });
      }
    }
  
    function handleDiagram(diagram) {
      handlePlane(diagram.plane);
    }
  
    function handlePlane(plane) {
      registerDi(plane);
  
      forEach(plane.planeElement, handlePlaneElement);
    }
  
    function handlePlaneElement(planeElement) {
      registerDi(planeElement);
    }
  
  
    ////// Semantic handling //////////////////////
  
    function handleDefinitions(definitions, diagram) {
      // make sure we walk the correct bpmnElement
  
      var diagrams = definitions.diagrams;
  
      if (diagram && diagrams.indexOf(diagram) === -1) {
        throw new Error('diagram not part of bpmn:Definitions');
      }
  
      if (!diagram && diagrams && diagrams.length) {
        diagram = diagrams[0];
      }
  
      // no diagram -> nothing to import
      if (!diagram) {
        return;
      }
  
      // load DI from selected diagram only
      handleDiagram(diagram);
  
  
      var plane = diagram.plane;
  
      if (!plane) {
        throw new Error('no plane for ' + 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) {
          return logError('no process or collaboration present to display');
        } else {
  
          logError('correcting missing bpmnElement on ' + elementToString(plane) + ' to ' + 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('unsupported bpmnElement for ' + elementToString(plane) + ' : ' + elementToString(rootElement));
      }
  
      // handle all deferred elements
      handleDeferred(deferred);
    }
  
    function handleDeferred(deferred) {
      forEach(deferred, function(d) { d(); });
    }
  
    function handleProcess(process, context) {
      handleFlowElementsContainer(process, context);
      handleIoSpecification(process.ioSpecification, context);
  
      handleArtifacts(process.artifacts, context);
  
      // log process handled
      handledProcesses.push(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 = filter(rootElements, function(e) {
        return is(e, 'bpmn:Process') && e.laneSets && handledProcesses.indexOf(e) === -1;
      });
  
      processes.forEach(contextual(handleProcess));
    }
  
    function handleMessageFlow(messageFlow, context) {
      visitIfDi(messageFlow, context);
    }
  
    function handleMessageFlows(messageFlows, context) {
      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) {
  
      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;
      }
  
      forEach(ioSpecification.dataInputs, contextual(handleDataInput, context));
      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);
      }
    }
  
    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) {
      var newContext = visitIfDi(lane, context);
  
      if (lane.childLaneSet) {
        handleLaneSet(lane.childLaneSet, newContext || context);
      } else {
        var filterList = filter(lane.flowNodeRef, function(e) {
          return e.$type !== 'bpmn:BoundaryEvent';
        });
        handleFlowElements(filterList, newContext || context);
      }
    }
  
    function handleLaneSet(laneSet, context) {
      forEach(laneSet.lanes, contextual(handleLane, context));
    }
  
    function handleLaneSets(laneSets, context) {
      forEach(laneSets, contextual(handleLaneSet, context));
    }
  
    function handleFlowElementsContainer(container, context) {
  
      if (container.laneSets) {
        handleLaneSets(container.laneSets, context);
        handleNonFlowNodes(container.flowElements);
      } else {
        handleFlowElements(container.flowElements, context);
      }
    }
  
    function handleNonFlowNodes(flowElements, context) {
      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: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);
        }
      });
    }
  
    function handleFlowElements(flowElements, context) {
      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);
  
          if (is(e, 'bpmn:Activity')) {
  
            handleIoSpecification(e.ioSpecification, context);
  
            // defer handling of associations
            deferred.push(function() {
              forEach(e.dataInputAssociations, contextual(handleDataAssociation, context));
              forEach(e.dataOutputAssociations, contextual(handleDataAssociation, 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(
            'unrecognized flowElement ' + elementToString(e) + ' in context ' +
            (context ? 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) {
  
      forEach(collaboration.participants, contextual(handleParticipant));
  
      handleArtifacts(collaboration.artifacts);
  
      // handle message flows latest in the process
      deferred.push(function() {
        handleMessageFlows(collaboration.messageFlows);
      });
    }
  
  
    ///// API ////////////////////////////////
  
    return {
      handleDefinitions: handleDefinitions
    };
  }
  
  module.exports = BpmnTreeWalker;
  },{"192":192,"75":75,"76":76,"77":77,"9":9}],8:[function(_dereq_,module,exports){
  'use strict';
  
  var BpmnTreeWalker = _dereq_(7);
  
  
  /**
   * 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 = diagram.get('bpmnImporter'),
        eventBus = diagram.get('eventBus');
  
    var error,
        warnings = [];
  
    function parse(definitions) {
  
      var visitor = {
  
        root: function(element) {
          return importer.add(element);
        },
  
        element: function(element, parentShape) {
          return importer.add(element, parentShape);
        },
  
        error: function(message, context) {
          warnings.push({ message: message, context: context });
        }
      };
  
      var walker = new BpmnTreeWalker(visitor);
  
      // import
      walker.handleDefinitions(definitions);
    }
  
    eventBus.fire('import.start');
  
    try {
      parse(definitions);
    } catch (e) {
      error = e;
    }
  
    eventBus.fire(error ? 'import.error' : 'import.success', { error: error, warnings: warnings });
    done(error, warnings);
  }
  
  module.exports.importBpmnDiagram = importBpmnDiagram;
  },{"7":7}],9:[function(_dereq_,module,exports){
  'use strict';
  
  module.exports.elementToString = function(e) {
    if (!e) {
      return '<null>';
    }
  
    return '<' + e.$type + (e.id ? ' id="' + e.id : '') + '" />';
  };
  },{}],10:[function(_dereq_,module,exports){
  module.exports = {
    bpmnImporter: [ 'type', _dereq_(6) ]
  };
  },{"6":6}],11:[function(_dereq_,module,exports){
  'use strict';
  
  var is = _dereq_(13).is,
      getBusinessObject = _dereq_(13).getBusinessObject;
  
  module.exports.isExpanded = function(element) {
  
    if (is(element, 'bpmn:CallActivity')) {
      return false;
    }
  
    if (is(element, 'bpmn:SubProcess')) {
      return getBusinessObject(element).di.isExpanded;
    }
  
    if (is(element, 'bpmn:Participant')) {
      return !!getBusinessObject(element).processRef;
    }
  
    return true;
  };
  
  },{"13":13}],12:[function(_dereq_,module,exports){
  'use strict';
  
  var assign = _dereq_(168);
  
  
  var DEFAULT_LABEL_SIZE = module.exports.DEFAULT_LABEL_SIZE = {
    width: 90,
    height: 20
  };
  
  
  /**
   * Returns true if the given semantic has an external label
   *
   * @param {BpmnElement} semantic
   * @return {Boolean} true if has label
   */
  module.exports.hasExternalLabel = function(semantic) {
  
    return semantic.$instanceOf('bpmn:Event') ||
           semantic.$instanceOf('bpmn:Gateway') ||
           semantic.$instanceOf('bpmn:DataStoreReference') ||
           semantic.$instanceOf('bpmn:DataObjectReference') ||
           semantic.$instanceOf('bpmn:SequenceFlow') ||
           semantic.$instanceOf('bpmn:MessageFlow');
  };
  
  
  /**
   * Get the middle of a number of waypoints
   *
   * @param  {Array<Point>} waypoints
   * @return {Point} the mid point
   */
  var getWaypointsMid = module.exports.getWaypointsMid = function(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
    };
  };
  
  
  var getExternalLabelMid = module.exports.getExternalLabelMid = function(element) {
  
    if (element.waypoints) {
      return getWaypointsMid(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
   */
  module.exports.getExternalLabelBounds = function(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 assign({
      x: mid.x - size.width / 2,
      y: mid.y - size.height / 2
    }, size);
  };
  },{"168":168}],13:[function(_dereq_,module,exports){
  'use strict';
  
  /**
   * 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 && bo.$instanceOf(type);
  }
  
  module.exports.is = is;
  
  
  /**
   * Return the business object for a given element.
   *
   * @param  {djs.model.Base|ModdleElement} element
   *
   * @return {ModdleElement}
   */
  function getBusinessObject(element) {
    return (element && element.businessObject) || element;
  }
  
  module.exports.getBusinessObject = getBusinessObject;
  
  },{}],14:[function(_dereq_,module,exports){
  module.exports = _dereq_(16);
  },{"16":16}],15:[function(_dereq_,module,exports){
  'use strict';
  
  var isString = _dereq_(165),
      isFunction = _dereq_(160),
      assign = _dereq_(168);
  
  var Moddle = _dereq_(22),
      XmlReader = _dereq_(18),
      XmlWriter = _dereq_(19);
  
  /**
   * A sub class of {@link Moddle} with support for import and export of BPMN 2.0 xml files.
   *
   * @class BpmnModdle
   * @extends Moddle
   *
   * @param {Object|Array} packages to use for instantiating the model
   * @param {Object} [options] additional options to pass over
   */
  function BpmnModdle(packages, options) {
    Moddle.call(this, packages, options);
  }
  
  BpmnModdle.prototype = Object.create(Moddle.prototype);
  
  module.exports = BpmnModdle;
  
  
  /**
   * 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 (!isString(typeName)) {
      done = options;
      options = typeName;
      typeName = 'bpmn:Definitions';
    }
  
    if (isFunction(options)) {
      done = options;
      options = {};
    }
  
    var reader = new XmlReader(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 (isFunction(options)) {
      done = options;
      options = {};
    }
  
    var writer = new XmlWriter(options);
    try {
      var result = writer.toXML(element);
      done(null, result);
    } catch (e) {
      done(e);
    }
  };
  
  },{"160":160,"165":165,"168":168,"18":18,"19":19,"22":22}],16:[function(_dereq_,module,exports){
  'use strict';
  
  var assign = _dereq_(168);
  
  var BpmnModdle = _dereq_(15);
  
  var packages = {
    bpmn: _dereq_(31),
    bpmndi: _dereq_(32),
    dc: _dereq_(33),
    di: _dereq_(34)
  };
  
  module.exports = function(additionalPackages, options) {
    return new BpmnModdle(assign({}, packages, additionalPackages), options);
  };
  },{"15":15,"168":168,"31":31,"32":32,"33":33,"34":34}],17:[function(_dereq_,module,exports){
  'use strict';
  
  function capitalize(string) {
    return string.charAt(0).toUpperCase() + string.slice(1);
  }
  
  function lower(string) {
    return string.charAt(0).toLowerCase() + string.slice(1);
  }
  
  function hasLowerCaseAlias(pkg) {
    return pkg.xml && pkg.xml.tagAlias === 'lowerCase';
  }
  
  
  module.exports.aliasToName = function(alias, pkg) {
    if (hasLowerCaseAlias(pkg)) {
      return capitalize(alias);
    } else {
      return alias;
    }
  };
  
  module.exports.nameToAlias = function(name, pkg) {
    if (hasLowerCaseAlias(pkg)) {
      return lower(name);
    } else {
      return name;
    }
  };
  
  module.exports.DEFAULT_NS_MAP = {
    'xsi': 'http://www.w3.org/2001/XMLSchema-instance'
  };
  
  var XSI_TYPE = module.exports.XSI_TYPE = 'xsi:type';
  
  function serializeFormat(element) {
    return element.xml && element.xml.serialize;
  }
  
  module.exports.serializeAsType = function(element) {
    return serializeFormat(element) === XSI_TYPE;
  };
  
  module.exports.serializeAsProperty = function(element) {
    return serializeFormat(element) === 'property';
  };
  },{}],18:[function(_dereq_,module,exports){
  'use strict';
  
  var reduce = _dereq_(81),
      forEach = _dereq_(77),
      find = _dereq_(76),
      assign = _dereq_(168),
      defer = _dereq_(85);
  
  var Stack = _dereq_(21),
      SaxParser = _dereq_(20).parser,
      Moddle = _dereq_(22),
      parseNameNs = _dereq_(27).parseName,
      Types = _dereq_(30),
      coerceType = Types.coerceType,
      isSimpleType = Types.isSimple,
      common = _dereq_(17),
      XSI_TYPE = common.XSI_TYPE,
      XSI_URI = common.DEFAULT_NS_MAP.xsi,
      serializeAsType = common.serializeAsType,
      aliasToName = common.aliasToName;
  
  function parseNodeAttributes(node) {
    var nodeAttrs = node.attributes;
  
    return reduce(nodeAttrs, function(result, v, k) {
      var name, ns;
  
      if (!v.local) {
        name = v.prefix;
      } else {
        ns = parseNameNs(v.name, v.prefix);
        name = ns.name;
      }
  
      result[name] = v.value;
      return result;
    }, {});
  }
  
  function normalizeType(node, attr, model) {
    var nameNs = parseNameNs(attr.value);
  
    var uri = node.ns[nameNs.prefix || ''],
        localName = nameNs.localName,
        pkg = uri && model.getPackage(uri),
        typePrefix;
  
    if (pkg) {
      typePrefix = pkg.xml && pkg.xml.typePrefix;
  
      if (typePrefix && localName.indexOf(typePrefix) === 0) {
        localName = localName.slice(typePrefix.length);
      }
  
      attr.value = pkg.prefix + ':' + localName;
    }
  }
  
  /**
   * Normalizes namespaces for a node given an optional default namespace and a
   * number of mappings from uris to default prefixes.
   *
   * @param  {XmlNode} node
   * @param  {Model} model the model containing all registered namespaces
   * @param  {Uri} defaultNsUri
   */
  function normalizeNamespaces(node, model, defaultNsUri) {
    var uri, prefix;
  
    uri = node.uri || defaultNsUri;
  
    if (uri) {
      var pkg = model.getPackage(uri);
  
      if (pkg) {
        prefix = pkg.prefix;
      } else {
        prefix = node.prefix;
      }
  
      node.prefix = prefix;
      node.uri = uri;
    }
  
    forEach(node.attributes, function(attr) {
  
      // normalize xsi:type attributes because the
      // assigned type may or may not be namespace prefixed
      if (attr.uri === XSI_URI && attr.local === 'type') {
        normalizeType(node, attr, model);
      }
  
      normalizeNamespaces(attr, model, null);
    });
  }
  
  
  /**
   * A parse context.
   *
   * @class
   *
   * @param {Object} options
   * @param {ElementHandler} options.parseRoot the root handler for parsing a document
   * @param {boolean} [options.lax=false] whether or not to ignore invalid elements
   */
  function Context(options) {
  
    /**
     * @property {ElementHandler} parseRoot
     */
  
    /**
     * @property {Boolean} lax
     */
  
    assign(this, options);
  
    var elementsById = this.elementsById = {};
    var references = this.references = [];
    var warnings = this.warnings = [];
  
    this.addReference = function(reference) {
      references.push(reference);
    };
  
    this.addElement = function(id, element) {
  
      if (!id || !element) {
        throw new Error('[xml-reader] id or ctx must not be null');
      }
  
      elementsById[id] = element;
    };
  
    this.addWarning = function (w) {
      warnings.push(w);
    };
  }
  
  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 = new BaseHandler();
  
  NoopHandler.prototype.handleNode = function() {
    return this;
  };
  
  function BodyHandler() {}
  
  BodyHandler.prototype = new BaseHandler();
  
  BodyHandler.prototype.handleText = function(text) {
    this.body = (this.body || '') + text;
  };
  
  function ReferenceHandler(property, context) {
    this.property = property;
    this.context = context;
  }
  
  ReferenceHandler.prototype = new BodyHandler();
  
  ReferenceHandler.prototype.handleNode = function(node) {
  
    if (this.element) {
      throw new 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() {
    return {
      property: this.property.ns.name,
      id: ''
    };
  };
  
  function ValueHandler(propertyDesc, element) {
    this.element = element;
    this.propertyDesc = propertyDesc;
  }
  
  ValueHandler.prototype = new BodyHandler();
  
  ValueHandler.prototype.handleEnd = function() {
  
    var value = this.body,
        element = this.element,
        propertyDesc = this.propertyDesc;
  
    value = 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,
        id;
  
    if (!element) {
      element = this.element = this.createElement(node);
      id = element.id;
  
      if (id) {
        this.context.addElement(id, element);
      }
    } else {
      parser = this.handleChild(node);
    }
  
    return parser;
  };
  
  /**
   * @class XMLReader.ElementHandler
   *
   */
  function ElementHandler(model, type, context) {
    this.model = model;
    this.type = model.getType(type);
    this.context = context;
  }
  
  ElementHandler.prototype = new BaseElementHandler();
  
  ElementHandler.prototype.addReference = function(reference) {
    this.context.addReference(reference);
  };
  
  ElementHandler.prototype.handleEnd = function() {
  
    var value = this.body,
        element = this.element,
        descriptor = element.$descriptor,
        bodyProperty = descriptor.bodyProperty;
  
    if (bodyProperty && value !== undefined) {
      value = 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 = parseNodeAttributes(node),
        Type = this.type,
        descriptor = Type.$descriptor,
        context = this.context,
        instance = new Type({});
  
    forEach(attributes, function(value, name) {
  
      var prop = descriptor.propertiesByName[name];
  
      if (prop && prop.isReference) {
        context.addReference({
          element: instance,
          property: prop.ns.name,
          id: value
        });
      } else {
        if (prop) {
          value = coerceType(prop.type, value);
        }
  
        instance.set(name, value);
      }
    });
  
    return instance;
  };
  
  ElementHandler.prototype.getPropertyForNode = function(node) {
  
    var nameNs = parseNameNs(node.local, node.prefix);
  
    var type = this.type,
        model = this.model,
        descriptor = type.$descriptor;
  
    var propertyName = nameNs.name,
        property = descriptor.propertiesByName[propertyName],
        elementTypeName,
        elementType,
        typeAnnotation;
  
    // search for properties by name first
  
    if (property) {
  
      if (serializeAsType(property)) {
        typeAnnotation = node.attributes[XSI_TYPE];
  
        // xsi type is optional, if it does not exists the
        // default type is assumed
        if (typeAnnotation) {
  
          elementTypeName = typeAnnotation.value;
  
          // TODO: extract real name from attribute
          elementType = model.getType(elementTypeName);
  
          return assign({}, property, { effectiveType: elementType.$descriptor.name });
        }
      }
  
      // search for properties by name first
      return property;
    }
  
  
    var pkg = model.getPackage(nameNs.prefix);
  
    if (pkg) {
      elementTypeName = nameNs.prefix + ':' + aliasToName(nameNs.localName, descriptor.$pkg);
      elementType = model.getType(elementTypeName);
  
      // search for collection members later
      property = find(descriptor.properties, function(p) {
        return !p.isVirtual && !p.isReference && !p.isAttribute && elementType.hasType(p.type);
      });
  
      if (property) {
        return assign({}, property, { effectiveType: elementType.$descriptor.name });
      }
    } else {
      // parse unknown element (maybe extension)
      property = find(descriptor.properties, function(p) {
        return !p.isReference && !p.isAttribute && p.type === 'Element';
      });
  
      if (property) {
        return property;
      }
    }
  
    throw new Error('unrecognized element <' + nameNs.name + '>');
  };
  
  ElementHandler.prototype.toString = function() {
    return 'ElementDescriptor[' + this.type.$descriptor.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 (isSimpleType(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) {
        assign(newElement, {
          element: element
        });
  
        this.context.addReference(newElement);
      } else {
        // establish child -> parent relationship
        newElement.$parent = element;
      }
    }
  
    return childHandler;
  };
  
  
  function GenericElementHandler(model, type, context) {
    this.model = model;
    this.context = context;
  }
  
  GenericElementHandler.prototype = Object.create(BaseElementHandler.prototype);
  
  GenericElementHandler.prototype.createElement = function(node) {
  
    var name = node.name,
        prefix = node.prefix,
        uri = node.ns[prefix],
        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 XMLReader(options) {
  
    if (options instanceof Moddle) {
      options = {
        model: options
      };
    }
  
    assign(this, { lax: false }, options);
  }
  
  
  XMLReader.prototype.fromXML = function(xml, rootHandler, done) {
  
    var model = this.model,
        lax = this.lax,
        context = new Context({
          parseRoot: rootHandler
        });
  
    var parser = new SaxParser(true, { xmlns: true, trim: true }),
        stack = new Stack();
  
    rootHandler.context = context;
  
    // push root handler
    stack.push(rootHandler);
  
  
    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 = element.$descriptor.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);
  
          if (!reference) {
            // remove unresolvable reference
            collection.splice(idx, 1);
          } else {
            // update reference
            collection[idx] = reference;
          }
        } else {
          element.set(property.name, reference);
        }
      }
    }
  
    function handleClose(tagName) {
      stack.pop().handleEnd();
    }
  
    function handleOpen(node) {
      var handler = stack.peek();
  
      normalizeNamespaces(node, model);
  
      try {
        stack.push(handler.handleNode(node));
      } catch (e) {
  
        var line = this.line,
            column = this.column;
  
        var message =
          'unparsable content <' + node.name + '> detected\n\t' +
            'line: ' + line + '\n\t' +
            'column: ' + column + '\n\t' +
            'nested error: ' + e.message;
  
        if (lax) {
          context.addWarning({
            message: message,
            error: e
          });
  
          console.warn('could not parse node');
          console.warn(e);
  
          stack.push(new NoopHandler());
        } else {
          console.error('could not parse document');
          console.error(e);
  
          throw new Error(message);
        }
      }
    }
  
    function handleText(text) {
      stack.peek().handleText(text);
    }
  
    parser.onopentag = handleOpen;
    parser.oncdata = parser.ontext = handleText;
    parser.onclosetag = handleClose;
    parser.onend = resolveReferences;
  
    // 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 error;
  
      try {
        parser.write(xml).close();
      } catch (e) {
        error = e;
      }
  
      done(error, error ? undefined : rootHandler.element, context);
    });
  };
  
  XMLReader.prototype.handler = function(name) {
    return new ElementHandler(this.model, name);
  };
  
  module.exports = XMLReader;
  module.exports.ElementHandler = ElementHandler;
  },{"168":168,"17":17,"20":20,"21":21,"22":22,"27":27,"30":30,"76":76,"77":77,"81":81,"85":85}],19:[function(_dereq_,module,exports){
  'use strict';
  
  var map = _dereq_(80),
      forEach = _dereq_(77),
      isString = _dereq_(165),
      filter = _dereq_(75),
      assign = _dereq_(168);
  
  var Types = _dereq_(30),
      parseNameNs = _dereq_(27).parseName,
      common = _dereq_(17),
      nameToAlias = common.nameToAlias,
      serializeAsType = common.serializeAsType,
      serializeAsProperty = common.serializeAsProperty;
  
  var XML_PREAMBLE = '<?xml version="1.0" encoding="UTF-8"?>\n',
      ESCAPE_CHARS = /(<|>|'|"|&|\n\r|\n)/g,
      DEFAULT_NS_MAP = common.DEFAULT_NS_MAP,
      XSI_TYPE = common.XSI_TYPE;
  
  
  function nsName(ns) {
    if (isString(ns)) {
      return ns;
    } else {
      return (ns.prefix ? ns.prefix + ':' : '') + ns.localName;
    }
  }
  
  function getElementNs(ns, descriptor) {
    if (descriptor.isGeneric) {
      return descriptor.name;
    } else {
      return assign({ localName: nameToAlias(descriptor.ns.localName, descriptor.$pkg) }, ns);
    }
  }
  
  function getPropertyNs(ns, descriptor) {
    return assign({ localName: descriptor.ns.localName }, ns);
  }
  
  function getSerializableProperties(element) {
    var descriptor = element.$descriptor;
  
    return filter(descriptor.properties, function(p) {
      var name = p.name;
  
      // 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;
      }
  
      return p.isMany ? value.length : true;
    });
  }
  
  var ESCAPE_MAP = {
    '\n': '10',
    '\n\r': '10',
    '"': '34',
    '\'': '39',
    '<': '60',
    '>': '62',
    '&': '38'
  };
  
  /**
   * 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) {
  
    // ensure we are handling strings here
    str = isString(str) ? str : '' + str;
  
    return str.replace(ESCAPE_CHARS, function(str) {
      return '&#' + ESCAPE_MAP[str] + ';';
    });
  }
  
  function filterAttributes(props) {
    return filter(props, function(p) { return p.isAttr; });
  }
  
  function filterContained(props) {
    return filter(props, function(p) { return !p.isAttr; });
  }
  
  
  function ReferenceSerializer(parent, ns) {
    this.ns = ns;
  }
  
  ReferenceSerializer.prototype.build = function(element) {
    this.element = element;
    return this;
  };
  
  ReferenceSerializer.prototype.serializeTo = function(writer) {
    writer
      .appendIndent()
      .append('<' + nsName(this.ns) + '>' + this.element.id + '</' + nsName(this.ns) + '>')
      .appendNewLine();
  };
  
  function BodySerializer() {}
  
  BodySerializer.prototype.serializeValue = BodySerializer.prototype.serializeTo = function(writer) {
    var escape = this.escape;
  
    if (escape) {
      writer.append('<![CDATA[');
    }
  
    writer.append(this.value);
  
    if (escape) {
      writer.append(']]>');
    }
  };
  
  BodySerializer.prototype.build = function(prop, value) {
    this.value = value;
  
    if (prop.type === 'String' && ESCAPE_CHARS.test(value)) {
      this.escape = true;
    }
  
    return this;
  };
  
  function ValueSerializer(ns) {
    this.ns = ns;
  }
  
  ValueSerializer.prototype = new BodySerializer();
  
  ValueSerializer.prototype.serializeTo = function(writer) {
  
    writer
      .appendIndent()
      .append('<' + nsName(this.ns) + '>');
  
    this.serializeValue(writer);
  
    writer
      .append( '</' + nsName(this.ns) + '>')
      .appendNewLine();
  };
  
  function ElementSerializer(parent, ns) {
    this.body = [];
    this.attrs = [];
  
    this.parent = parent;
    this.ns = ns;
  }
  
  ElementSerializer.prototype.build = function(element) {
    this.element = element;
  
    var otherAttrs = this.parseNsAttributes(element);
  
    if (!this.ns) {
      this.ns = this.nsTagName(element.$descriptor);
    }
  
    if (element.$descriptor.isGeneric) {
      this.parseGeneric(element);
    } else {
      var 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;
  };
  
  ElementSerializer.prototype.nsAttributeName = function(element) {
  
    var ns;
  
    if (isString(element)) {
      ns = parseNameNs(element);
    } else
    if (element.ns) {
      ns = element.ns;
    }
  
    var effectiveNs = this.logNamespaceUsed(ns);
  
    // strip prefix if same namespace like parent
    if (this.isLocalNs(effectiveNs)) {
      return { localName: ns.localName };
    } else {
      return assign({ localName: ns.localName }, effectiveNs);
    }
  };
  
  ElementSerializer.prototype.parseGeneric = function(element) {
  
    var self = this,
        body = this.body,
        attrs = this.attrs;
  
    forEach(element, function(val, key) {
  
      if (key === '$body') {
        body.push(new BodySerializer().build({ type: 'String' }, val));
      } else
      if (key === '$children') {
        forEach(val, function(child) {
          body.push(new ElementSerializer(self).build(child));
        });
      } else
      if (key.indexOf('$') !== 0) {
        attrs.push({ name: key, value: escapeAttr(val) });
      }
    });
  };
  
  /**
   * Parse namespaces and return a list of left over generic attributes
   *
   * @param  {Object} element
   * @return {Array<Object>}
   */
  ElementSerializer.prototype.parseNsAttributes = function(element) {
    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
    forEach(genericAttrs, function(value, name) {
      var nameNs = parseNameNs(name);
  
      if (nameNs.prefix === 'xmlns') {
        self.logNamespace({ prefix: nameNs.localName, uri: value });
      } else
      if (!nameNs.prefix && nameNs.localName === 'xmlns') {
        self.logNamespace({ uri: value });
      } else {
        attributes.push({ name: name, value: value });
      }
    });
  
    return attributes;
  };
  
  ElementSerializer.prototype.parseGenericAttributes = function(element, attributes) {
  
    var self = this;
  
    forEach(attributes, function(attr) {
  
      // do not serialize xsi:type attribute
      // it is set manually based on the actual implementation type
      if (attr.name === XSI_TYPE) {
        return;
      }
  
      try {
        self.addAttribute(self.nsAttributeName(attr.name), attr.value);
      } catch (e) {
        console.warn('[writer] 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;
  
    forEach(properties, function(p) {
      var value = element.get(p.name),
          isReference = p.isReference,
          isMany = p.isMany;
  
      var ns = self.nsPropertyTagName(p);
  
      if (!isMany) {
        value = [ value ];
      }
  
      if (p.isBody) {
        body.push(new BodySerializer().build(p, value[0]));
      } else
      if (Types.isSimple(p.type)) {
        forEach(value, function(v) {
          body.push(new ValueSerializer(ns).build(p, v));
        });
      } else
      if (isReference) {
        forEach(value, function(v) {
          body.push(new ReferenceSerializer(self, ns).build(v));
        });
      } else {
        // allow serialization via type
        // rather than element name
        var asType = serializeAsType(p),
            asProperty = serializeAsProperty(p);
  
        forEach(value, function(v) {
          var serializer;
  
          if (asType) {
            serializer = new TypeSerializer(self, ns);
          } else
          if (asProperty) {
            serializer = new ElementSerializer(self, ns);
          } else {
            serializer = new ElementSerializer(self);
          }
  
          body.push(serializer.build(v));
        });
      }
    });
  };
  
  ElementSerializer.prototype.getNamespaces = function() {
    if (!this.parent) {
      if (!this.namespaces) {
        this.namespaces = {
          prefixMap: {},
          uriMap: {},
          used: {}
        };
      }
    } else {
      this.namespaces = this.parent.getNamespaces();
    }
  
    return this.namespaces;
  };
  
  ElementSerializer.prototype.logNamespace = function(ns) {
    var namespaces = this.getNamespaces();
  
    var existing = namespaces.uriMap[ns.uri];
  
    if (!existing) {
      namespaces.uriMap[ns.uri] = ns;
    }
  
    namespaces.prefixMap[ns.prefix] = ns.uri;
  
    return ns;
  };
  
  ElementSerializer.prototype.logNamespaceUsed = function(ns) {
    var element = this.element,
        model = element.$model,
        namespaces = this.getNamespaces();
  
    // ns may be
    //
    //   * prefix only
    //   * prefix:uri
  
    var prefix = ns.prefix;
    var uri = ns.uri || DEFAULT_NS_MAP[prefix] ||
              namespaces.prefixMap[prefix] || (model ? (model.getPackage(prefix) || {}).uri : null);
  
    if (!uri) {
      throw new Error('no namespace uri given for prefix <' + ns.prefix + '>');
    }
  
    ns = namespaces.uriMap[uri];
  
    if (!ns) {
      ns = this.logNamespace({ prefix: prefix, uri: uri });
    }
  
    if (!namespaces.used[ns.uri]) {
      namespaces.used[ns.uri] = ns;
    }
  
    return ns;
  };
  
  ElementSerializer.prototype.parseAttributes = function(properties) {
    var self = this,
        element = this.element;
  
    forEach(properties, function(p) {
      self.logNamespaceUsed(p.ns);
  
      var value = element.get(p.name);
  
      if (p.isReference) {
        value = value.id;
      }
  
      self.addAttribute(self.nsAttributeName(p), value);
    });
  };
  
  ElementSerializer.prototype.addAttribute = function(name, value) {
    var attrs = this.attrs;
  
    if (isString(value)) {
      value = escapeAttr(value);
    }
  
    attrs.push({ name: name, value: value });
  };
  
  ElementSerializer.prototype.serializeAttributes = function(writer) {
    var attrs = this.attrs,
        root = !this.parent,
        namespaces = this.namespaces;
  
    function collectNsAttrs() {
      return map(namespaces.used, function(ns) {
        var name = 'xmlns' + (ns.prefix ? ':' + ns.prefix : '');
        return { name: name, value: ns.uri };
      });
    }
  
    if (root) {
      attrs = collectNsAttrs().concat(attrs);
    }
  
    forEach(attrs, function(a) {
      writer
        .append(' ')
        .append(nsName(a.name)).append('="').append(a.value).append('"');
    });
  };
  
  ElementSerializer.prototype.serializeTo = function(writer) {
    var hasBody = this.body.length,
        indent = !(this.body.length === 1 && this.body[0] instanceof BodySerializer);
  
    writer
      .appendIndent()
      .append('<' + nsName(this.ns));
  
    this.serializeAttributes(writer);
  
    writer.append(hasBody ? '>' : ' />');
  
    if (hasBody) {
  
      if (indent) {
        writer
          .appendNewLine()
          .indent();
      }
  
      forEach(this.body, function(b) {
        b.serializeTo(writer);
      });
  
      if (indent) {
        writer
          .unindent()
          .appendIndent();
      }
  
      writer.append('</' + nsName(this.ns) + '>');
    }
  
    writer.appendNewLine();
  };
  
  /**
   * A serializer for types that handles serialization of data types
   */
  function TypeSerializer(parent, ns) {
    ElementSerializer.call(this, parent, ns);
  }
  
  TypeSerializer.prototype = new ElementSerializer();
  
  TypeSerializer.prototype.build = function(element) {
    var descriptor = element.$descriptor;
  
    this.element = element;
  
    this.typeNs = this.nsTagName(descriptor);
  
    // add xsi:type attribute to represent the elements
    // actual type
  
    var typeNs = this.typeNs,
        pkg = element.$model.getPackage(typeNs.uri),
        typePrefix = (pkg.xml && pkg.xml.typePrefix) || '';
  
    this.addAttribute(this.nsAttributeName(XSI_TYPE),
      (typeNs.prefix ? typeNs.prefix + ':' : '') +
      typePrefix + descriptor.ns.localName);
  
    // do the usual stuff
    return ElementSerializer.prototype.build.call(this, element);
  };
  
  TypeSerializer.prototype.isLocalNs = function(ns) {
    return ns.uri === this.typeNs.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 XMLWriter(options) {
  
    options = 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
    };
  }
  
  module.exports = XMLWriter;
  
  },{"165":165,"168":168,"17":17,"27":27,"30":30,"75":75,"77":77,"80":80}],20:[function(_dereq_,module,exports){
  (function (Buffer){
  // wrapper for non-node envs
  ;(function (sax) {
  
  sax.parser = function (strict, opt) { return new SAXParser(strict, opt) }
  sax.SAXParser = SAXParser
  sax.SAXStream = SAXStream
  sax.createStream = createStream
  
  // When we pass the MAX_BUFFER_LENGTH position, start checking for buffer overruns.
  // When we check, schedule the next check for MAX_BUFFER_LENGTH - (max(buffer lengths)),
  // since that's the earliest that a buffer overrun could occur.  This way, checks are
  // as rare as required, but as often as necessary to ensure never crossing this bound.
  // Furthermore, buffers are only tested at most once per write(), so passing a very
  // large string into write() might have undesirable effects, but this is manageable by
  // the caller, so it is assumed to be safe.  Thus, a call to write() may, in the extreme
  // edge case, result in creating at most one complete copy of the string passed in.
  // Set to Infinity to have unlimited buffers.
  sax.MAX_BUFFER_LENGTH = 64 * 1024
  
  var buffers = [
    "comment", "sgmlDecl", "textNode", "tagName", "doctype",
    "procInstName", "procInstBody", "entity", "attribName",
    "attribValue", "cdata", "script"
  ]
  
  sax.EVENTS = // for discoverability.
    [ "text"
    , "processinginstruction"
    , "sgmldeclaration"
    , "doctype"
    , "comment"
    , "attribute"
    , "opentag"
    , "closetag"
    , "opencdata"
    , "cdata"
    , "closecdata"
    , "error"
    , "end"
    , "ready"
    , "script"
    , "opennamespace"
    , "closenamespace"
    ]
  
  function SAXParser (strict, opt) {
    if (!(this instanceof SAXParser)) return new SAXParser(strict, opt)
  
    var parser = this
    clearBuffers(parser)
    parser.q = parser.c = ""
    parser.bufferCheckPosition = sax.MAX_BUFFER_LENGTH
    parser.opt = opt || {}
    parser.opt.lowercase = parser.opt.lowercase || parser.opt.lowercasetags
    parser.looseCase = parser.opt.lowercase ? "toLowerCase" : "toUpperCase"
    parser.tags = []
    parser.closed = parser.closedRoot = parser.sawRoot = false
    parser.tag = parser.error = null
    parser.strict = !!strict
    parser.noscript = !!(strict || parser.opt.noscript)
    parser.state = S.BEGIN
    parser.ENTITIES = Object.create(sax.ENTITIES)
    parser.attribList = []
  
    // namespaces form a prototype chain.
    // it always points at the current tag,
    // which protos to its parent tag.
    if (parser.opt.xmlns) parser.ns = Object.create(rootNS)
  
    // mostly just for error reporting
    parser.trackPosition = parser.opt.position !== false
    if (parser.trackPosition) {
      parser.position = parser.line = parser.column = 0
    }
    emit(parser, "onready")
  }
  
  if (!Object.create) Object.create = function (o) {
    function f () { this.__proto__ = o }
    f.prototype = o
    return new f
  }
  
  if (!Object.getPrototypeOf) Object.getPrototypeOf = function (o) {
    return o.__proto__
  }
  
  if (!Object.keys) Object.keys = function (o) {
    var a = []
    for (var i in o) if (o.hasOwnProperty(i)) a.push(i)
    return a
  }
  
  function checkBufferLength (parser) {
    var maxAllowed = Math.max(sax.MAX_BUFFER_LENGTH, 10)
      , maxActual = 0
    for (var i = 0, l = buffers.length; i < l; i ++) {
      var len = parser[buffers[i]].length
      if (len > maxAllowed) {
        // Text/cdata nodes can get big, and since they're buffered,
        // we can get here under normal conditions.
        // Avoid issues by emitting the text node now,
        // so at least it won't get any bigger.
        switch (buffers[i]) {
          case "textNode":
            closeText(parser)
          break
  
          case "cdata":
            emitNode(parser, "oncdata", parser.cdata)
            parser.cdata = ""
          break
  
          case "script":
            emitNode(parser, "onscript", parser.script)
            parser.script = ""
          break
  
          default:
            error(parser, "Max buffer length exceeded: "+buffers[i])
        }
      }
      maxActual = Math.max(maxActual, len)
    }
    // schedule the next check for the earliest possible buffer overrun.
    parser.bufferCheckPosition = (sax.MAX_BUFFER_LENGTH - maxActual)
                               + parser.position
  }
  
  function clearBuffers (parser) {
    for (var i = 0, l = buffers.length; i < l; i ++) {
      parser[buffers[i]] = ""
    }
  }
  
  function flushBuffers (parser) {
    closeText(parser)
    if (parser.cdata !== "") {
      emitNode(parser, "oncdata", parser.cdata)
      parser.cdata = ""
    }
    if (parser.script !== "") {
      emitNode(parser, "onscript", parser.script)
      parser.script = ""
    }
  }
  
  SAXParser.prototype =
    { end: function () { end(this) }
    , write: write
    , resume: function () { this.error = null; return this }
    , close: function () { return this.write(null) }
    , flush: function () { flushBuffers(this) }
    }
  
  try {
    var Stream = _dereq_("stream").Stream
  } catch (ex) {
    var Stream = function () {}
  }
  
  
  var streamWraps = sax.EVENTS.filter(function (ev) {
    return ev !== "error" && ev !== "end"
  })
  
  function createStream (strict, opt) {
    return new SAXStream(strict, opt)
  }
  
  function SAXStream (strict, opt) {
    if (!(this instanceof SAXStream)) return new SAXStream(strict, opt)
  
    Stream.apply(this)
  
    this._parser = new SAXParser(strict, opt)
    this.writable = true
    this.readable = true
  
  
    var me = this
  
    this._parser.onend = function () {
      me.emit("end")
    }
  
    this._parser.onerror = function (er) {
      me.emit("error", er)
  
      // if didn't throw, then means error was handled.
      // go ahead and clear error, so we can write again.
      me._parser.error = null
    }
  
    this._decoder = null;
  
    streamWraps.forEach(function (ev) {
      Object.defineProperty(me, "on" + ev, {
        get: function () { return me._parser["on" + ev] },
        set: function (h) {
          if (!h) {
            me.removeAllListeners(ev)
            return me._parser["on"+ev] = h
          }
          me.on(ev, h)
        },
        enumerable: true,
        configurable: false
      })
    })
  }
  
  SAXStream.prototype = Object.create(Stream.prototype,
    { constructor: { value: SAXStream } })
  
  SAXStream.prototype.write = function (data) {
    if (typeof Buffer === 'function' &&
        typeof Buffer.isBuffer === 'function' &&
        Buffer.isBuffer(data)) {
      if (!this._decoder) {
        var SD = _dereq_('string_decoder').StringDecoder
        this._decoder = new SD('utf8')
      }
      data = this._decoder.write(data);
    }
  
    this._parser.write(data.toString())
    this.emit("data", data)
    return true
  }
  
  SAXStream.prototype.end = function (chunk) {
    if (chunk && chunk.length) this.write(chunk)
    this._parser.end()
    return true
  }
  
  SAXStream.prototype.on = function (ev, handler) {
    var me = this
    if (!me._parser["on"+ev] && streamWraps.indexOf(ev) !== -1) {
      me._parser["on"+ev] = function () {
        var args = arguments.length === 1 ? [arguments[0]]
                 : Array.apply(null, arguments)
        args.splice(0, 0, ev)
        me.emit.apply(me, args)
      }
    }
  
    return Stream.prototype.on.call(me, ev, handler)
  }
  
  
  
  // character classes and tokens
  var whitespace = "\r\n\t "
    // this really needs to be replaced with character classes.
    // XML allows all manner of ridiculous numbers and digits.
    , number = "0124356789"
    , letter = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
    // (Letter | "_" | ":")
    , quote = "'\""
    , entity = number+letter+"#"
    , attribEnd = whitespace + ">"
    , CDATA = "[CDATA["
    , DOCTYPE = "DOCTYPE"
    , XML_NAMESPACE = "http://www.w3.org/XML/1998/namespace"
    , XMLNS_NAMESPACE = "http://www.w3.org/2000/xmlns/"
    , rootNS = { xml: XML_NAMESPACE, xmlns: XMLNS_NAMESPACE }
  
  // turn all the string character sets into character class objects.
  whitespace = charClass(whitespace)
  number = charClass(number)
  letter = charClass(letter)
  
  // http://www.w3.org/TR/REC-xml/#NT-NameStartChar
  // This implementation works on strings, a single character at a time
  // as such, it cannot ever support astral-plane characters (10000-EFFFF)
  // without a significant breaking change to either this  parser, or the
  // JavaScript language.  Implementation of an emoji-capable xml parser
  // is left as an exercise for the reader.
  var nameStart = /[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/
  
  var nameBody = /[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u00B7\u0300-\u036F\u203F-\u2040\.\d-]/
  
  quote = charClass(quote)
  entity = charClass(entity)
  attribEnd = charClass(attribEnd)
  
  function charClass (str) {
    return str.split("").reduce(function (s, c) {
      s[c] = true
      return s
    }, {})
  }
  
  function isRegExp (c) {
    return Object.prototype.toString.call(c) === '[object RegExp]'
  }
  
  function is (charclass, c) {
    return isRegExp(charclass) ? !!c.match(charclass) : charclass[c]
  }
  
  function not (charclass, c) {
    return !is(charclass, c)
  }
  
  var S = 0
  sax.STATE =
  { BEGIN                     : S++
  , TEXT                      : S++ // general stuff
  , TEXT_ENTITY               : S++ // &amp and such.
  , OPEN_WAKA                 : S++ // <
  , SGML_DECL                 : S++ // <!BLARG
  , SGML_DECL_QUOTED          : S++ // <!BLARG foo "bar
  , DOCTYPE                   : S++ // <!DOCTYPE
  , DOCTYPE_QUOTED            : S++ // <!DOCTYPE "//blah
  , DOCTYPE_DTD               : S++ // <!DOCTYPE "//blah" [ ...
  , DOCTYPE_DTD_QUOTED        : S++ // <!DOCTYPE "//blah" [ "foo
  , COMMENT_STARTING          : S++ // <!-
  , COMMENT                   : S++ // <!--
  , COMMENT_ENDING            : S++ // <!-- blah -
  , COMMENT_ENDED             : S++ // <!-- blah --
  , CDATA                     : S++ // <![CDATA[ something
  , CDATA_ENDING              : S++ // ]
  , CDATA_ENDING_2            : S++ // ]]
  , PROC_INST                 : S++ // <?hi
  , PROC_INST_BODY            : S++ // <?hi there
  , PROC_INST_ENDING          : S++ // <?hi "there" ?
  , OPEN_TAG                  : S++ // <strong
  , OPEN_TAG_SLASH            : S++ // <strong /
  , ATTRIB                    : S++ // <a
  , ATTRIB_NAME               : S++ // <a foo
  , ATTRIB_NAME_SAW_WHITE     : S++ // <a foo _
  , ATTRIB_VALUE              : S++ // <a foo=
  , ATTRIB_VALUE_QUOTED       : S++ // <a foo="bar
  , ATTRIB_VALUE_CLOSED       : S++ // <a foo="bar"
  , ATTRIB_VALUE_UNQUOTED     : S++ // <a foo=bar
  , ATTRIB_VALUE_ENTITY_Q     : S++ // <foo bar="&quot;"
  , ATTRIB_VALUE_ENTITY_U     : S++ // <foo bar=&quot;
  , CLOSE_TAG                 : S++ // </a
  , CLOSE_TAG_SAW_WHITE       : S++ // </a   >
  , SCRIPT                    : S++ // <script> ...
  , SCRIPT_ENDING             : S++ // <script> ... <
  }
  
  sax.ENTITIES =
  { "amp" : "&"
  , "gt" : ">"
  , "lt" : "<"
  , "quot" : "\""
  , "apos" : "'"
  , "AElig" : 198
  , "Aacute" : 193
  , "Acirc" : 194
  , "Agrave" : 192
  , "Aring" : 197
  , "Atilde" : 195
  , "Auml" : 196
  , "Ccedil" : 199
  , "ETH" : 208
  , "Eacute" : 201
  , "Ecirc" : 202
  , "Egrave" : 200
  , "Euml" : 203
  , "Iacute" : 205
  , "Icirc" : 206
  , "Igrave" : 204
  , "Iuml" : 207
  , "Ntilde" : 209
  , "Oacute" : 211
  , "Ocirc" : 212
  , "Ograve" : 210
  , "Oslash" : 216
  , "Otilde" : 213
  , "Ouml" : 214
  , "THORN" : 222
  , "Uacute" : 218
  , "Ucirc" : 219
  , "Ugrave" : 217
  , "Uuml" : 220
  , "Yacute" : 221
  , "aacute" : 225
  , "acirc" : 226
  , "aelig" : 230
  , "agrave" : 224
  , "aring" : 229
  , "atilde" : 227
  , "auml" : 228
  , "ccedil" : 231
  , "eacute" : 233
  , "ecirc" : 234
  , "egrave" : 232
  , "eth" : 240
  , "euml" : 235
  , "iacute" : 237
  , "icirc" : 238
  , "igrave" : 236
  , "iuml" : 239
  , "ntilde" : 241
  , "oacute" : 243
  , "ocirc" : 244
  , "ograve" : 242
  , "oslash" : 248
  , "otilde" : 245
  , "ouml" : 246
  , "szlig" : 223
  , "thorn" : 254
  , "uacute" : 250
  , "ucirc" : 251
  , "ugrave" : 249
  , "uuml" : 252
  , "yacute" : 253
  , "yuml" : 255
  , "copy" : 169
  , "reg" : 174
  , "nbsp" : 160
  , "iexcl" : 161
  , "cent" : 162
  , "pound" : 163
  , "curren" : 164
  , "yen" : 165
  , "brvbar" : 166
  , "sect" : 167
  , "uml" : 168
  , "ordf" : 170
  , "laquo" : 171
  , "not" : 172
  , "shy" : 173
  , "macr" : 175
  , "deg" : 176
  , "plusmn" : 177
  , "sup1" : 185
  , "sup2" : 178
  , "sup3" : 179
  , "acute" : 180
  , "micro" : 181
  , "para" : 182
  , "middot" : 183
  , "cedil" : 184
  , "ordm" : 186
  , "raquo" : 187
  , "frac14" : 188
  , "frac12" : 189
  , "frac34" : 190
  , "iquest" : 191
  , "times" : 215
  , "divide" : 247
  , "OElig" : 338
  , "oelig" : 339
  , "Scaron" : 352
  , "scaron" : 353
  , "Yuml" : 376
  , "fnof" : 402
  , "circ" : 710
  , "tilde" : 732
  , "Alpha" : 913
  , "Beta" : 914
  , "Gamma" : 915
  , "Delta" : 916
  , "Epsilon" : 917
  , "Zeta" : 918
  , "Eta" : 919
  , "Theta" : 920
  , "Iota" : 921
  , "Kappa" : 922
  , "Lambda" : 923
  , "Mu" : 924
  , "Nu" : 925
  , "Xi" : 926
  , "Omicron" : 927
  , "Pi" : 928
  , "Rho" : 929
  , "Sigma" : 931
  , "Tau" : 932
  , "Upsilon" : 933
  , "Phi" : 934
  , "Chi" : 935
  , "Psi" : 936
  , "Omega" : 937
  , "alpha" : 945
  , "beta" : 946
  , "gamma" : 947
  , "delta" : 948
  , "epsilon" : 949
  , "zeta" : 950
  , "eta" : 951
  , "theta" : 952
  , "iota" : 953
  , "kappa" : 954
  , "lambda" : 955
  , "mu" : 956
  , "nu" : 957
  , "xi" : 958
  , "omicron" : 959
  , "pi" : 960
  , "rho" : 961
  , "sigmaf" : 962
  , "sigma" : 963
  , "tau" : 964
  , "upsilon" : 965
  , "phi" : 966
  , "chi" : 967
  , "psi" : 968
  , "omega" : 969
  , "thetasym" : 977
  , "upsih" : 978
  , "piv" : 982
  , "ensp" : 8194
  , "emsp" : 8195
  , "thinsp" : 8201
  , "zwnj" : 8204
  , "zwj" : 8205
  , "lrm" : 8206
  , "rlm" : 8207
  , "ndash" : 8211
  , "mdash" : 8212
  , "lsquo" : 8216
  , "rsquo" : 8217
  , "sbquo" : 8218
  , "ldquo" : 8220
  , "rdquo" : 8221
  , "bdquo" : 8222
  , "dagger" : 8224
  , "Dagger" : 8225
  , "bull" : 8226
  , "hellip" : 8230
  , "permil" : 8240
  , "prime" : 8242
  , "Prime" : 8243
  , "lsaquo" : 8249
  , "rsaquo" : 8250
  , "oline" : 8254
  , "frasl" : 8260
  , "euro" : 8364
  , "image" : 8465
  , "weierp" : 8472
  , "real" : 8476
  , "trade" : 8482
  , "alefsym" : 8501
  , "larr" : 8592
  , "uarr" : 8593
  , "rarr" : 8594
  , "darr" : 8595
  , "harr" : 8596
  , "crarr" : 8629
  , "lArr" : 8656
  , "uArr" : 8657
  , "rArr" : 8658
  , "dArr" : 8659
  , "hArr" : 8660
  , "forall" : 8704
  , "part" : 8706
  , "exist" : 8707
  , "empty" : 8709
  , "nabla" : 8711
  , "isin" : 8712
  , "notin" : 8713
  , "ni" : 8715
  , "prod" : 8719
  , "sum" : 8721
  , "minus" : 8722
  , "lowast" : 8727
  , "radic" : 8730
  , "prop" : 8733
  , "infin" : 8734
  , "ang" : 8736
  , "and" : 8743
  , "or" : 8744
  , "cap" : 8745
  , "cup" : 8746
  , "int" : 8747
  , "there4" : 8756
  , "sim" : 8764
  , "cong" : 8773
  , "asymp" : 8776
  , "ne" : 8800
  , "equiv" : 8801
  , "le" : 8804
  , "ge" : 8805
  , "sub" : 8834
  , "sup" : 8835
  , "nsub" : 8836
  , "sube" : 8838
  , "supe" : 8839
  , "oplus" : 8853
  , "otimes" : 8855
  , "perp" : 8869
  , "sdot" : 8901
  , "lceil" : 8968
  , "rceil" : 8969
  , "lfloor" : 8970
  , "rfloor" : 8971
  , "lang" : 9001
  , "rang" : 9002
  , "loz" : 9674
  , "spades" : 9824
  , "clubs" : 9827
  , "hearts" : 9829
  , "diams" : 9830
  }
  
  Object.keys(sax.ENTITIES).forEach(function (key) {
      var e = sax.ENTITIES[key]
      var s = typeof e === 'number' ? String.fromCharCode(e) : e
      sax.ENTITIES[key] = s
  })
  
  for (var S in sax.STATE) sax.STATE[sax.STATE[S]] = S
  
  // shorthand
  S = sax.STATE
  
  function emit (parser, event, data) {
    parser[event] && parser[event](data)
  }
  
  function emitNode (parser, nodeType, data) {
    if (parser.textNode) closeText(parser)
    emit(parser, nodeType, data)
  }
  
  function closeText (parser) {
    parser.textNode = textopts(parser.opt, parser.textNode)
    if (parser.textNode) emit(parser, "ontext", parser.textNode)
    parser.textNode = ""
  }
  
  function textopts (opt, text) {
    if (opt.trim) text = text.trim()
    if (opt.normalize) text = text.replace(/\s+/g, " ")
    return text
  }
  
  function error (parser, er) {
    closeText(parser)
    if (parser.trackPosition) {
      er += "\nLine: "+parser.line+
            "\nColumn: "+parser.column+
            "\nChar: "+parser.c
    }
    er = new Error(er)
    parser.error = er
    emit(parser, "onerror", er)
    return parser
  }
  
  function end (parser) {
    if (!parser.closedRoot) strictFail(parser, "Unclosed root tag")
    if ((parser.state !== S.BEGIN) && (parser.state !== S.TEXT)) error(parser, "Unexpected end")
    closeText(parser)
    parser.c = ""
    parser.closed = true
    emit(parser, "onend")
    SAXParser.call(parser, parser.strict, parser.opt)
    return parser
  }
  
  function strictFail (parser, message) {
    if (typeof parser !== 'object' || !(parser instanceof SAXParser))
      throw new Error('bad call to strictFail');
    if (parser.strict) error(parser, message)
  }
  
  function newTag (parser) {
    if (!parser.strict) parser.tagName = parser.tagName[parser.looseCase]()
    var parent = parser.tags[parser.tags.length - 1] || parser
      , tag = parser.tag = { name : parser.tagName, attributes : {} }
  
    // will be overridden if tag contails an xmlns="foo" or xmlns:foo="bar"
    if (parser.opt.xmlns) tag.ns = parent.ns
    parser.attribList.length = 0
  }
  
  function qname (name, attribute) {
    var i = name.indexOf(":")
      , qualName = i < 0 ? [ "", name ] : name.split(":")
      , prefix = qualName[0]
      , local = qualName[1]
  
    // <x "xmlns"="http://foo">
    if (attribute && name === "xmlns") {
      prefix = "xmlns"
      local = ""
    }
  
    return { prefix: prefix, local: local }
  }
  
  function attrib (parser) {
    if (!parser.strict) parser.attribName = parser.attribName[parser.looseCase]()
  
    if (parser.attribList.indexOf(parser.attribName) !== -1 ||
        parser.tag.attributes.hasOwnProperty(parser.attribName)) {
      return parser.attribName = parser.attribValue = ""
    }
  
    if (parser.opt.xmlns) {
      var qn = qname(parser.attribName, true)
        , prefix = qn.prefix
        , local = qn.local
  
      if (prefix === "xmlns") {
        // namespace binding attribute; push the binding into scope
        if (local === "xml" && parser.attribValue !== XML_NAMESPACE) {
          strictFail( parser
                    , "xml: prefix must be bound to " + XML_NAMESPACE + "\n"
                    + "Actual: " + parser.attribValue )
        } else if (local === "xmlns" && parser.attribValue !== XMLNS_NAMESPACE) {
          strictFail( parser
                    , "xmlns: prefix must be bound to " + XMLNS_NAMESPACE + "\n"
                    + "Actual: " + parser.attribValue )
        } else {
          var tag = parser.tag
            , parent = parser.tags[parser.tags.length - 1] || parser
          if (tag.ns === parent.ns) {
            tag.ns = Object.create(parent.ns)
          }
          tag.ns[local] = parser.attribValue
        }
      }
  
      // defer onattribute events until all attributes have been seen
      // so any new bindings can take effect; preserve attribute order
      // so deferred events can be emitted in document order
      parser.attribList.push([parser.attribName, parser.attribValue])
    } else {
      // in non-xmlns mode, we can emit the event right away
      parser.tag.attributes[parser.attribName] = parser.attribValue
      emitNode( parser
              , "onattribute"
              , { name: parser.attribName
                , value: parser.attribValue } )
    }
  
    parser.attribName = parser.attribValue = ""
  }
  
  function openTag (parser, selfClosing) {
    if (parser.opt.xmlns) {
      // emit namespace binding events
      var tag = parser.tag
  
      // add namespace info to tag
      var qn = qname(parser.tagName)
      tag.prefix = qn.prefix
      tag.local = qn.local
      tag.uri = tag.ns[qn.prefix] || ""
  
      if (tag.prefix && !tag.uri) {
        strictFail(parser, "Unbound namespace prefix: "
                         + JSON.stringify(parser.tagName))
        tag.uri = qn.prefix
      }
  
      var parent = parser.tags[parser.tags.length - 1] || parser
      if (tag.ns && parent.ns !== tag.ns) {
        Object.keys(tag.ns).forEach(function (p) {
          emitNode( parser
                  , "onopennamespace"
                  , { prefix: p , uri: tag.ns[p] } )
        })
      }
  
      // handle deferred onattribute events
      // Note: do not apply default ns to attributes:
      //   http://www.w3.org/TR/REC-xml-names/#defaulting
      for (var i = 0, l = parser.attribList.length; i < l; i ++) {
        var nv = parser.attribList[i]
        var name = nv[0]
          , value = nv[1]
          , qualName = qname(name, true)
          , prefix = qualName.prefix
          , local = qualName.local
          , uri = prefix == "" ? "" : (tag.ns[prefix] || "")
          , a = { name: name
                , value: value
                , prefix: prefix
                , local: local
                , uri: uri
                }
  
        // if there's any attributes with an undefined namespace,
        // then fail on them now.
        if (prefix && prefix != "xmlns" && !uri) {
          strictFail(parser, "Unbound namespace prefix: "
                           + JSON.stringify(prefix))
          a.uri = prefix
        }
        parser.tag.attributes[name] = a
        emitNode(parser, "onattribute", a)
      }
      parser.attribList.length = 0
    }
  
    parser.tag.isSelfClosing = !!selfClosing
  
    // process the tag
    parser.sawRoot = true
    parser.tags.push(parser.tag)
    emitNode(parser, "onopentag", parser.tag)
    if (!selfClosing) {
      // special case for <script> in non-strict mode.
      if (!parser.noscript && parser.tagName.toLowerCase() === "script") {
        parser.state = S.SCRIPT
      } else {
        parser.state = S.TEXT
      }
      parser.tag = null
      parser.tagName = ""
    }
    parser.attribName = parser.attribValue = ""
    parser.attribList.length = 0
  }
  
  function closeTag (parser) {
    if (!parser.tagName) {
      strictFail(parser, "Weird empty close tag.")
      parser.textNode += "</>"
      parser.state = S.TEXT
      return
    }
  
    if (parser.script) {
      if (parser.tagName !== "script") {
        parser.script += "</" + parser.tagName + ">"
        parser.tagName = ""
        parser.state = S.SCRIPT
        return
      }
      emitNode(parser, "onscript", parser.script)
      parser.script = ""
    }
  
    // first make sure that the closing tag actually exists.
    // <a><b></c></b></a> will close everything, otherwise.
    var t = parser.tags.length
    var tagName = parser.tagName
    if (!parser.strict) tagName = tagName[parser.looseCase]()
    var closeTo = tagName
    while (t --) {
      var close = parser.tags[t]
      if (close.name !== closeTo) {
        // fail the first time in strict mode
        strictFail(parser, "Unexpected close tag")
      } else break
    }
  
    // didn't find it.  we already failed for strict, so just abort.
    if (t < 0) {
      strictFail(parser, "Unmatched closing tag: "+parser.tagName)
      parser.textNode += "</" + parser.tagName + ">"
      parser.state = S.TEXT
      return
    }
    parser.tagName = tagName
    var s = parser.tags.length
    while (s --> t) {
      var tag = parser.tag = parser.tags.pop()
      parser.tagName = parser.tag.name
      emitNode(parser, "onclosetag", parser.tagName)
  
      var x = {}
      for (var i in tag.ns) x[i] = tag.ns[i]
  
      var parent = parser.tags[parser.tags.length - 1] || parser
      if (parser.opt.xmlns && tag.ns !== parent.ns) {
        // remove namespace bindings introduced by tag
        Object.keys(tag.ns).forEach(function (p) {
          var n = tag.ns[p]
          emitNode(parser, "onclosenamespace", { prefix: p, uri: n })
        })
      }
    }
    if (t === 0) parser.closedRoot = true
    parser.tagName = parser.attribValue = parser.attribName = ""
    parser.attribList.length = 0
    parser.state = S.TEXT
  }
  
  function parseEntity (parser) {
    var entity = parser.entity
      , entityLC = entity.toLowerCase()
      , num
      , numStr = ""
    if (parser.ENTITIES[entity])
      return parser.ENTITIES[entity]
    if (parser.ENTITIES[entityLC])
      return parser.ENTITIES[entityLC]
    entity = entityLC
    if (entity.charAt(0) === "#") {
      if (entity.charAt(1) === "x") {
        entity = entity.slice(2)
        num = parseInt(entity, 16)
        numStr = num.toString(16)
      } else {
        entity = entity.slice(1)
        num = parseInt(entity, 10)
        numStr = num.toString(10)
      }
    }
    entity = entity.replace(/^0+/, "")
    if (numStr.toLowerCase() !== entity) {
      strictFail(parser, "Invalid character entity")
      return "&"+parser.entity + ";"
    }
  
    return String.fromCodePoint(num)
  }
  
  function write (chunk) {
    var parser = this
    if (this.error) throw this.error
    if (parser.closed) return error(parser,
      "Cannot write after close. Assign an onready handler.")
    if (chunk === null) return end(parser)
    var i = 0, c = ""
    while (parser.c = c = chunk.charAt(i++)) {
      if (parser.trackPosition) {
        parser.position ++
        if (c === "\n") {
          parser.line ++
          parser.column = 0
        } else parser.column ++
      }
      switch (parser.state) {
  
        case S.BEGIN:
          if (c === "<") {
            parser.state = S.OPEN_WAKA
            parser.startTagPosition = parser.position
          } else if (not(whitespace,c)) {
            // have to process this as a text node.
            // weird, but happens.
            strictFail(parser, "Non-whitespace before first tag.")
            parser.textNode = c
            parser.state = S.TEXT
          }
        continue
  
        case S.TEXT:
          if (parser.sawRoot && !parser.closedRoot) {
            var starti = i-1
            while (c && c!=="<" && c!=="&") {
              c = chunk.charAt(i++)
              if (c && parser.trackPosition) {
                parser.position ++
                if (c === "\n") {
                  parser.line ++
                  parser.column = 0
                } else parser.column ++
              }
            }
            parser.textNode += chunk.substring(starti, i-1)
          }
          if (c === "<") {
            parser.state = S.OPEN_WAKA
            parser.startTagPosition = parser.position
          } else {
            if (not(whitespace, c) && (!parser.sawRoot || parser.closedRoot))
              strictFail(parser, "Text data outside of root node.")
            if (c === "&") parser.state = S.TEXT_ENTITY
            else parser.textNode += c
          }
        continue
  
        case S.SCRIPT:
          // only non-strict
          if (c === "<") {
            parser.state = S.SCRIPT_ENDING
          } else parser.script += c
        continue
  
        case S.SCRIPT_ENDING:
          if (c === "/") {
            parser.state = S.CLOSE_TAG
          } else {
            parser.script += "<" + c
            parser.state = S.SCRIPT
          }
        continue
  
        case S.OPEN_WAKA:
          // either a /, ?, !, or text is coming next.
          if (c === "!") {
            parser.state = S.SGML_DECL
            parser.sgmlDecl = ""
          } else if (is(whitespace, c)) {
            // wait for it...
          } else if (is(nameStart,c)) {
            parser.state = S.OPEN_TAG
            parser.tagName = c
          } else if (c === "/") {
            parser.state = S.CLOSE_TAG
            parser.tagName = ""
          } else if (c === "?") {
            parser.state = S.PROC_INST
            parser.procInstName = parser.procInstBody = ""
          } else {
            strictFail(parser, "Unencoded <")
            // if there was some whitespace, then add that in.
            if (parser.startTagPosition + 1 < parser.position) {
              var pad = parser.position - parser.startTagPosition
              c = new Array(pad).join(" ") + c
            }
            parser.textNode += "<" + c
            parser.state = S.TEXT
          }
        continue
  
        case S.SGML_DECL:
          if ((parser.sgmlDecl+c).toUpperCase() === CDATA) {
            emitNode(parser, "onopencdata")
            parser.state = S.CDATA
            parser.sgmlDecl = ""
            parser.cdata = ""
          } else if (parser.sgmlDecl+c === "--") {
            parser.state = S.COMMENT
            parser.comment = ""
            parser.sgmlDecl = ""
          } else if ((parser.sgmlDecl+c).toUpperCase() === DOCTYPE) {
            parser.state = S.DOCTYPE
            if (parser.doctype || parser.sawRoot) strictFail(parser,
              "Inappropriately located doctype declaration")
            parser.doctype = ""
            parser.sgmlDecl = ""
          } else if (c === ">") {
            emitNode(parser, "onsgmldeclaration", parser.sgmlDecl)
            parser.sgmlDecl = ""
            parser.state = S.TEXT
          } else if (is(quote, c)) {
            parser.state = S.SGML_DECL_QUOTED
            parser.sgmlDecl += c
          } else parser.sgmlDecl += c
        continue
  
        case S.SGML_DECL_QUOTED:
          if (c === parser.q) {
            parser.state = S.SGML_DECL
            parser.q = ""
          }
          parser.sgmlDecl += c
        continue
  
        case S.DOCTYPE:
          if (c === ">") {
            parser.state = S.TEXT
            emitNode(parser, "ondoctype", parser.doctype)
            parser.doctype = true // just remember that we saw it.
          } else {
            parser.doctype += c
            if (c === "[") parser.state = S.DOCTYPE_DTD
            else if (is(quote, c)) {
              parser.state = S.DOCTYPE_QUOTED
              parser.q = c
            }
          }
        continue
  
        case S.DOCTYPE_QUOTED:
          parser.doctype += c
          if (c === parser.q) {
            parser.q = ""
            parser.state = S.DOCTYPE
          }
        continue
  
        case S.DOCTYPE_DTD:
          parser.doctype += c
          if (c === "]") parser.state = S.DOCTYPE
          else if (is(quote,c)) {
            parser.state = S.DOCTYPE_DTD_QUOTED
            parser.q = c
          }
        continue
  
        case S.DOCTYPE_DTD_QUOTED:
          parser.doctype += c
          if (c === parser.q) {
            parser.state = S.DOCTYPE_DTD
            parser.q = ""
          }
        continue
  
        case S.COMMENT:
          if (c === "-") parser.state = S.COMMENT_ENDING
          else parser.comment += c
        continue
  
        case S.COMMENT_ENDING:
          if (c === "-") {
            parser.state = S.COMMENT_ENDED
            parser.comment = textopts(parser.opt, parser.comment)
            if (parser.comment) emitNode(parser, "oncomment", parser.comment)
            parser.comment = ""
          } else {
            parser.comment += "-" + c
            parser.state = S.COMMENT
          }
        continue
  
        case S.COMMENT_ENDED:
          if (c !== ">") {
            strictFail(parser, "Malformed comment")
            // allow <!-- blah -- bloo --> in non-strict mode,
            // which is a comment of " blah -- bloo "
            parser.comment += "--" + c
            parser.state = S.COMMENT
          } else parser.state = S.TEXT
        continue
  
        case S.CDATA:
          if (c === "]") parser.state = S.CDATA_ENDING
          else parser.cdata += c
        continue
  
        case S.CDATA_ENDING:
          if (c === "]") parser.state = S.CDATA_ENDING_2
          else {
            parser.cdata += "]" + c
            parser.state = S.CDATA
          }
        continue
  
        case S.CDATA_ENDING_2:
          if (c === ">") {
            if (parser.cdata) emitNode(parser, "oncdata", parser.cdata)
            emitNode(parser, "onclosecdata")
            parser.cdata = ""
            parser.state = S.TEXT
          } else if (c === "]") {
            parser.cdata += "]"
          } else {
            parser.cdata += "]]" + c
            parser.state = S.CDATA
          }
        continue
  
        case S.PROC_INST:
          if (c === "?") parser.state = S.PROC_INST_ENDING
          else if (is(whitespace, c)) parser.state = S.PROC_INST_BODY
          else parser.procInstName += c
        continue
  
        case S.PROC_INST_BODY:
          if (!parser.procInstBody && is(whitespace, c)) continue
          else if (c === "?") parser.state = S.PROC_INST_ENDING
          else parser.procInstBody += c
        continue
  
        case S.PROC_INST_ENDING:
          if (c === ">") {
            emitNode(parser, "onprocessinginstruction", {
              name : parser.procInstName,
              body : parser.procInstBody
            })
            parser.procInstName = parser.procInstBody = ""
            parser.state = S.TEXT
          } else {
            parser.procInstBody += "?" + c
            parser.state = S.PROC_INST_BODY
          }
        continue
  
        case S.OPEN_TAG:
          if (is(nameBody, c)) parser.tagName += c
          else {
            newTag(parser)
            if (c === ">") openTag(parser)
            else if (c === "/") parser.state = S.OPEN_TAG_SLASH
            else {
              if (not(whitespace, c)) strictFail(
                parser, "Invalid character in tag name")
              parser.state = S.ATTRIB
            }
          }
        continue
  
        case S.OPEN_TAG_SLASH:
          if (c === ">") {
            openTag(parser, true)
            closeTag(parser)
          } else {
            strictFail(parser, "Forward-slash in opening tag not followed by >")
            parser.state = S.ATTRIB
          }
        continue
  
        case S.ATTRIB:
          // haven't read the attribute name yet.
          if (is(whitespace, c)) continue
          else if (c === ">") openTag(parser)
          else if (c === "/") parser.state = S.OPEN_TAG_SLASH
          else if (is(nameStart, c)) {
            parser.attribName = c
            parser.attribValue = ""
            parser.state = S.ATTRIB_NAME
          } else strictFail(parser, "Invalid attribute name")
        continue
  
        case S.ATTRIB_NAME:
          if (c === "=") parser.state = S.ATTRIB_VALUE
          else if (c === ">") {
            strictFail(parser, "Attribute without value")
            parser.attribValue = parser.attribName
            attrib(parser)
            openTag(parser)
          }
          else if (is(whitespace, c)) parser.state = S.ATTRIB_NAME_SAW_WHITE
          else if (is(nameBody, c)) parser.attribName += c
          else strictFail(parser, "Invalid attribute name")
        continue
  
        case S.ATTRIB_NAME_SAW_WHITE:
          if (c === "=") parser.state = S.ATTRIB_VALUE
          else if (is(whitespace, c)) continue
          else {
            strictFail(parser, "Attribute without value")
            parser.tag.attributes[parser.attribName] = ""
            parser.attribValue = ""
            emitNode(parser, "onattribute",
                     { name : parser.attribName, value : "" })
            parser.attribName = ""
            if (c === ">") openTag(parser)
            else if (is(nameStart, c)) {
              parser.attribName = c
              parser.state = S.ATTRIB_NAME
            } else {
              strictFail(parser, "Invalid attribute name")
              parser.state = S.ATTRIB
            }
          }
        continue
  
        case S.ATTRIB_VALUE:
          if (is(whitespace, c)) continue
          else if (is(quote, c)) {
            parser.q = c
            parser.state = S.ATTRIB_VALUE_QUOTED
          } else {
            strictFail(parser, "Unquoted attribute value")
            parser.state = S.ATTRIB_VALUE_UNQUOTED
            parser.attribValue = c
          }
        continue
  
        case S.ATTRIB_VALUE_QUOTED:
          if (c !== parser.q) {
            if (c === "&") parser.state = S.ATTRIB_VALUE_ENTITY_Q
            else parser.attribValue += c
            continue
          }
          attrib(parser)
          parser.q = ""
          parser.state = S.ATTRIB_VALUE_CLOSED
        continue
  
        case S.ATTRIB_VALUE_CLOSED:
          if (is(whitespace, c)) {
            parser.state = S.ATTRIB
          } else if (c === ">") openTag(parser)
          else if (c === "/") parser.state = S.OPEN_TAG_SLASH
          else if (is(nameStart, c)) {
            strictFail(parser, "No whitespace between attributes")
            parser.attribName = c
            parser.attribValue = ""
            parser.state = S.ATTRIB_NAME
          } else strictFail(parser, "Invalid attribute name")
        continue
  
        case S.ATTRIB_VALUE_UNQUOTED:
          if (not(attribEnd,c)) {
            if (c === "&") parser.state = S.ATTRIB_VALUE_ENTITY_U
            else parser.attribValue += c
            continue
          }
          attrib(parser)
          if (c === ">") openTag(parser)
          else parser.state = S.ATTRIB
        continue
  
        case S.CLOSE_TAG:
          if (!parser.tagName) {
            if (is(whitespace, c)) continue
            else if (not(nameStart, c)) {
              if (parser.script) {
                parser.script += "</" + c
                parser.state = S.SCRIPT
              } else {
                strictFail(parser, "Invalid tagname in closing tag.")
              }
            } else parser.tagName = c
          }
          else if (c === ">") closeTag(parser)
          else if (is(nameBody, c)) parser.tagName += c
          else if (parser.script) {
            parser.script += "</" + parser.tagName
            parser.tagName = ""
            parser.state = S.SCRIPT
          } else {
            if (not(whitespace, c)) strictFail(parser,
              "Invalid tagname in closing tag")
            parser.state = S.CLOSE_TAG_SAW_WHITE
          }
        continue
  
        case S.CLOSE_TAG_SAW_WHITE:
          if (is(whitespace, c)) continue
          if (c === ">") closeTag(parser)
          else strictFail(parser, "Invalid characters in closing tag")
        continue
  
        case S.TEXT_ENTITY:
        case S.ATTRIB_VALUE_ENTITY_Q:
        case S.ATTRIB_VALUE_ENTITY_U:
          switch(parser.state) {
            case S.TEXT_ENTITY:
              var returnState = S.TEXT, buffer = "textNode"
            break
  
            case S.ATTRIB_VALUE_ENTITY_Q:
              var returnState = S.ATTRIB_VALUE_QUOTED, buffer = "attribValue"
            break
  
            case S.ATTRIB_VALUE_ENTITY_U:
              var returnState = S.ATTRIB_VALUE_UNQUOTED, buffer = "attribValue"
            break
          }
          if (c === ";") {
            parser[buffer] += parseEntity(parser)
            parser.entity = ""
            parser.state = returnState
          }
          else if (is(entity, c)) parser.entity += c
          else {
            strictFail(parser, "Invalid character entity")
            parser[buffer] += "&" + parser.entity + c
            parser.entity = ""
            parser.state = returnState
          }
        continue
  
        default:
          throw new Error(parser, "Unknown state: " + parser.state)
      }
    } // while
    // cdata blocks can get very big under normal conditions. emit and move on.
    // if (parser.state === S.CDATA && parser.cdata) {
    //   emitNode(parser, "oncdata", parser.cdata)
    //   parser.cdata = ""
    // }
    if (parser.position >= parser.bufferCheckPosition) checkBufferLength(parser)
    return parser
  }
  
  /*! http://mths.be/fromcodepoint v0.1.0 by @mathias */
  if (!String.fromCodePoint) {
          (function() {
                  var stringFromCharCode = String.fromCharCode;
                  var floor = Math.floor;
                  var fromCodePoint = function() {
                          var MAX_SIZE = 0x4000;
                          var codeUnits = [];
                          var highSurrogate;
                          var lowSurrogate;
                          var index = -1;
                          var length = arguments.length;
                          if (!length) {
                                  return '';
                          }
                          var result = '';
                          while (++index < length) {
                                  var codePoint = Number(arguments[index]);
                                  if (
                                          !isFinite(codePoint) || // `NaN`, `+Infinity`, or `-Infinity`
                                          codePoint < 0 || // not a valid Unicode code point
                                          codePoint > 0x10FFFF || // not a valid Unicode code point
                                          floor(codePoint) != codePoint // not an integer
                                  ) {
                                          throw RangeError('Invalid code point: ' + codePoint);
                                  }
                                  if (codePoint <= 0xFFFF) { // BMP code point
                                          codeUnits.push(codePoint);
                                  } else { // Astral code point; split in surrogate halves
                                          // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
                                          codePoint -= 0x10000;
                                          highSurrogate = (codePoint >> 10) + 0xD800;
                                          lowSurrogate = (codePoint % 0x400) + 0xDC00;
                                          codeUnits.push(highSurrogate, lowSurrogate);
                                  }
                                  if (index + 1 == length || codeUnits.length > MAX_SIZE) {
                                          result += stringFromCharCode.apply(null, codeUnits);
                                          codeUnits.length = 0;
                                  }
                          }
                          return result;
                  };
                  if (Object.defineProperty) {
                          Object.defineProperty(String, 'fromCodePoint', {
                                  'value': fromCodePoint,
                                  'configurable': true,
                                  'writable': true
                          });
                  } else {
                          String.fromCodePoint = fromCodePoint;
                  }
          }());
  }
  
  })(typeof exports === "undefined" ? sax = {} : exports);
  
  }).call(this,undefined)
  //# sourceMappingURL=data:application/json;charset:utf-8;base64,{"version":3,"sources":["node_modules/bpmn-moddle/node_modules/moddle-xml/node_modules/sax/lib/sax.js"],"names":[],"mappings":";AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["// wrapper for non-node envs\n;(function (sax) {\n\nsax.parser = function (strict, opt) { return new SAXParser(strict, opt) }\nsax.SAXParser = SAXParser\nsax.SAXStream = SAXStream\nsax.createStream = createStream\n\n// When we pass the MAX_BUFFER_LENGTH position, start checking for buffer overruns.\n// When we check, schedule the next check for MAX_BUFFER_LENGTH - (max(buffer lengths)),\n// since that's the earliest that a buffer overrun could occur.  This way, checks are\n// as rare as required, but as often as necessary to ensure never crossing this bound.\n// Furthermore, buffers are only tested at most once per write(), so passing a very\n// large string into write() might have undesirable effects, but this is manageable by\n// the caller, so it is assumed to be safe.  Thus, a call to write() may, in the extreme\n// edge case, result in creating at most one complete copy of the string passed in.\n// Set to Infinity to have unlimited buffers.\nsax.MAX_BUFFER_LENGTH = 64 * 1024\n\nvar buffers = [\n  \"comment\", \"sgmlDecl\", \"textNode\", \"tagName\", \"doctype\",\n  \"procInstName\", \"procInstBody\", \"entity\", \"attribName\",\n  \"attribValue\", \"cdata\", \"script\"\n]\n\nsax.EVENTS = // for discoverability.\n  [ \"text\"\n  , \"processinginstruction\"\n  , \"sgmldeclaration\"\n  , \"doctype\"\n  , \"comment\"\n  , \"attribute\"\n  , \"opentag\"\n  , \"closetag\"\n  , \"opencdata\"\n  , \"cdata\"\n  , \"closecdata\"\n  , \"error\"\n  , \"end\"\n  , \"ready\"\n  , \"script\"\n  , \"opennamespace\"\n  , \"closenamespace\"\n  ]\n\nfunction SAXParser (strict, opt) {\n  if (!(this instanceof SAXParser)) return new SAXParser(strict, opt)\n\n  var parser = this\n  clearBuffers(parser)\n  parser.q = parser.c = \"\"\n  parser.bufferCheckPosition = sax.MAX_BUFFER_LENGTH\n  parser.opt = opt || {}\n  parser.opt.lowercase = parser.opt.lowercase || parser.opt.lowercasetags\n  parser.looseCase = parser.opt.lowercase ? \"toLowerCase\" : \"toUpperCase\"\n  parser.tags = []\n  parser.closed = parser.closedRoot = parser.sawRoot = false\n  parser.tag = parser.error = null\n  parser.strict = !!strict\n  parser.noscript = !!(strict || parser.opt.noscript)\n  parser.state = S.BEGIN\n  parser.ENTITIES = Object.create(sax.ENTITIES)\n  parser.attribList = []\n\n  // namespaces form a prototype chain.\n  // it always points at the current tag,\n  // which protos to its parent tag.\n  if (parser.opt.xmlns) parser.ns = Object.create(rootNS)\n\n  // mostly just for error reporting\n  parser.trackPosition = parser.opt.position !== false\n  if (parser.trackPosition) {\n    parser.position = parser.line = parser.column = 0\n  }\n  emit(parser, \"onready\")\n}\n\nif (!Object.create) Object.create = function (o) {\n  function f () { this.__proto__ = o }\n  f.prototype = o\n  return new f\n}\n\nif (!Object.getPrototypeOf) Object.getPrototypeOf = function (o) {\n  return o.__proto__\n}\n\nif (!Object.keys) Object.keys = function (o) {\n  var a = []\n  for (var i in o) if (o.hasOwnProperty(i)) a.push(i)\n  return a\n}\n\nfunction checkBufferLength (parser) {\n  var maxAllowed = Math.max(sax.MAX_BUFFER_LENGTH, 10)\n    , maxActual = 0\n  for (var i = 0, l = buffers.length; i < l; i ++) {\n    var len = parser[buffers[i]].length\n    if (len > maxAllowed) {\n      // Text/cdata nodes can get big, and since they're buffered,\n      // we can get here under normal conditions.\n      // Avoid issues by emitting the text node now,\n      // so at least it won't get any bigger.\n      switch (buffers[i]) {\n        case \"textNode\":\n          closeText(parser)\n        break\n\n        case \"cdata\":\n          emitNode(parser, \"oncdata\", parser.cdata)\n          parser.cdata = \"\"\n        break\n\n        case \"script\":\n          emitNode(parser, \"onscript\", parser.script)\n          parser.script = \"\"\n        break\n\n        default:\n          error(parser, \"Max buffer length exceeded: \"+buffers[i])\n      }\n    }\n    maxActual = Math.max(maxActual, len)\n  }\n  // schedule the next check for the earliest possible buffer overrun.\n  parser.bufferCheckPosition = (sax.MAX_BUFFER_LENGTH - maxActual)\n                             + parser.position\n}\n\nfunction clearBuffers (parser) {\n  for (var i = 0, l = buffers.length; i < l; i ++) {\n    parser[buffers[i]] = \"\"\n  }\n}\n\nfunction flushBuffers (parser) {\n  closeText(parser)\n  if (parser.cdata !== \"\") {\n    emitNode(parser, \"oncdata\", parser.cdata)\n    parser.cdata = \"\"\n  }\n  if (parser.script !== \"\") {\n    emitNode(parser, \"onscript\", parser.script)\n    parser.script = \"\"\n  }\n}\n\nSAXParser.prototype =\n  { end: function () { end(this) }\n  , write: write\n  , resume: function () { this.error = null; return this }\n  , close: function () { return this.write(null) }\n  , flush: function () { flushBuffers(this) }\n  }\n\ntry {\n  var Stream = require(\"stream\").Stream\n} catch (ex) {\n  var Stream = function () {}\n}\n\n\nvar streamWraps = sax.EVENTS.filter(function (ev) {\n  return ev !== \"error\" && ev !== \"end\"\n})\n\nfunction createStream (strict, opt) {\n  return new SAXStream(strict, opt)\n}\n\nfunction SAXStream (strict, opt) {\n  if (!(this instanceof SAXStream)) return new SAXStream(strict, opt)\n\n  Stream.apply(this)\n\n  this._parser = new SAXParser(strict, opt)\n  this.writable = true\n  this.readable = true\n\n\n  var me = this\n\n  this._parser.onend = function () {\n    me.emit(\"end\")\n  }\n\n  this._parser.onerror = function (er) {\n    me.emit(\"error\", er)\n\n    // if didn't throw, then means error was handled.\n    // go ahead and clear error, so we can write again.\n    me._parser.error = null\n  }\n\n  this._decoder = null;\n\n  streamWraps.forEach(function (ev) {\n    Object.defineProperty(me, \"on\" + ev, {\n      get: function () { return me._parser[\"on\" + ev] },\n      set: function (h) {\n        if (!h) {\n          me.removeAllListeners(ev)\n          return me._parser[\"on\"+ev] = h\n        }\n        me.on(ev, h)\n      },\n      enumerable: true,\n      configurable: false\n    })\n  })\n}\n\nSAXStream.prototype = Object.create(Stream.prototype,\n  { constructor: { value: SAXStream } })\n\nSAXStream.prototype.write = function (data) {\n  if (typeof Buffer === 'function' &&\n      typeof Buffer.isBuffer === 'function' &&\n      Buffer.isBuffer(data)) {\n    if (!this._decoder) {\n      var SD = require('string_decoder').StringDecoder\n      this._decoder = new SD('utf8')\n    }\n    data = this._decoder.write(data);\n  }\n\n  this._parser.write(data.toString())\n  this.emit(\"data\", data)\n  return true\n}\n\nSAXStream.prototype.end = function (chunk) {\n  if (chunk && chunk.length) this.write(chunk)\n  this._parser.end()\n  return true\n}\n\nSAXStream.prototype.on = function (ev, handler) {\n  var me = this\n  if (!me._parser[\"on\"+ev] && streamWraps.indexOf(ev) !== -1) {\n    me._parser[\"on\"+ev] = function () {\n      var args = arguments.length === 1 ? [arguments[0]]\n               : Array.apply(null, arguments)\n      args.splice(0, 0, ev)\n      me.emit.apply(me, args)\n    }\n  }\n\n  return Stream.prototype.on.call(me, ev, handler)\n}\n\n\n\n// character classes and tokens\nvar whitespace = \"\\r\\n\\t \"\n  // this really needs to be replaced with character classes.\n  // XML allows all manner of ridiculous numbers and digits.\n  , number = \"0124356789\"\n  , letter = \"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\"\n  // (Letter | \"_\" | \":\")\n  , quote = \"'\\\"\"\n  , entity = number+letter+\"#\"\n  , attribEnd = whitespace + \">\"\n  , CDATA = \"[CDATA[\"\n  , DOCTYPE = \"DOCTYPE\"\n  , XML_NAMESPACE = \"http://www.w3.org/XML/1998/namespace\"\n  , XMLNS_NAMESPACE = \"http://www.w3.org/2000/xmlns/\"\n  , rootNS = { xml: XML_NAMESPACE, xmlns: XMLNS_NAMESPACE }\n\n// turn all the string character sets into character class objects.\nwhitespace = charClass(whitespace)\nnumber = charClass(number)\nletter = charClass(letter)\n\n// http://www.w3.org/TR/REC-xml/#NT-NameStartChar\n// This implementation works on strings, a single character at a time\n// as such, it cannot ever support astral-plane characters (10000-EFFFF)\n// without a significant breaking change to either this  parser, or the\n// JavaScript language.  Implementation of an emoji-capable xml parser\n// is left as an exercise for the reader.\nvar nameStart = /[:_A-Za-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD]/\n\nvar nameBody = /[:_A-Za-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\u00B7\\u0300-\\u036F\\u203F-\\u2040\\.\\d-]/\n\nquote = charClass(quote)\nentity = charClass(entity)\nattribEnd = charClass(attribEnd)\n\nfunction charClass (str) {\n  return str.split(\"\").reduce(function (s, c) {\n    s[c] = true\n    return s\n  }, {})\n}\n\nfunction isRegExp (c) {\n  return Object.prototype.toString.call(c) === '[object RegExp]'\n}\n\nfunction is (charclass, c) {\n  return isRegExp(charclass) ? !!c.match(charclass) : charclass[c]\n}\n\nfunction not (charclass, c) {\n  return !is(charclass, c)\n}\n\nvar S = 0\nsax.STATE =\n{ BEGIN                     : S++\n, TEXT                      : S++ // general stuff\n, TEXT_ENTITY               : S++ // &amp and such.\n, OPEN_WAKA                 : S++ // <\n, SGML_DECL                 : S++ // <!BLARG\n, SGML_DECL_QUOTED          : S++ // <!BLARG foo \"bar\n, DOCTYPE                   : S++ // <!DOCTYPE\n, DOCTYPE_QUOTED            : S++ // <!DOCTYPE \"//blah\n, DOCTYPE_DTD               : S++ // <!DOCTYPE \"//blah\" [ ...\n, DOCTYPE_DTD_QUOTED        : S++ // <!DOCTYPE \"//blah\" [ \"foo\n, COMMENT_STARTING          : S++ // <!-\n, COMMENT                   : S++ // <!--\n, COMMENT_ENDING            : S++ // <!-- blah -\n, COMMENT_ENDED             : S++ // <!-- blah --\n, CDATA                     : S++ // <![CDATA[ something\n, CDATA_ENDING              : S++ // ]\n, CDATA_ENDING_2            : S++ // ]]\n, PROC_INST                 : S++ // <?hi\n, PROC_INST_BODY            : S++ // <?hi there\n, PROC_INST_ENDING          : S++ // <?hi \"there\" ?\n, OPEN_TAG                  : S++ // <strong\n, OPEN_TAG_SLASH            : S++ // <strong /\n, ATTRIB                    : S++ // <a\n, ATTRIB_NAME               : S++ // <a foo\n, ATTRIB_NAME_SAW_WHITE     : S++ // <a foo _\n, ATTRIB_VALUE              : S++ // <a foo=\n, ATTRIB_VALUE_QUOTED       : S++ // <a foo=\"bar\n, ATTRIB_VALUE_CLOSED       : S++ // <a foo=\"bar\"\n, ATTRIB_VALUE_UNQUOTED     : S++ // <a foo=bar\n, ATTRIB_VALUE_ENTITY_Q     : S++ // <foo bar=\"&quot;\"\n, ATTRIB_VALUE_ENTITY_U     : S++ // <foo bar=&quot;\n, CLOSE_TAG                 : S++ // </a\n, CLOSE_TAG_SAW_WHITE       : S++ // </a   >\n, SCRIPT                    : S++ // <script> ...\n, SCRIPT_ENDING             : S++ // <script> ... <\n}\n\nsax.ENTITIES =\n{ \"amp\" : \"&\"\n, \"gt\" : \">\"\n, \"lt\" : \"<\"\n, \"quot\" : \"\\\"\"\n, \"apos\" : \"'\"\n, \"AElig\" : 198\n, \"Aacute\" : 193\n, \"Acirc\" : 194\n, \"Agrave\" : 192\n, \"Aring\" : 197\n, \"Atilde\" : 195\n, \"Auml\" : 196\n, \"Ccedil\" : 199\n, \"ETH\" : 208\n, \"Eacute\" : 201\n, \"Ecirc\" : 202\n, \"Egrave\" : 200\n, \"Euml\" : 203\n, \"Iacute\" : 205\n, \"Icirc\" : 206\n, \"Igrave\" : 204\n, \"Iuml\" : 207\n, \"Ntilde\" : 209\n, \"Oacute\" : 211\n, \"Ocirc\" : 212\n, \"Ograve\" : 210\n, \"Oslash\" : 216\n, \"Otilde\" : 213\n, \"Ouml\" : 214\n, \"THORN\" : 222\n, \"Uacute\" : 218\n, \"Ucirc\" : 219\n, \"Ugrave\" : 217\n, \"Uuml\" : 220\n, \"Yacute\" : 221\n, \"aacute\" : 225\n, \"acirc\" : 226\n, \"aelig\" : 230\n, \"agrave\" : 224\n, \"aring\" : 229\n, \"atilde\" : 227\n, \"auml\" : 228\n, \"ccedil\" : 231\n, \"eacute\" : 233\n, \"ecirc\" : 234\n, \"egrave\" : 232\n, \"eth\" : 240\n, \"euml\" : 235\n, \"iacute\" : 237\n, \"icirc\" : 238\n, \"igrave\" : 236\n, \"iuml\" : 239\n, \"ntilde\" : 241\n, \"oacute\" : 243\n, \"ocirc\" : 244\n, \"ograve\" : 242\n, \"oslash\" : 248\n, \"otilde\" : 245\n, \"ouml\" : 246\n, \"szlig\" : 223\n, \"thorn\" : 254\n, \"uacute\" : 250\n, \"ucirc\" : 251\n, \"ugrave\" : 249\n, \"uuml\" : 252\n, \"yacute\" : 253\n, \"yuml\" : 255\n, \"copy\" : 169\n, \"reg\" : 174\n, \"nbsp\" : 160\n, \"iexcl\" : 161\n, \"cent\" : 162\n, \"pound\" : 163\n, \"curren\" : 164\n, \"yen\" : 165\n, \"brvbar\" : 166\n, \"sect\" : 167\n, \"uml\" : 168\n, \"ordf\" : 170\n, \"laquo\" : 171\n, \"not\" : 172\n, \"shy\" : 173\n, \"macr\" : 175\n, \"deg\" : 176\n, \"plusmn\" : 177\n, \"sup1\" : 185\n, \"sup2\" : 178\n, \"sup3\" : 179\n, \"acute\" : 180\n, \"micro\" : 181\n, \"para\" : 182\n, \"middot\" : 183\n, \"cedil\" : 184\n, \"ordm\" : 186\n, \"raquo\" : 187\n, \"frac14\" : 188\n, \"frac12\" : 189\n, \"frac34\" : 190\n, \"iquest\" : 191\n, \"times\" : 215\n, \"divide\" : 247\n, \"OElig\" : 338\n, \"oelig\" : 339\n, \"Scaron\" : 352\n, \"scaron\" : 353\n, \"Yuml\" : 376\n, \"fnof\" : 402\n, \"circ\" : 710\n, \"tilde\" : 732\n, \"Alpha\" : 913\n, \"Beta\" : 914\n, \"Gamma\" : 915\n, \"Delta\" : 916\n, \"Epsilon\" : 917\n, \"Zeta\" : 918\n, \"Eta\" : 919\n, \"Theta\" : 920\n, \"Iota\" : 921\n, \"Kappa\" : 922\n, \"Lambda\" : 923\n, \"Mu\" : 924\n, \"Nu\" : 925\n, \"Xi\" : 926\n, \"Omicron\" : 927\n, \"Pi\" : 928\n, \"Rho\" : 929\n, \"Sigma\" : 931\n, \"Tau\" : 932\n, \"Upsilon\" : 933\n, \"Phi\" : 934\n, \"Chi\" : 935\n, \"Psi\" : 936\n, \"Omega\" : 937\n, \"alpha\" : 945\n, \"beta\" : 946\n, \"gamma\" : 947\n, \"delta\" : 948\n, \"epsilon\" : 949\n, \"zeta\" : 950\n, \"eta\" : 951\n, \"theta\" : 952\n, \"iota\" : 953\n, \"kappa\" : 954\n, \"lambda\" : 955\n, \"mu\" : 956\n, \"nu\" : 957\n, \"xi\" : 958\n, \"omicron\" : 959\n, \"pi\" : 960\n, \"rho\" : 961\n, \"sigmaf\" : 962\n, \"sigma\" : 963\n, \"tau\" : 964\n, \"upsilon\" : 965\n, \"phi\" : 966\n, \"chi\" : 967\n, \"psi\" : 968\n, \"omega\" : 969\n, \"thetasym\" : 977\n, \"upsih\" : 978\n, \"piv\" : 982\n, \"ensp\" : 8194\n, \"emsp\" : 8195\n, \"thinsp\" : 8201\n, \"zwnj\" : 8204\n, \"zwj\" : 8205\n, \"lrm\" : 8206\n, \"rlm\" : 8207\n, \"ndash\" : 8211\n, \"mdash\" : 8212\n, \"lsquo\" : 8216\n, \"rsquo\" : 8217\n, \"sbquo\" : 8218\n, \"ldquo\" : 8220\n, \"rdquo\" : 8221\n, \"bdquo\" : 8222\n, \"dagger\" : 8224\n, \"Dagger\" : 8225\n, \"bull\" : 8226\n, \"hellip\" : 8230\n, \"permil\" : 8240\n, \"prime\" : 8242\n, \"Prime\" : 8243\n, \"lsaquo\" : 8249\n, \"rsaquo\" : 8250\n, \"oline\" : 8254\n, \"frasl\" : 8260\n, \"euro\" : 8364\n, \"image\" : 8465\n, \"weierp\" : 8472\n, \"real\" : 8476\n, \"trade\" : 8482\n, \"alefsym\" : 8501\n, \"larr\" : 8592\n, \"uarr\" : 8593\n, \"rarr\" : 8594\n, \"darr\" : 8595\n, \"harr\" : 8596\n, \"crarr\" : 8629\n, \"lArr\" : 8656\n, \"uArr\" : 8657\n, \"rArr\" : 8658\n, \"dArr\" : 8659\n, \"hArr\" : 8660\n, \"forall\" : 8704\n, \"part\" : 8706\n, \"exist\" : 8707\n, \"empty\" : 8709\n, \"nabla\" : 8711\n, \"isin\" : 8712\n, \"notin\" : 8713\n, \"ni\" : 8715\n, \"prod\" : 8719\n, \"sum\" : 8721\n, \"minus\" : 8722\n, \"lowast\" : 8727\n, \"radic\" : 8730\n, \"prop\" : 8733\n, \"infin\" : 8734\n, \"ang\" : 8736\n, \"and\" : 8743\n, \"or\" : 8744\n, \"cap\" : 8745\n, \"cup\" : 8746\n, \"int\" : 8747\n, \"there4\" : 8756\n, \"sim\" : 8764\n, \"cong\" : 8773\n, \"asymp\" : 8776\n, \"ne\" : 8800\n, \"equiv\" : 8801\n, \"le\" : 8804\n, \"ge\" : 8805\n, \"sub\" : 8834\n, \"sup\" : 8835\n, \"nsub\" : 8836\n, \"sube\" : 8838\n, \"supe\" : 8839\n, \"oplus\" : 8853\n, \"otimes\" : 8855\n, \"perp\" : 8869\n, \"sdot\" : 8901\n, \"lceil\" : 8968\n, \"rceil\" : 8969\n, \"lfloor\" : 8970\n, \"rfloor\" : 8971\n, \"lang\" : 9001\n, \"rang\" : 9002\n, \"loz\" : 9674\n, \"spades\" : 9824\n, \"clubs\" : 9827\n, \"hearts\" : 9829\n, \"diams\" : 9830\n}\n\nObject.keys(sax.ENTITIES).forEach(function (key) {\n    var e = sax.ENTITIES[key]\n    var s = typeof e === 'number' ? String.fromCharCode(e) : e\n    sax.ENTITIES[key] = s\n})\n\nfor (var S in sax.STATE) sax.STATE[sax.STATE[S]] = S\n\n// shorthand\nS = sax.STATE\n\nfunction emit (parser, event, data) {\n  parser[event] && parser[event](data)\n}\n\nfunction emitNode (parser, nodeType, data) {\n  if (parser.textNode) closeText(parser)\n  emit(parser, nodeType, data)\n}\n\nfunction closeText (parser) {\n  parser.textNode = textopts(parser.opt, parser.textNode)\n  if (parser.textNode) emit(parser, \"ontext\", parser.textNode)\n  parser.textNode = \"\"\n}\n\nfunction textopts (opt, text) {\n  if (opt.trim) text = text.trim()\n  if (opt.normalize) text = text.replace(/\\s+/g, \" \")\n  return text\n}\n\nfunction error (parser, er) {\n  closeText(parser)\n  if (parser.trackPosition) {\n    er += \"\\nLine: \"+parser.line+\n          \"\\nColumn: \"+parser.column+\n          \"\\nChar: \"+parser.c\n  }\n  er = new Error(er)\n  parser.error = er\n  emit(parser, \"onerror\", er)\n  return parser\n}\n\nfunction end (parser) {\n  if (!parser.closedRoot) strictFail(parser, \"Unclosed root tag\")\n  if ((parser.state !== S.BEGIN) && (parser.state !== S.TEXT)) error(parser, \"Unexpected end\")\n  closeText(parser)\n  parser.c = \"\"\n  parser.closed = true\n  emit(parser, \"onend\")\n  SAXParser.call(parser, parser.strict, parser.opt)\n  return parser\n}\n\nfunction strictFail (parser, message) {\n  if (typeof parser !== 'object' || !(parser instanceof SAXParser))\n    throw new Error('bad call to strictFail');\n  if (parser.strict) error(parser, message)\n}\n\nfunction newTag (parser) {\n  if (!parser.strict) parser.tagName = parser.tagName[parser.looseCase]()\n  var parent = parser.tags[parser.tags.length - 1] || parser\n    , tag = parser.tag = { name : parser.tagName, attributes : {} }\n\n  // will be overridden if tag contails an xmlns=\"foo\" or xmlns:foo=\"bar\"\n  if (parser.opt.xmlns) tag.ns = parent.ns\n  parser.attribList.length = 0\n}\n\nfunction qname (name, attribute) {\n  var i = name.indexOf(\":\")\n    , qualName = i < 0 ? [ \"\", name ] : name.split(\":\")\n    , prefix = qualName[0]\n    , local = qualName[1]\n\n  // <x \"xmlns\"=\"http://foo\">\n  if (attribute && name === \"xmlns\") {\n    prefix = \"xmlns\"\n    local = \"\"\n  }\n\n  return { prefix: prefix, local: local }\n}\n\nfunction attrib (parser) {\n  if (!parser.strict) parser.attribName = parser.attribName[parser.looseCase]()\n\n  if (parser.attribList.indexOf(parser.attribName) !== -1 ||\n      parser.tag.attributes.hasOwnProperty(parser.attribName)) {\n    return parser.attribName = parser.attribValue = \"\"\n  }\n\n  if (parser.opt.xmlns) {\n    var qn = qname(parser.attribName, true)\n      , prefix = qn.prefix\n      , local = qn.local\n\n    if (prefix === \"xmlns\") {\n      // namespace binding attribute; push the binding into scope\n      if (local === \"xml\" && parser.attribValue !== XML_NAMESPACE) {\n        strictFail( parser\n                  , \"xml: prefix must be bound to \" + XML_NAMESPACE + \"\\n\"\n                  + \"Actual: \" + parser.attribValue )\n      } else if (local === \"xmlns\" && parser.attribValue !== XMLNS_NAMESPACE) {\n        strictFail( parser\n                  , \"xmlns: prefix must be bound to \" + XMLNS_NAMESPACE + \"\\n\"\n                  + \"Actual: \" + parser.attribValue )\n      } else {\n        var tag = parser.tag\n          , parent = parser.tags[parser.tags.length - 1] || parser\n        if (tag.ns === parent.ns) {\n          tag.ns = Object.create(parent.ns)\n        }\n        tag.ns[local] = parser.attribValue\n      }\n    }\n\n    // defer onattribute events until all attributes have been seen\n    // so any new bindings can take effect; preserve attribute order\n    // so deferred events can be emitted in document order\n    parser.attribList.push([parser.attribName, parser.attribValue])\n  } else {\n    // in non-xmlns mode, we can emit the event right away\n    parser.tag.attributes[parser.attribName] = parser.attribValue\n    emitNode( parser\n            , \"onattribute\"\n            , { name: parser.attribName\n              , value: parser.attribValue } )\n  }\n\n  parser.attribName = parser.attribValue = \"\"\n}\n\nfunction openTag (parser, selfClosing) {\n  if (parser.opt.xmlns) {\n    // emit namespace binding events\n    var tag = parser.tag\n\n    // add namespace info to tag\n    var qn = qname(parser.tagName)\n    tag.prefix = qn.prefix\n    tag.local = qn.local\n    tag.uri = tag.ns[qn.prefix] || \"\"\n\n    if (tag.prefix && !tag.uri) {\n      strictFail(parser, \"Unbound namespace prefix: \"\n                       + JSON.stringify(parser.tagName))\n      tag.uri = qn.prefix\n    }\n\n    var parent = parser.tags[parser.tags.length - 1] || parser\n    if (tag.ns && parent.ns !== tag.ns) {\n      Object.keys(tag.ns).forEach(function (p) {\n        emitNode( parser\n                , \"onopennamespace\"\n                , { prefix: p , uri: tag.ns[p] } )\n      })\n    }\n\n    // handle deferred onattribute events\n    // Note: do not apply default ns to attributes:\n    //   http://www.w3.org/TR/REC-xml-names/#defaulting\n    for (var i = 0, l = parser.attribList.length; i < l; i ++) {\n      var nv = parser.attribList[i]\n      var name = nv[0]\n        , value = nv[1]\n        , qualName = qname(name, true)\n        , prefix = qualName.prefix\n        , local = qualName.local\n        , uri = prefix == \"\" ? \"\" : (tag.ns[prefix] || \"\")\n        , a = { name: name\n              , value: value\n              , prefix: prefix\n              , local: local\n              , uri: uri\n              }\n\n      // if there's any attributes with an undefined namespace,\n      // then fail on them now.\n      if (prefix && prefix != \"xmlns\" && !uri) {\n        strictFail(parser, \"Unbound namespace prefix: \"\n                         + JSON.stringify(prefix))\n        a.uri = prefix\n      }\n      parser.tag.attributes[name] = a\n      emitNode(parser, \"onattribute\", a)\n    }\n    parser.attribList.length = 0\n  }\n\n  parser.tag.isSelfClosing = !!selfClosing\n\n  // process the tag\n  parser.sawRoot = true\n  parser.tags.push(parser.tag)\n  emitNode(parser, \"onopentag\", parser.tag)\n  if (!selfClosing) {\n    // special case for <script> in non-strict mode.\n    if (!parser.noscript && parser.tagName.toLowerCase() === \"script\") {\n      parser.state = S.SCRIPT\n    } else {\n      parser.state = S.TEXT\n    }\n    parser.tag = null\n    parser.tagName = \"\"\n  }\n  parser.attribName = parser.attribValue = \"\"\n  parser.attribList.length = 0\n}\n\nfunction closeTag (parser) {\n  if (!parser.tagName) {\n    strictFail(parser, \"Weird empty close tag.\")\n    parser.textNode += \"</>\"\n    parser.state = S.TEXT\n    return\n  }\n\n  if (parser.script) {\n    if (parser.tagName !== \"script\") {\n      parser.script += \"</\" + parser.tagName + \">\"\n      parser.tagName = \"\"\n      parser.state = S.SCRIPT\n      return\n    }\n    emitNode(parser, \"onscript\", parser.script)\n    parser.script = \"\"\n  }\n\n  // first make sure that the closing tag actually exists.\n  // <a><b></c></b></a> will close everything, otherwise.\n  var t = parser.tags.length\n  var tagName = parser.tagName\n  if (!parser.strict) tagName = tagName[parser.looseCase]()\n  var closeTo = tagName\n  while (t --) {\n    var close = parser.tags[t]\n    if (close.name !== closeTo) {\n      // fail the first time in strict mode\n      strictFail(parser, \"Unexpected close tag\")\n    } else break\n  }\n\n  // didn't find it.  we already failed for strict, so just abort.\n  if (t < 0) {\n    strictFail(parser, \"Unmatched closing tag: \"+parser.tagName)\n    parser.textNode += \"</\" + parser.tagName + \">\"\n    parser.state = S.TEXT\n    return\n  }\n  parser.tagName = tagName\n  var s = parser.tags.length\n  while (s --> t) {\n    var tag = parser.tag = parser.tags.pop()\n    parser.tagName = parser.tag.name\n    emitNode(parser, \"onclosetag\", parser.tagName)\n\n    var x = {}\n    for (var i in tag.ns) x[i] = tag.ns[i]\n\n    var parent = parser.tags[parser.tags.length - 1] || parser\n    if (parser.opt.xmlns && tag.ns !== parent.ns) {\n      // remove namespace bindings introduced by tag\n      Object.keys(tag.ns).forEach(function (p) {\n        var n = tag.ns[p]\n        emitNode(parser, \"onclosenamespace\", { prefix: p, uri: n })\n      })\n    }\n  }\n  if (t === 0) parser.closedRoot = true\n  parser.tagName = parser.attribValue = parser.attribName = \"\"\n  parser.attribList.length = 0\n  parser.state = S.TEXT\n}\n\nfunction parseEntity (parser) {\n  var entity = parser.entity\n    , entityLC = entity.toLowerCase()\n    , num\n    , numStr = \"\"\n  if (parser.ENTITIES[entity])\n    return parser.ENTITIES[entity]\n  if (parser.ENTITIES[entityLC])\n    return parser.ENTITIES[entityLC]\n  entity = entityLC\n  if (entity.charAt(0) === \"#\") {\n    if (entity.charAt(1) === \"x\") {\n      entity = entity.slice(2)\n      num = parseInt(entity, 16)\n      numStr = num.toString(16)\n    } else {\n      entity = entity.slice(1)\n      num = parseInt(entity, 10)\n      numStr = num.toString(10)\n    }\n  }\n  entity = entity.replace(/^0+/, \"\")\n  if (numStr.toLowerCase() !== entity) {\n    strictFail(parser, \"Invalid character entity\")\n    return \"&\"+parser.entity + \";\"\n  }\n\n  return String.fromCodePoint(num)\n}\n\nfunction write (chunk) {\n  var parser = this\n  if (this.error) throw this.error\n  if (parser.closed) return error(parser,\n    \"Cannot write after close. Assign an onready handler.\")\n  if (chunk === null) return end(parser)\n  var i = 0, c = \"\"\n  while (parser.c = c = chunk.charAt(i++)) {\n    if (parser.trackPosition) {\n      parser.position ++\n      if (c === \"\\n\") {\n        parser.line ++\n        parser.column = 0\n      } else parser.column ++\n    }\n    switch (parser.state) {\n\n      case S.BEGIN:\n        if (c === \"<\") {\n          parser.state = S.OPEN_WAKA\n          parser.startTagPosition = parser.position\n        } else if (not(whitespace,c)) {\n          // have to process this as a text node.\n          // weird, but happens.\n          strictFail(parser, \"Non-whitespace before first tag.\")\n          parser.textNode = c\n          parser.state = S.TEXT\n        }\n      continue\n\n      case S.TEXT:\n        if (parser.sawRoot && !parser.closedRoot) {\n          var starti = i-1\n          while (c && c!==\"<\" && c!==\"&\") {\n            c = chunk.charAt(i++)\n            if (c && parser.trackPosition) {\n              parser.position ++\n              if (c === \"\\n\") {\n                parser.line ++\n                parser.column = 0\n              } else parser.column ++\n            }\n          }\n          parser.textNode += chunk.substring(starti, i-1)\n        }\n        if (c === \"<\") {\n          parser.state = S.OPEN_WAKA\n          parser.startTagPosition = parser.position\n        } else {\n          if (not(whitespace, c) && (!parser.sawRoot || parser.closedRoot))\n            strictFail(parser, \"Text data outside of root node.\")\n          if (c === \"&\") parser.state = S.TEXT_ENTITY\n          else parser.textNode += c\n        }\n      continue\n\n      case S.SCRIPT:\n        // only non-strict\n        if (c === \"<\") {\n          parser.state = S.SCRIPT_ENDING\n        } else parser.script += c\n      continue\n\n      case S.SCRIPT_ENDING:\n        if (c === \"/\") {\n          parser.state = S.CLOSE_TAG\n        } else {\n          parser.script += \"<\" + c\n          parser.state = S.SCRIPT\n        }\n      continue\n\n      case S.OPEN_WAKA:\n        // either a /, ?, !, or text is coming next.\n        if (c === \"!\") {\n          parser.state = S.SGML_DECL\n          parser.sgmlDecl = \"\"\n        } else if (is(whitespace, c)) {\n          // wait for it...\n        } else if (is(nameStart,c)) {\n          parser.state = S.OPEN_TAG\n          parser.tagName = c\n        } else if (c === \"/\") {\n          parser.state = S.CLOSE_TAG\n          parser.tagName = \"\"\n        } else if (c === \"?\") {\n          parser.state = S.PROC_INST\n          parser.procInstName = parser.procInstBody = \"\"\n        } else {\n          strictFail(parser, \"Unencoded <\")\n          // if there was some whitespace, then add that in.\n          if (parser.startTagPosition + 1 < parser.position) {\n            var pad = parser.position - parser.startTagPosition\n            c = new Array(pad).join(\" \") + c\n          }\n          parser.textNode += \"<\" + c\n          parser.state = S.TEXT\n        }\n      continue\n\n      case S.SGML_DECL:\n        if ((parser.sgmlDecl+c).toUpperCase() === CDATA) {\n          emitNode(parser, \"onopencdata\")\n          parser.state = S.CDATA\n          parser.sgmlDecl = \"\"\n          parser.cdata = \"\"\n        } else if (parser.sgmlDecl+c === \"--\") {\n          parser.state = S.COMMENT\n          parser.comment = \"\"\n          parser.sgmlDecl = \"\"\n        } else if ((parser.sgmlDecl+c).toUpperCase() === DOCTYPE) {\n          parser.state = S.DOCTYPE\n          if (parser.doctype || parser.sawRoot) strictFail(parser,\n            \"Inappropriately located doctype declaration\")\n          parser.doctype = \"\"\n          parser.sgmlDecl = \"\"\n        } else if (c === \">\") {\n          emitNode(parser, \"onsgmldeclaration\", parser.sgmlDecl)\n          parser.sgmlDecl = \"\"\n          parser.state = S.TEXT\n        } else if (is(quote, c)) {\n          parser.state = S.SGML_DECL_QUOTED\n          parser.sgmlDecl += c\n        } else parser.sgmlDecl += c\n      continue\n\n      case S.SGML_DECL_QUOTED:\n        if (c === parser.q) {\n          parser.state = S.SGML_DECL\n          parser.q = \"\"\n        }\n        parser.sgmlDecl += c\n      continue\n\n      case S.DOCTYPE:\n        if (c === \">\") {\n          parser.state = S.TEXT\n          emitNode(parser, \"ondoctype\", parser.doctype)\n          parser.doctype = true // just remember that we saw it.\n        } else {\n          parser.doctype += c\n          if (c === \"[\") parser.state = S.DOCTYPE_DTD\n          else if (is(quote, c)) {\n            parser.state = S.DOCTYPE_QUOTED\n            parser.q = c\n          }\n        }\n      continue\n\n      case S.DOCTYPE_QUOTED:\n        parser.doctype += c\n        if (c === parser.q) {\n          parser.q = \"\"\n          parser.state = S.DOCTYPE\n        }\n      continue\n\n      case S.DOCTYPE_DTD:\n        parser.doctype += c\n        if (c === \"]\") parser.state = S.DOCTYPE\n        else if (is(quote,c)) {\n          parser.state = S.DOCTYPE_DTD_QUOTED\n          parser.q = c\n        }\n      continue\n\n      case S.DOCTYPE_DTD_QUOTED:\n        parser.doctype += c\n        if (c === parser.q) {\n          parser.state = S.DOCTYPE_DTD\n          parser.q = \"\"\n        }\n      continue\n\n      case S.COMMENT:\n        if (c === \"-\") parser.state = S.COMMENT_ENDING\n        else parser.comment += c\n      continue\n\n      case S.COMMENT_ENDING:\n        if (c === \"-\") {\n          parser.state = S.COMMENT_ENDED\n          parser.comment = textopts(parser.opt, parser.comment)\n          if (parser.comment) emitNode(parser, \"oncomment\", parser.comment)\n          parser.comment = \"\"\n        } else {\n          parser.comment += \"-\" + c\n          parser.state = S.COMMENT\n        }\n      continue\n\n      case S.COMMENT_ENDED:\n        if (c !== \">\") {\n          strictFail(parser, \"Malformed comment\")\n          // allow <!-- blah -- bloo --> in non-strict mode,\n          // which is a comment of \" blah -- bloo \"\n          parser.comment += \"--\" + c\n          parser.state = S.COMMENT\n        } else parser.state = S.TEXT\n      continue\n\n      case S.CDATA:\n        if (c === \"]\") parser.state = S.CDATA_ENDING\n        else parser.cdata += c\n      continue\n\n      case S.CDATA_ENDING:\n        if (c === \"]\") parser.state = S.CDATA_ENDING_2\n        else {\n          parser.cdata += \"]\" + c\n          parser.state = S.CDATA\n        }\n      continue\n\n      case S.CDATA_ENDING_2:\n        if (c === \">\") {\n          if (parser.cdata) emitNode(parser, \"oncdata\", parser.cdata)\n          emitNode(parser, \"onclosecdata\")\n          parser.cdata = \"\"\n          parser.state = S.TEXT\n        } else if (c === \"]\") {\n          parser.cdata += \"]\"\n        } else {\n          parser.cdata += \"]]\" + c\n          parser.state = S.CDATA\n        }\n      continue\n\n      case S.PROC_INST:\n        if (c === \"?\") parser.state = S.PROC_INST_ENDING\n        else if (is(whitespace, c)) parser.state = S.PROC_INST_BODY\n        else parser.procInstName += c\n      continue\n\n      case S.PROC_INST_BODY:\n        if (!parser.procInstBody && is(whitespace, c)) continue\n        else if (c === \"?\") parser.state = S.PROC_INST_ENDING\n        else parser.procInstBody += c\n      continue\n\n      case S.PROC_INST_ENDING:\n        if (c === \">\") {\n          emitNode(parser, \"onprocessinginstruction\", {\n            name : parser.procInstName,\n            body : parser.procInstBody\n          })\n          parser.procInstName = parser.procInstBody = \"\"\n          parser.state = S.TEXT\n        } else {\n          parser.procInstBody += \"?\" + c\n          parser.state = S.PROC_INST_BODY\n        }\n      continue\n\n      case S.OPEN_TAG:\n        if (is(nameBody, c)) parser.tagName += c\n        else {\n          newTag(parser)\n          if (c === \">\") openTag(parser)\n          else if (c === \"/\") parser.state = S.OPEN_TAG_SLASH\n          else {\n            if (not(whitespace, c)) strictFail(\n              parser, \"Invalid character in tag name\")\n            parser.state = S.ATTRIB\n          }\n        }\n      continue\n\n      case S.OPEN_TAG_SLASH:\n        if (c === \">\") {\n          openTag(parser, true)\n          closeTag(parser)\n        } else {\n          strictFail(parser, \"Forward-slash in opening tag not followed by >\")\n          parser.state = S.ATTRIB\n        }\n      continue\n\n      case S.ATTRIB:\n        // haven't read the attribute name yet.\n        if (is(whitespace, c)) continue\n        else if (c === \">\") openTag(parser)\n        else if (c === \"/\") parser.state = S.OPEN_TAG_SLASH\n        else if (is(nameStart, c)) {\n          parser.attribName = c\n          parser.attribValue = \"\"\n          parser.state = S.ATTRIB_NAME\n        } else strictFail(parser, \"Invalid attribute name\")\n      continue\n\n      case S.ATTRIB_NAME:\n        if (c === \"=\") parser.state = S.ATTRIB_VALUE\n        else if (c === \">\") {\n          strictFail(parser, \"Attribute without value\")\n          parser.attribValue = parser.attribName\n          attrib(parser)\n          openTag(parser)\n        }\n        else if (is(whitespace, c)) parser.state = S.ATTRIB_NAME_SAW_WHITE\n        else if (is(nameBody, c)) parser.attribName += c\n        else strictFail(parser, \"Invalid attribute name\")\n      continue\n\n      case S.ATTRIB_NAME_SAW_WHITE:\n        if (c === \"=\") parser.state = S.ATTRIB_VALUE\n        else if (is(whitespace, c)) continue\n        else {\n          strictFail(parser, \"Attribute without value\")\n          parser.tag.attributes[parser.attribName] = \"\"\n          parser.attribValue = \"\"\n          emitNode(parser, \"onattribute\",\n                   { name : parser.attribName, value : \"\" })\n          parser.attribName = \"\"\n          if (c === \">\") openTag(parser)\n          else if (is(nameStart, c)) {\n            parser.attribName = c\n            parser.state = S.ATTRIB_NAME\n          } else {\n            strictFail(parser, \"Invalid attribute name\")\n            parser.state = S.ATTRIB\n          }\n        }\n      continue\n\n      case S.ATTRIB_VALUE:\n        if (is(whitespace, c)) continue\n        else if (is(quote, c)) {\n          parser.q = c\n          parser.state = S.ATTRIB_VALUE_QUOTED\n        } else {\n          strictFail(parser, \"Unquoted attribute value\")\n          parser.state = S.ATTRIB_VALUE_UNQUOTED\n          parser.attribValue = c\n        }\n      continue\n\n      case S.ATTRIB_VALUE_QUOTED:\n        if (c !== parser.q) {\n          if (c === \"&\") parser.state = S.ATTRIB_VALUE_ENTITY_Q\n          else parser.attribValue += c\n          continue\n        }\n        attrib(parser)\n        parser.q = \"\"\n        parser.state = S.ATTRIB_VALUE_CLOSED\n      continue\n\n      case S.ATTRIB_VALUE_CLOSED:\n        if (is(whitespace, c)) {\n          parser.state = S.ATTRIB\n        } else if (c === \">\") openTag(parser)\n        else if (c === \"/\") parser.state = S.OPEN_TAG_SLASH\n        else if (is(nameStart, c)) {\n          strictFail(parser, \"No whitespace between attributes\")\n          parser.attribName = c\n          parser.attribValue = \"\"\n          parser.state = S.ATTRIB_NAME\n        } else strictFail(parser, \"Invalid attribute name\")\n      continue\n\n      case S.ATTRIB_VALUE_UNQUOTED:\n        if (not(attribEnd,c)) {\n          if (c === \"&\") parser.state = S.ATTRIB_VALUE_ENTITY_U\n          else parser.attribValue += c\n          continue\n        }\n        attrib(parser)\n        if (c === \">\") openTag(parser)\n        else parser.state = S.ATTRIB\n      continue\n\n      case S.CLOSE_TAG:\n        if (!parser.tagName) {\n          if (is(whitespace, c)) continue\n          else if (not(nameStart, c)) {\n            if (parser.script) {\n              parser.script += \"</\" + c\n              parser.state = S.SCRIPT\n            } else {\n              strictFail(parser, \"Invalid tagname in closing tag.\")\n            }\n          } else parser.tagName = c\n        }\n        else if (c === \">\") closeTag(parser)\n        else if (is(nameBody, c)) parser.tagName += c\n        else if (parser.script) {\n          parser.script += \"</\" + parser.tagName\n          parser.tagName = \"\"\n          parser.state = S.SCRIPT\n        } else {\n          if (not(whitespace, c)) strictFail(parser,\n            \"Invalid tagname in closing tag\")\n          parser.state = S.CLOSE_TAG_SAW_WHITE\n        }\n      continue\n\n      case S.CLOSE_TAG_SAW_WHITE:\n        if (is(whitespace, c)) continue\n        if (c === \">\") closeTag(parser)\n        else strictFail(parser, \"Invalid characters in closing tag\")\n      continue\n\n      case S.TEXT_ENTITY:\n      case S.ATTRIB_VALUE_ENTITY_Q:\n      case S.ATTRIB_VALUE_ENTITY_U:\n        switch(parser.state) {\n          case S.TEXT_ENTITY:\n            var returnState = S.TEXT, buffer = \"textNode\"\n          break\n\n          case S.ATTRIB_VALUE_ENTITY_Q:\n            var returnState = S.ATTRIB_VALUE_QUOTED, buffer = \"attribValue\"\n          break\n\n          case S.ATTRIB_VALUE_ENTITY_U:\n            var returnState = S.ATTRIB_VALUE_UNQUOTED, buffer = \"attribValue\"\n          break\n        }\n        if (c === \";\") {\n          parser[buffer] += parseEntity(parser)\n          parser.entity = \"\"\n          parser.state = returnState\n        }\n        else if (is(entity, c)) parser.entity += c\n        else {\n          strictFail(parser, \"Invalid character entity\")\n          parser[buffer] += \"&\" + parser.entity + c\n          parser.entity = \"\"\n          parser.state = returnState\n        }\n      continue\n\n      default:\n        throw new Error(parser, \"Unknown state: \" + parser.state)\n    }\n  } // while\n  // cdata blocks can get very big under normal conditions. emit and move on.\n  // if (parser.state === S.CDATA && parser.cdata) {\n  //   emitNode(parser, \"oncdata\", parser.cdata)\n  //   parser.cdata = \"\"\n  // }\n  if (parser.position >= parser.bufferCheckPosition) checkBufferLength(parser)\n  return parser\n}\n\n/*! http://mths.be/fromcodepoint v0.1.0 by @mathias */\nif (!String.fromCodePoint) {\n        (function() {\n                var stringFromCharCode = String.fromCharCode;\n                var floor = Math.floor;\n                var fromCodePoint = function() {\n                        var MAX_SIZE = 0x4000;\n                        var codeUnits = [];\n                        var highSurrogate;\n                        var lowSurrogate;\n                        var index = -1;\n                        var length = arguments.length;\n                        if (!length) {\n                                return '';\n                        }\n                        var result = '';\n                        while (++index < length) {\n                                var codePoint = Number(arguments[index]);\n                                if (\n                                        !isFinite(codePoint) || // `NaN`, `+Infinity`, or `-Infinity`\n                                        codePoint < 0 || // not a valid Unicode code point\n                                        codePoint > 0x10FFFF || // not a valid Unicode code point\n                                        floor(codePoint) != codePoint // not an integer\n                                ) {\n                                        throw RangeError('Invalid code point: ' + codePoint);\n                                }\n                                if (codePoint <= 0xFFFF) { // BMP code point\n                                        codeUnits.push(codePoint);\n                                } else { // Astral code point; split in surrogate halves\n                                        // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae\n                                        codePoint -= 0x10000;\n                                        highSurrogate = (codePoint >> 10) + 0xD800;\n                                        lowSurrogate = (codePoint % 0x400) + 0xDC00;\n                                        codeUnits.push(highSurrogate, lowSurrogate);\n                                }\n                                if (index + 1 == length || codeUnits.length > MAX_SIZE) {\n                                        result += stringFromCharCode.apply(null, codeUnits);\n                                        codeUnits.length = 0;\n                                }\n                        }\n                        return result;\n                };\n                if (Object.defineProperty) {\n                        Object.defineProperty(String, 'fromCodePoint', {\n                                'value': fromCodePoint,\n                                'configurable': true,\n                                'writable': true\n                        });\n                } else {\n                        String.fromCodePoint = fromCodePoint;\n                }\n        }());\n}\n\n})(typeof exports === \"undefined\" ? sax = {} : exports);\n"]}
  },{"undefined":undefined}],21:[function(_dereq_,module,exports){
  /**
   * Tiny stack for browser or server
   *
   * @author Jason Mulligan <jason.mulligan@avoidwork.com>
   * @copyright 2014 Jason Mulligan
   * @license BSD-3 <https://raw.github.com/avoidwork/tiny-stack/master/LICENSE>
   * @link http://avoidwork.github.io/tiny-stack
   * @module tiny-stack
   * @version 0.1.0
   */
  
  ( function ( global ) {
  
  "use strict";
  
  /**
   * TinyStack
   *
   * @constructor
   */
  function TinyStack () {
  	this.data = [null];
  	this.top  = 0;
  }
  
  /**
   * Clears the stack
   *
   * @method clear
   * @memberOf TinyStack
   * @return {Object} {@link TinyStack}
   */
  TinyStack.prototype.clear = function clear () {
  	this.data = [null];
  	this.top  = 0;
  
  	return this;
  };
  
  /**
   * Gets the size of the stack
   *
   * @method length
   * @memberOf TinyStack
   * @return {Number} Size of stack
   */
  TinyStack.prototype.length = function length () {
  	return this.top;
  };
  
  /**
   * Gets the item at the top of the stack
   *
   * @method peek
   * @memberOf TinyStack
   * @return {Mixed} Item at the top of the stack
   */
  TinyStack.prototype.peek = function peek () {
  	return this.data[this.top];
  };
  
  /**
   * Gets & removes the item at the top of the stack
   *
   * @method pop
   * @memberOf TinyStack
   * @return {Mixed} Item at the top of the stack
   */
  TinyStack.prototype.pop = function pop () {
  	if ( this.top > 0 ) {
  		this.top--;
  
  		return this.data.pop();
  	}
  	else {
  		return undefined;
  	}
  };
  
  /**
   * Pushes an item onto the stack
   *
   * @method push
   * @memberOf TinyStack
   * @return {Object} {@link TinyStack}
   */
  TinyStack.prototype.push = function push ( arg ) {
  	this.data[++this.top] = arg;
  
  	return this;
  };
  
  /**
   * TinyStack factory
   *
   * @method factory
   * @return {Object} {@link TinyStack}
   */
  function factory () {
  	return new TinyStack();
  }
  
  // Node, AMD & window supported
  if ( typeof exports != "undefined" ) {
  	module.exports = factory;
  }
  else if ( typeof define == "function" ) {
  	define( function () {
  		return factory;
  	} );
  }
  else {
  	global.stack = factory;
  }
  } )( this );
  
  },{}],22:[function(_dereq_,module,exports){
  module.exports = _dereq_(26);
  },{"26":26}],23:[function(_dereq_,module,exports){
  'use strict';
  
  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);
  };
  
  
  module.exports = Base;
  },{}],24:[function(_dereq_,module,exports){
  'use strict';
  
  var pick = _dereq_(174),
      assign = _dereq_(168),
      forEach = _dereq_(77);
  
  var parseNameNs = _dereq_(27).parseName;
  
  
  function DescriptorBuilder(nameNs) {
    this.ns = nameNs;
    this.name = nameNs.name;
    this.allTypes = [];
    this.properties = [];
    this.propertiesByName = {};
  }
  
  module.exports = DescriptorBuilder;
  
  
  DescriptorBuilder.prototype.build = function() {
    return pick(this, [ 'ns', 'name', 'allTypes', 'properties', 'propertiesByName', 'bodyProperty' ]);
  };
  
  DescriptorBuilder.prototype.addProperty = function(p, idx) {
    this.addNamedProperty(p, true);
  
    var properties = this.properties;
  
    if (idx !== undefined) {
      properties.splice(idx, 0, p);
    } else {
      properties.push(p);
    }
  };
  
  
  DescriptorBuilder.prototype.replaceProperty = function(oldProperty, newProperty) {
    var oldNameNs = oldProperty.ns;
  
    var props = this.properties,
        propertiesByName = this.propertiesByName,
        rename = oldProperty.name !== newProperty.name;
  
    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);
    }
  
    // replacing the named property is intentional
    // thus, validate only if this is a "rename" operation
    this.addNamedProperty(newProperty, rename);
  
    // replace old property at index with new one
    var idx = props.indexOf(oldProperty);
    if (idx === -1) {
      throw new Error('property <' + oldNameNs.name + '> not found in property list');
    }
  
    props[idx] = newProperty;
  
    // replace propertiesByName entry with new property
    propertiesByName[oldNameNs.name] = propertiesByName[oldNameNs.localName] = newProperty;
  };
  
  
  DescriptorBuilder.prototype.redefineProperty = function(p) {
  
    var nsPrefix = p.ns.prefix;
    var parts = p.redefines.split('#');
  
    var name = parseNameNs(parts[0], nsPrefix);
    var attrName = parseNameNs(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);
    }
  
    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.addIdProperty = function(name) {
    var nameNs = parseNameNs(name, this.ns.prefix);
  
    var p = {
      name: nameNs.localName,
      type: 'String',
      isAttr: true,
      ns: nameNs
    };
  
    // ensure that id is always the first attribute (if present)
    this.addProperty(p, 0);
  };
  
  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) {
  
    var allTypes = this.allTypes;
  
    if (allTypes.indexOf(t) !== -1) {
      return;
    }
  
    forEach(t.properties, function(p) {
  
      // clone property to allow extensions
      p = assign({}, p, {
        name: p.ns.localName
      });
  
      Object.defineProperty(p, 'definedBy', {
        value: t
      });
  
      // add redefine support
      if (p.redefines) {
        this.redefineProperty(p);
      } else {
        if (p.isBody) {
          this.setBodyProperty(p);
        }
        this.addProperty(p);
      }
    }, this);
  
    allTypes.push(t);
  };
  
  },{"168":168,"174":174,"27":27,"77":77}],25:[function(_dereq_,module,exports){
  'use strict';
  
  var forEach = _dereq_(77);
  
  var Base = _dereq_(23);
  
  
  function Factory(model, properties) {
    this.model = model;
    this.properties = properties;
  }
  
  module.exports = Factory;
  
  
  Factory.prototype.createType = function(descriptor) {
  
    var model = this.model;
  
    var props = this.properties,
        prototype = Object.create(Base.prototype);
  
    // initialize default values
    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 });
  
      forEach(attrs, 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;
  };
  },{"23":23,"77":77}],26:[function(_dereq_,module,exports){
  'use strict';
  
  var isString = _dereq_(165),
      isObject = _dereq_(163),
      forEach = _dereq_(77),
      find = _dereq_(76);
  
  
  var Factory = _dereq_(25),
      Registry = _dereq_(29),
      Properties = _dereq_(28);
  
  var parseNameNs = _dereq_(27).parseName;
  
  
  //// 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
   * @param {Object} options  additional options to pass to the model
   */
  function Moddle(packages, options) {
  
    options = options || {};
  
    this.properties = new Properties(this);
  
    this.factory = new Factory(this, this.properties);
    this.registry = new Registry(packages, this.properties, options);
  
    this.typeCache = {};
  }
  
  module.exports = Moddle;
  
  
  /**
   * 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 = 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 = parseNameNs(name);
  
    var element = {
      $type: name
    };
  
    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 });
  
    forEach(properties, function(a, key) {
      if (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 !!find(descriptor.allTypes, function(t) {
      return t.name === type;
    });
  };
  
  
  /**
   * Returns the descriptor of an elements named property
   */
  Moddle.prototype.getPropertyDescriptor = function(element, property) {
    return this.getElementDescriptor(element).propertiesByName[property];
  };
  
  },{"163":163,"165":165,"25":25,"27":27,"28":28,"29":29,"76":76,"77":77}],27:[function(_dereq_,module,exports){
  'use strict';
  
  /**
   * 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
   */
  module.exports.parseName = function(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
    };
  };
  },{}],28:[function(_dereq_,module,exports){
  'use strict';
  
  
  /**
   * A utility that gets and sets properties of model elements.
   *
   * @param {Model} model
   */
  function Properties(model) {
    this.model = model;
  }
  
  module.exports = Properties;
  
  
  /**
   * Sets a named property on the target element
   *
   * @param {Object} target
   * @param {String} name
   * @param {Object} value
   */
  Properties.prototype.set = function(target, name, value) {
  
    var property = this.model.getPropertyDescriptor(target, name);
  
    if (!property) {
      target.$attrs[name] = value;
    } else {
      Object.defineProperty(target, property.name, {
        enumerable: !property.isReference,
        writable: true,
        value: 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) {
      Object.defineProperty(target, propertyName, {
        enumerable: !property.isReference,
        writable: true,
        value: []
      });
    }
  
    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 });
  };
  },{}],29:[function(_dereq_,module,exports){
  'use strict';
  
  var assign = _dereq_(168),
      forEach = _dereq_(77);
  
  var Types = _dereq_(30),
      DescriptorBuilder = _dereq_(24);
  
  var parseNameNs = _dereq_(27).parseName,
      isBuiltInType = Types.isBuiltIn;
  
  
  function Registry(packages, properties, options) {
    this.options = assign({ generateId: 'id' }, options || {});
  
    this.packageMap = {};
    this.typeMap = {};
  
    this.packages = [];
  
    this.properties = properties;
  
    forEach(packages, this.registerPackage, this);
  }
  
  module.exports = Registry;
  
  
  Registry.prototype.getPackage = function(uriOrPrefix) {
    return this.packageMap[uriOrPrefix];
  };
  
  Registry.prototype.getPackages = function() {
    return this.packages;
  };
  
  
  Registry.prototype.registerPackage = function(pkg) {
  
    // copy package
    pkg = assign({}, pkg);
  
    // register types
    forEach(pkg.types, function(descriptor) {
      this.registerType(descriptor, pkg);
    }, this);
  
    this.packageMap[pkg.uri] = this.packageMap[pkg.prefix] = pkg;
    this.packages.push(pkg);
  };
  
  
  /**
   * Register a type from a specific package with us
   */
  Registry.prototype.registerType = function(type, pkg) {
  
    type = assign({}, type, {
      superClass: (type.superClass || []).slice(),
      extends: (type.extends || []).slice(),
      properties: (type.properties || []).slice()
    });
  
    var ns = parseNameNs(type.name, pkg.prefix),
        name = ns.name,
        propertiesByName = {};
  
    // parse properties
    forEach(type.properties, function(p) {
  
      // namespace property names
      var propertyNs = parseNameNs(p.name, ns.prefix),
          propertyName = propertyNs.name;
  
      // namespace property types
      if (!isBuiltInType(p.type)) {
        p.type = parseNameNs(p.type, propertyNs.prefix).name;
      }
  
      assign(p, {
        ns: propertyNs,
        name: propertyName
      });
  
      propertiesByName[propertyName] = p;
    });
  
    // update ns + name
    assign(type, {
      ns: ns,
      name: name,
      propertiesByName: propertiesByName
    });
  
    forEach(type.extends, 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.
   */
  Registry.prototype.mapTypes = function(nsName, iterator) {
  
    var type = isBuiltInType(nsName.name) ? { name: nsName.name } : this.typeMap[nsName.name];
  
    var self = this;
  
    /**
     * Traverse the selected super type or trait
     *
     * @param {String} cls
     */
    function traverseSuper(cls) {
      var parentNs = parseNameNs(cls, isBuiltInType(cls) ? '' : nsName.prefix);
      self.mapTypes(parentNs, iterator);
    }
  
    if (!type) {
      throw new Error('unknown type <' + nsName.name + '>');
    }
  
    forEach(type.superClass, traverseSuper);
  
    iterator(type);
  
    forEach(type.traits, traverseSuper);
  };
  
  
  /**
   * 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 = parseNameNs(name);
  
    var builder = new DescriptorBuilder(nsName);
  
    this.mapTypes(nsName, function(type) {
      builder.addTrait(type);
    });
  
    // check we have an id assigned
    var id = this.options.generateId;
    if (id && !builder.hasProperty(id)) {
      builder.addIdProperty(id);
    }
  
    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 });
  };
  },{"168":168,"24":24,"27":27,"30":30,"77":77}],30:[function(_dereq_,module,exports){
  'use strict';
  
  /**
   * 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(s) { return s; },
    Boolean: function(s) { return s === 'true'; },
    Integer: function(s) { return parseInt(s, 10); },
    Real: function(s) { return parseFloat(s, 10); }
  };
  
  /**
   * Convert a type to its real representation
   */
  module.exports.coerceType = function(type, value) {
  
    var converter = TYPE_CONVERTERS[type];
  
    if (converter) {
      return converter(value);
    } else {
      return value;
    }
  };
  
  /**
   * Return whether the given type is built-in
   */
  module.exports.isBuiltIn = function(type) {
    return !!BUILTINS[type];
  };
  
  /**
   * Return whether the given type is simple
   */
  module.exports.isSimple = function(type) {
    return !!TYPE_CONVERTERS[type];
  };
  },{}],31:[function(_dereq_,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",
            "isAttr": true,
            "isReference": true
          },
          {
            "name": "outMessageRef",
            "type": "Message",
            "isAttr": true,
            "isReference": true
          },
          {
            "name": "errorRefs",
            "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": "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": "childLaneSet",
            "type": "LaneSet",
            "xml": {
              "serialize": "xsi:type"
            }
          },
          {
            "name": "partitionElementRef",
            "type": "BaseElement",
            "isAttr": true,
            "isReference": true
          },
          {
            "name": "flowNodeRef",
            "type": "FlowNode",
            "isMany": true,
            "isReference": true
          },
          {
            "name": "partitionElement",
            "type": "BaseElement"
          }
        ]
      },
      {
        "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"
          },
          {
            "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"
          }
        ]
      },
      {
        "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": "inputSet",
            "type": "InputSet"
          },
          {
            "name": "eventDefinitionRefs",
            "type": "EventDefinition",
            "isMany": true,
            "isReference": true
          },
          {
            "name": "dataInputAssociation",
            "type": "DataInputAssociation",
            "isMany": true
          },
          {
            "name": "dataInputs",
            "type": "DataInput",
            "isMany": true
          },
          {
            "name": "eventDefinitions",
            "type": "EventDefinition",
            "isMany": true
          }
        ]
      },
      {
        "name": "CatchEvent",
        "isAbstract": true,
        "superClass": [
          "Event"
        ],
        "properties": [
          {
            "name": "parallelMultiple",
            "isAttr": true,
            "type": "Boolean",
            "default": false
          },
          {
            "name": "outputSet",
            "type": "OutputSet"
          },
          {
            "name": "eventDefinitionRefs",
            "type": "EventDefinition",
            "isMany": true,
            "isReference": true
          },
          {
            "name": "dataOutputAssociation",
            "type": "DataOutputAssociation",
            "isMany": true
          },
          {
            "name": "dataOutputs",
            "type": "DataOutput",
            "isMany": true
          },
          {
            "name": "eventDefinitions",
            "type": "EventDefinition",
            "isMany": 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"
          },
          {
            "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": "transformation",
            "type": "FormalExpression"
          },
          {
            "name": "assignment",
            "type": "Assignment",
            "isMany": true
          },
          {
            "name": "sourceRef",
            "type": "ItemAwareElement",
            "isMany": true,
            "isReference": true
          },
          {
            "name": "targetRef",
            "type": "ItemAwareElement",
            "isReference": true
          }
        ]
      },
      {
        "name": "DataInput",
        "superClass": [
          "ItemAwareElement"
        ],
        "properties": [
          {
            "name": "name",
            "isAttr": true,
            "type": "String"
          },
          {
            "name": "isCollection",
            "default": false,
            "isAttr": true,
            "type": "Boolean"
          },
          {
            "name": "inputSetRefs",
            "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": "outputSetRefs",
            "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": "participantRefs",
            "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": true
      },
      {
        "name": "FormalExpression",
        "superClass": [
          "Expression"
        ],
        "properties": [
          {
            "name": "language",
            "isAttr": true,
            "type": "String"
          },
          {
            "name": "body",
            "type": "String",
            "isBody": true
          },
          {
            "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": "supportedInterfaceRefs",
            "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": "interfaceRefs",
            "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"
          }
        ]
      },
      {
        "name": "Collaboration",
        "superClass": [
          "RootElement"
        ],
        "properties": [
          {
            "name": "name",
            "isAttr": true,
            "type": "String"
          },
          {
            "name": "isClosed",
            "isAttr": true,
            "type": "Boolean"
          },
          {
            "name": "choreographyRef",
            "type": "Choreography",
            "isMany": true,
            "isReference": true
          },
          {
            "name": "artifacts",
            "type": "Artifact",
            "isMany": true
          },
          {
            "name": "participantAssociations",
            "type": "ParticipantAssociation",
            "isMany": true
          },
          {
            "name": "messageFlowAssociations",
            "type": "MessageFlowAssociation",
            "isMany": true
          },
          {
            "name": "conversationAssociations",
            "type": "ConversationAssociation"
          },
          {
            "name": "participants",
            "type": "Participant",
            "isMany": true
          },
          {
            "name": "messageFlows",
            "type": "MessageFlow",
            "isMany": true
          },
          {
            "name": "correlationKeys",
            "type": "CorrelationKey",
            "isMany": true
          },
          {
            "name": "conversations",
            "type": "ConversationNode",
            "isMany": true
          },
          {
            "name": "conversationLinks",
            "type": "ConversationLink",
            "isMany": true
          }
        ]
      },
      {
        "name": "ChoreographyActivity",
        "isAbstract": true,
        "superClass": [
          "FlowNode"
        ],
        "properties": [
          {
            "name": "participantRefs",
            "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": [
          "FlowElementsContainer",
          "Collaboration"
        ]
      },
      {
        "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",
            "isAttr": true,
            "isReference": true
          },
          {
            "name": "loopDataOutputRef",
            "type": "ItemAwareElement",
            "isAttr": true,
            "isReference": true
          },
          {
            "name": "inputDataItem",
            "type": "DataInput"
          },
          {
            "name": "outputDataItem",
            "type": "DataOutput"
          },
          {
            "name": "completionCondition",
            "type": "Expression",
            "xml": {
              "serialize": "xsi:type"
            }
          },
          {
            "name": "complexBehaviorDefinition",
            "type": "ComplexBehaviorDefinition",
            "isMany": true
          },
          {
            "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": "Expression",
            "xml": {
              "serialize": "xsi:type"
            }
          }
        ]
      },
      {
        "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
          }
        ]
      },
      {
        "name": "ResourceAssignmentExpression",
        "properties": [
          {
            "name": "expression",
            "type": "Expression",
            "xml": {
              "serialize": "xsi:type"
            }
          }
        ]
      },
      {
        "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"
          }
        ]
      }
    ],
    "emumerations": [
      {
        "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"
    }
  }
  },{}],32:[function(_dereq_,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"
        ]
      }
    ],
    "emumerations": [
      {
        "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"
  }
  },{}],33:[function(_dereq_,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": []
  }
  },{}],34:[function(_dereq_,module,exports){
  module.exports={
    "name": "DI",
    "uri": "http://www.omg.org/spec/DD/20100524/DI",
    "types": [
      {
        "name": "DiagramElement",
        "isAbstract": true,
        "properties": [
          {
            "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": "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
      },
      {
        "name": "Extension",
        "properties": [
          {
            "name": "values",
            "type": "Element",
            "isMany": true
          }
        ]
      }
    ],
    "associations": [],
    "prefix": "di",
    "xml": {
      "tagAlias": "lowerCase"
    }
  }
  },{}],35:[function(_dereq_,module,exports){
  module.exports = _dereq_(36);
  },{"36":36}],36:[function(_dereq_,module,exports){
  'use strict';
  
  var di = _dereq_(69);
  
  
  /**
   * 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 di.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 coreModule = _dereq_(42);
  
    var modules = [ configModule, coreModule ].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
   * module.exports = {
   *   __init__: [ 'myLoggingPlugin' ],
   *     myLoggingPlugin: [ 'type', MyLoggingPlugin ]
   * };
   *
   *
   * // instantiate the diagram with the new plug-in
   *
   * var diagram = new Diagram({ modules: [ require('path-to-my-logging-plugin') ] });
   *
   * 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 {Object} [locals] a number of locals to use to resolve certain dependencies
     */
    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');
  }
  
  module.exports = Diagram;
  
  
  /**
   * Destroys the diagram
   *
   * @method  Diagram#destroy
   */
  Diagram.prototype.destroy = function() {
    this.get('eventBus').fire('diagram.destroy');
  };
  },{"42":42,"69":69}],37:[function(_dereq_,module,exports){
  'use strict';
  
  var isNumber = _dereq_(162),
      assign = _dereq_(168),
      forEach = _dereq_(77),
      every = _dereq_(74);
  
  var Collections = _dereq_(57);
  
  var Snap = _dereq_(67);
  
  function round(number, resolution) {
    return Math.round(number * resolution) / resolution;
  }
  
  function ensurePx(number) {
    return 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 = 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');
  
    assign(parent.style, {
      position: 'relative',
      overflow: 'hidden',
      width: ensurePx(options.width),
      height: ensurePx(options.height)
    });
  
    container.appendChild(parent);
  
    return parent;
  }
  
  function createGroup(parent, cls) {
    return parent.group().attr({ 'class' : cls });
  }
  
  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' ];
  
  module.exports = Canvas;
  
  
  Canvas.prototype._init = function(config) {
  
    // 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 eventBus = this._eventBus,
  
        container = createContainer(config),
        svg = Snap.createSnapAt('100%', '100%', container),
        viewport = createGroup(svg, 'viewport'),
  
        self = this;
  
    this._container = container;
    this._svg = svg;
    this._viewport = viewport;
    this._layers = {};
  
    eventBus.on('diagram.init', function(event) {
  
      /**
       * An event indicating that the canvas is ready to be drawn on.
       *
       * @memberOf Canvas
       *
       * @event canvas.init
       *
       * @type {Object}
       * @property {Snap<SVGSVGElement>} svg the created svg element
       * @property {Snap<SVGGroup>} viewport the direct parent of diagram elements and shapes
       */
      eventBus.fire('canvas.init', { svg: svg, viewport: viewport });
    });
  
    eventBus.on('diagram.destroy', function() {
  
      var parent = self._container.parentNode;
  
      if (parent) {
        parent.removeChild(container);
      }
  
      eventBus.fire('canvas.destroy', { svg: self._svg, viewport: self._viewport });
  
      self._svg.remove();
  
      self._svg = self._container = self._layers = self._viewport = null;
    });
  
  };
  
  /**
   * Returns the default layer on which
   * all elements are drawn.
   *
   * @returns {Snap<SVGGroup>}
   */
  Canvas.prototype.getDefaultLayer = function() {
    return this.getLayer(BASE_LAYER);
  };
  
  /**
   * Returns a layer that is used to draw elements
   * or annotations on it.
   *
   * @param  {String} name
   *
   * @returns {Snap<SVGGroup>}
   */
  Canvas.prototype.getLayer = function(name) {
  
    if (!name) {
      throw new Error('must specify a name');
    }
  
    var layer = this._layers[name];
    if (!layer) {
      layer = this._layers[name] = createGroup(this._viewport, 'layer-' + name);
    }
  
    return layer;
  };
  
  
  /**
   * 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;
    }
  
    forEach([ container.gfx, container.secondaryGfx ], function(gfx) {
      if (gfx) {
        // invoke either addClass or removeClass based on mode
        gfx[add ? 'addClass' : 'removeClass'](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 gfx && gfx.hasClass(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' });
    }
  
    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) {
  
    this._ensureValid('root', element);
  
    var oldRoot = this._rootElement,
        elementRegistry = this._elementRegistry,
        eventBus = this._eventBus;
  
    if (oldRoot) {
      if (!override) {
        throw new Error('rootElement already set, need to specify override');
      }
  
      // simulate element remove event sequence
      eventBus.fire('root.remove', { element: oldRoot });
      eventBus.fire('root.removed', { element: oldRoot });
  
      elementRegistry.remove(oldRoot);
    }
  
    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 = 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, idx) {
    Collections.add(parent.children, element, idx);
    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]
   *
   * @return {Object|djs.model.Base} the added element
   */
  Canvas.prototype._addElement = function(type, element, parent) {
  
    parent = parent || this.getRootElement();
  
    var eventBus = this._eventBus,
        graphicsFactory = this._graphicsFactory,
        idx;
  
    this._ensureValid(type, element);
  
    eventBus.fire(type + '.add', { element: element, parent: parent });
  
    this._setParent(element, parent, idx);
  
    // create graphics
    var gfx = graphicsFactory.create(type, element);
  
    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]
   *
   * @return {djs.model.Shape} the added shape
   */
  Canvas.prototype.addShape = function(shape, parent) {
    return this._addElement('shape', shape, parent);
  };
  
  /**
   * Adds a connection to the canvas
   *
   * @param {Object|djs.model.Connection} connection to add to the diagram
   * @param {djs.model.Base} [parent]
   *
   * @return {djs.model.Connection} the added connection
   */
  Canvas.prototype.addConnection = function(connection, parent) {
    return this._addElement('connection', connection, parent);
  };
  
  
  /**
   * 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
    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');
  };
  
  
  /**
   * Sends a shape to the front.
   *
   * This method takes parent / child relationships between shapes into account
   * and makes sure that children are properly handled, too.
   *
   * @param {djs.model.Shape} shape descriptor of the shape to be sent to front
   * @param {boolean} [bubble=true] whether to send parent shapes to front, too
   */
  Canvas.prototype.sendToFront = function(shape, bubble) {
  
    if (bubble !== false) {
      bubble = true;
    }
  
    if (bubble && shape.parent) {
      this.sendToFront(shape.parent);
    }
  
    forEach(shape.children, function(child) {
      this.sendToFront(child, false);
    }, this);
  
    var gfx = this.getGraphics(shape),
        gfxParent = gfx.parent();
  
    gfx.remove().appendTo(gfxParent);
  };
  
  
  /**
   * 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);
  };
  
  
  Canvas.prototype._fireViewboxChange = function() {
    this._eventBus.fire('canvas.viewbox.changed', { viewbox: this.viewbox(false) });
  };
  
  
  /**
   * Gets or sets the view box of the canvas, i.e. the area that is currently displayed
   *
   * @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
   *
   * @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
   *
   * @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,
        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(true);
  
      matrix = viewport.transform().localMatrix;
      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 {
      scale = Math.min(outerBox.width / box.width, outerBox.height / box.height);
  
      matrix = new Snap.Matrix().scale(scale).translate(-box.x, -box.y);
      viewport.transform(matrix);
  
      this._fireViewboxChange();
    }
  
    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.node;
    var matrix = node.getCTM();
  
    if (delta) {
      delta = assign({ dx: 0, dy: 0 }, delta || {});
  
      matrix = this._svg.node.createSVGMatrix().translate(delta.dx, delta.dy).multiply(matrix);
  
      setCTM(node, matrix);
  
      this._fireViewboxChange();
    }
  
    return { x: matrix.e, y: matrix.f };
  };
  
  
  /**
   * Gets or sets the current zoom of the canvas, optionally zooming to the specified position.
   *
   * @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 === 'fit-viewport') {
      return this._fitViewport(center);
    }
  
    var vbox = this.viewbox(),
        outer,
        matrix;
  
    if (newScale === undefined) {
      return vbox.scale;
    }
  
    if (typeof center !== 'object') {
      outer = vbox.outer;
  
      center = {
        x: outer.width / 2,
        y: outer.height / 2
      };
    }
  
    matrix = this._setZoom(newScale, center);
  
    this._fireViewboxChange();
  
    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().scale;
  };
  
  
  Canvas.prototype._setZoom = function(scale, center) {
  
    var svg = this._svg.node,
        viewport = this._viewport.node;
  
    var matrix = svg.createSVGMatrix();
    var point = svg.createSVGPoint();
  
    var centerPoint,
        originalPoint,
        currentMatrix,
        scaleMatrix,
        newMatrix;
  
    currentMatrix = viewport.getCTM();
  
  
    var currentScale = currentMatrix.a;
  
    if (center) {
      centerPoint = 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.node, 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);
  
      var transformBBox = gfx.getBBox(true);
      bbox = gfx.getBBox();
  
      bbox.x -= transformBBox.x;
      bbox.y -= transformBBox.y;
  
      bbox.width += 2 * transformBBox.x;
      bbox.height +=  2 * transformBBox.y;
    }
    // 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
    };
  };
  
  },{"162":162,"168":168,"57":57,"67":67,"74":74,"77":77}],38:[function(_dereq_,module,exports){
  'use strict';
  
  var Model = _dereq_(56);
  
  
  /**
   * A factory for diagram-js shapes
   */
  function ElementFactory() {
    this._uid = 12;
  }
  
  module.exports = ElementFactory;
  
  
  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 = attrs || {};
  
    if (!attrs.id) {
      attrs.id = type + '_' + (this._uid++);
    }
  
    return Model.create(type, attrs);
  };
  },{"56":56}],39:[function(_dereq_,module,exports){
  'use strict';
  
  var ELEMENT_ID = 'data-element-id';
  
  
  /**
   * @class
   *
   * A registry that keeps track of all shapes in the diagram.
   */
  function ElementRegistry() {
    this._elements = {};
  }
  
  module.exports = ElementRegistry;
  
  /**
   * Register a pair of (element, gfx, (secondaryGfx)).
   *
   * @param {djs.model.Base} element
   * @param {Snap<SVGElement>} gfx
   * @param {Snap<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
    gfx.attr(ELEMENT_ID, id);
  
    if (secondaryGfx) {
      secondaryGfx.attr(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
      container.gfx.attr(ELEMENT_ID, null);
  
      if (container.secondaryGfx) {
        container.secondaryGfx.attr(ELEMENT_ID, null);
      }
  
      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);
    }
  
    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 && filter.attr(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');
    }
  };
  },{}],40:[function(_dereq_,module,exports){
  'use strict';
  
  var isFunction = _dereq_(160),
      isArray = _dereq_(159),
      isNumber = _dereq_(162),
      assign = _dereq_(168);
  
  var DEFAULT_PRIORITY = 1000;
  
  
  /**
   * 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!');
   * });
   * ```
   *
   *
   * ## 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
  
    var self = this;
  
    // destroy on lowest priority to allow
    // message passing until the bitter end
    this.on('diagram.destroy', 1, function() {
      self._listeners = null;
    });
  }
  
  module.exports = EventBus;
  
  
  /**
   * 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
   */
  EventBus.prototype.on = function(events, priority, callback) {
  
    events = isArray(events) ? events : [ events ];
  
    if (isFunction(priority)) {
      callback = priority;
      priority = DEFAULT_PRIORITY;
    }
  
    if (!isNumber(priority)) {
      throw new Error('priority must be a number');
    }
  
    var self = this,
        listener = { priority: priority, callback: callback };
  
    events.forEach(function(e) {
      self._addListener(e, listener);
    });
  };
  
  
  /**
   * 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
   */
  EventBus.prototype.once = function(event, callback) {
  
    var self = this;
  
    function wrappedCallback() {
      callback.apply(self, arguments);
      self.off(event, wrappedCallback);
    }
  
    this.on(event, 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} event
   * @param {Function} [callback]
   */
  EventBus.prototype.off = function(event, callback) {
    var listeners = this._getListeners(event),
        listener, idx;
  
    if (callback) {
  
      // move through listeners from back to front
      // and remove matching listeners
      for (idx = listeners.length - 1; !!(listener = listeners[idx]); idx--) {
        if (listener.callback === callback) {
          listeners.splice(idx, 1);
        }
      }
    } else {
      // clear listeners
      listeners.length = 0;
    }
  };
  
  
  /**
   * 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,
        originalType,
        listeners, idx, listener,
        returnValue,
        args;
  
    args = Array.prototype.slice.call(arguments);
  
    if (typeof type === 'object') {
      event = type;
      type = event.type;
    }
  
    if (!type) {
      throw new Error('no event type specified');
    }
  
    listeners = this._listeners[type];
  
    if (!listeners) {
      return;
    }
  
    // we make sure we fire instances of our home made
    // events here. We wrap them only once, though
    if (data instanceof Event) {
      // we are fine, we alread have an event
      event = data;
    } else {
      event = new Event();
      event.init(data);
    }
  
    // ensure we pass the event as the first parameter
    args[0] = event;
  
    // original event type (in case we delegate)
    originalType = event.type;
  
    try {
  
      // update event type before delegation
      if (type !== originalType) {
        event.type = type;
      }
  
      for (idx = 0; !!(listener = listeners[idx]); idx++) {
  
        // handle stopped propagation
        if (event.cancelBubble) {
          break;
        }
  
        try {
          // returning false prevents the default action
          returnValue = event.returnValue = listener.callback.apply(null, args);
  
          // stop propagation on return value
          if (returnValue !== undefined) {
            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;
          }
        }
      }
    } 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;
  };
  
  
  /*
   * 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 listeners = this._getListeners(event),
        existingListener,
        idx;
  
    // ensure we order listeners by priority from
    // 0 (high) to n > 0 (low)
    for (idx = 0; !!(existingListener = listeners[idx]); idx++) {
      if (existingListener.priority < newListener.priority) {
  
        // prepend newListener at before existingListener
        listeners.splice(idx, 0, newListener);
        return;
      }
    }
  
    listeners.push(newListener);
  };
  
  
  EventBus.prototype._getListeners = function(name) {
    var listeners = this._listeners[name];
  
    if (!listeners) {
      this._listeners[name] = listeners = [];
    }
  
    return listeners;
  };
  
  
  /**
   * A event that is emitted via the event bus.
   */
  function Event() { }
  
  module.exports.Event = Event;
  
  Event.prototype.stopPropagation = function() {
    this.cancelBubble = true;
  };
  
  Event.prototype.preventDefault = function() {
    this.defaultPrevented = true;
  };
  
  Event.prototype.init = function(data) {
    assign(this, data || {});
  };
  
  },{"159":159,"160":160,"162":162,"168":168}],41:[function(_dereq_,module,exports){
  'use strict';
  
  var forEach = _dereq_(77),
      reduce = _dereq_(81);
  
  var GraphicsUtil = _dereq_(60),
      domClear = _dereq_(179);
  
  /**
   * A factory that creates graphical elements
   *
   * @param {Renderer} renderer
   */
  function GraphicsFactory(renderer, elementRegistry) {
    this._renderer = renderer;
    this._elementRegistry = elementRegistry;
  }
  
  GraphicsFactory.$inject = [ 'renderer', 'elementRegistry' ];
  
  module.exports = GraphicsFactory;
  
  
  GraphicsFactory.prototype._getChildren = function(element) {
  
    var gfx = this._elementRegistry.getGraphics(element);
  
    var childrenGfx;
  
    // root element
    if (!element.parent) {
      childrenGfx = gfx;
    } else {
      childrenGfx = GraphicsUtil.getChildren(gfx);
      if (!childrenGfx) {
        childrenGfx = gfx.parent().group().attr('class', 'djs-children');
      }
    }
  
    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 = GraphicsUtil.getVisual(gfx);
  
    domClear(visual.node);
  
    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
   */
  GraphicsFactory.prototype._createContainer = function(type, parentGfx) {
    var outerGfx = parentGfx.group().attr('class', 'djs-group'),
        gfx = outerGfx.group().attr('class', 'djs-element djs-' + type);
  
    // create visual
    gfx.group().attr('class', 'djs-visual');
  
    return gfx;
  };
  
  GraphicsFactory.prototype.create = function(type, element) {
    var childrenGfx = this._getChildren(element.parent);
    return this._createContainer(type, childrenGfx);
  };
  
  
  GraphicsFactory.prototype.updateContainments = function(elements) {
  
    var self = this,
        elementRegistry = this._elementRegistry,
        parents;
  
  
    parents = 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)
    forEach(parents, function(parent) {
  
      var childGfx = self._getChildren(parent),
          children = parent.children;
  
      if (!children) {
        return;
      }
  
      forEach(children.slice().reverse(), function(c) {
        var gfx = elementRegistry.getGraphics(c);
        gfx.parent().prependTo(childGfx);
      });
    });
  
  };
  
  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._renderer.drawShape(visual, element);
  
      // update positioning
      gfx.translate(element.x, element.y);
    } else
    if (type === 'connection') {
      this._renderer.drawConnection(visual, element);
    } else {
      throw new Error('unknown type: ' + type);
    }
  
    gfx.attr('display', element.hidden ? 'none' : 'block');
  };
  
  
  GraphicsFactory.prototype.remove = function(element) {
    var gfx = this._elementRegistry.getGraphics(element);
  
    // remove
    gfx.parent().remove();
  };
  
  },{"179":179,"60":60,"77":77,"81":81}],42:[function(_dereq_,module,exports){
  module.exports = {
    __depends__: [ _dereq_(45) ],
    __init__: [ 'canvas' ],
    canvas: [ 'type', _dereq_(37) ],
    elementRegistry: [ 'type', _dereq_(39) ],
    elementFactory: [ 'type', _dereq_(38) ],
    eventBus: [ 'type', _dereq_(40) ],
    graphicsFactory: [ 'type', _dereq_(41) ]
  };
  },{"37":37,"38":38,"39":39,"40":40,"41":41,"45":45}],43:[function(_dereq_,module,exports){
  'use strict';
  
  var Snap = _dereq_(67);
  
  
  /**
   * The default renderer used for shapes and connections.
   *
   * @param {Styles} styles
   */
  function Renderer(styles) {
    this.CONNECTION_STYLE = styles.style([ 'no-fill' ], { strokeWidth: 5, stroke: 'fuchsia' });
    this.SHAPE_STYLE = styles.style({ fill: 'white', stroke: 'fuchsia', strokeWidth: 2 });
  }
  
  module.exports = Renderer;
  
  Renderer.$inject = ['styles'];
  
  
  Renderer.prototype.drawShape = function drawShape(gfxGroup, data) {
    return gfxGroup.rect(0, 0, data.width || 0, data.height || 0).attr(this.SHAPE_STYLE);
  };
  
  Renderer.prototype.drawConnection = function drawConnection(gfxGroup, data) {
    return createLine(data.waypoints, this.CONNECTION_STYLE).appendTo(gfxGroup);
  };
  
  function componentsToPath(components) {
    return components.join(',').replace(/,?([A-z]),?/g, '$1');
  }
  
  /**
   * Gets the default SVG path of a shape that represents it's visual bounds.
   *
   * @param {djs.model.Shape} shape
   * @return {string} svg path
   */
  Renderer.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);
  };
  
  /**
   * Gets the default SVG path of a connection that represents it's visual bounds.
   *
   * @param {djs.model.Connection} connection
   * @return {string} svg path
   */
  Renderer.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);
  };
  
  
  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) {
    return Snap.create('polyline', { points: toSVGPoints(points) }).attr(attrs || {});
  }
  
  function updateLine(gfx, points) {
    return gfx.attr({ points: toSVGPoints(points) });
  }
  
  module.exports.createLine = createLine;
  module.exports.updateLine = updateLine;
  },{"67":67}],44:[function(_dereq_,module,exports){
  'use strict';
  
  var isArray = _dereq_(159),
      assign = _dereq_(168),
      reduce = _dereq_(81);
  
  
  /**
   * A component that manages shape styles
   */
  function Styles() {
  
    var defaultTraits = {
  
      'no-fill': {
        fill: 'none'
      },
      'no-border': {
        strokeOpacity: 0.0
      },
      'no-events': {
        pointerEvents: 'none'
      }
    };
  
    /**
     * 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(traits) && !additionalAttrs) {
        additionalAttrs = traits;
        traits = [];
      }
  
      var attrs = reduce(traits, function(attrs, t) {
        return assign(attrs, defaultTraits[t] || {});
      }, {});
  
      return additionalAttrs ? assign(attrs, additionalAttrs) : attrs;
    };
  }
  
  module.exports = Styles;
  },{"159":159,"168":168,"81":81}],45:[function(_dereq_,module,exports){
  module.exports = {
    renderer: [ 'type', _dereq_(43) ],
    styles: [ 'type', _dereq_(44) ]
  };
  },{"43":43,"44":44}],46:[function(_dereq_,module,exports){
  'use strict';
  
  var forEach = _dereq_(77),
      domDelegate = _dereq_(180),
      Renderer = _dereq_(43),
      createLine = Renderer.createLine,
      updateLine = Renderer.updateLine;
  
  
  var isPrimaryButton = _dereq_(62).isPrimaryButton;
  
  var Snap = _dereq_(67);
  
  /**
   * A plugin that provides interaction events for diagram elements.
   *
   * It emits the following events:
   *
   *   * element.hover
   *   * element.out
   *   * element.click
   *   * element.dblclick
   *   * element.mousedown
   *
   * 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
    });
  
    function fire(type, event) {
      var target = event.delegateTarget || event.target,
          gfx = target && new Snap(target),
          element = elementRegistry.get(gfx),
          returnValue;
  
      if (!gfx || !element) {
        return;
      }
  
      returnValue = eventBus.fire(type, { element: element, gfx: gfx, originalEvent: event });
  
      if (returnValue === false) {
        event.stopPropagation();
        event.preventDefault();
      }
    }
  
    var handlers = {};
  
    function mouseHandler(type) {
  
      var fn = handlers[type];
  
      if (!fn) {
        fn = handlers[type] = function(event) {
          // only indicate left mouse button interactions
          if (isPrimaryButton(event)) {
            fire(type, event);
          }
        };
      }
  
      return fn;
    }
  
    var bindings = {
      mouseover: 'element.hover',
      mouseout: 'element.out',
      click: 'element.click',
      dblclick: 'element.dblclick',
      mousedown: 'element.mousedown',
      mouseup: 'element.mouseup'
    };
  
    var elementSelector = 'svg, .djs-element';
  
    ///// event registration
  
    function registerEvent(node, event, localEvent) {
      var handler = mouseHandler(localEvent);
      handler.$delegate = domDelegate.bind(node, elementSelector, event, handler);
    }
  
    function unregisterEvent(node, event, localEvent) {
      domDelegate.unbind(node, event, mouseHandler(localEvent).$delegate);
    }
  
    function registerEvents(svg) {
      forEach(bindings, function(val, key) {
        registerEvent(svg.node, key, val);
      });
    }
  
    function unregisterEvents(svg) {
      forEach(bindings, function(val, key) {
        unregisterEvent(svg.node, 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,
          type;
  
      if (element.waypoints) {
        hit = createLine(element.waypoints);
        type = 'connection';
      } else {
        hit = Snap.create('rect', { x: 0, y: 0, width: element.width, height: element.height });
        type = 'shape';
      }
  
      hit.attr(HIT_STYLE).appendTo(gfx.node);
    });
  
    // update djs-hit on change
  
    eventBus.on('shape.changed', function(event) {
  
      var element = event.element,
          gfx = event.gfx,
          hit = gfx.select('.djs-hit');
  
      hit.attr({
        width: element.width,
        height: element.height
      });
    });
  
    eventBus.on('connection.changed', function(event) {
  
      var element = event.element,
          gfx = event.gfx,
          hit = gfx.select('.djs-hit');
  
      updateLine(hit, element.waypoints);
    });
  
  
    // API
  
    this.fire = fire;
  
    this.mouseHandler = mouseHandler;
  
    this.registerEvent = registerEvent;
    this.unregisterEvent = unregisterEvent;
  }
  
  
  InteractionEvents.$inject = [ 'eventBus', 'elementRegistry', 'styles' ];
  
  module.exports = InteractionEvents;
  
  
  /**
   * An event indicating that the mouse hovered over an element
   *
   * @event element.hover
   *
   * @type {Object}
   * @property {djs.model.Base} element
   * @property {Snap<Element>} 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 {Snap<Element>} 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 {Snap<Element>} 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 {Snap<Element>} 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 {Snap<Element>} 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 {Snap<Element>} gfx
   * @property {Event} originalEvent
   */
  },{"180":180,"43":43,"62":62,"67":67,"77":77}],47:[function(_dereq_,module,exports){
  module.exports = {
    __init__: [ 'interactionEvents' ],
    interactionEvents: [ 'type', _dereq_(46) ]
  };
  },{"46":46}],48:[function(_dereq_,module,exports){
  'use strict';
  
  var getBBox = _dereq_(58).getBBox;
  
  
  /**
   * @class
   *
   * A plugin that adds an outline to shapes and connections that may be activated and styled
   * via CSS classes.
   *
   * @param {EventBus} events the event bus
   */
  function Outline(eventBus, styles, elementRegistry) {
  
    var OUTLINE_OFFSET = 6;
  
    var OUTLINE_STYLE = styles.cls('djs-outline', [ 'no-fill' ]);
  
    function createOutline(gfx, bounds) {
      return gfx.rect(10, 10, 0, 0).attr(OUTLINE_STYLE);
    }
  
    function updateShapeOutline(outline, bounds) {
  
      outline.attr({
        x: -OUTLINE_OFFSET,
        y: -OUTLINE_OFFSET,
        width: bounds.width + OUTLINE_OFFSET * 2,
        height: bounds.height + OUTLINE_OFFSET * 2
      });
    }
  
    function updateConnectionOutline(outline, connection) {
  
      var bbox = getBBox(connection);
  
      outline.attr({
        x: bbox.x - OUTLINE_OFFSET,
        y: bbox.y - OUTLINE_OFFSET,
        width: bbox.width + OUTLINE_OFFSET * 2,
        height: bbox.height + OUTLINE_OFFSET * 2
      });
    }
  
    eventBus.on([ 'shape.added', 'shape.changed' ], function(event) {
      var element = event.element,
          gfx     = event.gfx;
  
      var outline = gfx.select('.djs-outline');
  
      if (!outline) {
        outline = createOutline(gfx, element);
      }
  
      updateShapeOutline(outline, element);
    });
  
    eventBus.on([ 'connection.added', 'connection.changed' ], function(event) {
      var element = event.element,
          gfx     = event.gfx;
  
      var outline = gfx.select('.djs-outline');
  
      if (!outline) {
        outline = createOutline(gfx, element);
      }
  
      updateConnectionOutline(outline, element);
    });
  
  
  }
  
  
  Outline.$inject = ['eventBus', 'styles', 'elementRegistry'];
  
  module.exports = Outline;
  
  },{"58":58}],49:[function(_dereq_,module,exports){
  'use strict';
  
  module.exports = {
    __init__: [ 'outline' ],
    outline: [ 'type', _dereq_(48) ]
  };
  },{"48":48}],50:[function(_dereq_,module,exports){
  'use strict';
  
  var isArray = _dereq_(159),
      isString = _dereq_(165),
      isObject = _dereq_(163),
      assign = _dereq_(168),
      forEach = _dereq_(77),
      filter = _dereq_(75),
      debounce = _dereq_(84);
  
  var domify = _dereq_(181),
      domClasses = _dereq_(178),
      domRemove = _dereq_(183);
  
  var getBBox = _dereq_(58).getBBox;
  
  // document wide unique overlay ids
  var ids = new (_dereq_(61))('ov');
  
  
  function createRoot(parent) {
    var root = domify('<div class="djs-overlay-container" style="position: absolute; width: 0; height: 0;" />');
    parent.insertBefore(root, parent.firstChild);
  
    return root;
  }
  
  
  function setPosition(el, x, y) {
    assign(el.style, { left: x + 'px', top: y + 'px' });
  }
  
  function setVisible(el, visible) {
    el.style.display = visible === false ? 'none' : '';
  }
  
  /**
   * 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);
   *
   * @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 = {
      show: {
        minZoom: 0.7,
        maxZoom: 5.0
      }
    };
  
    /**
     * Mapping overlayId -> overlay
     */
    this._overlays = {};
  
    /**
     * Mapping elementId -> overlay container
     */
    this._overlayContainers = {};
  
    // root html element for all overlays
    this._overlayRoot = createRoot(canvas.getContainer());
  
    this._init(config);
  }
  
  
  Overlays.$inject = [ 'config.overlays', 'eventBus', 'canvas', 'elementRegistry' ];
  
  module.exports = Overlays;
  
  
  /**
   * 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 (isString(search)) {
      search = { id: search };
    }
  
    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 ? filter(container.overlays, { type: search.type }) : container.overlays.slice();
      } else {
        return [];
      }
    } else
    if (search.type) {
      return filter(this._overlays, { 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
   *
   * @return {String}                 id that may be used to reference the overlay for update or removal
   */
  Overlays.prototype.add = function(element, type, overlay) {
  
    if (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 = 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 (!isArray(overlays)) {
      overlays = [ overlays ];
    }
  
    var self = this;
  
    forEach(overlays, function(overlay) {
  
      var container = self._getOverlayContainer(overlay.element, true);
  
      if (overlay) {
        domRemove(overlay.html);
        domRemove(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._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 = getBBox(element);
      x = bbox.x;
      y = bbox.y;
    }
  
    setPosition(html, x, y);
  };
  
  
  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 = getBBox(element).width;
      } else {
        width = element.width;
      }
  
      left = position.right * -1 + width;
    }
  
    if (position.bottom !== undefined) {
  
      var height;
  
      if (element.waypoints) {
        height = 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 = domify('<div class="djs-overlays djs-overlays-' + element.id + '" style="position: absolute" />');
  
    this._overlayRoot.appendChild(html);
  
    var container = {
      html: html,
      element: element,
      overlays: []
    };
  
    this._updateOverlayContainer(container);
  
    return container;
  };
  
  
  Overlays.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._overlayRoot.style.transform = matrix;
    this._overlayRoot.style['-ms-transform'] = matrix;
  };
  
  
  Overlays.prototype._getOverlayContainer = function(element, raw) {
    var id = (element && element.id) || element;
  
    var container = this._overlayContainers[id];
    if (!container && !raw) {
      container = this._overlayContainers[id] = 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 = html.get(0);
    }
  
    // create proper html elements from
    // overlay HTML strings
    if (isString(html)) {
      html = domify(html);
    }
  
    overlayContainer = this._getOverlayContainer(element);
  
    htmlContainer = domify('<div class="djs-overlay" data-overlay-id="' + id + '" style="position: absolute">');
  
    htmlContainer.appendChild(html);
  
    if (overlay.type) {
      domClasses(htmlContainer).add('djs-overlay-' + overlay.type);
    }
  
    overlay.htmlContainer = htmlContainer;
  
    overlayContainer.overlays.push(overlay);
    overlayContainer.html.appendChild(htmlContainer);
  
    this._overlays[id] = overlay;
  
    this._updateOverlay(overlay);
  };
  
  Overlays.prototype._updateOverlayVisibilty = function(viewbox) {
  
    forEach(this._overlays, function(overlay) {
      var show = overlay.show,
          htmlContainer = overlay.htmlContainer,
          visible = true;
  
      if (show) {
        if (show.minZoom > viewbox.scale ||
            show.maxZoom < viewbox.scale) {
          visible = false;
        }
  
        setVisible(htmlContainer, visible);
      }
    });
  };
  
  Overlays.prototype._init = function(config) {
  
    var eventBus = this._eventBus;
  
    var self = this;
  
  
    // scroll/zoom integration
  
    var updateViewbox = function(viewbox) {
      self._updateRoot(viewbox);
      self._updateOverlayVisibilty(viewbox);
  
      self.show();
    };
  
    if (!config || config.deferUpdate !== false) {
      updateViewbox = debounce(updateViewbox, 300);
    }
  
    eventBus.on('canvas.viewbox.changed', function(event) {
      self.hide();
      updateViewbox(event.viewbox);
    });
  
  
    // remove integration
  
    eventBus.on([ 'shape.remove', 'connection.remove' ], function(e) {
      var overlays = self.get({ element: e.element });
  
      forEach(overlays, function(o) {
        self.remove(o.id);
      });
    });
  
  
    // move integration
  
    eventBus.on([
      'element.changed'
    ], function(e) {
      var element = e.element;
  
      var container = self._getOverlayContainer(element, true);
  
      if (container) {
        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) {
        domClasses(container.html)[e.add ? 'add' : 'remove'](e.marker);
      }
    });
  };
  
  },{"159":159,"163":163,"165":165,"168":168,"178":178,"181":181,"183":183,"58":58,"61":61,"75":75,"77":77,"84":84}],51:[function(_dereq_,module,exports){
  module.exports = {
    __init__: [ 'overlays' ],
    overlays: [ 'type', _dereq_(50) ]
  };
  },{"50":50}],52:[function(_dereq_,module,exports){
  'use strict';
  
  var isArray = _dereq_(159),
      forEach = _dereq_(77);
  
  
  /**
   * 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);
    });
  }
  
  Selection.$inject = [ 'eventBus' ];
  
  module.exports = Selection;
  
  
  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 (!isArray(elements)) {
      elements = elements ? [ elements ] : [];
    }
  
    // selection may be cleared by passing an empty array or null
    // to the method
    if (add) {
      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 });
  };
  
  },{"159":159,"77":77}],53:[function(_dereq_,module,exports){
  'use strict';
  
  var hasPrimaryModifier = _dereq_(62).hasPrimaryModifier;
  
  
  function SelectionBehavior(eventBus, selection, canvas) {
  
    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 = e.context.shape;
  
      // make sure at least the main moved element is being
      // selected after a move operation
      if (previousSelection.indexOf(shape) === -1) {
        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 = 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' ];
  
  module.exports = SelectionBehavior;
  
  },{"62":62}],54:[function(_dereq_,module,exports){
  'use strict';
  
  var forEach = _dereq_(77);
  
  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, graphicsFactory, 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;
  
      forEach(oldSelection, function(e) {
        if (newSelection.indexOf(e) === -1) {
          deselect(e);
        }
      });
  
      forEach(newSelection, function(e) {
        if (oldSelection.indexOf(e) === -1) {
          select(e);
        }
      });
    });
  }
  
  SelectionVisuals.$inject = [
    'eventBus',
    'canvas',
    'selection',
    'graphicsFactory',
    'styles'
  ];
  
  module.exports = SelectionVisuals;
  
  },{"77":77}],55:[function(_dereq_,module,exports){
  module.exports = {
    __init__: [ 'selectionVisuals', 'selectionBehavior' ],
    __depends__: [
      _dereq_(47),
      _dereq_(49)
    ],
    selection: [ 'type', _dereq_(52) ],
    selectionVisuals: [ 'type', _dereq_(54) ],
    selectionBehavior: [ 'type', _dereq_(53) ]
  };
  
  },{"47":47,"49":49,"52":52,"53":53,"54":54}],56:[function(_dereq_,module,exports){
  'use strict';
  
  var assign = _dereq_(168),
      inherits = _dereq_(72);
  
  var Refs = _dereq_(192);
  
  var parentRefs = new Refs({ name: 'children', enumerable: true, collection: true }, { name: 'parent' }),
      labelRefs = new Refs({ name: 'label', enumerable: true }, { name: 'labelTarget' }),
      attacherRefs = new Refs({ name: 'attachers', collection: true }, { name: 'host' }),
      outgoingRefs = new Refs({ name: 'outgoing', collection: true }, { name: 'source' }),
      incomingRefs = new Refs({ name: 'incoming', collection: true }, { name: 'target' });
  
  /**
   * @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
    });
  
    /**
     * The parent shape
     *
     * @name Base#parent
     * @type Shape
     */
    parentRefs.bind(this, 'parent');
  
    /**
     * @name Base#label
     * @type Label
     */
    labelRefs.bind(this, 'label');
  
    /**
     * The list of outgoing connections
     *
     * @name Base#outgoing
     * @type Array<Connection>
     */
    outgoingRefs.bind(this, 'outgoing');
  
    /**
     * The list of outgoing 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');
  }
  
  inherits(Shape, Base);
  
  
  /**
   * A root graphical object
   *
   * @class
   * @constructor
   *
   * @extends Shape
   */
  function Root() {
    Shape.call(this);
  }
  
  inherits(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');
  }
  
  inherits(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');
  }
  
  inherits(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
   */
  module.exports.create = function(type, attrs) {
    var Type = types[type];
    if (!Type) {
      throw new Error('unknown type: <' + type + '>');
    }
    return assign(new Type(), attrs);
  };
  
  
  module.exports.Base = Base;
  module.exports.Root = Root;
  module.exports.Shape = Shape;
  module.exports.Connection = Connection;
  module.exports.Label = Label;
  },{"168":168,"192":192,"72":72}],57:[function(_dereq_,module,exports){
  'use strict';
  
  /**
   * Failsafe remove an element from a collection
   *
   * @param  {Array<Object>} [collection]
   * @param  {Object} [element]
   *
   * @return {Object} the element that got removed or undefined
   */
  module.exports.remove = function(collection, element) {
  
    if (!collection || !element) {
      return;
    }
  
    var idx = collection.indexOf(element);
    if (idx === -1) {
      return;
    }
  
    collection.splice(idx, 1);
  
    return element;
  };
  
  /**
   * 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
   */
  module.exports.add = function(collection, element, idx) {
  
    if (!collection || !element) {
      return;
    }
  
    if (isNaN(idx)) {
      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 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.
   */
  module.exports.indexOf = function(collection, element) {
  
    if (!collection || !element) {
      return -1;
    }
  
    return collection.indexOf(element);
  };
  
  },{}],58:[function(_dereq_,module,exports){
  'use strict';
  
  var isArray = _dereq_(159),
      isNumber = _dereq_(162),
      groupBy = _dereq_(78),
      forEach = _dereq_(77);
  
  /**
   * 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;
  }
  
  function eachElement(elements, fn, depth) {
  
    depth = depth || 0;
  
    forEach(elements, function(s, i) {
      var filter = fn(s, i, depth);
  
      if (isArray(filter) && filter.length) {
        eachElement(filter, fn, depth + 1);
      }
    });
  }
  
  /**
   * Collects self + child elements up to a given depth from a list of elements.
   *
   * @param  {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 fo all selected elements,
   * their connections and
   *
   * @param {Array<djs.model.Base>} elements
   * @return {Object} enclosure
   */
  function getClosure(elements) {
  
    // original elements passed to this function
    var topLevel = groupBy(elements, function(e) { return e.id; });
  
    var allShapes = {},
        allConnections = {},
        enclosedElements = {},
        enclosedConnections = {};
  
    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.
   */
  function getBBox(elements, stopRecursion) {
  
    stopRecursion = !!stopRecursion;
    if (!isArray(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.
   *
   * @param {Array<Object>} elements List of Elements to search through
   * @param {Object} bbox the enclosing bbox.
   * <ul>
   *  <li>If bbox.(width|height) is not specified
   * the method returns all elements with element.x/y &gt; bbox.x/y
   * </li>
   *  <li>If only bbox.x or bbox.y is specified, method return all elements with
   *  e.x &gt; bbox.x or e.y &gt; bbox.y.</li>
   * </ul>
   *
   */
  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;
  }
  
  
  
  module.exports.eachElement = eachElement;
  module.exports.selfAndDirectChildren = selfAndDirectChildren;
  module.exports.selfAndAllChildren = selfAndAllChildren;
  module.exports.getBBox = getBBox;
  module.exports.getEnclosedElements = getEnclosedElements;
  
  module.exports.getClosure = getClosure;
  
  },{"159":159,"162":162,"77":77,"78":78}],59:[function(_dereq_,module,exports){
  'use strict';
  
  function __preventDefault(event) {
    return event && event.preventDefault();
  }
  
  function __stopPropagation(event, immediate) {
    if (!event) {
      return;
    }
  
    if (event.stopPropagation) {
      event.stopPropagation();
    }
  
    if (immediate && event.stopImmediatePropagation) {
      event.stopImmediatePropagation();
    }
  }
  
  
  function getOriginal(event) {
    return event.originalEvent || event.srcEvent;
  }
  
  module.exports.getOriginal = getOriginal;
  
  
  function stopEvent(event, immediate) {
    stopPropagation(event, immediate);
    preventDefault(event);
  }
  
  module.exports.stopEvent = stopEvent;
  
  
  function preventDefault(event) {
    __preventDefault(event);
    __preventDefault(getOriginal(event));
  }
  
  module.exports.preventDefault = preventDefault;
  
  
  function stopPropagation(event, immediate) {
    __stopPropagation(event, immediate);
    __stopPropagation(getOriginal(event), immediate);
  }
  
  module.exports.stopPropagation = stopPropagation;
  
  
  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;
  }
  
  module.exports.toPoint = toPoint;
  
  },{}],60:[function(_dereq_,module,exports){
  'use strict';
  
  /**
   * 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 gfx.select('.djs-visual');
  }
  
  /**
   * Returns the children for a given diagram element.
   *
   * @param {Snap<SVGElement>} gfx
   * @return {Snap<SVGElement>}
   */
  function getChildren(gfx) {
    return gfx.parent().children()[1];
  }
  
  /**
   * Returns the visual bbox of an element
   *
   * @param {Snap<SVGElement>} gfx
   *
   * @return {Bounds}
   */
  function getBBox(gfx) {
    return getVisual(gfx).select('*').getBBox();
  }
  
  
  module.exports.getVisual = getVisual;
  module.exports.getChildren = getChildren;
  module.exports.getBBox = getBBox;
  },{}],61:[function(_dereq_,module,exports){
  'use strict';
  
  /**
   * 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) + '-';
  }
  
  module.exports = IdGenerator;
  
  /**
   * Returns a next unique ID.
   *
   * @method djs.util.IdGenerator#next
   *
   * @returns {String} the id
   */
  IdGenerator.prototype.next = function() {
    return this._prefix + (++this._counter);
  };
  
  },{}],62:[function(_dereq_,module,exports){
  'use strict';
  
  var getOriginalEvent = _dereq_(59).getOriginal;
  
  var isMac = _dereq_(63).isMac;
  
  
  function isPrimaryButton(event) {
    // button === 0 -> left áka primary mouse button
    return !(getOriginalEvent(event) || event).button;
  }
  
  module.exports.isPrimaryButton = isPrimaryButton;
  
  module.exports.isMac = isMac;
  
  module.exports.hasPrimaryModifier = function(event) {
    var originalEvent = getOriginalEvent(event) || event;
  
    if (!isPrimaryButton(event)) {
      return false;
    }
  
    // Use alt as primary modifier key for mac OS
    if (isMac()) {
      return originalEvent.altKey;
    } else {
      return originalEvent.ctrlKey;
    }
  };
  
  
  module.exports.hasSecondaryModifier = function(event) {
    var originalEvent = getOriginalEvent(event) || event;
  
    return isPrimaryButton(event) && originalEvent.shiftKey;
  };
  
  },{"59":59,"63":63}],63:[function(_dereq_,module,exports){
  'use strict';
  
  module.exports.isMac = function isMac() {
    return (/mac/i).test(navigator.platform);
  };
  },{}],64:[function(_dereq_,module,exports){
  'use strict';
  
  var isObject = _dereq_(163),
      assign = _dereq_(168),
      pick = _dereq_(174),
      forEach = _dereq_(77),
      reduce = _dereq_(81),
      merge = _dereq_(171);
  
  var Snap = _dereq_(67);
  
  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 (isObject(padding)) {
      return 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;
    return pick(fakeText.getBBox(), [ 'width', 'height' ]);
  }
  
  
  /**
   * 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;
  
    while (true) {
      textBBox = getTextBBox(fitLine, fakeText);
  
      textBBox.width = fitLine ? textBBox.width : 0;
  
      // try to fit
      if (fitLine === ' ' || fitLine === '' || textBBox.width < Math.round(maxWidth) || fitLine.length < 4) {
        return fit(lines, fitLine, originalLine, textBBox);
      }
  
      fitLine = shortenLine(fitLine, textBBox.width, maxWidth);
    }
  }
  
  function fit(lines, fitLine, originalLine, textBBox) {
    if (fitLine.length < originalLine.length) {
      var nextLine = lines[0] || '',
          remainder = originalLine.slice(fitLine.length).trim();
  
      if (/-\s*$/.test(remainder)) {
        nextLine = remainder.replace(/-\s*$/, '') + nextLine.replace(/^\s+/, '');
      } else {
        nextLine = remainder + ' ' + nextLine;
      }
  
      lines[0] = nextLine;
    }
    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;
  }
  
  
  /**
   * 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 = assign({}, {
      size: DEFAULT_LABEL_SIZE,
      padding: DEFAULT_BOX_PADDING,
      style: {},
      align: 'center-top'
    }, config || {});
  }
  
  
  /**
   * Create a label in the parent node.
   *
   * @method Text#createText
   *
   * @param {SVGElement} parent the parent to draw the label on
   * @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
   *
   * @return {SVGText} the text element created
   */
  Text.prototype.createText = function(parent, text, options) {
  
    var box = merge({}, this._config.size, options.box || {}),
        style = merge({}, this._config.style, options.style || {}),
        align = parseAlign(options.align || this._config.align),
        padding = parsePadding(options.padding !== undefined ? options.padding : this._config.padding);
  
    var lines = text.split(/\r?\n/g),
        layouted = [];
  
    var maxWidth = box.width - padding.left - padding.right;
  
    // FF regression: ensure text is shown during rendering
    // by attaching it directly to the body
    var fakeText = parent.paper.text(0, 0, '').attr(style).node;
  
    while (lines.length) {
      layouted.push(layoutNext(lines, maxWidth, fakeText));
    }
  
    var totalHeight = reduce(layouted, function(sum, line, idx) {
      return sum + line.height;
    }, 0);
  
    // the y position of the next line
    var y, x;
  
    switch (align.vertical) {
      case 'middle':
        y = (box.height - totalHeight) / 2 - layouted[0].height / 4;
        break;
  
      default:
        y = padding.top;
    }
  
    var textElement = parent.text().attr(style);
  
    forEach(layouted, function(line) {
      y += line.height;
  
      switch (align.horizontal) {
        case 'left':
          x = padding.left;
          break;
  
        case 'right':
          x = (maxWidth - padding.right - line.width);
          break;
  
        default:
          // aka center
          x = Math.max(((maxWidth - line.width) / 2 + padding.left), 0);
      }
  
  
      var tspan = Snap.create('tspan', { x: x, y: y }).node;
      tspan.textContent = line.text;
  
      textElement.append(tspan);
    });
  
    // remove fake text
    fakeText.parentNode.removeChild(fakeText);
  
    return textElement;
  };
  
  
  module.exports = Text;
  
  },{"163":163,"168":168,"171":171,"174":174,"67":67,"77":77,"81":81}],65:[function(_dereq_,module,exports){
  // Copyright (c) 2013 Adobe Systems Incorporated. All rights reserved.
  // 
  // Licensed under the Apache License, Version 2.0 (the "License");
  // you may not use this file except in compliance with the License.
  // You may obtain a copy of the License at
  // 
  // http://www.apache.org/licenses/LICENSE-2.0
  // 
  // Unless required by applicable law or agreed to in writing, software
  // distributed under the License is distributed on an "AS IS" BASIS,
  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  // See the License for the specific language governing permissions and
  // limitations under the License.
  // ┌────────────────────────────────────────────────────────────┐ \\
  // │ Eve 0.4.2 - JavaScript Events Library                      │ \\
  // ├────────────────────────────────────────────────────────────┤ \\
  // │ Author Dmitry Baranovskiy (http://dmitry.baranovskiy.com/) │ \\
  // └────────────────────────────────────────────────────────────┘ \\
  
  (function (glob) {
      var version = "0.4.2",
          has = "hasOwnProperty",
          separator = /[\.\/]/,
          comaseparator = /\s*,\s*/,
          wildcard = "*",
          fun = function () {},
          numsort = function (a, b) {
              return a - b;
          },
          current_event,
          stop,
          events = {n: {}},
          firstDefined = function () {
              for (var i = 0, ii = this.length; i < ii; i++) {
                  if (typeof this[i] != "undefined") {
                      return this[i];
                  }
              }
          },
          lastDefined = function () {
              var i = this.length;
              while (--i) {
                  if (typeof this[i] != "undefined") {
                      return this[i];
                  }
              }
          },
      /*\
       * eve
       [ method ]
  
       * Fires event with given `name`, given scope and other parameters.
  
       > Arguments
  
       - name (string) name of the *event*, dot (`.`) or slash (`/`) separated
       - scope (object) context for the event handlers
       - varargs (...) the rest of arguments will be sent to event handlers
  
       = (object) array of returned values from the listeners. Array has two methods `.firstDefined()` and `.lastDefined()` to get first or last not `undefined` value.
      \*/
          eve = function (name, scope) {
              name = String(name);
              var e = events,
                  oldstop = stop,
                  args = Array.prototype.slice.call(arguments, 2),
                  listeners = eve.listeners(name),
                  z = 0,
                  f = false,
                  l,
                  indexed = [],
                  queue = {},
                  out = [],
                  ce = current_event,
                  errors = [];
              out.firstDefined = firstDefined;
              out.lastDefined = lastDefined;
              current_event = name;
              stop = 0;
              for (var i = 0, ii = listeners.length; i < ii; i++) if ("zIndex" in listeners[i]) {
                  indexed.push(listeners[i].zIndex);
                  if (listeners[i].zIndex < 0) {
                      queue[listeners[i].zIndex] = listeners[i];
                  }
              }
              indexed.sort(numsort);
              while (indexed[z] < 0) {
                  l = queue[indexed[z++]];
                  out.push(l.apply(scope, args));
                  if (stop) {
                      stop = oldstop;
                      return out;
                  }
              }
              for (i = 0; i < ii; i++) {
                  l = listeners[i];
                  if ("zIndex" in l) {
                      if (l.zIndex == indexed[z]) {
                          out.push(l.apply(scope, args));
                          if (stop) {
                              break;
                          }
                          do {
                              z++;
                              l = queue[indexed[z]];
                              l && out.push(l.apply(scope, args));
                              if (stop) {
                                  break;
                              }
                          } while (l)
                      } else {
                          queue[l.zIndex] = l;
                      }
                  } else {
                      out.push(l.apply(scope, args));
                      if (stop) {
                          break;
                      }
                  }
              }
              stop = oldstop;
              current_event = ce;
              return out;
          };
          // Undocumented. Debug only.
          eve._events = events;
      /*\
       * eve.listeners
       [ method ]
  
       * Internal method which gives you array of all event handlers that will be triggered by the given `name`.
  
       > Arguments
  
       - name (string) name of the event, dot (`.`) or slash (`/`) separated
  
       = (array) array of event handlers
      \*/
      eve.listeners = function (name) {
          var names = name.split(separator),
              e = events,
              item,
              items,
              k,
              i,
              ii,
              j,
              jj,
              nes,
              es = [e],
              out = [];
          for (i = 0, ii = names.length; i < ii; i++) {
              nes = [];
              for (j = 0, jj = es.length; j < jj; j++) {
                  e = es[j].n;
                  items = [e[names[i]], e[wildcard]];
                  k = 2;
                  while (k--) {
                      item = items[k];
                      if (item) {
                          nes.push(item);
                          out = out.concat(item.f || []);
                      }
                  }
              }
              es = nes;
          }
          return out;
      };
      
      /*\
       * eve.on
       [ method ]
       **
       * Binds given event handler with a given name. You can use wildcards “`*`” for the names:
       | eve.on("*.under.*", f);
       | eve("mouse.under.floor"); // triggers f
       * Use @eve to trigger the listener.
       **
       > Arguments
       **
       - name (string) name of the event, dot (`.`) or slash (`/`) separated, with optional wildcards
       - f (function) event handler function
       **
       = (function) returned function accepts a single numeric parameter that represents z-index of the handler. It is an optional feature and only used when you need to ensure that some subset of handlers will be invoked in a given order, despite of the order of assignment. 
       > Example:
       | eve.on("mouse", eatIt)(2);
       | eve.on("mouse", scream);
       | eve.on("mouse", catchIt)(1);
       * This will ensure that `catchIt` function will be called before `eatIt`.
       *
       * If you want to put your handler before non-indexed handlers, specify a negative value.
       * Note: I assume most of the time you don’t need to worry about z-index, but it’s nice to have this feature “just in case”.
      \*/
      eve.on = function (name, f) {
          name = String(name);
          if (typeof f != "function") {
              return function () {};
          }
          var names = name.split(comaseparator);
          for (var i = 0, ii = names.length; i < ii; i++) {
              (function (name) {
                  var names = name.split(separator),
                      e = events,
                      exist;
                  for (var i = 0, ii = names.length; i < ii; i++) {
                      e = e.n;
                      e = e.hasOwnProperty(names[i]) && e[names[i]] || (e[names[i]] = {n: {}});
                  }
                  e.f = e.f || [];
                  for (i = 0, ii = e.f.length; i < ii; i++) if (e.f[i] == f) {
                      exist = true;
                      break;
                  }
                  !exist && e.f.push(f);
              }(names[i]));
          }
          return function (zIndex) {
              if (+zIndex == +zIndex) {
                  f.zIndex = +zIndex;
              }
          };
      };
      /*\
       * eve.f
       [ method ]
       **
       * Returns function that will fire given event with optional arguments.
       * Arguments that will be passed to the result function will be also
       * concated to the list of final arguments.
       | el.onclick = eve.f("click", 1, 2);
       | eve.on("click", function (a, b, c) {
       |     console.log(a, b, c); // 1, 2, [event object]
       | });
       > Arguments
       - event (string) event name
       - varargs (…) and any other arguments
       = (function) possible event handler function
      \*/
      eve.f = function (event) {
          var attrs = [].slice.call(arguments, 1);
          return function () {
              eve.apply(null, [event, null].concat(attrs).concat([].slice.call(arguments, 0)));
          };
      };
      /*\
       * eve.stop
       [ method ]
       **
       * Is used inside an event handler to stop the event, preventing any subsequent listeners from firing.
      \*/
      eve.stop = function () {
          stop = 1;
      };
      /*\
       * eve.nt
       [ method ]
       **
       * Could be used inside event handler to figure out actual name of the event.
       **
       > Arguments
       **
       - subname (string) #optional subname of the event
       **
       = (string) name of the event, if `subname` is not specified
       * or
       = (boolean) `true`, if current event’s name contains `subname`
      \*/
      eve.nt = function (subname) {
          if (subname) {
              return new RegExp("(?:\\.|\\/|^)" + subname + "(?:\\.|\\/|$)").test(current_event);
          }
          return current_event;
      };
      /*\
       * eve.nts
       [ method ]
       **
       * Could be used inside event handler to figure out actual name of the event.
       **
       **
       = (array) names of the event
      \*/
      eve.nts = function () {
          return current_event.split(separator);
      };
      /*\
       * eve.off
       [ method ]
       **
       * Removes given function from the list of event listeners assigned to given name.
       * If no arguments specified all the events will be cleared.
       **
       > Arguments
       **
       - name (string) name of the event, dot (`.`) or slash (`/`) separated, with optional wildcards
       - f (function) event handler function
      \*/
      /*\
       * eve.unbind
       [ method ]
       **
       * See @eve.off
      \*/
      eve.off = eve.unbind = function (name, f) {
          if (!name) {
              eve._events = events = {n: {}};
              return;
          }
          var names = name.split(comaseparator);
          if (names.length > 1) {
              for (var i = 0, ii = names.length; i < ii; i++) {
                  eve.off(names[i], f);
              }
              return;
          }
          names = name.split(separator);
          var e,
              key,
              splice,
              i, ii, j, jj,
              cur = [events];
          for (i = 0, ii = names.length; i < ii; i++) {
              for (j = 0; j < cur.length; j += splice.length - 2) {
                  splice = [j, 1];
                  e = cur[j].n;
                  if (names[i] != wildcard) {
                      if (e[names[i]]) {
                          splice.push(e[names[i]]);
                      }
                  } else {
                      for (key in e) if (e[has](key)) {
                          splice.push(e[key]);
                      }
                  }
                  cur.splice.apply(cur, splice);
              }
          }
          for (i = 0, ii = cur.length; i < ii; i++) {
              e = cur[i];
              while (e.n) {
                  if (f) {
                      if (e.f) {
                          for (j = 0, jj = e.f.length; j < jj; j++) if (e.f[j] == f) {
                              e.f.splice(j, 1);
                              break;
                          }
                          !e.f.length && delete e.f;
                      }
                      for (key in e.n) if (e.n[has](key) && e.n[key].f) {
                          var funcs = e.n[key].f;
                          for (j = 0, jj = funcs.length; j < jj; j++) if (funcs[j] == f) {
                              funcs.splice(j, 1);
                              break;
                          }
                          !funcs.length && delete e.n[key].f;
                      }
                  } else {
                      delete e.f;
                      for (key in e.n) if (e.n[has](key) && e.n[key].f) {
                          delete e.n[key].f;
                      }
                  }
                  e = e.n;
              }
          }
      };
      /*\
       * eve.once
       [ method ]
       **
       * Binds given event handler with a given name to only run once then unbind itself.
       | eve.once("login", f);
       | eve("login"); // triggers f
       | eve("login"); // no listeners
       * Use @eve to trigger the listener.
       **
       > Arguments
       **
       - name (string) name of the event, dot (`.`) or slash (`/`) separated, with optional wildcards
       - f (function) event handler function
       **
       = (function) same return function as @eve.on
      \*/
      eve.once = function (name, f) {
          var f2 = function () {
              eve.unbind(name, f2);
              return f.apply(this, arguments);
          };
          return eve.on(name, f2);
      };
      /*\
       * eve.version
       [ property (string) ]
       **
       * Current version of the library.
      \*/
      eve.version = version;
      eve.toString = function () {
          return "You are running Eve " + version;
      };
      (typeof module != "undefined" && module.exports) ? (module.exports = eve) : (typeof define === "function" && define.amd ? (define("eve", [], function() { return eve; })) : (glob.eve = eve));
  })(this);
  
  },{}],66:[function(_dereq_,module,exports){
  // Snap.svg 0.3.0
  // 
  // Copyright (c) 2013 – 2014 Adobe Systems Incorporated. All rights reserved.
  // 
  // Licensed under the Apache License, Version 2.0 (the "License");
  // you may not use this file except in compliance with the License.
  // You may obtain a copy of the License at
  // 
  // http://www.apache.org/licenses/LICENSE-2.0
  // 
  // Unless required by applicable law or agreed to in writing, software
  // distributed under the License is distributed on an "AS IS" BASIS,
  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  // See the License for the specific language governing permissions and
  // limitations under the License.
  // 
  // build: 2014-09-08
  
  (function (glob, factory) {
      // AMD support
      if (typeof define === "function" && define.amd) {
          // Define as an anonymous module
          define(["eve"], function( eve ) {
              return factory(glob, eve);
          });
      } else if (typeof exports !== 'undefined') {
          // Next for Node.js or CommonJS
          var eve = _dereq_(65);
          module.exports = factory(glob, eve);
      } else {
          // Browser globals (glob is window)
          // Snap adds itself to window
          factory(glob, glob.eve);
      }
  }(window || this, function (window, eve) {
  
  // Copyright (c) 2013 Adobe Systems Incorporated. All rights reserved.
  // 
  // Licensed under the Apache License, Version 2.0 (the "License");
  // you may not use this file except in compliance with the License.
  // You may obtain a copy of the License at
  // 
  // http://www.apache.org/licenses/LICENSE-2.0
  // 
  // Unless required by applicable law or agreed to in writing, software
  // distributed under the License is distributed on an "AS IS" BASIS,
  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  // See the License for the specific language governing permissions and
  // limitations under the License.
  var mina = (function (eve) {
      var animations = {},
      requestAnimFrame = window.requestAnimationFrame       ||
                         window.webkitRequestAnimationFrame ||
                         window.mozRequestAnimationFrame    ||
                         window.oRequestAnimationFrame      ||
                         window.msRequestAnimationFrame     ||
                         function (callback) {
                             setTimeout(callback, 16);
                         },
      isArray = Array.isArray || function (a) {
          return a instanceof Array ||
              Object.prototype.toString.call(a) == "[object Array]";
      },
      idgen = 0,
      idprefix = "M" + (+new Date).toString(36),
      ID = function () {
          return idprefix + (idgen++).toString(36);
      },
      diff = function (a, b, A, B) {
          if (isArray(a)) {
              res = [];
              for (var i = 0, ii = a.length; i < ii; i++) {
                  res[i] = diff(a[i], b, A[i], B);
              }
              return res;
          }
          var dif = (A - a) / (B - b);
          return function (bb) {
              return a + dif * (bb - b);
          };
      },
      timer = Date.now || function () {
          return +new Date;
      },
      sta = function (val) {
          var a = this;
          if (val == null) {
              return a.s;
          }
          var ds = a.s - val;
          a.b += a.dur * ds;
          a.B += a.dur * ds;
          a.s = val;
      },
      speed = function (val) {
          var a = this;
          if (val == null) {
              return a.spd;
          }
          a.spd = val;
      },
      duration = function (val) {
          var a = this;
          if (val == null) {
              return a.dur;
          }
          a.s = a.s * val / a.dur;
          a.dur = val;
      },
      stopit = function () {
          var a = this;
          delete animations[a.id];
          a.update();
          eve("mina.stop." + a.id, a);
      },
      pause = function () {
          var a = this;
          if (a.pdif) {
              return;
          }
          delete animations[a.id];
          a.update();
          a.pdif = a.get() - a.b;
      },
      resume = function () {
          var a = this;
          if (!a.pdif) {
              return;
          }
          a.b = a.get() - a.pdif;
          delete a.pdif;
          animations[a.id] = a;
      },
      update = function () {
          var a = this,
              res;
          if (isArray(a.start)) {
              res = [];
              for (var j = 0, jj = a.start.length; j < jj; j++) {
                  res[j] = +a.start[j] +
                      (a.end[j] - a.start[j]) * a.easing(a.s);
              }
          } else {
              res = +a.start + (a.end - a.start) * a.easing(a.s);
          }
          a.set(res);
      },
      frame = function () {
          var len = 0;
          for (var i in animations) if (animations.hasOwnProperty(i)) {
              var a = animations[i],
                  b = a.get(),
                  res;
              len++;
              a.s = (b - a.b) / (a.dur / a.spd);
              if (a.s >= 1) {
                  delete animations[i];
                  a.s = 1;
                  len--;
                  (function (a) {
                      setTimeout(function () {
                          eve("mina.finish." + a.id, a);
                      });
                  }(a));
              }
              a.update();
          }
          len && requestAnimFrame(frame);
      },
      /*\
       * mina
       [ method ]
       **
       * Generic animation of numbers
       **
       - a (number) start _slave_ number
       - A (number) end _slave_ number
       - b (number) start _master_ number (start time in general case)
       - B (number) end _master_ number (end time in gereal case)
       - get (function) getter of _master_ number (see @mina.time)
       - set (function) setter of _slave_ number
       - easing (function) #optional easing function, default is @mina.linear
       = (object) animation descriptor
       o {
       o         id (string) animation id,
       o         start (number) start _slave_ number,
       o         end (number) end _slave_ number,
       o         b (number) start _master_ number,
       o         s (number) animation status (0..1),
       o         dur (number) animation duration,
       o         spd (number) animation speed,
       o         get (function) getter of _master_ number (see @mina.time),
       o         set (function) setter of _slave_ number,
       o         easing (function) easing function, default is @mina.linear,
       o         status (function) status getter/setter,
       o         speed (function) speed getter/setter,
       o         duration (function) duration getter/setter,
       o         stop (function) animation stopper
       o         pause (function) pauses the animation
       o         resume (function) resumes the animation
       o         update (function) calles setter with the right value of the animation
       o }
      \*/
      mina = function (a, A, b, B, get, set, easing) {
          var anim = {
              id: ID(),
              start: a,
              end: A,
              b: b,
              s: 0,
              dur: B - b,
              spd: 1,
              get: get,
              set: set,
              easing: easing || mina.linear,
              status: sta,
              speed: speed,
              duration: duration,
              stop: stopit,
              pause: pause,
              resume: resume,
              update: update
          };
          animations[anim.id] = anim;
          var len = 0, i;
          for (i in animations) if (animations.hasOwnProperty(i)) {
              len++;
              if (len == 2) {
                  break;
              }
          }
          len == 1 && requestAnimFrame(frame);
          return anim;
      };
      /*\
       * mina.time
       [ method ]
       **
       * Returns the current time. Equivalent to:
       | function () {
       |     return (new Date).getTime();
       | }
      \*/
      mina.time = timer;
      /*\
       * mina.getById
       [ method ]
       **
       * Returns an animation by its id
       - id (string) animation's id
       = (object) See @mina
      \*/
      mina.getById = function (id) {
          return animations[id] || null;
      };
  
      /*\
       * mina.linear
       [ method ]
       **
       * Default linear easing
       - n (number) input 0..1
       = (number) output 0..1
      \*/
      mina.linear = function (n) {
          return n;
      };
      /*\
       * mina.easeout
       [ method ]
       **
       * Easeout easing
       - n (number) input 0..1
       = (number) output 0..1
      \*/
      mina.easeout = function (n) {
          return Math.pow(n, 1.7);
      };
      /*\
       * mina.easein
       [ method ]
       **
       * Easein easing
       - n (number) input 0..1
       = (number) output 0..1
      \*/
      mina.easein = function (n) {
          return Math.pow(n, .48);
      };
      /*\
       * mina.easeinout
       [ method ]
       **
       * Easeinout easing
       - n (number) input 0..1
       = (number) output 0..1
      \*/
      mina.easeinout = function (n) {
          if (n == 1) {
              return 1;
          }
          if (n == 0) {
              return 0;
          }
          var q = .48 - n / 1.04,
              Q = Math.sqrt(.1734 + q * q),
              x = Q - q,
              X = Math.pow(Math.abs(x), 1 / 3) * (x < 0 ? -1 : 1),
              y = -Q - q,
              Y = Math.pow(Math.abs(y), 1 / 3) * (y < 0 ? -1 : 1),
              t = X + Y + .5;
          return (1 - t) * 3 * t * t + t * t * t;
      };
      /*\
       * mina.backin
       [ method ]
       **
       * Backin easing
       - n (number) input 0..1
       = (number) output 0..1
      \*/
      mina.backin = function (n) {
          if (n == 1) {
              return 1;
          }
          var s = 1.70158;
          return n * n * ((s + 1) * n - s);
      };
      /*\
       * mina.backout
       [ method ]
       **
       * Backout easing
       - n (number) input 0..1
       = (number) output 0..1
      \*/
      mina.backout = function (n) {
          if (n == 0) {
              return 0;
          }
          n = n - 1;
          var s = 1.70158;
          return n * n * ((s + 1) * n + s) + 1;
      };
      /*\
       * mina.elastic
       [ method ]
       **
       * Elastic easing
       - n (number) input 0..1
       = (number) output 0..1
      \*/
      mina.elastic = function (n) {
          if (n == !!n) {
              return n;
          }
          return Math.pow(2, -10 * n) * Math.sin((n - .075) *
              (2 * Math.PI) / .3) + 1;
      };
      /*\
       * mina.bounce
       [ method ]
       **
       * Bounce easing
       - n (number) input 0..1
       = (number) output 0..1
      \*/
      mina.bounce = function (n) {
          var s = 7.5625,
              p = 2.75,
              l;
          if (n < (1 / p)) {
              l = s * n * n;
          } else {
              if (n < (2 / p)) {
                  n -= (1.5 / p);
                  l = s * n * n + .75;
              } else {
                  if (n < (2.5 / p)) {
                      n -= (2.25 / p);
                      l = s * n * n + .9375;
                  } else {
                      n -= (2.625 / p);
                      l = s * n * n + .984375;
                  }
              }
          }
          return l;
      };
      window.mina = mina;
      return mina;
  })(typeof eve == "undefined" ? function () {} : eve);
  // Copyright (c) 2013 Adobe Systems Incorporated. All rights reserved.
  //
  // Licensed under the Apache License, Version 2.0 (the "License");
  // you may not use this file except in compliance with the License.
  // You may obtain a copy of the License at
  //
  // http://www.apache.org/licenses/LICENSE-2.0
  //
  // Unless required by applicable law or agreed to in writing, software
  // distributed under the License is distributed on an "AS IS" BASIS,
  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  // See the License for the specific language governing permissions and
  // limitations under the License.
  
  var Snap = (function(root) {
  Snap.version = "0.3.0";
  /*\
   * Snap
   [ method ]
   **
   * Creates a drawing surface or wraps existing SVG element.
   **
   - width (number|string) width of surface
   - height (number|string) height of surface
   * or
   - DOM (SVGElement) element to be wrapped into Snap structure
   * or
   - array (array) array of elements (will return set of elements)
   * or
   - query (string) CSS query selector
   = (object) @Element
  \*/
  function Snap(w, h) {
      if (w) {
          if (w.tagName) {
              return wrap(w);
          }
          if (is(w, "array") && Snap.set) {
              return Snap.set.apply(Snap, w);
          }
          if (w instanceof Element) {
              return w;
          }
          if (h == null) {
              w = glob.doc.querySelector(w);
              return wrap(w);
          }
      }
      w = w == null ? "100%" : w;
      h = h == null ? "100%" : h;
      return new Paper(w, h);
  }
  Snap.toString = function () {
      return "Snap v" + this.version;
  };
  Snap._ = {};
  var glob = {
      win: root.window,
      doc: root.window.document
  };
  Snap._.glob = glob;
  var has = "hasOwnProperty",
      Str = String,
      toFloat = parseFloat,
      toInt = parseInt,
      math = Math,
      mmax = math.max,
      mmin = math.min,
      abs = math.abs,
      pow = math.pow,
      PI = math.PI,
      round = math.round,
      E = "",
      S = " ",
      objectToString = Object.prototype.toString,
      ISURL = /^url\(['"]?([^\)]+?)['"]?\)$/i,
      colourRegExp = /^\s*((#[a-f\d]{6})|(#[a-f\d]{3})|rgba?\(\s*([\d\.]+%?\s*,\s*[\d\.]+%?\s*,\s*[\d\.]+%?(?:\s*,\s*[\d\.]+%?)?)\s*\)|hsba?\(\s*([\d\.]+(?:deg|\xb0|%)?\s*,\s*[\d\.]+%?\s*,\s*[\d\.]+(?:%?\s*,\s*[\d\.]+)?%?)\s*\)|hsla?\(\s*([\d\.]+(?:deg|\xb0|%)?\s*,\s*[\d\.]+%?\s*,\s*[\d\.]+(?:%?\s*,\s*[\d\.]+)?%?)\s*\))\s*$/i,
      bezierrg = /^(?:cubic-)?bezier\(([^,]+),([^,]+),([^,]+),([^\)]+)\)/,
      reURLValue = /^url\(#?([^)]+)\)$/,
      separator = Snap._.separator = /[,\s]+/,
      whitespace = /[\s]/g,
      commaSpaces = /[\s]*,[\s]*/,
      hsrg = {hs: 1, rg: 1},
      pathCommand = /([a-z])[\s,]*((-?\d*\.?\d*(?:e[\-+]?\d+)?[\s]*,?[\s]*)+)/ig,
      tCommand = /([rstm])[\s,]*((-?\d*\.?\d*(?:e[\-+]?\d+)?[\s]*,?[\s]*)+)/ig,
      pathValues = /(-?\d*\.?\d*(?:e[\-+]?\\d+)?)[\s]*,?[\s]*/ig,
      idgen = 0,
      idprefix = "S" + (+new Date).toString(36),
      ID = function (el) {
          return (el && el.type ? el.type : E) + idprefix + (idgen++).toString(36);
      },
      xlink = "http://www.w3.org/1999/xlink",
      xmlns = "http://www.w3.org/2000/svg",
      hub = {},
      URL = Snap.url = function (url) {
          return "url('#" + url + "')";
      };
  
  function $(el, attr) {
      if (attr) {
          if (el == "#text") {
              el = glob.doc.createTextNode(attr.text || "");
          }
          if (typeof el == "string") {
              el = $(el);
          }
          if (typeof attr == "string") {
              if (attr.substring(0, 6) == "xlink:") {
                  return el.getAttributeNS(xlink, attr.substring(6));
              }
              if (attr.substring(0, 4) == "xml:") {
                  return el.getAttributeNS(xmlns, attr.substring(4));
              }
              return el.getAttribute(attr);
          }
          for (var key in attr) if (attr[has](key)) {
              var val = Str(attr[key]);
              if (val) {
                  if (key.substring(0, 6) == "xlink:") {
                      el.setAttributeNS(xlink, key.substring(6), val);
                  } else if (key.substring(0, 4) == "xml:") {
                      el.setAttributeNS(xmlns, key.substring(4), val);
                  } else {
                      el.setAttribute(key, val);
                  }
              } else {
                  el.removeAttribute(key);
              }
          }
      } else {
          el = glob.doc.createElementNS(xmlns, el);
      }
      return el;
  }
  Snap._.$ = $;
  Snap._.id = ID;
  function getAttrs(el) {
      var attrs = el.attributes,
          name,
          out = {};
      for (var i = 0; i < attrs.length; i++) {
          if (attrs[i].namespaceURI == xlink) {
              name = "xlink:";
          } else {
              name = "";
          }
          name += attrs[i].name;
          out[name] = attrs[i].textContent;
      }
      return out;
  }
  function is(o, type) {
      type = Str.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 && o !== null) ||
              (type == "object" && o === Object(o)) ||
              objectToString.call(o).slice(8, -1).toLowerCase() == type;
  }
  /*\
   * Snap.format
   [ method ]
   **
   * Replaces construction of type `{<name>}` to the corresponding argument
   **
   - token (string) string to format
   - json (object) object which properties are used as a replacement
   = (string) formatted string
   > Usage
   | // this draws a rectangular shape equivalent to "M10,20h40v50h-40z"
   | paper.path(Snap.format("M{x},{y}h{dim.width}v{dim.height}h{dim['negative width']}z", {
   |     x: 10,
   |     y: 20,
   |     dim: {
   |         width: 40,
   |         height: 50,
   |         "negative width": -40
   |     }
   | }));
  \*/
  Snap.format = (function () {
      var tokenRegex = /\{([^\}]+)\}/g,
          objNotationRegex = /(?:(?:^|\.)(.+?)(?=\[|\.|$|\()|\[('|")(.+?)\2\])(\(\))?/g, // matches .xxxxx or ["xxxxx"] to run over object properties
          replacer = function (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;
          };
      return function (str, obj) {
          return Str(str).replace(tokenRegex, function (all, key) {
              return replacer(all, key, obj);
          });
      };
  })();
  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;
  }
  Snap._.clone = clone;
  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;
  }
  Snap._.cacher = cacher;
  function angle(x1, y1, x2, y2, x3, y3) {
      if (x3 == null) {
          var x = x1 - x2,
              y = y1 - y2;
          if (!x && !y) {
              return 0;
          }
          return (180 + math.atan2(-y, -x) * 180 / PI + 360) % 360;
      } else {
          return angle(x1, y1, x3, y3) - angle(x2, y2, x3, y3);
      }
  }
  function rad(deg) {
      return deg % 360 * PI / 180;
  }
  function deg(rad) {
      return rad * 180 / PI % 360;
  }
  function x_y() {
      return this.x + S + this.y;
  }
  function x_y_w_h() {
      return this.x + S + this.y + S + this.width + " \xd7 " + this.height;
  }
  
  /*\
   * Snap.rad
   [ method ]
   **
   * Transform angle to radians
   - deg (number) angle in degrees
   = (number) angle in radians
  \*/
  Snap.rad = rad;
  /*\
   * Snap.deg
   [ method ]
   **
   * Transform angle to degrees
   - rad (number) angle in radians
   = (number) angle in degrees
  \*/
  Snap.deg = deg;
  /*\
   * Snap.angle
   [ method ]
   **
   * Returns an angle between two or three points
   > Parameters
   - x1 (number) x coord of first point
   - y1 (number) y coord of first point
   - x2 (number) x coord of second point
   - y2 (number) y coord of second point
   - x3 (number) #optional x coord of third point
   - y3 (number) #optional y coord of third point
   = (number) angle in degrees
  \*/
  Snap.angle = angle;
  /*\
   * Snap.is
   [ method ]
   **
   * Handy replacement for the `typeof` operator
   - o (…) any object or primitive
   - type (string) name of the type, e.g., `string`, `function`, `number`, etc.
   = (boolean) `true` if given value is of given type
  \*/
  Snap.is = is;
  /*\
   * Snap.snapTo
   [ method ]
   **
   * Snaps given value to given grid
   - values (array|number) given array of values or step of the grid
   - value (number) value to adjust
   - tolerance (number) #optional maximum distance to the target value that would trigger the snap. Default is `10`.
   = (number) adjusted value
  \*/
  Snap.snapTo = function (values, value, tolerance) {
      tolerance = is(tolerance, "finite") ? tolerance : 10;
      if (is(values, "array")) {
          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;
  };
  // Colour
  /*\
   * Snap.getRGB
   [ method ]
   **
   * Parses color string as RGB object
   - color (string) color string in one of the following formats:
   # <ul>
   #     <li>Color name (<code>red</code>, <code>green</code>, <code>cornflowerblue</code>, etc)</li>
   #     <li>#••• — shortened HTML color: (<code>#000</code>, <code>#fc0</code>, etc.)</li>
   #     <li>#•••••• — full length HTML color: (<code>#000000</code>, <code>#bd2300</code>)</li>
   #     <li>rgb(•••, •••, •••) — red, green and blue channels values: (<code>rgb(200,&nbsp;100,&nbsp;0)</code>)</li>
   #     <li>rgba(•••, •••, •••, •••) — also with opacity</li>
   #     <li>rgb(•••%, •••%, •••%) — same as above, but in %: (<code>rgb(100%,&nbsp;175%,&nbsp;0%)</code>)</li>
   #     <li>rgba(•••%, •••%, •••%, •••%) — also with opacity</li>
   #     <li>hsb(•••, •••, •••) — hue, saturation and brightness values: (<code>hsb(0.5,&nbsp;0.25,&nbsp;1)</code>)</li>
   #     <li>hsba(•••, •••, •••, •••) — also with opacity</li>
   #     <li>hsb(•••%, •••%, •••%) — same as above, but in %</li>
   #     <li>hsba(•••%, •••%, •••%, •••%) — also with opacity</li>
   #     <li>hsl(•••, •••, •••) — hue, saturation and luminosity values: (<code>hsb(0.5,&nbsp;0.25,&nbsp;0.5)</code>)</li>
   #     <li>hsla(•••, •••, •••, •••) — also with opacity</li>
   #     <li>hsl(•••%, •••%, •••%) — same as above, but in %</li>
   #     <li>hsla(•••%, •••%, •••%, •••%) — also with opacity</li>
   # </ul>
   * Note that `%` can be used any time: `rgb(20%, 255, 50%)`.
   = (object) RGB object in the following format:
   o {
   o     r (number) red,
   o     g (number) green,
   o     b (number) blue,
   o     hex (string) color in HTML/CSS format: #••••••,
   o     error (boolean) true if string can't be parsed
   o }
  \*/
  Snap.getRGB = cacher(function (colour) {
      if (!colour || !!((colour = Str(colour)).indexOf("-") + 1)) {
          return {r: -1, g: -1, b: -1, hex: "none", error: 1, toString: rgbtoString};
      }
      if (colour == "none") {
          return {r: -1, g: -1, b: -1, hex: "none", toString: rgbtoString};
      }
      !(hsrg[has](colour.toLowerCase().substring(0, 2)) || colour.charAt() == "#") && (colour = toHex(colour));
      if (!colour) {
          return {r: -1, g: -1, b: -1, hex: "none", error: 1, toString: rgbtoString};
      }
      var res,
          red,
          green,
          blue,
          opacity,
          t,
          values,
          rgb = colour.match(colourRegExp);
      if (rgb) {
          if (rgb[2]) {
              blue = toInt(rgb[2].substring(5), 16);
              green = toInt(rgb[2].substring(3, 5), 16);
              red = toInt(rgb[2].substring(1, 3), 16);
          }
          if (rgb[3]) {
              blue = toInt((t = rgb[3].charAt(3)) + t, 16);
              green = toInt((t = rgb[3].charAt(2)) + t, 16);
              red = toInt((t = rgb[3].charAt(1)) + t, 16);
          }
          if (rgb[4]) {
              values = rgb[4].split(commaSpaces);
              red = toFloat(values[0]);
              values[0].slice(-1) == "%" && (red *= 2.55);
              green = toFloat(values[1]);
              values[1].slice(-1) == "%" && (green *= 2.55);
              blue = toFloat(values[2]);
              values[2].slice(-1) == "%" && (blue *= 2.55);
              rgb[1].toLowerCase().slice(0, 4) == "rgba" && (opacity = toFloat(values[3]));
              values[3] && values[3].slice(-1) == "%" && (opacity /= 100);
          }
          if (rgb[5]) {
              values = rgb[5].split(commaSpaces);
              red = toFloat(values[0]);
              values[0].slice(-1) == "%" && (red /= 100);
              green = toFloat(values[1]);
              values[1].slice(-1) == "%" && (green /= 100);
              blue = toFloat(values[2]);
              values[2].slice(-1) == "%" && (blue /= 100);
              (values[0].slice(-3) == "deg" || values[0].slice(-1) == "\xb0") && (red /= 360);
              rgb[1].toLowerCase().slice(0, 4) == "hsba" && (opacity = toFloat(values[3]));
              values[3] && values[3].slice(-1) == "%" && (opacity /= 100);
              return Snap.hsb2rgb(red, green, blue, opacity);
          }
          if (rgb[6]) {
              values = rgb[6].split(commaSpaces);
              red = toFloat(values[0]);
              values[0].slice(-1) == "%" && (red /= 100);
              green = toFloat(values[1]);
              values[1].slice(-1) == "%" && (green /= 100);
              blue = toFloat(values[2]);
              values[2].slice(-1) == "%" && (blue /= 100);
              (values[0].slice(-3) == "deg" || values[0].slice(-1) == "\xb0") && (red /= 360);
              rgb[1].toLowerCase().slice(0, 4) == "hsla" && (opacity = toFloat(values[3]));
              values[3] && values[3].slice(-1) == "%" && (opacity /= 100);
              return Snap.hsl2rgb(red, green, blue, opacity);
          }
          red = mmin(math.round(red), 255);
          green = mmin(math.round(green), 255);
          blue = mmin(math.round(blue), 255);
          opacity = mmin(mmax(opacity, 0), 1);
          rgb = {r: red, g: green, b: blue, toString: rgbtoString};
          rgb.hex = "#" + (16777216 | blue | (green << 8) | (red << 16)).toString(16).slice(1);
          rgb.opacity = is(opacity, "finite") ? opacity : 1;
          return rgb;
      }
      return {r: -1, g: -1, b: -1, hex: "none", error: 1, toString: rgbtoString};
  }, Snap);
  // SIERRA It seems odd that the following 3 conversion methods are not expressed as .this2that(), like the others.
  /*\
   * Snap.hsb
   [ method ]
   **
   * Converts HSB values to a hex representation of the color
   - h (number) hue
   - s (number) saturation
   - b (number) value or brightness
   = (string) hex representation of the color
  \*/
  Snap.hsb = cacher(function (h, s, b) {
      return Snap.hsb2rgb(h, s, b).hex;
  });
  /*\
   * Snap.hsl
   [ method ]
   **
   * Converts HSL values to a hex representation of the color
   - h (number) hue
   - s (number) saturation
   - l (number) luminosity
   = (string) hex representation of the color
  \*/
  Snap.hsl = cacher(function (h, s, l) {
      return Snap.hsl2rgb(h, s, l).hex;
  });
  /*\
   * Snap.rgb
   [ method ]
   **
   * Converts RGB values to a hex representation of the color
   - r (number) red
   - g (number) green
   - b (number) blue
   = (string) hex representation of the color
  \*/
  Snap.rgb = cacher(function (r, g, b, o) {
      if (is(o, "finite")) {
          var round = math.round;
          return "rgba(" + [round(r), round(g), round(b), +o.toFixed(2)] + ")";
      }
      return "#" + (16777216 | b | (g << 8) | (r << 16)).toString(16).slice(1);
  });
  var toHex = function (color) {
      var i = glob.doc.getElementsByTagName("head")[0] || glob.doc.getElementsByTagName("svg")[0],
          red = "rgb(255, 0, 0)";
      toHex = cacher(function (color) {
          if (color.toLowerCase() == "red") {
              return red;
          }
          i.style.color = red;
          i.style.color = color;
          var out = glob.doc.defaultView.getComputedStyle(i, E).getPropertyValue("color");
          return out == red ? null : out;
      });
      return toHex(color);
  },
  hsbtoString = function () {
      return "hsb(" + [this.h, this.s, this.b] + ")";
  },
  hsltoString = function () {
      return "hsl(" + [this.h, this.s, this.l] + ")";
  },
  rgbtoString = function () {
      return this.opacity == 1 || this.opacity == null ?
              this.hex :
              "rgba(" + [this.r, this.g, this.b, this.opacity] + ")";
  },
  prepareRGB = function (r, g, b) {
      if (g == null && is(r, "object") && "r" in r && "g" in r && "b" in r) {
          b = r.b;
          g = r.g;
          r = r.r;
      }
      if (g == null && is(r, string)) {
          var clr = Snap.getRGB(r);
          r = clr.r;
          g = clr.g;
          b = clr.b;
      }
      if (r > 1 || g > 1 || b > 1) {
          r /= 255;
          g /= 255;
          b /= 255;
      }
  
      return [r, g, b];
  },
  packageRGB = function (r, g, b, o) {
      r = math.round(r * 255);
      g = math.round(g * 255);
      b = math.round(b * 255);
      var rgb = {
          r: r,
          g: g,
          b: b,
          opacity: is(o, "finite") ? o : 1,
          hex: Snap.rgb(r, g, b),
          toString: rgbtoString
      };
      is(o, "finite") && (rgb.opacity = o);
      return rgb;
  };
  // SIERRA Clarify if Snap does not support consolidated HSLA/RGBA colors. E.g., can you specify a semi-transparent value for Snap.filter.shadow()?
  /*\
   * Snap.color
   [ method ]
   **
   * Parses the color string and returns an object featuring the color's component values
   - clr (string) color string in one of the supported formats (see @Snap.getRGB)
   = (object) Combined RGB/HSB object in the following format:
   o {
   o     r (number) red,
   o     g (number) green,
   o     b (number) blue,
   o     hex (string) color in HTML/CSS format: #••••••,
   o     error (boolean) `true` if string can't be parsed,
   o     h (number) hue,
   o     s (number) saturation,
   o     v (number) value (brightness),
   o     l (number) lightness
   o }
  \*/
  Snap.color = function (clr) {
      var rgb;
      if (is(clr, "object") && "h" in clr && "s" in clr && "b" in clr) {
          rgb = Snap.hsb2rgb(clr);
          clr.r = rgb.r;
          clr.g = rgb.g;
          clr.b = rgb.b;
          clr.opacity = 1;
          clr.hex = rgb.hex;
      } else if (is(clr, "object") && "h" in clr && "s" in clr && "l" in clr) {
          rgb = Snap.hsl2rgb(clr);
          clr.r = rgb.r;
          clr.g = rgb.g;
          clr.b = rgb.b;
          clr.opacity = 1;
          clr.hex = rgb.hex;
      } else {
          if (is(clr, "string")) {
              clr = Snap.getRGB(clr);
          }
          if (is(clr, "object") && "r" in clr && "g" in clr && "b" in clr && !("error" in clr)) {
              rgb = Snap.rgb2hsl(clr);
              clr.h = rgb.h;
              clr.s = rgb.s;
              clr.l = rgb.l;
              rgb = Snap.rgb2hsb(clr);
              clr.v = rgb.b;
          } else {
              clr = {hex: "none"};
              clr.r = clr.g = clr.b = clr.h = clr.s = clr.v = clr.l = -1;
              clr.error = 1;
          }
      }
      clr.toString = rgbtoString;
      return clr;
  };
  /*\
   * Snap.hsb2rgb
   [ method ]
   **
   * Converts HSB values to an RGB object
   - h (number) hue
   - s (number) saturation
   - v (number) value or brightness
   = (object) RGB object in the following format:
   o {
   o     r (number) red,
   o     g (number) green,
   o     b (number) blue,
   o     hex (string) color in HTML/CSS format: #••••••
   o }
  \*/
  Snap.hsb2rgb = function (h, s, v, o) {
      if (is(h, "object") && "h" in h && "s" in h && "b" in h) {
          v = h.b;
          s = h.s;
          h = h.h;
          o = h.o;
      }
      h *= 360;
      var R, G, B, X, C;
      h = (h % 360) / 60;
      C = v * s;
      X = C * (1 - abs(h % 2 - 1));
      R = G = B = v - C;
  
      h = ~~h;
      R += [C, X, 0, 0, X, C][h];
      G += [X, C, C, X, 0, 0][h];
      B += [0, 0, X, C, C, X][h];
      return packageRGB(R, G, B, o);
  };
  /*\
   * Snap.hsl2rgb
   [ method ]
   **
   * Converts HSL values to an RGB object
   - h (number) hue
   - s (number) saturation
   - l (number) luminosity
   = (object) RGB object in the following format:
   o {
   o     r (number) red,
   o     g (number) green,
   o     b (number) blue,
   o     hex (string) color in HTML/CSS format: #••••••
   o }
  \*/
  Snap.hsl2rgb = function (h, s, l, o) {
      if (is(h, "object") && "h" in h && "s" in h && "l" in h) {
          l = h.l;
          s = h.s;
          h = h.h;
      }
      if (h > 1 || s > 1 || l > 1) {
          h /= 360;
          s /= 100;
          l /= 100;
      }
      h *= 360;
      var R, G, B, X, C;
      h = (h % 360) / 60;
      C = 2 * s * (l < .5 ? l : 1 - l);
      X = C * (1 - abs(h % 2 - 1));
      R = G = B = l - C / 2;
  
      h = ~~h;
      R += [C, X, 0, 0, X, C][h];
      G += [X, C, C, X, 0, 0][h];
      B += [0, 0, X, C, C, X][h];
      return packageRGB(R, G, B, o);
  };
  /*\
   * Snap.rgb2hsb
   [ method ]
   **
   * Converts RGB values to an HSB object
   - r (number) red
   - g (number) green
   - b (number) blue
   = (object) HSB object in the following format:
   o {
   o     h (number) hue,
   o     s (number) saturation,
   o     b (number) brightness
   o }
  \*/
  Snap.rgb2hsb = function (r, g, b) {
      b = prepareRGB(r, g, b);
      r = b[0];
      g = b[1];
      b = b[2];
  
      var H, S, V, C;
      V = mmax(r, g, b);
      C = V - mmin(r, g, b);
      H = (C == 0 ? null :
           V == r ? (g - b) / C :
           V == g ? (b - r) / C + 2 :
                    (r - g) / C + 4
          );
      H = ((H + 360) % 6) * 60 / 360;
      S = C == 0 ? 0 : C / V;
      return {h: H, s: S, b: V, toString: hsbtoString};
  };
  /*\
   * Snap.rgb2hsl
   [ method ]
   **
   * Converts RGB values to an HSL object
   - r (number) red
   - g (number) green
   - b (number) blue
   = (object) HSL object in the following format:
   o {
   o     h (number) hue,
   o     s (number) saturation,
   o     l (number) luminosity
   o }
  \*/
  Snap.rgb2hsl = function (r, g, b) {
      b = prepareRGB(r, g, b);
      r = b[0];
      g = b[1];
      b = b[2];
  
      var H, S, L, M, m, C;
      M = mmax(r, g, b);
      m = mmin(r, g, b);
      C = M - m;
      H = (C == 0 ? null :
           M == r ? (g - b) / C :
           M == g ? (b - r) / C + 2 :
                    (r - g) / C + 4);
      H = ((H + 360) % 6) * 60 / 360;
      L = (M + m) / 2;
      S = (C == 0 ? 0 :
           L < .5 ? C / (2 * L) :
                    C / (2 - 2 * L));
      return {h: H, s: S, l: L, toString: hsltoString};
  };
  
  // Transformations
  // SIERRA Snap.parsePathString(): By _array of arrays,_ I assume you mean a format like this for two separate segments? [ ["M10,10","L90,90"], ["M90,10","L10,90"] ] Otherwise how is each command structured?
  /*\
   * Snap.parsePathString
   [ method ]
   **
   * Utility method
   **
   * Parses given path string into an array of arrays of path segments
   - pathString (string|array) path string or array of segments (in the last case it is returned straight away)
   = (array) array of segments
  \*/
  Snap.parsePathString = function (pathString) {
      if (!pathString) {
          return null;
      }
      var pth = Snap.path(pathString);
      if (pth.arr) {
          return Snap.path.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 = Snap.path.clone(pathString);
      }
      if (!data.length) {
          Str(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 = Snap.path.toString;
      pth.arr = Snap.path.clone(data);
      return data;
  };
  /*\
   * Snap.parseTransformString
   [ method ]
   **
   * Utility method
   **
   * Parses given transform string into an array of transformations
   - TString (string|array) transform string or array of transformations (in the last case it is returned straight away)
   = (array) array of transformations
  \*/
  var parseTransformString = Snap.parseTransformString = function (TString) {
      if (!TString) {
          return null;
      }
      var paramCounts = {r: 3, s: 4, t: 2, m: 6},
          data = [];
      if (is(TString, "array") && is(TString[0], "array")) { // rough assumption
          data = Snap.path.clone(TString);
      }
      if (!data.length) {
          Str(TString).replace(tCommand, function (a, b, c) {
              var params = [],
                  name = b.toLowerCase();
              c.replace(pathValues, function (a, b) {
                  b && params.push(+b);
              });
              data.push([b].concat(params));
          });
      }
      data.toString = Snap.path.toString;
      return data;
  };
  function svgTransform2string(tstr) {
      var res = [];
      tstr = tstr.replace(/(?:^|\s)(\w+)\(([^)]+)\)/g, function (all, name, params) {
          params = params.split(/\s*,\s*|\s+/);
          if (name == "rotate" && params.length == 1) {
              params.push(0, 0);
          }
          if (name == "scale") {
              if (params.length > 2) {
                  params = params.slice(0, 2);
              } else if (params.length == 2) {
                  params.push(0, 0);
              }
              if (params.length == 1) {
                  params.push(params[0], 0, 0);
              }
          }
          if (name == "skewX") {
              res.push(["m", 1, 0, math.tan(rad(params[0])), 1, 0, 0]);
          } else if (name == "skewY") {
              res.push(["m", 1, math.tan(rad(params[0])), 0, 1, 0, 0]);
          } else {
              res.push([name.charAt(0)].concat(params));
          }
          return all;
      });
      return res;
  }
  Snap._.svgTransform2string = svgTransform2string;
  Snap._.rgTransform = /^[a-z][\s]*-?\.?\d/i;
  function transform2matrix(tstr, bbox) {
      var tdata = parseTransformString(tstr),
          m = new Snap.Matrix;
      if (tdata) {
          for (var i = 0, ii = tdata.length; i < ii; i++) {
              var t = tdata[i],
                  tlen = t.length,
                  command = Str(t[0]).toLowerCase(),
                  absolute = t[0] != command,
                  inver = absolute ? m.invert() : 0,
                  x1,
                  y1,
                  x2,
                  y2,
                  bb;
              if (command == "t" && tlen == 2){
                  m.translate(t[1], 0);
              } else if (command == "t" && tlen == 3) {
                  if (absolute) {
                      x1 = inver.x(0, 0);
                      y1 = inver.y(0, 0);
                      x2 = inver.x(t[1], t[2]);
                      y2 = inver.y(t[1], t[2]);
                      m.translate(x2 - x1, y2 - y1);
                  } else {
                      m.translate(t[1], t[2]);
                  }
              } else if (command == "r") {
                  if (tlen == 2) {
                      bb = bb || bbox;
                      m.rotate(t[1], bb.x + bb.width / 2, bb.y + bb.height / 2);
                  } else if (tlen == 4) {
                      if (absolute) {
                          x2 = inver.x(t[2], t[3]);
                          y2 = inver.y(t[2], t[3]);
                          m.rotate(t[1], x2, y2);
                      } else {
                          m.rotate(t[1], t[2], t[3]);
                      }
                  }
              } else if (command == "s") {
                  if (tlen == 2 || tlen == 3) {
                      bb = bb || bbox;
                      m.scale(t[1], t[tlen - 1], bb.x + bb.width / 2, bb.y + bb.height / 2);
                  } else if (tlen == 4) {
                      if (absolute) {
                          x2 = inver.x(t[2], t[3]);
                          y2 = inver.y(t[2], t[3]);
                          m.scale(t[1], t[1], x2, y2);
                      } else {
                          m.scale(t[1], t[1], t[2], t[3]);
                      }
                  } else if (tlen == 5) {
                      if (absolute) {
                          x2 = inver.x(t[3], t[4]);
                          y2 = inver.y(t[3], t[4]);
                          m.scale(t[1], t[2], x2, y2);
                      } else {
                          m.scale(t[1], t[2], t[3], t[4]);
                      }
                  }
              } else if (command == "m" && tlen == 7) {
                  m.add(t[1], t[2], t[3], t[4], t[5], t[6]);
              }
          }
      }
      return m;
  }
  Snap._.transform2matrix = transform2matrix;
  Snap._unit2px = unit2px;
  var contains = glob.doc.contains || glob.doc.compareDocumentPosition ?
      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 = b.parentNode;
                  if (b == a) {
                      return true;
                  }
              }
          }
          return false;
      };
  function getSomeDefs(el) {
      var p = (el.node.ownerSVGElement && wrap(el.node.ownerSVGElement)) ||
              (el.node.parentNode && wrap(el.node.parentNode)) ||
              Snap.select("svg") ||
              Snap(0, 0),
          pdefs = p.select("defs"),
          defs  = pdefs == null ? false : pdefs.node;
      if (!defs) {
          defs = make("defs", p.node).node;
      }
      return defs;
  }
  function getSomeSVG(el) {
      return el.node.ownerSVGElement && wrap(el.node.ownerSVGElement) || Snap.select("svg");
  }
  Snap._.getSomeDefs = getSomeDefs;
  Snap._.getSomeSVG = getSomeSVG;
  function unit2px(el, name, value) {
      var svg = getSomeSVG(el).node,
          out = {},
          mgr = svg.querySelector(".svg---mgr");
      if (!mgr) {
          mgr = $("rect");
          $(mgr, {x: -9e9, y: -9e9, width: 10, height: 10, "class": "svg---mgr", fill: "none"});
          svg.appendChild(mgr);
      }
      function getW(val) {
          if (val == null) {
              return E;
          }
          if (val == +val) {
              return val;
          }
          $(mgr, {width: val});
          try {
              return mgr.getBBox().width;
          } catch (e) {
              return 0;
          }
      }
      function getH(val) {
          if (val == null) {
              return E;
          }
          if (val == +val) {
              return val;
          }
          $(mgr, {height: val});
          try {
              return mgr.getBBox().height;
          } catch (e) {
              return 0;
          }
      }
      function set(nam, f) {
          if (name == null) {
              out[nam] = f(el.attr(nam) || 0);
          } else if (nam == name) {
              out = f(value == null ? el.attr(nam) || 0 : value);
          }
      }
      switch (el.type) {
          case "rect":
              set("rx", getW);
              set("ry", getH);
          case "image":
              set("width", getW);
              set("height", getH);
          case "text":
              set("x", getW);
              set("y", getH);
          break;
          case "circle":
              set("cx", getW);
              set("cy", getH);
              set("r", getW);
          break;
          case "ellipse":
              set("cx", getW);
              set("cy", getH);
              set("rx", getW);
              set("ry", getH);
          break;
          case "line":
              set("x1", getW);
              set("x2", getW);
              set("y1", getH);
              set("y2", getH);
          break;
          case "marker":
              set("refX", getW);
              set("markerWidth", getW);
              set("refY", getH);
              set("markerHeight", getH);
          break;
          case "radialGradient":
              set("fx", getW);
              set("fy", getH);
          break;
          case "tspan":
              set("dx", getW);
              set("dy", getH);
          break;
          default:
              set(name, getW);
      }
      svg.removeChild(mgr);
      return out;
  }
  /*\
   * Snap.select
   [ method ]
   **
   * Wraps a DOM element specified by CSS selector as @Element
   - query (string) CSS selector of the element
   = (Element) the current element
  \*/
  Snap.select = function (query) {
      query = Str(query).replace(/([^\\]):/g, "$1\\:");
      return wrap(glob.doc.querySelector(query));
  };
  /*\
   * Snap.selectAll
   [ method ]
   **
   * Wraps DOM elements specified by CSS selector as set or array of @Element
   - query (string) CSS selector of the element
   = (Element) the current element
  \*/
  Snap.selectAll = function (query) {
      var nodelist = glob.doc.querySelectorAll(query),
          set = (Snap.set || Array)();
      for (var i = 0; i < nodelist.length; i++) {
          set.push(wrap(nodelist[i]));
      }
      return set;
  };
  
  function add2group(list) {
      if (!is(list, "array")) {
          list = Array.prototype.slice.call(arguments, 0);
      }
      var i = 0,
          j = 0,
          node = this.node;
      while (this[i]) delete this[i++];
      for (i = 0; i < list.length; i++) {
          if (list[i].type == "set") {
              list[i].forEach(function (el) {
                  node.appendChild(el.node);
              });
          } else {
              node.appendChild(list[i].node);
          }
      }
      var children = node.childNodes;
      for (i = 0; i < children.length; i++) {
          this[j++] = wrap(children[i]);
      }
      return this;
  }
  // Hub garbage collector every 10s
  setInterval(function () {
      for (var key in hub) if (hub[has](key)) {
          var el = hub[key],
              node = el.node;
          if (el.type != "svg" && !node.ownerSVGElement || el.type == "svg" && (!node.parentNode || "ownerSVGElement" in node.parentNode && !node.ownerSVGElement)) {
              delete hub[key];
          }
      }
  }, 1e4);
  function Element(el) {
      if (el.snap in hub) {
          return hub[el.snap];
      }
      var svg;
      try {
          svg = el.ownerSVGElement;
      } catch(e) {}
      /*\
       * Element.node
       [ property (object) ]
       **
       * Gives you a reference to the DOM object, so you can assign event handlers or just mess around.
       > Usage
       | // draw a circle at coordinate 10,10 with radius of 10
       | var c = paper.circle(10, 10, 10);
       | c.node.onclick = function () {
       |     c.attr("fill", "red");
       | };
      \*/
      this.node = el;
      if (svg) {
          this.paper = new Paper(svg);
      }
      /*\
       * Element.type
       [ property (string) ]
       **
       * SVG tag name of the given element.
      \*/
      this.type = el.tagName;
      var id = this.id = ID(this);
      this.anims = {};
      this._ = {
          transform: []
      };
      el.snap = id;
      hub[id] = this;
      if (this.type == "g") {
          this.add = add2group;
      }
      if (this.type in {g: 1, mask: 1, pattern: 1, symbol: 1}) {
          for (var method in Paper.prototype) if (Paper.prototype[has](method)) {
              this[method] = Paper.prototype[method];
          }
      }
  }
     /*\
       * Element.attr
       [ method ]
       **
       * Gets or sets given attributes of the element.
       **
       - params (object) contains key-value pairs of attributes you want to set
       * or
       - param (string) name of the attribute
       = (Element) the current element
       * or
       = (string) value of attribute
       > Usage
       | el.attr({
       |     fill: "#fc0",
       |     stroke: "#000",
       |     strokeWidth: 2, // CamelCase...
       |     "fill-opacity": 0.5, // or dash-separated names
       |     width: "*=2" // prefixed values
       | });
       | console.log(el.attr("fill")); // #fc0
       * Prefixed values in format `"+=10"` supported. All four operations
       * (`+`, `-`, `*` and `/`) could be used. Optionally you can use units for `+`
       * and `-`: `"+=2em"`.
      \*/
      Element.prototype.attr = function (params, value) {
          var el = this,
              node = el.node;
          if (!params) {
              return el;
          }
          if (is(params, "string")) {
              if (arguments.length > 1) {
                  var json = {};
                  json[params] = value;
                  params = json;
              } else {
                  return eve("snap.util.getattr." + params, el).firstDefined();
              }
          }
          for (var att in params) {
              if (params[has](att)) {
                  eve("snap.util.attr." + att, el, params[att]);
              }
          }
          return el;
      };
  /*\
   * Snap.parse
   [ method ]
   **
   * Parses SVG fragment and converts it into a @Fragment
   **
   - svg (string) SVG string
   = (Fragment) the @Fragment
  \*/
  Snap.parse = function (svg) {
      var f = glob.doc.createDocumentFragment(),
          full = true,
          div = glob.doc.createElement("div");
      svg = Str(svg);
      if (!svg.match(/^\s*<\s*svg(?:\s|>)/)) {
          svg = "<svg>" + svg + "</svg>";
          full = false;
      }
      div.innerHTML = svg;
      svg = div.getElementsByTagName("svg")[0];
      if (svg) {
          if (full) {
              f = svg;
          } else {
              while (svg.firstChild) {
                  f.appendChild(svg.firstChild);
              }
              div.innerHTML = E;
          }
      }
      return new Fragment(f);
  };
  function Fragment(frag) {
      this.node = frag;
  }
  // SIERRA Snap.fragment() could especially use a code example
  /*\
   * Snap.fragment
   [ method ]
   **
   * Creates a DOM fragment from a given list of elements or strings
   **
   - varargs (…) SVG string
   = (Fragment) the @Fragment
  \*/
  Snap.fragment = function () {
      var args = Array.prototype.slice.call(arguments, 0),
          f = glob.doc.createDocumentFragment();
      for (var i = 0, ii = args.length; i < ii; i++) {
          var item = args[i];
          if (item.node && item.node.nodeType) {
              f.appendChild(item.node);
          }
          if (item.nodeType) {
              f.appendChild(item);
          }
          if (typeof item == "string") {
              f.appendChild(Snap.parse(item).node);
          }
      }
      return new Fragment(f);
  };
  
  function make(name, parent) {
      var res = $(name);
      parent.appendChild(res);
      var el = wrap(res);
      return el;
  }
  function Paper(w, h) {
      var res,
          desc,
          defs,
          proto = Paper.prototype;
      if (w && w.tagName == "svg") {
          if (w.snap in hub) {
              return hub[w.snap];
          }
          var doc = w.ownerDocument;
          res = new Element(w);
          desc = w.getElementsByTagName("desc")[0];
          defs = w.getElementsByTagName("defs")[0];
          if (!desc) {
              desc = $("desc");
              desc.appendChild(doc.createTextNode("Created with Snap"));
              res.node.appendChild(desc);
          }
          if (!defs) {
              defs = $("defs");
              res.node.appendChild(defs);
          }
          res.defs = defs;
          for (var key in proto) if (proto[has](key)) {
              res[key] = proto[key];
          }
          res.paper = res.root = res;
      } else {
          res = make("svg", glob.doc.body);
          $(res.node, {
              height: h,
              version: 1.1,
              width: w,
              xmlns: xmlns
          });
      }
      return res;
  }
  function wrap(dom) {
      if (!dom) {
          return dom;
      }
      if (dom instanceof Element || dom instanceof Fragment) {
          return dom;
      }
      if (dom.tagName && dom.tagName.toLowerCase() == "svg") {
          return new Paper(dom);
      }
      if (dom.tagName && dom.tagName.toLowerCase() == "object" && dom.type == "image/svg+xml") {
          return new Paper(dom.contentDocument.getElementsByTagName("svg")[0]);
      }
      return new Element(dom);
  }
  
  Snap._.make = make;
  Snap._.wrap = wrap;
  /*\
   * Paper.el
   [ method ]
   **
   * Creates an element on paper with a given name and no attributes
   **
   - name (string) tag name
   - attr (object) attributes
   = (Element) the current element
   > Usage
   | var c = paper.circle(10, 10, 10); // is the same as...
   | var c = paper.el("circle").attr({
   |     cx: 10,
   |     cy: 10,
   |     r: 10
   | });
   | // and the same as
   | var c = paper.el("circle", {
   |     cx: 10,
   |     cy: 10,
   |     r: 10
   | });
  \*/
  Paper.prototype.el = function (name, attr) {
      var el = make(name, this.node);
      attr && el.attr(attr);
      return el;
  };
  // default
  eve.on("snap.util.getattr", function () {
      var att = eve.nt();
      att = att.substring(att.lastIndexOf(".") + 1);
      var css = att.replace(/[A-Z]/g, function (letter) {
          return "-" + letter.toLowerCase();
      });
      if (cssAttr[has](css)) {
          return this.node.ownerDocument.defaultView.getComputedStyle(this.node, null).getPropertyValue(css);
      } else {
          return $(this.node, att);
      }
  });
  var cssAttr = {
      "alignment-baseline": 0,
      "baseline-shift": 0,
      "clip": 0,
      "clip-path": 0,
      "clip-rule": 0,
      "color": 0,
      "color-interpolation": 0,
      "color-interpolation-filters": 0,
      "color-profile": 0,
      "color-rendering": 0,
      "cursor": 0,
      "direction": 0,
      "display": 0,
      "dominant-baseline": 0,
      "enable-background": 0,
      "fill": 0,
      "fill-opacity": 0,
      "fill-rule": 0,
      "filter": 0,
      "flood-color": 0,
      "flood-opacity": 0,
      "font": 0,
      "font-family": 0,
      "font-size": 0,
      "font-size-adjust": 0,
      "font-stretch": 0,
      "font-style": 0,
      "font-variant": 0,
      "font-weight": 0,
      "glyph-orientation-horizontal": 0,
      "glyph-orientation-vertical": 0,
      "image-rendering": 0,
      "kerning": 0,
      "letter-spacing": 0,
      "lighting-color": 0,
      "marker": 0,
      "marker-end": 0,
      "marker-mid": 0,
      "marker-start": 0,
      "mask": 0,
      "opacity": 0,
      "overflow": 0,
      "pointer-events": 0,
      "shape-rendering": 0,
      "stop-color": 0,
      "stop-opacity": 0,
      "stroke": 0,
      "stroke-dasharray": 0,
      "stroke-dashoffset": 0,
      "stroke-linecap": 0,
      "stroke-linejoin": 0,
      "stroke-miterlimit": 0,
      "stroke-opacity": 0,
      "stroke-width": 0,
      "text-anchor": 0,
      "text-decoration": 0,
      "text-rendering": 0,
      "unicode-bidi": 0,
      "visibility": 0,
      "word-spacing": 0,
      "writing-mode": 0
  };
  
  eve.on("snap.util.attr", function (value) {
      var att = eve.nt(),
          attr = {};
      att = att.substring(att.lastIndexOf(".") + 1);
      attr[att] = value;
      var style = att.replace(/-(\w)/gi, function (all, letter) {
              return letter.toUpperCase();
          }),
          css = att.replace(/[A-Z]/g, function (letter) {
              return "-" + letter.toLowerCase();
          });
      if (cssAttr[has](css)) {
          this.node.style[style] = value == null ? E : value;
      } else {
          $(this.node, attr);
      }
  });
  (function (proto) {}(Paper.prototype));
  
  // simple ajax
  /*\
   * Snap.ajax
   [ method ]
   **
   * Simple implementation of Ajax
   **
   - url (string) URL
   - postData (object|string) data for post request
   - callback (function) callback
   - scope (object) #optional scope of callback
   * or
   - url (string) URL
   - callback (function) callback
   - scope (object) #optional scope of callback
   = (XMLHttpRequest) the XMLHttpRequest object, just in case
  \*/
  Snap.ajax = function (url, postData, callback, scope){
      var req = new XMLHttpRequest,
          id = ID();
      if (req) {
          if (is(postData, "function")) {
              scope = callback;
              callback = postData;
              postData = null;
          } else if (is(postData, "object")) {
              var pd = [];
              for (var key in postData) if (postData.hasOwnProperty(key)) {
                  pd.push(encodeURIComponent(key) + "=" + encodeURIComponent(postData[key]));
              }
              postData = pd.join("&");
          }
          req.open((postData ? "POST" : "GET"), url, true);
          if (postData) {
              req.setRequestHeader("X-Requested-With", "XMLHttpRequest");
              req.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
          }
          if (callback) {
              eve.once("snap.ajax." + id + ".0", callback);
              eve.once("snap.ajax." + id + ".200", callback);
              eve.once("snap.ajax." + id + ".304", callback);
          }
          req.onreadystatechange = function() {
              if (req.readyState != 4) return;
              eve("snap.ajax." + id + "." + req.status, scope, req);
          };
          if (req.readyState == 4) {
              return req;
          }
          req.send(postData);
          return req;
      }
  };
  /*\
   * Snap.load
   [ method ]
   **
   * Loads external SVG file as a @Fragment (see @Snap.ajax for more advanced AJAX)
   **
   - url (string) URL
   - callback (function) callback
   - scope (object) #optional scope of callback
  \*/
  Snap.load = function (url, callback, scope) {
      Snap.ajax(url, function (req) {
          var f = Snap.parse(req.responseText);
          scope ? callback.call(scope, f) : callback(f);
      });
  };
  var getOffset = function (elem) {
      var box = elem.getBoundingClientRect(),
          doc = elem.ownerDocument,
          body = doc.body,
          docElem = doc.documentElement,
          clientTop = docElem.clientTop || body.clientTop || 0, clientLeft = docElem.clientLeft || body.clientLeft || 0,
          top  = box.top  + (g.win.pageYOffset || docElem.scrollTop || body.scrollTop ) - clientTop,
          left = box.left + (g.win.pageXOffset || docElem.scrollLeft || body.scrollLeft) - clientLeft;
      return {
          y: top,
          x: left
      };
  };
  /*\
   * Snap.getElementByPoint
   [ method ]
   **
   * Returns you topmost element under given point.
   **
   = (object) Snap element object
   - x (number) x coordinate from the top left corner of the window
   - y (number) y coordinate from the top left corner of the window
   > Usage
   | Snap.getElementByPoint(mouseX, mouseY).attr({stroke: "#f00"});
  \*/
  Snap.getElementByPoint = function (x, y) {
      var paper = this,
          svg = paper.canvas,
          target = glob.doc.elementFromPoint(x, y);
      if (glob.win.opera && target.tagName == "svg") {
          var so = getOffset(target),
              sr = target.createSVGRect();
          sr.x = x - so.x;
          sr.y = y - so.y;
          sr.width = sr.height = 1;
          var hits = target.getIntersectionList(sr, null);
          if (hits.length) {
              target = hits[hits.length - 1];
          }
      }
      if (!target) {
          return null;
      }
      return wrap(target);
  };
  /*\
   * Snap.plugin
   [ method ]
   **
   * Let you write plugins. You pass in a function with four arguments, like this:
   | Snap.plugin(function (Snap, Element, Paper, global, Fragment) {
   |     Snap.newmethod = function () {};
   |     Element.prototype.newmethod = function () {};
   |     Paper.prototype.newmethod = function () {};
   | });
   * Inside the function you have access to all main objects (and their
   * prototypes). This allow you to extend anything you want.
   **
   - f (function) your plugin body
  \*/
  Snap.plugin = function (f) {
      f(Snap, Element, Paper, glob, Fragment);
  };
  glob.win.Snap = Snap;
  return Snap;
  }(window || this));
  // Copyright (c) 2013 Adobe Systems Incorporated. All rights reserved.
  //
  // Licensed under the Apache License, Version 2.0 (the "License");
  // you may not use this file except in compliance with the License.
  // You may obtain a copy of the License at
  //
  // http://www.apache.org/licenses/LICENSE-2.0
  //
  // Unless required by applicable law or agreed to in writing, software
  // distributed under the License is distributed on an "AS IS" BASIS,
  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  // See the License for the specific language governing permissions and
  // limitations under the License.
  Snap.plugin(function (Snap, Element, Paper, glob, Fragment) {
      var elproto = Element.prototype,
          is = Snap.is,
          Str = String,
          unit2px = Snap._unit2px,
          $ = Snap._.$,
          make = Snap._.make,
          getSomeDefs = Snap._.getSomeDefs,
          has = "hasOwnProperty",
          wrap = Snap._.wrap;
      /*\
       * Element.getBBox
       [ method ]
       **
       * Returns the bounding box descriptor for the given element
       **
       = (object) bounding box descriptor:
       o {
       o     cx: (number) x of the center,
       o     cy: (number) x of the center,
       o     h: (number) height,
       o     height: (number) height,
       o     path: (string) path command for the box,
       o     r0: (number) radius of a circle that fully encloses the box,
       o     r1: (number) radius of the smallest circle that can be enclosed,
       o     r2: (number) radius of the largest circle that can be enclosed,
       o     vb: (string) box as a viewbox command,
       o     w: (number) width,
       o     width: (number) width,
       o     x2: (number) x of the right side,
       o     x: (number) x of the left side,
       o     y2: (number) y of the bottom edge,
       o     y: (number) y of the top edge
       o }
      \*/
      elproto.getBBox = function (isWithoutTransform) {
          if (!Snap.Matrix || !Snap.path) {
              return this.node.getBBox();
          }
          var el = this,
              m = new Snap.Matrix;
          if (el.removed) {
              return Snap._.box();
          }
          while (el.type == "use") {
              if (!isWithoutTransform) {
                  m = m.add(el.transform().localMatrix.translate(el.attr("x") || 0, el.attr("y") || 0));
              }
              if (el.original) {
                  el = el.original;
              } else {
                  var href = el.attr("xlink:href");
                  el = el.original = el.node.ownerDocument.getElementById(href.substring(href.indexOf("#") + 1));
              }
          }
          var _ = el._,
              pathfinder = Snap.path.get[el.type] || Snap.path.get.deflt;
          try {
              if (isWithoutTransform) {
                  _.bboxwt = pathfinder ? Snap.path.getBBox(el.realPath = pathfinder(el)) : Snap._.box(el.node.getBBox());
                  return Snap._.box(_.bboxwt);
              } else {
                  el.realPath = pathfinder(el);
                  el.matrix = el.transform().localMatrix;
                  _.bbox = Snap.path.getBBox(Snap.path.map(el.realPath, m.add(el.matrix)));
                  return Snap._.box(_.bbox);
              }
          } catch (e) {
              // Firefox doesn’t give you bbox of hidden element
              return Snap._.box();
          }
      };
      var propString = function () {
          return this.string;
      };
      function extractTransform(el, tstr) {
          if (tstr == null) {
              var doReturn = true;
              if (el.type == "linearGradient" || el.type == "radialGradient") {
                  tstr = el.node.getAttribute("gradientTransform");
              } else if (el.type == "pattern") {
                  tstr = el.node.getAttribute("patternTransform");
              } else {
                  tstr = el.node.getAttribute("transform");
              }
              if (!tstr) {
                  return new Snap.Matrix;
              }
              tstr = Snap._.svgTransform2string(tstr);
          } else {
              if (!Snap._.rgTransform.test(tstr)) {
                  tstr = Snap._.svgTransform2string(tstr);
              } else {
                  tstr = Str(tstr).replace(/\.{3}|\u2026/g, el._.transform || E);
              }
              if (is(tstr, "array")) {
                  tstr = Snap.path ? Snap.path.toString.call(tstr) : Str(tstr);
              }
              el._.transform = tstr;
          }
          var m = Snap._.transform2matrix(tstr, el.getBBox(1));
          if (doReturn) {
              return m;
          } else {
              el.matrix = m;
          }
      }
      /*\
       * Element.transform
       [ method ]
       **
       * Gets or sets transformation of the element
       **
       - tstr (string) transform string in Snap or SVG format
       = (Element) the current element
       * or
       = (object) transformation descriptor:
       o {
       o     string (string) transform string,
       o     globalMatrix (Matrix) matrix of all transformations applied to element or its parents,
       o     localMatrix (Matrix) matrix of transformations applied only to the element,
       o     diffMatrix (Matrix) matrix of difference between global and local transformations,
       o     global (string) global transformation as string,
       o     local (string) local transformation as string,
       o     toString (function) returns `string` property
       o }
      \*/
      elproto.transform = function (tstr) {
          var _ = this._;
          if (tstr == null) {
              var papa = this,
                  global = new Snap.Matrix(this.node.getCTM()),
                  local = extractTransform(this),
                  ms = [local],
                  m = new Snap.Matrix,
                  i,
                  localString = local.toTransformString(),
                  string = Str(local) == Str(this.matrix) ?
                              Str(_.transform) : localString;
              while (papa.type != "svg" && (papa = papa.parent())) {
                  ms.push(extractTransform(papa));
              }
              i = ms.length;
              while (i--) {
                  m.add(ms[i]);
              }
              return {
                  string: string,
                  globalMatrix: global,
                  totalMatrix: m,
                  localMatrix: local,
                  diffMatrix: global.clone().add(local.invert()),
                  global: global.toTransformString(),
                  total: m.toTransformString(),
                  local: localString,
                  toString: propString
              };
          }
          if (tstr instanceof Snap.Matrix) {
              this.matrix = tstr;
              this._.transform = tstr.toTransformString();
          } else {
              extractTransform(this, tstr);
          }
  
          if (this.node) {
              if (this.type == "linearGradient" || this.type == "radialGradient") {
                  $(this.node, {gradientTransform: this.matrix});
              } else if (this.type == "pattern") {
                  $(this.node, {patternTransform: this.matrix});
              } else {
                  $(this.node, {transform: this.matrix});
              }
          }
  
          return this;
      };
      /*\
       * Element.parent
       [ method ]
       **
       * Returns the element's parent
       **
       = (Element) the parent element
      \*/
      elproto.parent = function () {
          return wrap(this.node.parentNode);
      };
      /*\
       * Element.append
       [ method ]
       **
       * Appends the given element to current one
       **
       - el (Element|Set) element to append
       = (Element) the parent element
      \*/
      /*\
       * Element.add
       [ method ]
       **
       * See @Element.append
      \*/
      elproto.append = elproto.add = function (el) {
          if (el) {
              if (el.type == "set") {
                  var it = this;
                  el.forEach(function (el) {
                      it.add(el);
                  });
                  return this;
              }
              el = wrap(el);
              this.node.appendChild(el.node);
              el.paper = this.paper;
          }
          return this;
      };
      /*\
       * Element.appendTo
       [ method ]
       **
       * Appends the current element to the given one
       **
       - el (Element) parent element to append to
       = (Element) the child element
      \*/
      elproto.appendTo = function (el) {
          if (el) {
              el = wrap(el);
              el.append(this);
          }
          return this;
      };
      /*\
       * Element.prepend
       [ method ]
       **
       * Prepends the given element to the current one
       **
       - el (Element) element to prepend
       = (Element) the parent element
      \*/
      elproto.prepend = function (el) {
          if (el) {
              if (el.type == "set") {
                  var it = this,
                      first;
                  el.forEach(function (el) {
                      if (first) {
                          first.after(el);
                      } else {
                          it.prepend(el);
                      }
                      first = el;
                  });
                  return this;
              }
              el = wrap(el);
              var parent = el.parent();
              this.node.insertBefore(el.node, this.node.firstChild);
              this.add && this.add();
              el.paper = this.paper;
              this.parent() && this.parent().add();
              parent && parent.add();
          }
          return this;
      };
      /*\
       * Element.prependTo
       [ method ]
       **
       * Prepends the current element to the given one
       **
       - el (Element) parent element to prepend to
       = (Element) the child element
      \*/
      elproto.prependTo = function (el) {
          el = wrap(el);
          el.prepend(this);
          return this;
      };
      /*\
       * Element.before
       [ method ]
       **
       * Inserts given element before the current one
       **
       - el (Element) element to insert
       = (Element) the parent element
      \*/
      elproto.before = function (el) {
          if (el.type == "set") {
              var it = this;
              el.forEach(function (el) {
                  var parent = el.parent();
                  it.node.parentNode.insertBefore(el.node, it.node);
                  parent && parent.add();
              });
              this.parent().add();
              return this;
          }
          el = wrap(el);
          var parent = el.parent();
          this.node.parentNode.insertBefore(el.node, this.node);
          this.parent() && this.parent().add();
          parent && parent.add();
          el.paper = this.paper;
          return this;
      };
      /*\
       * Element.after
       [ method ]
       **
       * Inserts given element after the current one
       **
       - el (Element) element to insert
       = (Element) the parent element
      \*/
      elproto.after = function (el) {
          el = wrap(el);
          var parent = el.parent();
          if (this.node.nextSibling) {
              this.node.parentNode.insertBefore(el.node, this.node.nextSibling);
          } else {
              this.node.parentNode.appendChild(el.node);
          }
          this.parent() && this.parent().add();
          parent && parent.add();
          el.paper = this.paper;
          return this;
      };
      /*\
       * Element.insertBefore
       [ method ]
       **
       * Inserts the element after the given one
       **
       - el (Element) element next to whom insert to
       = (Element) the parent element
      \*/
      elproto.insertBefore = function (el) {
          el = wrap(el);
          var parent = this.parent();
          el.node.parentNode.insertBefore(this.node, el.node);
          this.paper = el.paper;
          parent && parent.add();
          el.parent() && el.parent().add();
          return this;
      };
      /*\
       * Element.insertAfter
       [ method ]
       **
       * Inserts the element after the given one
       **
       - el (Element) element next to whom insert to
       = (Element) the parent element
      \*/
      elproto.insertAfter = function (el) {
          el = wrap(el);
          var parent = this.parent();
          el.node.parentNode.insertBefore(this.node, el.node.nextSibling);
          this.paper = el.paper;
          parent && parent.add();
          el.parent() && el.parent().add();
          return this;
      };
      /*\
       * Element.remove
       [ method ]
       **
       * Removes element from the DOM
       = (Element) the detached element
      \*/
      elproto.remove = function () {
          var parent = this.parent();
          this.node.parentNode && this.node.parentNode.removeChild(this.node);
          delete this.paper;
          this.removed = true;
          parent && parent.add();
          return this;
      };
      /*\
       * Element.select
       [ method ]
       **
       * Gathers the nested @Element matching the given set of CSS selectors
       **
       - query (string) CSS selector
       = (Element) result of query selection
      \*/
      elproto.select = function (query) {
          query = Str(query).replace(/([^\\]):/g, "$1\\:");
          return wrap(this.node.querySelector(query));
      };
      /*\
       * Element.selectAll
       [ method ]
       **
       * Gathers nested @Element objects matching the given set of CSS selectors
       **
       - query (string) CSS selector
       = (Set|array) result of query selection
      \*/
      elproto.selectAll = function (query) {
          var nodelist = this.node.querySelectorAll(query),
              set = (Snap.set || Array)();
          for (var i = 0; i < nodelist.length; i++) {
              set.push(wrap(nodelist[i]));
          }
          return set;
      };
      /*\
       * Element.asPX
       [ method ]
       **
       * Returns given attribute of the element as a `px` value (not %, em, etc.)
       **
       - attr (string) attribute name
       - value (string) #optional attribute value
       = (Element) result of query selection
      \*/
      elproto.asPX = function (attr, value) {
          if (value == null) {
              value = this.attr(attr);
          }
          return +unit2px(this, attr, value);
      };
      // SIERRA Element.use(): I suggest adding a note about how to access the original element the returned <use> instantiates. It's a part of SVG with which ordinary web developers may be least familiar.
      /*\
       * Element.use
       [ method ]
       **
       * Creates a `<use>` element linked to the current element
       **
       = (Element) the `<use>` element
      \*/
      elproto.use = function () {
          var use,
              id = this.node.id;
          if (!id) {
              id = this.id;
              $(this.node, {
                  id: id
              });
          }
          if (this.type == "linearGradient" || this.type == "radialGradient" ||
              this.type == "pattern") {
              use = make(this.type, this.node.parentNode);
          } else {
              use = make("use", this.node.parentNode);
          }
          $(use.node, {
              "xlink:href": "#" + id
          });
          use.original = this;
          return use;
      };
      function fixids(el) {
          var els = el.selectAll("*"),
              it,
              url = /^\s*url\(("|'|)(.*)\1\)\s*$/,
              ids = [],
              uses = {};
          function urltest(it, name) {
              var val = $(it.node, name);
              val = val && val.match(url);
              val = val && val[2];
              if (val && val.charAt() == "#") {
                  val = val.substring(1);
              } else {
                  return;
              }
              if (val) {
                  uses[val] = (uses[val] || []).concat(function (id) {
                      var attr = {};
                      attr[name] = URL(id);
                      $(it.node, attr);
                  });
              }
          }
          function linktest(it) {
              var val = $(it.node, "xlink:href");
              if (val && val.charAt() == "#") {
                  val = val.substring(1);
              } else {
                  return;
              }
              if (val) {
                  uses[val] = (uses[val] || []).concat(function (id) {
                      it.attr("xlink:href", "#" + id);
                  });
              }
          }
          for (var i = 0, ii = els.length; i < ii; i++) {
              it = els[i];
              urltest(it, "fill");
              urltest(it, "stroke");
              urltest(it, "filter");
              urltest(it, "mask");
              urltest(it, "clip-path");
              linktest(it);
              var oldid = $(it.node, "id");
              if (oldid) {
                  $(it.node, {id: it.id});
                  ids.push({
                      old: oldid,
                      id: it.id
                  });
              }
          }
          for (i = 0, ii = ids.length; i < ii; i++) {
              var fs = uses[ids[i].old];
              if (fs) {
                  for (var j = 0, jj = fs.length; j < jj; j++) {
                      fs[j](ids[i].id);
                  }
              }
          }
      }
      /*\
       * Element.clone
       [ method ]
       **
       * Creates a clone of the element and inserts it after the element
       **
       = (Element) the clone
      \*/
      elproto.clone = function () {
          var clone = wrap(this.node.cloneNode(true));
          if ($(clone.node, "id")) {
              $(clone.node, {id: clone.id});
          }
          fixids(clone);
          clone.insertAfter(this);
          return clone;
      };
      /*\
       * Element.toDefs
       [ method ]
       **
       * Moves element to the shared `<defs>` area
       **
       = (Element) the element
      \*/
      elproto.toDefs = function () {
          var defs = getSomeDefs(this);
          defs.appendChild(this.node);
          return this;
      };
      /*\
       * Element.toPattern
       [ method ]
       **
       * Creates a `<pattern>` element from the current element
       **
       * To create a pattern you have to specify the pattern rect:
       - x (string|number)
       - y (string|number)
       - width (string|number)
       - height (string|number)
       = (Element) the `<pattern>` element
       * You can use pattern later on as an argument for `fill` attribute:
       | var p = paper.path("M10-5-10,15M15,0,0,15M0-5-20,15").attr({
       |         fill: "none",
       |         stroke: "#bada55",
       |         strokeWidth: 5
       |     }).pattern(0, 0, 10, 10),
       |     c = paper.circle(200, 200, 100);
       | c.attr({
       |     fill: p
       | });
      \*/
      elproto.pattern = elproto.toPattern = function (x, y, width, height) {
          var p = make("pattern", getSomeDefs(this));
          if (x == null) {
              x = this.getBBox();
          }
          if (is(x, "object") && "x" in x) {
              y = x.y;
              width = x.width;
              height = x.height;
              x = x.x;
          }
          $(p.node, {
              x: x,
              y: y,
              width: width,
              height: height,
              patternUnits: "userSpaceOnUse",
              id: p.id,
              viewBox: [x, y, width, height].join(" ")
          });
          p.node.appendChild(this.node);
          return p;
      };
  // SIERRA Element.marker(): clarify what a reference point is. E.g., helps you offset the object from its edge such as when centering it over a path.
  // SIERRA Element.marker(): I suggest the method should accept default reference point values.  Perhaps centered with (refX = width/2) and (refY = height/2)? Also, couldn't it assume the element's current _width_ and _height_? And please specify what _x_ and _y_ mean: offsets? If so, from where?  Couldn't they also be assigned default values?
      /*\
       * Element.marker
       [ method ]
       **
       * Creates a `<marker>` element from the current element
       **
       * To create a marker you have to specify the bounding rect and reference point:
       - x (number)
       - y (number)
       - width (number)
       - height (number)
       - refX (number)
       - refY (number)
       = (Element) the `<marker>` element
       * You can specify the marker later as an argument for `marker-start`, `marker-end`, `marker-mid`, and `marker` attributes. The `marker` attribute places the marker at every point along the path, and `marker-mid` places them at every point except the start and end.
      \*/
      // TODO add usage for markers
      elproto.marker = function (x, y, width, height, refX, refY) {
          var p = make("marker", getSomeDefs(this));
          if (x == null) {
              x = this.getBBox();
          }
          if (is(x, "object") && "x" in x) {
              y = x.y;
              width = x.width;
              height = x.height;
              refX = x.refX || x.cx;
              refY = x.refY || x.cy;
              x = x.x;
          }
          $(p.node, {
              viewBox: [x, y, width, height].join(" "),
              markerWidth: width,
              markerHeight: height,
              orient: "auto",
              refX: refX || 0,
              refY: refY || 0,
              id: p.id
          });
          p.node.appendChild(this.node);
          return p;
      };
      // animation
      function slice(from, to, f) {
          return function (arr) {
              var res = arr.slice(from, to);
              if (res.length == 1) {
                  res = res[0];
              }
              return f ? f(res) : res;
          };
      }
      var Animation = function (attr, ms, easing, callback) {
          if (typeof easing == "function" && !easing.length) {
              callback = easing;
              easing = mina.linear;
          }
          this.attr = attr;
          this.dur = ms;
          easing && (this.easing = easing);
          callback && (this.callback = callback);
      };
      Snap._.Animation = Animation;
      /*\
       * Snap.animation
       [ method ]
       **
       * Creates an animation object
       **
       - attr (object) attributes of final destination
       - duration (number) duration of the animation, in milliseconds
       - easing (function) #optional one of easing functions of @mina or custom one
       - callback (function) #optional callback function that fires when animation ends
       = (object) animation object
      \*/
      Snap.animation = function (attr, ms, easing, callback) {
          return new Animation(attr, ms, easing, callback);
      };
      /*\
       * Element.inAnim
       [ method ]
       **
       * Returns a set of animations that may be able to manipulate the current element
       **
       = (object) in format:
       o {
       o     anim (object) animation object,
       o     mina (object) @mina object,
       o     curStatus (number) 0..1 — status of the animation: 0 — just started, 1 — just finished,
       o     status (function) gets or sets the status of the animation,
       o     stop (function) stops the animation
       o }
      \*/
      elproto.inAnim = function () {
          var el = this,
              res = [];
          for (var id in el.anims) if (el.anims[has](id)) {
              (function (a) {
                  res.push({
                      anim: new Animation(a._attrs, a.dur, a.easing, a._callback),
                      mina: a,
                      curStatus: a.status(),
                      status: function (val) {
                          return a.status(val);
                      },
                      stop: function () {
                          a.stop();
                      }
                  });
              }(el.anims[id]));
          }
          return res;
      };
      /*\
       * Snap.animate
       [ method ]
       **
       * Runs generic animation of one number into another with a caring function
       **
       - from (number|array) number or array of numbers
       - to (number|array) number or array of numbers
       - setter (function) caring function that accepts one number argument
       - duration (number) duration, in milliseconds
       - easing (function) #optional easing function from @mina or custom
       - callback (function) #optional callback function to execute when animation ends
       = (object) animation object in @mina format
       o {
       o     id (string) animation id, consider it read-only,
       o     duration (function) gets or sets the duration of the animation,
       o     easing (function) easing,
       o     speed (function) gets or sets the speed of the animation,
       o     status (function) gets or sets the status of the animation,
       o     stop (function) stops the animation
       o }
       | var rect = Snap().rect(0, 0, 10, 10);
       | Snap.animate(0, 10, function (val) {
       |     rect.attr({
       |         x: val
       |     });
       | }, 1000);
       | // in given context is equivalent to
       | rect.animate({x: 10}, 1000);
      \*/
      Snap.animate = function (from, to, setter, ms, easing, callback) {
          if (typeof easing == "function" && !easing.length) {
              callback = easing;
              easing = mina.linear;
          }
          var now = mina.time(),
              anim = mina(from, to, now, now + ms, mina.time, setter, easing);
          callback && eve.once("mina.finish." + anim.id, callback);
          return anim;
      };
      /*\
       * Element.stop
       [ method ]
       **
       * Stops all the animations for the current element
       **
       = (Element) the current element
      \*/
      elproto.stop = function () {
          var anims = this.inAnim();
          for (var i = 0, ii = anims.length; i < ii; i++) {
              anims[i].stop();
          }
          return this;
      };
      /*\
       * Element.animate
       [ method ]
       **
       * Animates the given attributes of the element
       **
       - attrs (object) key-value pairs of destination attributes
       - duration (number) duration of the animation in milliseconds
       - easing (function) #optional easing function from @mina or custom
       - callback (function) #optional callback function that executes when the animation ends
       = (Element) the current element
      \*/
      elproto.animate = function (attrs, ms, easing, callback) {
          if (typeof easing == "function" && !easing.length) {
              callback = easing;
              easing = mina.linear;
          }
          if (attrs instanceof Animation) {
              callback = attrs.callback;
              easing = attrs.easing;
              ms = easing.dur;
              attrs = attrs.attr;
          }
          var fkeys = [], tkeys = [], keys = {}, from, to, f, eq,
              el = this;
          for (var key in attrs) if (attrs[has](key)) {
              if (el.equal) {
                  eq = el.equal(key, Str(attrs[key]));
                  from = eq.from;
                  to = eq.to;
                  f = eq.f;
              } else {
                  from = +el.attr(key);
                  to = +attrs[key];
              }
              var len = is(from, "array") ? from.length : 1;
              keys[key] = slice(fkeys.length, fkeys.length + len, f);
              fkeys = fkeys.concat(from);
              tkeys = tkeys.concat(to);
          }
          var now = mina.time(),
              anim = mina(fkeys, tkeys, now, now + ms, mina.time, function (val) {
                  var attr = {};
                  for (var key in keys) if (keys[has](key)) {
                      attr[key] = keys[key](val);
                  }
                  el.attr(attr);
              }, easing);
          el.anims[anim.id] = anim;
          anim._attrs = attrs;
          anim._callback = callback;
          eve("snap.animcreated." + el.id, anim);
          eve.once("mina.finish." + anim.id, function () {
              delete el.anims[anim.id];
              callback && callback.call(el);
          });
          eve.once("mina.stop." + anim.id, function () {
              delete el.anims[anim.id];
          });
          return el;
      };
      var eldata = {};
      /*\
       * Element.data
       [ method ]
       **
       * Adds or retrieves given value associated with given key. (Don’t confuse
       * with `data-` attributes)
       *
       * See also @Element.removeData
       - key (string) key to store data
       - value (any) #optional value to store
       = (object) @Element
       * or, if value is not specified:
       = (any) value
       > Usage
       | for (var i = 0, i < 5, i++) {
       |     paper.circle(10 + 15 * i, 10, 10)
       |          .attr({fill: "#000"})
       |          .data("i", i)
       |          .click(function () {
       |             alert(this.data("i"));
       |          });
       | }
      \*/
      elproto.data = function (key, value) {
          var data = eldata[this.id] = eldata[this.id] || {};
          if (arguments.length == 0){
              eve("snap.data.get." + this.id, this, data, null);
              return data;
          }
          if (arguments.length == 1) {
              if (Snap.is(key, "object")) {
                  for (var i in key) if (key[has](i)) {
                      this.data(i, key[i]);
                  }
                  return this;
              }
              eve("snap.data.get." + this.id, this, data[key], key);
              return data[key];
          }
          data[key] = value;
          eve("snap.data.set." + this.id, this, value, key);
          return this;
      };
      /*\
       * Element.removeData
       [ method ]
       **
       * Removes value associated with an element by given key.
       * If key is not provided, removes all the data of the element.
       - key (string) #optional key
       = (object) @Element
      \*/
      elproto.removeData = function (key) {
          if (key == null) {
              eldata[this.id] = {};
          } else {
              eldata[this.id] && delete eldata[this.id][key];
          }
          return this;
      };
      /*\
       * Element.outerSVG
       [ method ]
       **
       * Returns SVG code for the element, equivalent to HTML's `outerHTML`.
       *
       * See also @Element.innerSVG
       = (string) SVG code for the element
      \*/
      /*\
       * Element.toString
       [ method ]
       **
       * See @Element.outerSVG
      \*/
      elproto.outerSVG = elproto.toString = toString(1);
      /*\
       * Element.innerSVG
       [ method ]
       **
       * Returns SVG code for the element's contents, equivalent to HTML's `innerHTML`
       = (string) SVG code for the element
      \*/
      elproto.innerSVG = toString();
      function toString(type) {
          return function () {
              var res = type ? "<" + this.type : "",
                  attr = this.node.attributes,
                  chld = this.node.childNodes;
              if (type) {
                  for (var i = 0, ii = attr.length; i < ii; i++) {
                      res += " " + attr[i].name + '="' +
                              attr[i].value.replace(/"/g, '\\"') + '"';
                  }
              }
              if (chld.length) {
                  type && (res += ">");
                  for (i = 0, ii = chld.length; i < ii; i++) {
                      if (chld[i].nodeType == 3) {
                          res += chld[i].nodeValue;
                      } else if (chld[i].nodeType == 1) {
                          res += wrap(chld[i]).toString();
                      }
                  }
                  type && (res += "</" + this.type + ">");
              } else {
                  type && (res += "/>");
              }
              return res;
          };
      }
      elproto.toDataURL = function () {
          if (window && window.btoa) {
              var bb = this.getBBox(),
                  svg = Snap.format('<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="{width}" height="{height}" viewBox="{x} {y} {width} {height}">{contents}</svg>', {
                  x: +bb.x.toFixed(3),
                  y: +bb.y.toFixed(3),
                  width: +bb.width.toFixed(3),
                  height: +bb.height.toFixed(3),
                  contents: this.outerSVG()
              });
              return "data:image/svg+xml;base64," + btoa(unescape(encodeURIComponent(svg)));
          }
      };
      /*\
       * Fragment.select
       [ method ]
       **
       * See @Element.select
      \*/
      Fragment.prototype.select = elproto.select;
      /*\
       * Fragment.selectAll
       [ method ]
       **
       * See @Element.selectAll
      \*/
      Fragment.prototype.selectAll = elproto.selectAll;
  });
  
  // Copyright (c) 2013 Adobe Systems Incorporated. All rights reserved.
  // 
  // Licensed under the Apache License, Version 2.0 (the "License");
  // you may not use this file except in compliance with the License.
  // You may obtain a copy of the License at
  // 
  // http://www.apache.org/licenses/LICENSE-2.0
  // 
  // Unless required by applicable law or agreed to in writing, software
  // distributed under the License is distributed on an "AS IS" BASIS,
  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  // See the License for the specific language governing permissions and
  // limitations under the License.
  Snap.plugin(function (Snap, Element, Paper, glob, Fragment) {
      var objectToString = Object.prototype.toString,
          Str = String,
          math = Math,
          E = "";
      function Matrix(a, b, c, d, e, f) {
          if (b == null && objectToString.call(a) == "[object SVGMatrix]") {
              this.a = a.a;
              this.b = a.b;
              this.c = a.c;
              this.d = a.d;
              this.e = a.e;
              this.f = a.f;
              return;
          }
          if (a != null) {
              this.a = +a;
              this.b = +b;
              this.c = +c;
              this.d = +d;
              this.e = +e;
              this.f = +f;
          } else {
              this.a = 1;
              this.b = 0;
              this.c = 0;
              this.d = 1;
              this.e = 0;
              this.f = 0;
          }
      }
      (function (matrixproto) {
          /*\
           * Matrix.add
           [ method ]
           **
           * Adds the given matrix to existing one
           - a (number)
           - b (number)
           - c (number)
           - d (number)
           - e (number)
           - f (number)
           * or
           - matrix (object) @Matrix
          \*/
          matrixproto.add = function (a, b, c, d, e, f) {
              var out = [[], [], []],
                  m = [[this.a, this.c, this.e], [this.b, this.d, this.f], [0, 0, 1]],
                  matrix = [[a, c, e], [b, d, f], [0, 0, 1]],
                  x, y, z, res;
  
              if (a && a instanceof Matrix) {
                  matrix = [[a.a, a.c, a.e], [a.b, a.d, a.f], [0, 0, 1]];
              }
  
              for (x = 0; x < 3; x++) {
                  for (y = 0; y < 3; y++) {
                      res = 0;
                      for (z = 0; z < 3; z++) {
                          res += m[x][z] * matrix[z][y];
                      }
                      out[x][y] = res;
                  }
              }
              this.a = out[0][0];
              this.b = out[1][0];
              this.c = out[0][1];
              this.d = out[1][1];
              this.e = out[0][2];
              this.f = out[1][2];
              return this;
          };
          /*\
           * Matrix.invert
           [ method ]
           **
           * Returns an inverted version of the matrix
           = (object) @Matrix
          \*/
          matrixproto.invert = function () {
              var me = this,
                  x = me.a * me.d - me.b * me.c;
              return new Matrix(me.d / x, -me.b / x, -me.c / x, me.a / x, (me.c * me.f - me.d * me.e) / x, (me.b * me.e - me.a * me.f) / x);
          };
          /*\
           * Matrix.clone
           [ method ]
           **
           * Returns a copy of the matrix
           = (object) @Matrix
          \*/
          matrixproto.clone = function () {
              return new Matrix(this.a, this.b, this.c, this.d, this.e, this.f);
          };
          /*\
           * Matrix.translate
           [ method ]
           **
           * Translate the matrix
           - x (number) horizontal offset distance
           - y (number) vertical offset distance
          \*/
          matrixproto.translate = function (x, y) {
              return this.add(1, 0, 0, 1, x, y);
          };
          /*\
           * Matrix.scale
           [ method ]
           **
           * Scales the matrix
           - x (number) amount to be scaled, with `1` resulting in no change
           - y (number) #optional amount to scale along the vertical axis. (Otherwise `x` applies to both axes.)
           - cx (number) #optional horizontal origin point from which to scale
           - cy (number) #optional vertical origin point from which to scale
           * Default cx, cy is the middle point of the element.
          \*/
          matrixproto.scale = function (x, y, cx, cy) {
              y == null && (y = x);
              (cx || cy) && this.add(1, 0, 0, 1, cx, cy);
              this.add(x, 0, 0, y, 0, 0);
              (cx || cy) && this.add(1, 0, 0, 1, -cx, -cy);
              return this;
          };
          /*\
           * Matrix.rotate
           [ method ]
           **
           * Rotates the matrix
           - a (number) angle of rotation, in degrees
           - x (number) horizontal origin point from which to rotate
           - y (number) vertical origin point from which to rotate
          \*/
          matrixproto.rotate = function (a, x, y) {
              a = Snap.rad(a);
              x = x || 0;
              y = y || 0;
              var cos = +math.cos(a).toFixed(9),
                  sin = +math.sin(a).toFixed(9);
              this.add(cos, sin, -sin, cos, x, y);
              return this.add(1, 0, 0, 1, -x, -y);
          };
          /*\
           * Matrix.x
           [ method ]
           **
           * Returns x coordinate for given point after transformation described by the matrix. See also @Matrix.y
           - x (number)
           - y (number)
           = (number) x
          \*/
          matrixproto.x = function (x, y) {
              return x * this.a + y * this.c + this.e;
          };
          /*\
           * Matrix.y
           [ method ]
           **
           * Returns y coordinate for given point after transformation described by the matrix. See also @Matrix.x
           - x (number)
           - y (number)
           = (number) y
          \*/
          matrixproto.y = function (x, y) {
              return x * this.b + y * this.d + this.f;
          };
          matrixproto.get = function (i) {
              return +this[Str.fromCharCode(97 + i)].toFixed(4);
          };
          matrixproto.toString = function () {
              return "matrix(" + [this.get(0), this.get(1), this.get(2), this.get(3), this.get(4), this.get(5)].join() + ")";
          };
          matrixproto.offset = function () {
              return [this.e.toFixed(4), this.f.toFixed(4)];
          };
          function norm(a) {
              return a[0] * a[0] + a[1] * a[1];
          }
          function normalize(a) {
              var mag = math.sqrt(norm(a));
              a[0] && (a[0] /= mag);
              a[1] && (a[1] /= mag);
          }
          /*\
           * Matrix.determinant
           [ method ]
           **
           * Finds determinant of the given matrix.
           = (number) determinant
          \*/
          matrixproto.determinant = function () {
              return this.a * this.d - this.b * this.c;
          };
          /*\
           * Matrix.split
           [ method ]
           **
           * Splits matrix into primitive transformations
           = (object) in format:
           o dx (number) translation by x
           o dy (number) translation by y
           o scalex (number) scale by x
           o scaley (number) scale by y
           o shear (number) shear
           o rotate (number) rotation in deg
           o isSimple (boolean) could it be represented via simple transformations
          \*/
          matrixproto.split = function () {
              var out = {};
              // translation
              out.dx = this.e;
              out.dy = this.f;
  
              // scale and shear
              var row = [[this.a, this.c], [this.b, this.d]];
              out.scalex = math.sqrt(norm(row[0]));
              normalize(row[0]);
  
              out.shear = row[0][0] * row[1][0] + row[0][1] * row[1][1];
              row[1] = [row[1][0] - row[0][0] * out.shear, row[1][1] - row[0][1] * out.shear];
  
              out.scaley = math.sqrt(norm(row[1]));
              normalize(row[1]);
              out.shear /= out.scaley;
  
              if (this.determinant() < 0) {
                  out.scalex = -out.scalex;
              }
  
              // rotation
              var sin = -row[0][1],
                  cos = row[1][1];
              if (cos < 0) {
                  out.rotate = Snap.deg(math.acos(cos));
                  if (sin < 0) {
                      out.rotate = 360 - out.rotate;
                  }
              } else {
                  out.rotate = Snap.deg(math.asin(sin));
              }
  
              out.isSimple = !+out.shear.toFixed(9) && (out.scalex.toFixed(9) == out.scaley.toFixed(9) || !out.rotate);
              out.isSuperSimple = !+out.shear.toFixed(9) && out.scalex.toFixed(9) == out.scaley.toFixed(9) && !out.rotate;
              out.noRotation = !+out.shear.toFixed(9) && !out.rotate;
              return out;
          };
          /*\
           * Matrix.toTransformString
           [ method ]
           **
           * Returns transform string that represents given matrix
           = (string) transform string
          \*/
          matrixproto.toTransformString = function (shorter) {
              var s = shorter || this.split();
              if (!+s.shear.toFixed(9)) {
                  s.scalex = +s.scalex.toFixed(4);
                  s.scaley = +s.scaley.toFixed(4);
                  s.rotate = +s.rotate.toFixed(4);
                  return  (s.dx || s.dy ? "t" + [+s.dx.toFixed(4), +s.dy.toFixed(4)] : E) + 
                          (s.scalex != 1 || s.scaley != 1 ? "s" + [s.scalex, s.scaley, 0, 0] : E) +
                          (s.rotate ? "r" + [+s.rotate.toFixed(4), 0, 0] : E);
              } else {
                  return "m" + [this.get(0), this.get(1), this.get(2), this.get(3), this.get(4), this.get(5)];
              }
          };
      })(Matrix.prototype);
      /*\
       * Snap.Matrix
       [ method ]
       **
       * Matrix constructor, extend on your own risk.
       * To create matrices use @Snap.matrix.
      \*/
      Snap.Matrix = Matrix;
      /*\
       * Snap.matrix
       [ method ]
       **
       * Utility method
       **
       * Returns a matrix based on the given parameters
       - a (number)
       - b (number)
       - c (number)
       - d (number)
       - e (number)
       - f (number)
       * or
       - svgMatrix (SVGMatrix)
       = (object) @Matrix
      \*/
      Snap.matrix = function (a, b, c, d, e, f) {
          return new Matrix(a, b, c, d, e, f);
      };
  });
  // Copyright (c) 2013 Adobe Systems Incorporated. All rights reserved.
  // 
  // Licensed under the Apache License, Version 2.0 (the "License");
  // you may not use this file except in compliance with the License.
  // You may obtain a copy of the License at
  // 
  // http://www.apache.org/licenses/LICENSE-2.0
  // 
  // Unless required by applicable law or agreed to in writing, software
  // distributed under the License is distributed on an "AS IS" BASIS,
  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  // See the License for the specific language governing permissions and
  // limitations under the License.
  Snap.plugin(function (Snap, Element, Paper, glob, Fragment) {
      var has = "hasOwnProperty",
          make = Snap._.make,
          wrap = Snap._.wrap,
          is = Snap.is,
          getSomeDefs = Snap._.getSomeDefs,
          reURLValue = /^url\(#?([^)]+)\)$/,
          $ = Snap._.$,
          URL = Snap.url,
          Str = String,
          separator = Snap._.separator,
          E = "";
      // Attributes event handlers
      eve.on("snap.util.attr.mask", function (value) {
          if (value instanceof Element || value instanceof Fragment) {
              eve.stop();
              if (value instanceof Fragment && value.node.childNodes.length == 1) {
                  value = value.node.firstChild;
                  getSomeDefs(this).appendChild(value);
                  value = wrap(value);
              }
              if (value.type == "mask") {
                  var mask = value;
              } else {
                  mask = make("mask", getSomeDefs(this));
                  mask.node.appendChild(value.node);
              }
              !mask.node.id && $(mask.node, {
                  id: mask.id
              });
              $(this.node, {
                  mask: URL(mask.id)
              });
          }
      });
      (function (clipIt) {
          eve.on("snap.util.attr.clip", clipIt);
          eve.on("snap.util.attr.clip-path", clipIt);
          eve.on("snap.util.attr.clipPath", clipIt);
      }(function (value) {
          if (value instanceof Element || value instanceof Fragment) {
              eve.stop();
              if (value.type == "clipPath") {
                  var clip = value;
              } else {
                  clip = make("clipPath", getSomeDefs(this));
                  clip.node.appendChild(value.node);
                  !clip.node.id && $(clip.node, {
                      id: clip.id
                  });
              }
              $(this.node, {
                  "clip-path": URL(clip.node.id || clip.id)
              });
          }
      }));
      function fillStroke(name) {
          return function (value) {
              eve.stop();
              if (value instanceof Fragment && value.node.childNodes.length == 1 &&
                  (value.node.firstChild.tagName == "radialGradient" ||
                  value.node.firstChild.tagName == "linearGradient" ||
                  value.node.firstChild.tagName == "pattern")) {
                  value = value.node.firstChild;
                  getSomeDefs(this).appendChild(value);
                  value = wrap(value);
              }
              if (value instanceof Element) {
                  if (value.type == "radialGradient" || value.type == "linearGradient"
                     || value.type == "pattern") {
                      if (!value.node.id) {
                          $(value.node, {
                              id: value.id
                          });
                      }
                      var fill = URL(value.node.id);
                  } else {
                      fill = value.attr(name);
                  }
              } else {
                  fill = Snap.color(value);
                  if (fill.error) {
                      var grad = Snap(getSomeDefs(this).ownerSVGElement).gradient(value);
                      if (grad) {
                          if (!grad.node.id) {
                              $(grad.node, {
                                  id: grad.id
                              });
                          }
                          fill = URL(grad.node.id);
                      } else {
                          fill = value;
                      }
                  } else {
                      fill = Str(fill);
                  }
              }
              var attrs = {};
              attrs[name] = fill;
              $(this.node, attrs);
              this.node.style[name] = E;
          };
      }
      eve.on("snap.util.attr.fill", fillStroke("fill"));
      eve.on("snap.util.attr.stroke", fillStroke("stroke"));
      var gradrg = /^([lr])(?:\(([^)]*)\))?(.*)$/i;
      eve.on("snap.util.grad.parse", function parseGrad(string) {
          string = Str(string);
          var tokens = string.match(gradrg);
          if (!tokens) {
              return null;
          }
          var type = tokens[1],
              params = tokens[2],
              stops = tokens[3];
          params = params.split(/\s*,\s*/).map(function (el) {
              return +el == el ? +el : el;
          });
          if (params.length == 1 && params[0] == 0) {
              params = [];
          }
          stops = stops.split("-");
          stops = stops.map(function (el) {
              el = el.split(":");
              var out = {
                  color: el[0]
              };
              if (el[1]) {
                  out.offset = parseFloat(el[1]);
              }
              return out;
          });
          return {
              type: type,
              params: params,
              stops: stops
          };
      });
  
      eve.on("snap.util.attr.d", function (value) {
          eve.stop();
          if (is(value, "array") && is(value[0], "array")) {
              value = Snap.path.toString.call(value);
          }
          value = Str(value);
          if (value.match(/[ruo]/i)) {
              value = Snap.path.toAbsolute(value);
          }
          $(this.node, {d: value});
      })(-1);
      eve.on("snap.util.attr.#text", function (value) {
          eve.stop();
          value = Str(value);
          var txt = glob.doc.createTextNode(value);
          while (this.node.firstChild) {
              this.node.removeChild(this.node.firstChild);
          }
          this.node.appendChild(txt);
      })(-1);
      eve.on("snap.util.attr.path", function (value) {
          eve.stop();
          this.attr({d: value});
      })(-1);
      eve.on("snap.util.attr.class", function (value) {
          eve.stop();
          this.node.className.baseVal = value;
      })(-1);
      eve.on("snap.util.attr.viewBox", function (value) {
          var vb;
          if (is(value, "object") && "x" in value) {
              vb = [value.x, value.y, value.width, value.height].join(" ");
          } else if (is(value, "array")) {
              vb = value.join(" ");
          } else {
              vb = value;
          }
          $(this.node, {
              viewBox: vb
          });
          eve.stop();
      })(-1);
      eve.on("snap.util.attr.transform", function (value) {
          this.transform(value);
          eve.stop();
      })(-1);
      eve.on("snap.util.attr.r", function (value) {
          if (this.type == "rect") {
              eve.stop();
              $(this.node, {
                  rx: value,
                  ry: value
              });
          }
      })(-1);
      eve.on("snap.util.attr.textpath", function (value) {
          eve.stop();
          if (this.type == "text") {
              var id, tp, node;
              if (!value && this.textPath) {
                  tp = this.textPath;
                  while (tp.node.firstChild) {
                      this.node.appendChild(tp.node.firstChild);
                  }
                  tp.remove();
                  delete this.textPath;
                  return;
              }
              if (is(value, "string")) {
                  var defs = getSomeDefs(this),
                      path = wrap(defs.parentNode).path(value);
                  defs.appendChild(path.node);
                  id = path.id;
                  path.attr({id: id});
              } else {
                  value = wrap(value);
                  if (value instanceof Element) {
                      id = value.attr("id");
                      if (!id) {
                          id = value.id;
                          value.attr({id: id});
                      }
                  }
              }
              if (id) {
                  tp = this.textPath;
                  node = this.node;
                  if (tp) {
                      tp.attr({"xlink:href": "#" + id});
                  } else {
                      tp = $("textPath", {
                          "xlink:href": "#" + id
                      });
                      while (node.firstChild) {
                          tp.appendChild(node.firstChild);
                      }
                      node.appendChild(tp);
                      this.textPath = wrap(tp);
                  }
              }
          }
      })(-1);
      eve.on("snap.util.attr.text", function (value) {
          if (this.type == "text") {
              var i = 0,
                  node = this.node,
                  tuner = function (chunk) {
                      var out = $("tspan");
                      if (is(chunk, "array")) {
                          for (var i = 0; i < chunk.length; i++) {
                              out.appendChild(tuner(chunk[i]));
                          }
                      } else {
                          out.appendChild(glob.doc.createTextNode(chunk));
                      }
                      out.normalize && out.normalize();
                      return out;
                  };
              while (node.firstChild) {
                  node.removeChild(node.firstChild);
              }
              var tuned = tuner(value);
              while (tuned.firstChild) {
                  node.appendChild(tuned.firstChild);
              }
          }
          eve.stop();
      })(-1);
      function setFontSize(value) {
          eve.stop();
          if (value == +value) {
              value += "px";
          }
          this.node.style.fontSize = value;
      }
      eve.on("snap.util.attr.fontSize", setFontSize)(-1);
      eve.on("snap.util.attr.font-size", setFontSize)(-1);
  
  
      eve.on("snap.util.getattr.transform", function () {
          eve.stop();
          return this.transform();
      })(-1);
      eve.on("snap.util.getattr.textpath", function () {
          eve.stop();
          return this.textPath;
      })(-1);
      // Markers
      (function () {
          function getter(end) {
              return function () {
                  eve.stop();
                  var style = glob.doc.defaultView.getComputedStyle(this.node, null).getPropertyValue("marker-" + end);
                  if (style == "none") {
                      return style;
                  } else {
                      return Snap(glob.doc.getElementById(style.match(reURLValue)[1]));
                  }
              };
          }
          function setter(end) {
              return function (value) {
                  eve.stop();
                  var name = "marker" + end.charAt(0).toUpperCase() + end.substring(1);
                  if (value == "" || !value) {
                      this.node.style[name] = "none";
                      return;
                  }
                  if (value.type == "marker") {
                      var id = value.node.id;
                      if (!id) {
                          $(value.node, {id: value.id});
                      }
                      this.node.style[name] = URL(id);
                      return;
                  }
              };
          }
          eve.on("snap.util.getattr.marker-end", getter("end"))(-1);
          eve.on("snap.util.getattr.markerEnd", getter("end"))(-1);
          eve.on("snap.util.getattr.marker-start", getter("start"))(-1);
          eve.on("snap.util.getattr.markerStart", getter("start"))(-1);
          eve.on("snap.util.getattr.marker-mid", getter("mid"))(-1);
          eve.on("snap.util.getattr.markerMid", getter("mid"))(-1);
          eve.on("snap.util.attr.marker-end", setter("end"))(-1);
          eve.on("snap.util.attr.markerEnd", setter("end"))(-1);
          eve.on("snap.util.attr.marker-start", setter("start"))(-1);
          eve.on("snap.util.attr.markerStart", setter("start"))(-1);
          eve.on("snap.util.attr.marker-mid", setter("mid"))(-1);
          eve.on("snap.util.attr.markerMid", setter("mid"))(-1);
      }());
      eve.on("snap.util.getattr.r", function () {
          if (this.type == "rect" && $(this.node, "rx") == $(this.node, "ry")) {
              eve.stop();
              return $(this.node, "rx");
          }
      })(-1);
      function textExtract(node) {
          var out = [];
          var children = node.childNodes;
          for (var i = 0, ii = children.length; i < ii; i++) {
              var chi = children[i];
              if (chi.nodeType == 3) {
                  out.push(chi.nodeValue);
              }
              if (chi.tagName == "tspan") {
                  if (chi.childNodes.length == 1 && chi.firstChild.nodeType == 3) {
                      out.push(chi.firstChild.nodeValue);
                  } else {
                      out.push(textExtract(chi));
                  }
              }
          }
          return out;
      }
      eve.on("snap.util.getattr.text", function () {
          if (this.type == "text" || this.type == "tspan") {
              eve.stop();
              var out = textExtract(this.node);
              return out.length == 1 ? out[0] : out;
          }
      })(-1);
      eve.on("snap.util.getattr.#text", function () {
          return this.node.textContent;
      })(-1);
      eve.on("snap.util.getattr.viewBox", function () {
          eve.stop();
          var vb = $(this.node, "viewBox");
          if (vb) {
              vb = vb.split(separator);
              return Snap._.box(+vb[0], +vb[1], +vb[2], +vb[3]);
          } else {
              return;
          }
      })(-1);
      eve.on("snap.util.getattr.points", function () {
          var p = $(this.node, "points");
          eve.stop();
          if (p) {
              return p.split(separator);
          } else {
              return;
          }
      })(-1);
      eve.on("snap.util.getattr.path", function () {
          var p = $(this.node, "d");
          eve.stop();
          return p;
      })(-1);
      eve.on("snap.util.getattr.class", function () {
          return this.node.className.baseVal;
      })(-1);
      function getFontSize() {
          eve.stop();
          return this.node.style.fontSize;
      }
      eve.on("snap.util.getattr.fontSize", getFontSize)(-1);
      eve.on("snap.util.getattr.font-size", getFontSize)(-1);
  });
  
  // Copyright (c) 2013 Adobe Systems Incorporated. All rights reserved.
  // 
  // Licensed under the Apache License, Version 2.0 (the "License");
  // you may not use this file except in compliance with the License.
  // You may obtain a copy of the License at
  // 
  // http://www.apache.org/licenses/LICENSE-2.0
  // 
  // Unless required by applicable law or agreed to in writing, software
  // distributed under the License is distributed on an "AS IS" BASIS,
  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  // See the License for the specific language governing permissions and
  // limitations under the License.
  Snap.plugin(function (Snap, Element, Paper, glob, Fragment) {
      var proto = Paper.prototype,
          is = Snap.is;
      /*\
       * Paper.rect
       [ method ]
       *
       * Draws a rectangle
       **
       - x (number) x coordinate of the top left corner
       - y (number) y coordinate of the top left corner
       - width (number) width
       - height (number) height
       - rx (number) #optional horizontal radius for rounded corners, default is 0
       - ry (number) #optional vertical radius for rounded corners, default is rx or 0
       = (object) the `rect` element
       **
       > Usage
       | // regular rectangle
       | var c = paper.rect(10, 10, 50, 50);
       | // rectangle with rounded corners
       | var c = paper.rect(40, 40, 50, 50, 10);
      \*/
      proto.rect = function (x, y, w, h, rx, ry) {
          var attr;
          if (ry == null) {
              ry = rx;
          }
          if (is(x, "object") && x == "[object Object]") {
              attr = x;
          } else if (x != null) {
              attr = {
                  x: x,
                  y: y,
                  width: w,
                  height: h
              };
              if (rx != null) {
                  attr.rx = rx;
                  attr.ry = ry;
              }
          }
          return this.el("rect", attr);
      };
      /*\
       * Paper.circle
       [ method ]
       **
       * Draws a circle
       **
       - x (number) x coordinate of the centre
       - y (number) y coordinate of the centre
       - r (number) radius
       = (object) the `circle` element
       **
       > Usage
       | var c = paper.circle(50, 50, 40);
      \*/
      proto.circle = function (cx, cy, r) {
          var attr;
          if (is(cx, "object") && cx == "[object Object]") {
              attr = cx;
          } else if (cx != null) {
              attr = {
                  cx: cx,
                  cy: cy,
                  r: r
              };
          }
          return this.el("circle", attr);
      };
  
      var preload = (function () {
          function onerror() {
              this.parentNode.removeChild(this);
          }
          return function (src, f) {
              var img = glob.doc.createElement("img"),
                  body = glob.doc.body;
              img.style.cssText = "position:absolute;left:-9999em;top:-9999em";
              img.onload = function () {
                  f.call(img);
                  img.onload = img.onerror = null;
                  body.removeChild(img);
              };
              img.onerror = onerror;
              body.appendChild(img);
              img.src = src;
          };
      }());
  
      /*\
       * Paper.image
       [ method ]
       **
       * Places an image on the surface
       **
       - src (string) URI of the source image
       - x (number) x offset position
       - y (number) y offset position
       - width (number) width of the image
       - height (number) height of the image
       = (object) the `image` element
       * or
       = (object) Snap element object with type `image`
       **
       > Usage
       | var c = paper.image("apple.png", 10, 10, 80, 80);
      \*/
      proto.image = function (src, x, y, width, height) {
          var el = this.el("image");
          if (is(src, "object") && "src" in src) {
              el.attr(src);
          } else if (src != null) {
              var set = {
                  "xlink:href": src,
                  preserveAspectRatio: "none"
              };
              if (x != null && y != null) {
                  set.x = x;
                  set.y = y;
              }
              if (width != null && height != null) {
                  set.width = width;
                  set.height = height;
              } else {
                  preload(src, function () {
                      Snap._.$(el.node, {
                          width: this.offsetWidth,
                          height: this.offsetHeight
                      });
                  });
              }
              Snap._.$(el.node, set);
          }
          return el;
      };
      /*\
       * Paper.ellipse
       [ method ]
       **
       * Draws an ellipse
       **
       - x (number) x coordinate of the centre
       - y (number) y coordinate of the centre
       - rx (number) horizontal radius
       - ry (number) vertical radius
       = (object) the `ellipse` element
       **
       > Usage
       | var c = paper.ellipse(50, 50, 40, 20);
      \*/
      proto.ellipse = function (cx, cy, rx, ry) {
          var attr;
          if (is(cx, "object") && cx == "[object Object]") {
              attr = cx;
          } else if (cx != null) {
              attr ={
                  cx: cx,
                  cy: cy,
                  rx: rx,
                  ry: ry
              };
          }
          return this.el("ellipse", attr);
      };
      // SIERRA Paper.path(): Unclear from the link what a Catmull-Rom curveto is, and why it would make life any easier.
      /*\
       * Paper.path
       [ method ]
       **
       * Creates a `<path>` element using the given string as the path's definition
       - pathString (string) #optional path string in SVG format
       * Path string consists of one-letter commands, followed by comma seprarated arguments in numerical form. Example:
       | "M10,20L30,40"
       * This example features two commands: `M`, with arguments `(10, 20)` and `L` with arguments `(30, 40)`. Uppercase letter commands express coordinates in absolute terms, while lowercase commands express them in relative terms from the most recently declared coordinates.
       *
       # <p>Here is short list of commands available, for more details see <a href="http://www.w3.org/TR/SVG/paths.html#PathData" title="Details of a path's data attribute's format are described in the SVG specification.">SVG path string format</a> or <a href="https://developer.mozilla.org/en/SVG/Tutorial/Paths">article about path strings at MDN</a>.</p>
       # <table><thead><tr><th>Command</th><th>Name</th><th>Parameters</th></tr></thead><tbody>
       # <tr><td>M</td><td>moveto</td><td>(x y)+</td></tr>
       # <tr><td>Z</td><td>closepath</td><td>(none)</td></tr>
       # <tr><td>L</td><td>lineto</td><td>(x y)+</td></tr>
       # <tr><td>H</td><td>horizontal lineto</td><td>x+</td></tr>
       # <tr><td>V</td><td>vertical lineto</td><td>y+</td></tr>
       # <tr><td>C</td><td>curveto</td><td>(x1 y1 x2 y2 x y)+</td></tr>
       # <tr><td>S</td><td>smooth curveto</td><td>(x2 y2 x y)+</td></tr>
       # <tr><td>Q</td><td>quadratic Bézier curveto</td><td>(x1 y1 x y)+</td></tr>
       # <tr><td>T</td><td>smooth quadratic Bézier curveto</td><td>(x y)+</td></tr>
       # <tr><td>A</td><td>elliptical arc</td><td>(rx ry x-axis-rotation large-arc-flag sweep-flag x y)+</td></tr>
       # <tr><td>R</td><td><a href="http://en.wikipedia.org/wiki/Catmull–Rom_spline#Catmull.E2.80.93Rom_spline">Catmull-Rom curveto</a>*</td><td>x1 y1 (x y)+</td></tr></tbody></table>
       * * _Catmull-Rom curveto_ is a not standard SVG command and added to make life easier.
       * Note: there is a special case when a path consists of only three commands: `M10,10R…z`. In this case the path connects back to its starting point.
       > Usage
       | var c = paper.path("M10 10L90 90");
       | // draw a diagonal line:
       | // move to 10,10, line to 90,90
      \*/
      proto.path = function (d) {
          var attr;
          if (is(d, "object") && !is(d, "array")) {
              attr = d;
          } else if (d) {
              attr = {d: d};
          }
          return this.el("path", attr);
      };
      /*\
       * Paper.g
       [ method ]
       **
       * Creates a group element
       **
       - varargs (…) #optional elements to nest within the group
       = (object) the `g` element
       **
       > Usage
       | var c1 = paper.circle(),
       |     c2 = paper.rect(),
       |     g = paper.g(c2, c1); // note that the order of elements is different
       * or
       | var c1 = paper.circle(),
       |     c2 = paper.rect(),
       |     g = paper.g();
       | g.add(c2, c1);
      \*/
      /*\
       * Paper.group
       [ method ]
       **
       * See @Paper.g
      \*/
      proto.group = proto.g = function (first) {
          var attr,
              el = this.el("g");
          if (arguments.length == 1 && first && !first.type) {
              el.attr(first);
          } else if (arguments.length) {
              el.add(Array.prototype.slice.call(arguments, 0));
          }
          return el;
      };
      /*\
       * Paper.svg
       [ method ]
       **
       * Creates a nested SVG element.
       - x (number) @optional X of the element
       - y (number) @optional Y of the element
       - width (number) @optional width of the element
       - height (number) @optional height of the element
       - vbx (number) @optional viewbox X
       - vby (number) @optional viewbox Y
       - vbw (number) @optional viewbox width
       - vbh (number) @optional viewbox height
       **
       = (object) the `svg` element
       **
      \*/
      proto.svg = function (x, y, width, height, vbx, vby, vbw, vbh) {
          var attrs = {};
          if (is(x, "object") && y == null) {
              attrs = x;
          } else {
              if (x != null) {
                  attrs.x = x;
              }
              if (y != null) {
                  attrs.y = y;
              }
              if (width != null) {
                  attrs.width = width;
              }
              if (height != null) {
                  attrs.height = height;
              }
              if (vbx != null && vby != null && vbw != null && vbh != null) {
                  attrs.viewBox = [vbx, vby, vbw, vbh];
              }
          }
          return this.el("svg", attrs);
      };
      /*\
       * Paper.mask
       [ method ]
       **
       * Equivalent in behaviour to @Paper.g, except it’s a mask.
       **
       = (object) the `mask` element
       **
      \*/
      proto.mask = function (first) {
          var attr,
              el = this.el("mask");
          if (arguments.length == 1 && first && !first.type) {
              el.attr(first);
          } else if (arguments.length) {
              el.add(Array.prototype.slice.call(arguments, 0));
          }
          return el;
      };
      /*\
       * Paper.ptrn
       [ method ]
       **
       * Equivalent in behaviour to @Paper.g, except it’s a pattern.
       - x (number) @optional X of the element
       - y (number) @optional Y of the element
       - width (number) @optional width of the element
       - height (number) @optional height of the element
       - vbx (number) @optional viewbox X
       - vby (number) @optional viewbox Y
       - vbw (number) @optional viewbox width
       - vbh (number) @optional viewbox height
       **
       = (object) the `pattern` element
       **
      \*/
      proto.ptrn = function (x, y, width, height, vx, vy, vw, vh) {
          if (is(x, "object")) {
              var attr = x;
          } else {
              attr = {patternUnits: "userSpaceOnUse"};
              if (x) {
                  attr.x = x;
              }
              if (y) {
                  attr.y = y;
              }
              if (width != null) {
                  attr.width = width;
              }
              if (height != null) {
                  attr.height = height;
              }
              if (vx != null && vy != null && vw != null && vh != null) {
                  attr.viewBox = [vx, vy, vw, vh];
              }
          }
          return this.el("pattern", attr);
      };
      /*\
       * Paper.use
       [ method ]
       **
       * Creates a <use> element.
       - id (string) @optional id of element to link
       * or
       - id (Element) @optional element to link
       **
       = (object) the `use` element
       **
      \*/
      proto.use = function (id) {
          if (id != null) {
              if (id instanceof Element) {
                  if (!id.attr("id")) {
                      id.attr({id: Snap._.id(id)});
                  }
                  id = id.attr("id");
              }
              if (String(id).charAt() == "#") {
                  id = id.substring(1);
              }
              return this.el("use", {"xlink:href": "#" + id});
          } else {
              return Element.prototype.use.call(this);
          }
      };
      /*\
       * Paper.symbol
       [ method ]
       **
       * Creates a <symbol> element.
       - vbx (number) @optional viewbox X
       - vby (number) @optional viewbox Y
       - vbw (number) @optional viewbox width
       - vbh (number) @optional viewbox height
       = (object) the `symbol` element
       **
      \*/
      proto.symbol = function (vx, vy, vw, vh) {
          var attr = {};
          if (vx != null && vy != null && vw != null && vh != null) {
              attr.viewBox = [vx, vy, vw, vh];
          }
  
          return this.el("symbol", attr);
      };
      /*\
       * Paper.text
       [ method ]
       **
       * Draws a text string
       **
       - x (number) x coordinate position
       - y (number) y coordinate position
       - text (string|array) The text string to draw or array of strings to nest within separate `<tspan>` elements
       = (object) the `text` element
       **
       > Usage
       | var t1 = paper.text(50, 50, "Snap");
       | var t2 = paper.text(50, 50, ["S","n","a","p"]);
       | // Text path usage
       | t1.attr({textpath: "M10,10L100,100"});
       | // or
       | var pth = paper.path("M10,10L100,100");
       | t1.attr({textpath: pth});
      \*/
      proto.text = function (x, y, text) {
          var attr = {};
          if (is(x, "object")) {
              attr = x;
          } else if (x != null) {
              attr = {
                  x: x,
                  y: y,
                  text: text || ""
              };
          }
          return this.el("text", attr);
      };
      /*\
       * Paper.line
       [ method ]
       **
       * Draws a line
       **
       - x1 (number) x coordinate position of the start
       - y1 (number) y coordinate position of the start
       - x2 (number) x coordinate position of the end
       - y2 (number) y coordinate position of the end
       = (object) the `line` element
       **
       > Usage
       | var t1 = paper.line(50, 50, 100, 100);
      \*/
      proto.line = function (x1, y1, x2, y2) {
          var attr = {};
          if (is(x1, "object")) {
              attr = x1;
          } else if (x1 != null) {
              attr = {
                  x1: x1,
                  x2: x2,
                  y1: y1,
                  y2: y2
              };
          }
          return this.el("line", attr);
      };
      /*\
       * Paper.polyline
       [ method ]
       **
       * Draws a polyline
       **
       - points (array) array of points
       * or
       - varargs (…) points
       = (object) the `polyline` element
       **
       > Usage
       | var p1 = paper.polyline([10, 10, 100, 100]);
       | var p2 = paper.polyline(10, 10, 100, 100);
      \*/
      proto.polyline = function (points) {
          if (arguments.length > 1) {
              points = Array.prototype.slice.call(arguments, 0);
          }
          var attr = {};
          if (is(points, "object") && !is(points, "array")) {
              attr = points;
          } else if (points != null) {
              attr = {points: points};
          }
          return this.el("polyline", attr);
      };
      /*\
       * Paper.polygon
       [ method ]
       **
       * Draws a polygon. See @Paper.polyline
      \*/
      proto.polygon = function (points) {
          if (arguments.length > 1) {
              points = Array.prototype.slice.call(arguments, 0);
          }
          var attr = {};
          if (is(points, "object") && !is(points, "array")) {
              attr = points;
          } else if (points != null) {
              attr = {points: points};
          }
          return this.el("polygon", attr);
      };
      // gradients
      (function () {
          var $ = Snap._.$;
          // gradients' helpers
          function Gstops() {
              return this.selectAll("stop");
          }
          function GaddStop(color, offset) {
              var stop = $("stop"),
                  attr = {
                      offset: +offset + "%"
                  };
              color = Snap.color(color);
              attr["stop-color"] = color.hex;
              if (color.opacity < 1) {
                  attr["stop-opacity"] = color.opacity;
              }
              $(stop, attr);
              this.node.appendChild(stop);
              return this;
          }
          function GgetBBox() {
              if (this.type == "linearGradient") {
                  var x1 = $(this.node, "x1") || 0,
                      x2 = $(this.node, "x2") || 1,
                      y1 = $(this.node, "y1") || 0,
                      y2 = $(this.node, "y2") || 0;
                  return Snap._.box(x1, y1, math.abs(x2 - x1), math.abs(y2 - y1));
              } else {
                  var cx = this.node.cx || .5,
                      cy = this.node.cy || .5,
                      r = this.node.r || 0;
                  return Snap._.box(cx - r, cy - r, r * 2, r * 2);
              }
          }
          function gradient(defs, str) {
              var grad = eve("snap.util.grad.parse", null, str).firstDefined(),
                  el;
              if (!grad) {
                  return null;
              }
              grad.params.unshift(defs);
              if (grad.type.toLowerCase() == "l") {
                  el = gradientLinear.apply(0, grad.params);
              } else {
                  el = gradientRadial.apply(0, grad.params);
              }
              if (grad.type != grad.type.toLowerCase()) {
                  $(el.node, {
                      gradientUnits: "userSpaceOnUse"
                  });
              }
              var stops = grad.stops,
                  len = stops.length,
                  start = 0,
                  j = 0;
              function seed(i, end) {
                  var step = (end - start) / (i - j);
                  for (var k = j; k < i; k++) {
                      stops[k].offset = +(+start + step * (k - j)).toFixed(2);
                  }
                  j = i;
                  start = end;
              }
              len--;
              for (var i = 0; i < len; i++) if ("offset" in stops[i]) {
                  seed(i, stops[i].offset);
              }
              stops[len].offset = stops[len].offset || 100;
              seed(len, stops[len].offset);
              for (i = 0; i <= len; i++) {
                  var stop = stops[i];
                  el.addStop(stop.color, stop.offset);
              }
              return el;
          }
          function gradientLinear(defs, x1, y1, x2, y2) {
              var el = Snap._.make("linearGradient", defs);
              el.stops = Gstops;
              el.addStop = GaddStop;
              el.getBBox = GgetBBox;
              if (x1 != null) {
                  $(el.node, {
                      x1: x1,
                      y1: y1,
                      x2: x2,
                      y2: y2
                  });
              }
              return el;
          }
          function gradientRadial(defs, cx, cy, r, fx, fy) {
              var el = Snap._.make("radialGradient", defs);
              el.stops = Gstops;
              el.addStop = GaddStop;
              el.getBBox = GgetBBox;
              if (cx != null) {
                  $(el.node, {
                      cx: cx,
                      cy: cy,
                      r: r
                  });
              }
              if (fx != null && fy != null) {
                  $(el.node, {
                      fx: fx,
                      fy: fy
                  });
              }
              return el;
          }
          /*\
           * Paper.gradient
           [ method ]
           **
           * Creates a gradient element
           **
           - gradient (string) gradient descriptor
           > Gradient Descriptor
           * The gradient descriptor is an expression formatted as
           * follows: `<type>(<coords>)<colors>`.  The `<type>` can be
           * either linear or radial.  The uppercase `L` or `R` letters
           * indicate absolute coordinates offset from the SVG surface.
           * Lowercase `l` or `r` letters indicate coordinates
           * calculated relative to the element to which the gradient is
           * applied.  Coordinates specify a linear gradient vector as
           * `x1`, `y1`, `x2`, `y2`, or a radial gradient as `cx`, `cy`,
           * `r` and optional `fx`, `fy` specifying a focal point away
           * from the center of the circle. Specify `<colors>` as a list
           * of dash-separated CSS color values.  Each color may be
           * followed by a custom offset value, separated with a colon
           * character.
           > Examples
           * Linear gradient, relative from top-left corner to bottom-right
           * corner, from black through red to white:
           | var g = paper.gradient("l(0, 0, 1, 1)#000-#f00-#fff");
           * Linear gradient, absolute from (0, 0) to (100, 100), from black
           * through red at 25% to white:
           | var g = paper.gradient("L(0, 0, 100, 100)#000-#f00:25-#fff");
           * Radial gradient, relative from the center of the element with radius
           * half the width, from black to white:
           | var g = paper.gradient("r(0.5, 0.5, 0.5)#000-#fff");
           * To apply the gradient:
           | paper.circle(50, 50, 40).attr({
           |     fill: g
           | });
           = (object) the `gradient` element
          \*/
          proto.gradient = function (str) {
              return gradient(this.defs, str);
          };
          proto.gradientLinear = function (x1, y1, x2, y2) {
              return gradientLinear(this.defs, x1, y1, x2, y2);
          };
          proto.gradientRadial = function (cx, cy, r, fx, fy) {
              return gradientRadial(this.defs, cx, cy, r, fx, fy);
          };
          /*\
           * Paper.toString
           [ method ]
           **
           * Returns SVG code for the @Paper
           = (string) SVG code for the @Paper
          \*/
          proto.toString = function () {
              var doc = this.node.ownerDocument,
                  f = doc.createDocumentFragment(),
                  d = doc.createElement("div"),
                  svg = this.node.cloneNode(true),
                  res;
              f.appendChild(d);
              d.appendChild(svg);
              Snap._.$(svg, {xmlns: "http://www.w3.org/2000/svg"});
              res = d.innerHTML;
              f.removeChild(f.firstChild);
              return res;
          };
          /*\
           * Paper.toDataURL
           [ method ]
           **
           * Returns SVG code for the @Paper as Data URI string.
           = (string) Data URI string
          \*/
          proto.toDataURL = function () {
              if (window && window.btoa) {
                  return "data:image/svg+xml;base64," + btoa(unescape(encodeURIComponent(this)));
              }
          };
          /*\
           * Paper.clear
           [ method ]
           **
           * Removes all child nodes of the paper, except <defs>.
          \*/
          proto.clear = function () {
              var node = this.node.firstChild,
                  next;
              while (node) {
                  next = node.nextSibling;
                  if (node.tagName != "defs") {
                      node.parentNode.removeChild(node);
                  } else {
                      proto.clear.call({node: node});
                  }
                  node = next;
              }
          };
      }());
  });
  
  // Copyright (c) 2013 Adobe Systems Incorporated. All rights reserved.
  // 
  // Licensed under the Apache License, Version 2.0 (the "License");
  // you may not use this file except in compliance with the License.
  // You may obtain a copy of the License at
  // 
  // http://www.apache.org/licenses/LICENSE-2.0
  // 
  // Unless required by applicable law or agreed to in writing, software
  // distributed under the License is distributed on an "AS IS" BASIS,
  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  // See the License for the specific language governing permissions and
  // limitations under the License.
  Snap.plugin(function (Snap, Element, Paper, glob) {
      var elproto = Element.prototype,
          is = Snap.is,
          clone = Snap._.clone,
          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;
      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 toString() {
          return this.join(",").replace(p2s, "$1");
      }
      function pathClone(pathArray) {
          var res = clone(pathArray);
          res.toString = toString;
          return res;
      }
      function getPointAtSegmentLength(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, length) {
          if (length == null) {
              return bezlen(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y);
          } else {
              return findDotsAtSegment(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y,
                  getTotLen(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, length));
          }
      }
      function getLengthFactory(istotal, subpath) {
          function O(val) {
              return +(+val).toFixed(3);
          }
          return Snap._.cacher(function (path, length, onlystart) {
              if (path instanceof Element) {
                  path = path.attr("d");
              }
              path = path2curve(path);
              var x, y, p, l, sp = "", subpaths = {}, point,
                  len = 0;
              for (var i = 0, ii = path.length; i < ii; i++) {
                  p = path[i];
                  if (p[0] == "M") {
                      x = +p[1];
                      y = +p[2];
                  } else {
                      l = getPointAtSegmentLength(x, y, p[1], p[2], p[3], p[4], p[5], p[6]);
                      if (len + l > length) {
                          if (subpath && !subpaths.start) {
                              point = getPointAtSegmentLength(x, y, p[1], p[2], p[3], p[4], p[5], p[6], length - len);
                              sp += [
                                  "C" + O(point.start.x),
                                  O(point.start.y),
                                  O(point.m.x),
                                  O(point.m.y),
                                  O(point.x),
                                  O(point.y)
                              ];
                              if (onlystart) {return sp;}
                              subpaths.start = sp;
                              sp = [
                                  "M" + O(point.x),
                                  O(point.y) + "C" + O(point.n.x),
                                  O(point.n.y),
                                  O(point.end.x),
                                  O(point.end.y),
                                  O(p[5]),
                                  O(p[6])
                              ].join();
                              len += l;
                              x = +p[5];
                              y = +p[6];
                              continue;
                          }
                          if (!istotal && !subpath) {
                              point = getPointAtSegmentLength(x, y, p[1], p[2], p[3], p[4], p[5], p[6], length - len);
                              return point;
                          }
                      }
                      len += l;
                      x = +p[5];
                      y = +p[6];
                  }
                  sp += p.shift() + p;
              }
              subpaths.end = sp;
              point = istotal ? len : subpath ? subpaths : findDotsAtSegment(x, y, p[0], p[1], p[2], p[3], p[4], p[5], 1);
              return point;
          }, null, Snap._.clone);
      }
      var getTotalLength = getLengthFactory(1),
          getPointAtLength = getLengthFactory(),
          getSubpathsAtLength = getLengthFactory(0, 1);
      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);
          // (mx > nx || my < ny) && (alpha += 180);
          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 (!Snap.is(p1x, "array")) {
              p1x = [p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y];
          }
          var bbox = curveDim.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 getTotLen(x1, y1, x2, y2, x3, y3, x4, y4, ll) {
          if (ll < 0 || bezlen(x1, y1, x2, y2, x3, y3, x4, y4) < ll) {
              return;
          }
          var t = 1,
              step = t / 2,
              t2 = t - step,
              l,
              e = .01;
          l = bezlen(x1, y1, x2, y2, x3, y3, x4, y4, t2);
          while (abs(l - ll) > e) {
              step /= 2;
              t2 += (l < ll ? 1 : -1) * step;
              l = bezlen(x1, y1, x2, y2, x3, y3, x4, y4, t2);
          }
          return t2;
      }
      function intersect(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 inter(bez1, bez2) {
          return interHelper(bez1, bez2);
      }
      function interCount(bez1, bez2) {
          return interHelper(bez1, bez2, 1);
      }
      function interHelper(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 / 8),
              n2 = ~~(l2 / 8),
              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) < .001 ? "y" : "x",
                      cj = abs(dj1.x - dj.x) < .001 ? "y" : "x",
                      is = intersect(di.x, di.y, di1.x, di1.y, dj.x, dj.y, dj1.x, dj1.y);
                  if (is) {
                      if (xy[is.x.toFixed(4)] == is.y.toFixed(4)) {
                          continue;
                      }
                      xy[is.x.toFixed(4)] = is.y.toFixed(4);
                      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;
      }
      function pathIntersection(path1, path2) {
          return interPathHelper(path1, path2);
      }
      function pathIntersectionNumber(path1, path2) {
          return interPathHelper(path1, path2, 1);
      }
      function interPathHelper(path1, path2, justCount) {
          path1 = path2curve(path1);
          path2 = path2curve(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 = interHelper(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 isPointInsidePath(path, x, y) {
          var bbox = pathBBox(path);
          return isPointInsideBBox(bbox, x, y) &&
                 interPathHelper(path, [["M", x, y], ["H", bbox.x2 + 10]], 1) % 2 == 1;
      }
      function pathBBox(path) {
          var pth = paths(path);
          if (pth.bbox) {
              return clone(pth.bbox);
          }
          if (!path) {
              return box();
          }
          path = path2curve(path);
          var x = 0, 
              y = 0,
              X = [],
              Y = [],
              p;
          for (var i = 0, ii = path.length; i < ii; i++) {
              p = path[i];
              if (p[0] == "M") {
                  x = p[1];
                  y = p[2];
                  X.push(x);
                  Y.push(y);
              } else {
                  var dim = curveDim(x, y, p[1], p[2], p[3], p[4], p[5], p[6]);
                  X = X.concat(dim.min.x, dim.max.x);
                  Y = Y.concat(dim.min.y, dim.max.y);
                  x = p[5];
                  y = p[6];
              }
          }
          var xmin = mmin.apply(0, X),
              ymin = mmin.apply(0, Y),
              xmax = mmax.apply(0, X),
              ymax = mmax.apply(0, Y),
              bb = box(xmin, ymin, xmax - xmin, ymax - ymin);
          pth.bbox = clone(bb);
          return bb;
      }
      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 = toString;
          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 = toString;
          return res;
      }
      var unit2px = Snap._unit2px,
          getPath = {
          path: function (el) {
              return el.attr("path");
          },
          circle: function (el) {
              var attr = unit2px(el);
              return ellipsePath(attr.cx, attr.cy, attr.r);
          },
          ellipse: function (el) {
              var attr = unit2px(el);
              return ellipsePath(attr.cx || 0, attr.cy || 0, attr.rx, attr.ry);
          },
          rect: function (el) {
              var attr = unit2px(el);
              return rectPath(attr.x || 0, attr.y || 0, attr.width, attr.height, attr.rx, attr.ry);
          },
          image: function (el) {
              var attr = unit2px(el);
              return rectPath(attr.x || 0, attr.y || 0, attr.width, attr.height);
          },
          line: function (el) {
              return "M" + [el.attr("x1") || 0, el.attr("y1") || 0, el.attr("x2"), el.attr("y2")];
          },
          polyline: function (el) {
              return "M" + el.attr("points");
          },
          polygon: function (el) {
              return "M" + el.attr("points") + "z";
          },
          deflt: function (el) {
              var bbox = el.node.getBBox();
              return rectPath(bbox.x, bbox.y, bbox.width, bbox.height);
          }
      };
      function pathToRelative(pathArray) {
          var pth = paths(pathArray),
              lowerCase = String.prototype.toLowerCase;
          if (pth.rel) {
              return pathClone(pth.rel);
          }
          if (!Snap.is(pathArray, "array") || !Snap.is(pathArray && pathArray[0], "array")) {
              pathArray = Snap.parsePathString(pathArray);
          }
          var res = [],
              x = 0,
              y = 0,
              mx = 0,
              my = 0,
              start = 0;
          if (pathArray[0][0] == "M") {
              x = pathArray[0][1];
              y = pathArray[0][2];
              mx = x;
              my = y;
              start++;
              res.push(["M", x, y]);
          }
          for (var i = start, ii = pathArray.length; i < ii; i++) {
              var r = res[i] = [],
                  pa = pathArray[i];
              if (pa[0] != lowerCase.call(pa[0])) {
                  r[0] = lowerCase.call(pa[0]);
                  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).toFixed(3);
                          r[7] = +(pa[7] - y).toFixed(3);
                          break;
                      case "v":
                          r[1] = +(pa[1] - y).toFixed(3);
                          break;
                      case "m":
                          mx = pa[1];
                          my = pa[2];
                      default:
                          for (var j = 1, jj = pa.length; j < jj; j++) {
                              r[j] = +(pa[j] - ((j % 2) ? x : y)).toFixed(3);
                          }
                  }
              } else {
                  r = res[i] = [];
                  if (pa[0] == "m") {
                      mx = pa[1] + x;
                      my = pa[2] + y;
                  }
                  for (var k = 0, kk = pa.length; k < kk; k++) {
                      res[i][k] = pa[k];
                  }
              }
              var len = res[i].length;
              switch (res[i][0]) {
                  case "z":
                      x = mx;
                      y = my;
                      break;
                  case "h":
                      x += +res[i][len - 1];
                      break;
                  case "v":
                      y += +res[i][len - 1];
                      break;
                  default:
                      x += +res[i][len - 2];
                      y += +res[i][len - 1];
              }
          }
          res.toString = toString;
          pth.rel = pathClone(res);
          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 = Snap.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(catmullRom2bezier(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(catmullRom2bezier(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 = toString;
          pth.abs = pathClone(res);
          return res;
      }
      function l2c(x1, y1, x2, y2) {
          return [x1, y1, x2, y2, x2, y2];
      }
      function q2c(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 a2c(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 = Snap._.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 cos = math.cos(PI / 180 * angle),
                  sin = math.sin(PI / 180 * angle),
                  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 = a2c(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;
          }
      }
      function findDotAtSegment(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, t) {
          var t1 = 1 - t;
          return {
              x: pow(t1, 3) * p1x + pow(t1, 2) * 3 * t * c1x + t1 * 3 * t * t * c2x + pow(t, 3) * p2x,
              y: pow(t1, 3) * p1y + pow(t1, 2) * 3 * t * c1y + t1 * 3 * t * t * c2y + pow(t, 3) * p2y
          };
      }
      
      // 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 curveDim(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 x, y, 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 path2curve(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 (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(a2c.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(q2c(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(q2c(d.x, d.y, path[1], path[2], path[3], path[4]));
                          break;
                      case "L":
                          path = ["C"].concat(l2c(d.x, d.y, path[1], path[2]));
                          break;
                      case "H":
                          path = ["C"].concat(l2c(d.x, d.y, path[1], d.y));
                          break;
                      case "V":
                          path = ["C"].concat(l2c(d.x, d.y, d.x, path[1]));
                          break;
                      case "Z":
                          path = ["C"].concat(l2c(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) {
                          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 (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;
      }
      function mapPath(path, matrix) {
          if (!matrix) {
              return path;
          }
          var x, y, i, j, ii, jj, pathi;
          path = path2curve(path);
          for (i = 0, ii = path.length; i < ii; i++) {
              pathi = path[i];
              for (j = 1, jj = pathi.length; j < jj; j += 2) {
                  x = matrix.x(pathi[j], pathi[j + 1]);
                  y = matrix.y(pathi[j], pathi[j + 1]);
                  pathi[j] = x;
                  pathi[j + 1] = y;
              }
          }
          return path;
      }
  
      // http://schepers.cc/getting-to-the-point
      function catmullRom2bezier(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;
      }
  
      // export
      Snap.path = paths;
  
      /*\
       * Snap.path.getTotalLength
       [ method ]
       **
       * Returns the length of the given path in pixels
       **
       - path (string) SVG path string
       **
       = (number) length
      \*/
      Snap.path.getTotalLength = getTotalLength;
      /*\
       * Snap.path.getPointAtLength
       [ method ]
       **
       * Returns the coordinates of the point located at the given length along the given path
       **
       - path (string) SVG path string
       - length (number) length, in pixels, from the start of the path, excluding non-rendering jumps
       **
       = (object) representation of the point:
       o {
       o     x: (number) x coordinate,
       o     y: (number) y coordinate,
       o     alpha: (number) angle of derivative
       o }
      \*/
      Snap.path.getPointAtLength = getPointAtLength;
      /*\
       * Snap.path.getSubpath
       [ method ]
       **
       * Returns the subpath of a given path between given start and end lengths
       **
       - path (string) SVG path string
       - from (number) length, in pixels, from the start of the path to the start of the segment
       - to (number) length, in pixels, from the start of the path to the end of the segment
       **
       = (string) path string definition for the segment
      \*/
      Snap.path.getSubpath = function (path, from, to) {
          if (this.getTotalLength(path) - to < 1e-6) {
              return getSubpathsAtLength(path, from).end;
          }
          var a = getSubpathsAtLength(path, to, 1);
          return from ? getSubpathsAtLength(a, from).end : a;
      };
      /*\
       * Element.getTotalLength
       [ method ]
       **
       * Returns the length of the path in pixels (only works for `path` elements)
       = (number) length
      \*/
      elproto.getTotalLength = function () {
          if (this.node.getTotalLength) {
              return this.node.getTotalLength();
          }
      };
      // SIERRA Element.getPointAtLength()/Element.getTotalLength(): If a <path> is broken into different segments, is the jump distance to the new coordinates set by the _M_ or _m_ commands calculated as part of the path's total length?
      /*\
       * Element.getPointAtLength
       [ method ]
       **
       * Returns coordinates of the point located at the given length on the given path (only works for `path` elements)
       **
       - length (number) length, in pixels, from the start of the path, excluding non-rendering jumps
       **
       = (object) representation of the point:
       o {
       o     x: (number) x coordinate,
       o     y: (number) y coordinate,
       o     alpha: (number) angle of derivative
       o }
      \*/
      elproto.getPointAtLength = function (length) {
          return getPointAtLength(this.attr("d"), length);
      };
      // SIERRA Element.getSubpath(): Similar to the problem for Element.getPointAtLength(). Unclear how this would work for a segmented path. Overall, the concept of _subpath_ and what I'm calling a _segment_ (series of non-_M_ or _Z_ commands) is unclear.
      /*\
       * Element.getSubpath
       [ method ]
       **
       * Returns subpath of a given element from given start and end lengths (only works for `path` elements)
       **
       - from (number) length, in pixels, from the start of the path to the start of the segment
       - to (number) length, in pixels, from the start of the path to the end of the segment
       **
       = (string) path string definition for the segment
      \*/
      elproto.getSubpath = function (from, to) {
          return Snap.path.getSubpath(this.attr("d"), from, to);
      };
      Snap._.box = box;
      /*\
       * Snap.path.findDotsAtSegment
       [ method ]
       **
       * Utility method
       **
       * Finds dot coordinates on the given cubic beziér curve at the given t
       - p1x (number) x of the first point of the curve
       - p1y (number) y of the first point of the curve
       - c1x (number) x of the first anchor of the curve
       - c1y (number) y of the first anchor of the curve
       - c2x (number) x of the second anchor of the curve
       - c2y (number) y of the second anchor of the curve
       - p2x (number) x of the second point of the curve
       - p2y (number) y of the second point of the curve
       - t (number) position on the curve (0..1)
       = (object) point information in format:
       o {
       o     x: (number) x coordinate of the point,
       o     y: (number) y coordinate of the point,
       o     m: {
       o         x: (number) x coordinate of the left anchor,
       o         y: (number) y coordinate of the left anchor
       o     },
       o     n: {
       o         x: (number) x coordinate of the right anchor,
       o         y: (number) y coordinate of the right anchor
       o     },
       o     start: {
       o         x: (number) x coordinate of the start of the curve,
       o         y: (number) y coordinate of the start of the curve
       o     },
       o     end: {
       o         x: (number) x coordinate of the end of the curve,
       o         y: (number) y coordinate of the end of the curve
       o     },
       o     alpha: (number) angle of the curve derivative at the point
       o }
      \*/
      Snap.path.findDotsAtSegment = findDotsAtSegment;
      /*\
       * Snap.path.bezierBBox
       [ method ]
       **
       * Utility method
       **
       * Returns the bounding box of a given cubic beziér curve
       - p1x (number) x of the first point of the curve
       - p1y (number) y of the first point of the curve
       - c1x (number) x of the first anchor of the curve
       - c1y (number) y of the first anchor of the curve
       - c2x (number) x of the second anchor of the curve
       - c2y (number) y of the second anchor of the curve
       - p2x (number) x of the second point of the curve
       - p2y (number) y of the second point of the curve
       * or
       - bez (array) array of six points for beziér curve
       = (object) bounding box
       o {
       o     x: (number) x coordinate of the left top point of the box,
       o     y: (number) y coordinate of the left top point of the box,
       o     x2: (number) x coordinate of the right bottom point of the box,
       o     y2: (number) y coordinate of the right bottom point of the box,
       o     width: (number) width of the box,
       o     height: (number) height of the box
       o }
      \*/
      Snap.path.bezierBBox = bezierBBox;
      /*\
       * Snap.path.isPointInsideBBox
       [ method ]
       **
       * Utility method
       **
       * Returns `true` if given point is inside bounding box
       - bbox (string) bounding box
       - x (string) x coordinate of the point
       - y (string) y coordinate of the point
       = (boolean) `true` if point is inside
      \*/
      Snap.path.isPointInsideBBox = isPointInsideBBox;
      /*\
       * Snap.path.isBBoxIntersect
       [ method ]
       **
       * Utility method
       **
       * Returns `true` if two bounding boxes intersect
       - bbox1 (string) first bounding box
       - bbox2 (string) second bounding box
       = (boolean) `true` if bounding boxes intersect
      \*/
      Snap.path.isBBoxIntersect = isBBoxIntersect;
      /*\
       * Snap.path.intersection
       [ method ]
       **
       * Utility method
       **
       * Finds intersections of two paths
       - path1 (string) path string
       - path2 (string) path string
       = (array) dots of intersection
       o [
       o     {
       o         x: (number) x coordinate of the point,
       o         y: (number) y coordinate of the point,
       o         t1: (number) t value for segment of path1,
       o         t2: (number) t value for segment of path2,
       o         segment1: (number) order number for segment of path1,
       o         segment2: (number) order number for segment of path2,
       o         bez1: (array) eight coordinates representing beziér curve for the segment of path1,
       o         bez2: (array) eight coordinates representing beziér curve for the segment of path2
       o     }
       o ]
      \*/
      Snap.path.intersection = pathIntersection;
      Snap.path.intersectionNumber = pathIntersectionNumber;
      /*\
       * Snap.path.isPointInside
       [ method ]
       **
       * Utility method
       **
       * Returns `true` if given point is inside a given closed path.
       *
       * Note: fill mode doesn’t affect the result of this method.
       - path (string) path string
       - x (number) x of the point
       - y (number) y of the point
       = (boolean) `true` if point is inside the path
      \*/
      Snap.path.isPointInside = isPointInsidePath;
      /*\
       * Snap.path.getBBox
       [ method ]
       **
       * Utility method
       **
       * Returns the bounding box of a given path
       - path (string) path string
       = (object) bounding box
       o {
       o     x: (number) x coordinate of the left top point of the box,
       o     y: (number) y coordinate of the left top point of the box,
       o     x2: (number) x coordinate of the right bottom point of the box,
       o     y2: (number) y coordinate of the right bottom point of the box,
       o     width: (number) width of the box,
       o     height: (number) height of the box
       o }
      \*/
      Snap.path.getBBox = pathBBox;
      Snap.path.get = getPath;
      /*\
       * Snap.path.toRelative
       [ method ]
       **
       * Utility method
       **
       * Converts path coordinates into relative values
       - path (string) path string
       = (array) path string
      \*/
      Snap.path.toRelative = pathToRelative;
      /*\
       * Snap.path.toAbsolute
       [ method ]
       **
       * Utility method
       **
       * Converts path coordinates into absolute values
       - path (string) path string
       = (array) path string
      \*/
      Snap.path.toAbsolute = pathToAbsolute;
      /*\
       * Snap.path.toCubic
       [ method ]
       **
       * Utility method
       **
       * Converts path to a new path where all segments are cubic beziér curves
       - pathString (string|array) path string or array of segments
       = (array) array of segments
      \*/
      Snap.path.toCubic = path2curve;
      /*\
       * Snap.path.map
       [ method ]
       **
       * Transform the path string with the given matrix
       - path (string) path string
       - matrix (object) see @Matrix
       = (string) transformed path string
      \*/
      Snap.path.map = mapPath;
      Snap.path.toString = toString;
      Snap.path.clone = pathClone;
  });
  // Copyright (c) 2013 Adobe Systems Incorporated. All rights reserved.
  // 
  // Licensed under the Apache License, Version 2.0 (the "License");
  // you may not use this file except in compliance with the License.
  // You may obtain a copy of the License at
  // 
  // http://www.apache.org/licenses/LICENSE-2.0
  // 
  // Unless required by applicable law or agreed to in writing, software
  // distributed under the License is distributed on an "AS IS" BASIS,
  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  // See the License for the specific language governing permissions and
  // limitations under the License.
  Snap.plugin(function (Snap, Element, Paper, glob) {
      var elproto = Element.prototype,
      has = "hasOwnProperty",
      supportsTouch = "createTouch" in glob.doc,
      events = [
          "click", "dblclick", "mousedown", "mousemove", "mouseout",
          "mouseover", "mouseup", "touchstart", "touchmove", "touchend",
          "touchcancel"
      ],
      touchMap = {
          mousedown: "touchstart",
          mousemove: "touchmove",
          mouseup: "touchend"
      },
      getScroll = function (xy, el) {
          var name = xy == "y" ? "scrollTop" : "scrollLeft",
              doc = el && el.node ? el.node.ownerDocument : glob.doc;
          return doc[name in doc.documentElement ? "documentElement" : "body"][name];
      },
      preventDefault = function () {
          this.returnValue = false;
      },
      preventTouch = function () {
          return this.originalEvent.preventDefault();
      },
      stopPropagation = function () {
          this.cancelBubble = true;
      },
      stopTouch = function () {
          return this.originalEvent.stopPropagation();
      },
      addEvent = (function () {
          if (glob.doc.addEventListener) {
              return function (obj, type, fn, element) {
                  var realName = supportsTouch && touchMap[type] ? touchMap[type] : type,
                      f = function (e) {
                          var scrollY = getScroll("y", element),
                              scrollX = getScroll("x", element);
                          if (supportsTouch && touchMap[has](type)) {
                              for (var i = 0, ii = e.targetTouches && e.targetTouches.length; i < ii; i++) {
                                  if (e.targetTouches[i].target == obj || obj.contains(e.targetTouches[i].target)) {
                                      var olde = e;
                                      e = e.targetTouches[i];
                                      e.originalEvent = olde;
                                      e.preventDefault = preventTouch;
                                      e.stopPropagation = stopTouch;
                                      break;
                                  }
                              }
                          }
                          var x = e.clientX + scrollX,
                              y = e.clientY + scrollY;
                          return fn.call(element, e, x, y);
                      };
  
                  if (type !== realName) {
                      obj.addEventListener(type, f, false);
                  }
  
                  obj.addEventListener(realName, f, false);
  
                  return function () {
                      if (type !== realName) {
                          obj.removeEventListener(type, f, false);
                      }
  
                      obj.removeEventListener(realName, f, false);
                      return true;
                  };
              };
          } else if (glob.doc.attachEvent) {
              return function (obj, type, fn, element) {
                  var f = function (e) {
                      e = e || element.node.ownerDocument.window.event;
                      var scrollY = getScroll("y", element),
                          scrollX = getScroll("x", element),
                          x = e.clientX + scrollX,
                          y = e.clientY + scrollY;
                      e.preventDefault = e.preventDefault || preventDefault;
                      e.stopPropagation = e.stopPropagation || stopPropagation;
                      return fn.call(element, e, x, y);
                  };
                  obj.attachEvent("on" + type, f);
                  var detacher = function () {
                      obj.detachEvent("on" + type, f);
                      return true;
                  };
                  return detacher;
              };
          }
      })(),
      drag = [],
      dragMove = function (e) {
          var x = e.clientX,
              y = e.clientY,
              scrollY = getScroll("y"),
              scrollX = getScroll("x"),
              dragi,
              j = drag.length;
          while (j--) {
              dragi = drag[j];
              if (supportsTouch) {
                  var i = e.touches && e.touches.length,
                      touch;
                  while (i--) {
                      touch = e.touches[i];
                      if (touch.identifier == dragi.el._drag.id || dragi.el.node.contains(touch.target)) {
                          x = touch.clientX;
                          y = touch.clientY;
                          (e.originalEvent ? e.originalEvent : e).preventDefault();
                          break;
                      }
                  }
              } else {
                  e.preventDefault();
              }
              var node = dragi.el.node,
                  o,
                  next = node.nextSibling,
                  parent = node.parentNode,
                  display = node.style.display;
              // glob.win.opera && parent.removeChild(node);
              // node.style.display = "none";
              // o = dragi.el.paper.getElementByPoint(x, y);
              // node.style.display = display;
              // glob.win.opera && (next ? parent.insertBefore(node, next) : parent.appendChild(node));
              // o && eve("snap.drag.over." + dragi.el.id, dragi.el, o);
              x += scrollX;
              y += scrollY;
              eve("snap.drag.move." + dragi.el.id, dragi.move_scope || dragi.el, x - dragi.el._drag.x, y - dragi.el._drag.y, x, y, e);
          }
      },
      dragUp = function (e) {
          Snap.unmousemove(dragMove).unmouseup(dragUp);
          var i = drag.length,
              dragi;
          while (i--) {
              dragi = drag[i];
              dragi.el._drag = {};
              eve("snap.drag.end." + dragi.el.id, dragi.end_scope || dragi.start_scope || dragi.move_scope || dragi.el, e);
          }
          drag = [];
      };
      /*\
       * Element.click
       [ method ]
       **
       * Adds a click event handler to the element
       - handler (function) handler for the event
       = (object) @Element
      \*/
      /*\
       * Element.unclick
       [ method ]
       **
       * Removes a click event handler from the element
       - handler (function) handler for the event
       = (object) @Element
      \*/
      
      /*\
       * Element.dblclick
       [ method ]
       **
       * Adds a double click event handler to the element
       - handler (function) handler for the event
       = (object) @Element
      \*/
      /*\
       * Element.undblclick
       [ method ]
       **
       * Removes a double click event handler from the element
       - handler (function) handler for the event
       = (object) @Element
      \*/
      
      /*\
       * Element.mousedown
       [ method ]
       **
       * Adds a mousedown event handler to the element
       - handler (function) handler for the event
       = (object) @Element
      \*/
      /*\
       * Element.unmousedown
       [ method ]
       **
       * Removes a mousedown event handler from the element
       - handler (function) handler for the event
       = (object) @Element
      \*/
      
      /*\
       * Element.mousemove
       [ method ]
       **
       * Adds a mousemove event handler to the element
       - handler (function) handler for the event
       = (object) @Element
      \*/
      /*\
       * Element.unmousemove
       [ method ]
       **
       * Removes a mousemove event handler from the element
       - handler (function) handler for the event
       = (object) @Element
      \*/
      
      /*\
       * Element.mouseout
       [ method ]
       **
       * Adds a mouseout event handler to the element
       - handler (function) handler for the event
       = (object) @Element
      \*/
      /*\
       * Element.unmouseout
       [ method ]
       **
       * Removes a mouseout event handler from the element
       - handler (function) handler for the event
       = (object) @Element
      \*/
      
      /*\
       * Element.mouseover
       [ method ]
       **
       * Adds a mouseover event handler to the element
       - handler (function) handler for the event
       = (object) @Element
      \*/
      /*\
       * Element.unmouseover
       [ method ]
       **
       * Removes a mouseover event handler from the element
       - handler (function) handler for the event
       = (object) @Element
      \*/
      
      /*\
       * Element.mouseup
       [ method ]
       **
       * Adds a mouseup event handler to the element
       - handler (function) handler for the event
       = (object) @Element
      \*/
      /*\
       * Element.unmouseup
       [ method ]
       **
       * Removes a mouseup event handler from the element
       - handler (function) handler for the event
       = (object) @Element
      \*/
      
      /*\
       * Element.touchstart
       [ method ]
       **
       * Adds a touchstart event handler to the element
       - handler (function) handler for the event
       = (object) @Element
      \*/
      /*\
       * Element.untouchstart
       [ method ]
       **
       * Removes a touchstart event handler from the element
       - handler (function) handler for the event
       = (object) @Element
      \*/
      
      /*\
       * Element.touchmove
       [ method ]
       **
       * Adds a touchmove event handler to the element
       - handler (function) handler for the event
       = (object) @Element
      \*/
      /*\
       * Element.untouchmove
       [ method ]
       **
       * Removes a touchmove event handler from the element
       - handler (function) handler for the event
       = (object) @Element
      \*/
      
      /*\
       * Element.touchend
       [ method ]
       **
       * Adds a touchend event handler to the element
       - handler (function) handler for the event
       = (object) @Element
      \*/
      /*\
       * Element.untouchend
       [ method ]
       **
       * Removes a touchend event handler from the element
       - handler (function) handler for the event
       = (object) @Element
      \*/
      
      /*\
       * Element.touchcancel
       [ method ]
       **
       * Adds a touchcancel event handler to the element
       - handler (function) handler for the event
       = (object) @Element
      \*/
      /*\
       * Element.untouchcancel
       [ method ]
       **
       * Removes a touchcancel event handler from the element
       - handler (function) handler for the event
       = (object) @Element
      \*/
      for (var i = events.length; i--;) {
          (function (eventName) {
              Snap[eventName] = elproto[eventName] = function (fn, scope) {
                  if (Snap.is(fn, "function")) {
                      this.events = this.events || [];
                      this.events.push({
                          name: eventName,
                          f: fn,
                          unbind: addEvent(this.node || document, eventName, fn, scope || this)
                      });
                  }
                  return this;
              };
              Snap["un" + eventName] =
              elproto["un" + eventName] = function (fn) {
                  var events = this.events || [],
                      l = events.length;
                  while (l--) if (events[l].name == eventName &&
                                 (events[l].f == fn || !fn)) {
                      events[l].unbind();
                      events.splice(l, 1);
                      !events.length && delete this.events;
                      return this;
                  }
                  return this;
              };
          })(events[i]);
      }
      /*\
       * Element.hover
       [ method ]
       **
       * Adds hover event handlers to the element
       - f_in (function) handler for hover in
       - f_out (function) handler for hover out
       - icontext (object) #optional context for hover in handler
       - ocontext (object) #optional context for hover out handler
       = (object) @Element
      \*/
      elproto.hover = function (f_in, f_out, scope_in, scope_out) {
          return this.mouseover(f_in, scope_in).mouseout(f_out, scope_out || scope_in);
      };
      /*\
       * Element.unhover
       [ method ]
       **
       * Removes hover event handlers from the element
       - f_in (function) handler for hover in
       - f_out (function) handler for hover out
       = (object) @Element
      \*/
      elproto.unhover = function (f_in, f_out) {
          return this.unmouseover(f_in).unmouseout(f_out);
      };
      var draggable = [];
      // SIERRA unclear what _context_ refers to for starting, ending, moving the drag gesture.
      // SIERRA Element.drag(): _x position of the mouse_: Where are the x/y values offset from?
      // SIERRA Element.drag(): much of this member's doc appears to be duplicated for some reason.
      // SIERRA Unclear about this sentence: _Additionally following drag events will be triggered: drag.start.<id> on start, drag.end.<id> on end and drag.move.<id> on every move._ Is there a global _drag_ object to which you can assign handlers keyed by an element's ID?
      /*\
       * Element.drag
       [ method ]
       **
       * Adds event handlers for an element's drag gesture
       **
       - onmove (function) handler for moving
       - onstart (function) handler for drag start
       - onend (function) handler for drag end
       - mcontext (object) #optional context for moving handler
       - scontext (object) #optional context for drag start handler
       - econtext (object) #optional context for drag end handler
       * Additionaly following `drag` events are triggered: `drag.start.<id>` on start, 
       * `drag.end.<id>` on end and `drag.move.<id>` on every move. When element is dragged over another element 
       * `drag.over.<id>` fires as well.
       *
       * Start event and start handler are called in specified context or in context of the element with following parameters:
       o x (number) x position of the mouse
       o y (number) y position of the mouse
       o event (object) DOM event object
       * Move event and move handler are called in specified context or in context of the element with following parameters:
       o dx (number) shift by x from the start point
       o dy (number) shift by y from the start point
       o x (number) x position of the mouse
       o y (number) y position of the mouse
       o event (object) DOM event object
       * End event and end handler are called in specified context or in context of the element with following parameters:
       o event (object) DOM event object
       = (object) @Element
      \*/
      elproto.drag = function (onmove, onstart, onend, move_scope, start_scope, end_scope) {
          if (!arguments.length) {
              var origTransform;
              return this.drag(function (dx, dy) {
                  this.attr({
                      transform: origTransform + (origTransform ? "T" : "t") + [dx, dy]
                  });
              }, function () {
                  origTransform = this.transform().local;
              });
          }
          function start(e, x, y) {
              (e.originalEvent || e).preventDefault();
              this._drag.x = x;
              this._drag.y = y;
              this._drag.id = e.identifier;
              !drag.length && Snap.mousemove(dragMove).mouseup(dragUp);
              drag.push({el: this, move_scope: move_scope, start_scope: start_scope, end_scope: end_scope});
              onstart && eve.on("snap.drag.start." + this.id, onstart);
              onmove && eve.on("snap.drag.move." + this.id, onmove);
              onend && eve.on("snap.drag.end." + this.id, onend);
              eve("snap.drag.start." + this.id, start_scope || move_scope || this, x, y, e);
          }
          this._drag = {};
          draggable.push({el: this, start: start});
          this.mousedown(start);
          return this;
      };
      /*
       * Element.onDragOver
       [ method ]
       **
       * Shortcut to assign event handler for `drag.over.<id>` event, where `id` is the element's `id` (see @Element.id)
       - f (function) handler for event, first argument would be the element you are dragging over
      \*/
      // elproto.onDragOver = function (f) {
      //     f ? eve.on("snap.drag.over." + this.id, f) : eve.unbind("snap.drag.over." + this.id);
      // };
      /*\
       * Element.undrag
       [ method ]
       **
       * Removes all drag event handlers from the given element
      \*/
      elproto.undrag = function () {
          var i = draggable.length;
          while (i--) if (draggable[i].el == this) {
              this.unmousedown(draggable[i].start);
              draggable.splice(i, 1);
              eve.unbind("snap.drag.*." + this.id);
          }
          !draggable.length && Snap.unmousemove(dragMove).unmouseup(dragUp);
          return this;
      };
  });
  // Copyright (c) 2013 Adobe Systems Incorporated. All rights reserved.
  // 
  // Licensed under the Apache License, Version 2.0 (the "License");
  // you may not use this file except in compliance with the License.
  // You may obtain a copy of the License at
  // 
  // http://www.apache.org/licenses/LICENSE-2.0
  // 
  // Unless required by applicable law or agreed to in writing, software
  // distributed under the License is distributed on an "AS IS" BASIS,
  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  // See the License for the specific language governing permissions and
  // limitations under the License.
  Snap.plugin(function (Snap, Element, Paper, glob) {
      var elproto = Element.prototype,
          pproto = Paper.prototype,
          rgurl = /^\s*url\((.+)\)/,
          Str = String,
          $ = Snap._.$;
      Snap.filter = {};
      /*\
       * Paper.filter
       [ method ]
       **
       * Creates a `<filter>` element
       **
       - filstr (string) SVG fragment of filter provided as a string
       = (object) @Element
       * Note: It is recommended to use filters embedded into the page inside an empty SVG element.
       > Usage
       | var f = paper.filter('<feGaussianBlur stdDeviation="2"/>'),
       |     c = paper.circle(10, 10, 10).attr({
       |         filter: f
       |     });
      \*/
      pproto.filter = function (filstr) {
          var paper = this;
          if (paper.type != "svg") {
              paper = paper.paper;
          }
          var f = Snap.parse(Str(filstr)),
              id = Snap._.id(),
              width = paper.node.offsetWidth,
              height = paper.node.offsetHeight,
              filter = $("filter");
          $(filter, {
              id: id,
              filterUnits: "userSpaceOnUse"
          });
          filter.appendChild(f.node);
          paper.defs.appendChild(filter);
          return new Element(filter);
      };
      
      eve.on("snap.util.getattr.filter", function () {
          eve.stop();
          var p = $(this.node, "filter");
          if (p) {
              var match = Str(p).match(rgurl);
              return match && Snap.select(match[1]);
          }
      });
      eve.on("snap.util.attr.filter", function (value) {
          if (value instanceof Element && value.type == "filter") {
              eve.stop();
              var id = value.node.id;
              if (!id) {
                  $(value.node, {id: value.id});
                  id = value.id;
              }
              $(this.node, {
                  filter: Snap.url(id)
              });
          }
          if (!value || value == "none") {
              eve.stop();
              this.node.removeAttribute("filter");
          }
      });
      /*\
       * Snap.filter.blur
       [ method ]
       **
       * Returns an SVG markup string for the blur filter
       **
       - x (number) amount of horizontal blur, in pixels
       - y (number) #optional amount of vertical blur, in pixels
       = (string) filter representation
       > Usage
       | var f = paper.filter(Snap.filter.blur(5, 10)),
       |     c = paper.circle(10, 10, 10).attr({
       |         filter: f
       |     });
      \*/
      Snap.filter.blur = function (x, y) {
          if (x == null) {
              x = 2;
          }
          var def = y == null ? x : [x, y];
          return Snap.format('\<feGaussianBlur stdDeviation="{def}"/>', {
              def: def
          });
      };
      Snap.filter.blur.toString = function () {
          return this();
      };
      /*\
       * Snap.filter.shadow
       [ method ]
       **
       * Returns an SVG markup string for the shadow filter
       **
       - dx (number) #optional horizontal shift of the shadow, in pixels
       - dy (number) #optional vertical shift of the shadow, in pixels
       - blur (number) #optional amount of blur
       - color (string) #optional color of the shadow
       - opacity (number) #optional `0..1` opacity of the shadow
       * or
       - dx (number) #optional horizontal shift of the shadow, in pixels
       - dy (number) #optional vertical shift of the shadow, in pixels
       - color (string) #optional color of the shadow
       - opacity (number) #optional `0..1` opacity of the shadow
       * which makes blur default to `4`. Or
       - dx (number) #optional horizontal shift of the shadow, in pixels
       - dy (number) #optional vertical shift of the shadow, in pixels
       - opacity (number) #optional `0..1` opacity of the shadow
       = (string) filter representation
       > Usage
       | var f = paper.filter(Snap.filter.shadow(0, 2, 3)),
       |     c = paper.circle(10, 10, 10).attr({
       |         filter: f
       |     });
      \*/
      Snap.filter.shadow = function (dx, dy, blur, color, opacity) {
          if (typeof blur == "string") {
              color = blur;
              opacity = color;
              blur = 4;
          }
          if (typeof color != "string") {
              opacity = color;
              color = "#000";
          }
          color = color || "#000";
          if (blur == null) {
              blur = 4;
          }
          if (opacity == null) {
              opacity = 1;
          }
          if (dx == null) {
              dx = 0;
              dy = 2;
          }
          if (dy == null) {
              dy = dx;
          }
          color = Snap.color(color);
          return Snap.format('<feGaussianBlur in="SourceAlpha" stdDeviation="{blur}"/><feOffset dx="{dx}" dy="{dy}" result="offsetblur"/><feFlood flood-color="{color}"/><feComposite in2="offsetblur" operator="in"/><feComponentTransfer><feFuncA type="linear" slope="{opacity}"/></feComponentTransfer><feMerge><feMergeNode/><feMergeNode in="SourceGraphic"/></feMerge>', {
              color: color,
              dx: dx,
              dy: dy,
              blur: blur,
              opacity: opacity
          });
      };
      Snap.filter.shadow.toString = function () {
          return this();
      };
      /*\
       * Snap.filter.grayscale
       [ method ]
       **
       * Returns an SVG markup string for the grayscale filter
       **
       - amount (number) amount of filter (`0..1`)
       = (string) filter representation
      \*/
      Snap.filter.grayscale = function (amount) {
          if (amount == null) {
              amount = 1;
          }
          return Snap.format('<feColorMatrix type="matrix" values="{a} {b} {c} 0 0 {d} {e} {f} 0 0 {g} {b} {h} 0 0 0 0 0 1 0"/>', {
              a: 0.2126 + 0.7874 * (1 - amount),
              b: 0.7152 - 0.7152 * (1 - amount),
              c: 0.0722 - 0.0722 * (1 - amount),
              d: 0.2126 - 0.2126 * (1 - amount),
              e: 0.7152 + 0.2848 * (1 - amount),
              f: 0.0722 - 0.0722 * (1 - amount),
              g: 0.2126 - 0.2126 * (1 - amount),
              h: 0.0722 + 0.9278 * (1 - amount)
          });
      };
      Snap.filter.grayscale.toString = function () {
          return this();
      };
      /*\
       * Snap.filter.sepia
       [ method ]
       **
       * Returns an SVG markup string for the sepia filter
       **
       - amount (number) amount of filter (`0..1`)
       = (string) filter representation
      \*/
      Snap.filter.sepia = function (amount) {
          if (amount == null) {
              amount = 1;
          }
          return Snap.format('<feColorMatrix type="matrix" values="{a} {b} {c} 0 0 {d} {e} {f} 0 0 {g} {h} {i} 0 0 0 0 0 1 0"/>', {
              a: 0.393 + 0.607 * (1 - amount),
              b: 0.769 - 0.769 * (1 - amount),
              c: 0.189 - 0.189 * (1 - amount),
              d: 0.349 - 0.349 * (1 - amount),
              e: 0.686 + 0.314 * (1 - amount),
              f: 0.168 - 0.168 * (1 - amount),
              g: 0.272 - 0.272 * (1 - amount),
              h: 0.534 - 0.534 * (1 - amount),
              i: 0.131 + 0.869 * (1 - amount)
          });
      };
      Snap.filter.sepia.toString = function () {
          return this();
      };
      /*\
       * Snap.filter.saturate
       [ method ]
       **
       * Returns an SVG markup string for the saturate filter
       **
       - amount (number) amount of filter (`0..1`)
       = (string) filter representation
      \*/
      Snap.filter.saturate = function (amount) {
          if (amount == null) {
              amount = 1;
          }
          return Snap.format('<feColorMatrix type="saturate" values="{amount}"/>', {
              amount: 1 - amount
          });
      };
      Snap.filter.saturate.toString = function () {
          return this();
      };
      /*\
       * Snap.filter.hueRotate
       [ method ]
       **
       * Returns an SVG markup string for the hue-rotate filter
       **
       - angle (number) angle of rotation
       = (string) filter representation
      \*/
      Snap.filter.hueRotate = function (angle) {
          angle = angle || 0;
          return Snap.format('<feColorMatrix type="hueRotate" values="{angle}"/>', {
              angle: angle
          });
      };
      Snap.filter.hueRotate.toString = function () {
          return this();
      };
      /*\
       * Snap.filter.invert
       [ method ]
       **
       * Returns an SVG markup string for the invert filter
       **
       - amount (number) amount of filter (`0..1`)
       = (string) filter representation
      \*/
      Snap.filter.invert = function (amount) {
          if (amount == null) {
              amount = 1;
          }
          return Snap.format('<feComponentTransfer><feFuncR type="table" tableValues="{amount} {amount2}"/><feFuncG type="table" tableValues="{amount} {amount2}"/><feFuncB type="table" tableValues="{amount} {amount2}"/></feComponentTransfer>', {
              amount: amount,
              amount2: 1 - amount
          });
      };
      Snap.filter.invert.toString = function () {
          return this();
      };
      /*\
       * Snap.filter.brightness
       [ method ]
       **
       * Returns an SVG markup string for the brightness filter
       **
       - amount (number) amount of filter (`0..1`)
       = (string) filter representation
      \*/
      Snap.filter.brightness = function (amount) {
          if (amount == null) {
              amount = 1;
          }
          return Snap.format('<feComponentTransfer><feFuncR type="linear" slope="{amount}"/><feFuncG type="linear" slope="{amount}"/><feFuncB type="linear" slope="{amount}"/></feComponentTransfer>', {
              amount: amount
          });
      };
      Snap.filter.brightness.toString = function () {
          return this();
      };
      /*\
       * Snap.filter.contrast
       [ method ]
       **
       * Returns an SVG markup string for the contrast filter
       **
       - amount (number) amount of filter (`0..1`)
       = (string) filter representation
      \*/
      Snap.filter.contrast = function (amount) {
          if (amount == null) {
              amount = 1;
          }
          return Snap.format('<feComponentTransfer><feFuncR type="linear" slope="{amount}" intercept="{amount2}"/><feFuncG type="linear" slope="{amount}" intercept="{amount2}"/><feFuncB type="linear" slope="{amount}" intercept="{amount2}"/></feComponentTransfer>', {
              amount: amount,
              amount2: .5 - amount / 2
          });
      };
      Snap.filter.contrast.toString = function () {
          return this();
      };
  });
  
  return Snap;
  }));
  },{"65":65}],67:[function(_dereq_,module,exports){
  'use strict';
  
  var snapsvg = module.exports = _dereq_(66);
  
  snapsvg.plugin(function(Snap, Element) {
  
    /*\
     * Element.children
     [ method ]
     **
     * Returns array of all the children of the element.
     = (array) array of Elements
    \*/
    Element.prototype.children = function () {
        var out = [],
            ch = this.node.childNodes;
        for (var i = 0, ii = ch.length; i < ii; i++) {
            out[i] = new Snap(ch[i]);
        }
        return out;
    };
  });
  
  
  /**
   * @class ClassPlugin
   *
   * Extends snapsvg with methods to add and remove classes
   */
  snapsvg.plugin(function (Snap, Element, Paper, global) {
  
    function split(str) {
      return str.split(/\s+/);
    }
  
    function join(array) {
      return array.join(' ');
    }
  
    function getClasses(e) {
      return split(e.attr('class') || '');
    }
  
    function setClasses(e, classes) {
      e.attr('class', join(classes));
    }
  
    /**
     * @method snapsvg.Element#addClass
     *
     * @example
     *
     * e.attr('class', 'selector');
     *
     * e.addClass('foo bar'); // adds classes foo and bar
     * e.attr('class'); // -> 'selector foo bar'
     *
     * e.addClass('fooBar');
     * e.attr('class'); // -> 'selector foo bar fooBar'
     *
     * @param {String} cls classes to be added to the element
     *
     * @return {snapsvg.Element} the element (this)
     */
    Element.prototype.addClass = function(cls) {
      var current = getClasses(this),
          add = split(cls),
          i, e;
  
      for (i = 0, e; !!(e = add[i]); i++) {
        if (current.indexOf(e) === -1) {
          current.push(e);
        }
      }
  
      setClasses(this, current);
  
      return this;
    };
  
    /**
     * @method snapsvg.Element#hasClass
     *
     * @param  {String}  cls the class to query for
     * @return {Boolean} returns true if the element has the given class
     */
    Element.prototype.hasClass = function(cls) {
      if (!cls) {
        throw new Error('[snapsvg] syntax: hasClass(clsStr)');
      }
  
      return getClasses(this).indexOf(cls) !== -1;
    };
  
    /**
     * @method snapsvg.Element#removeClass
     *
     * @example
     *
     * e.attr('class', 'foo bar');
     *
     * e.removeClass('foo');
     * e.attr('class'); // -> 'bar'
     *
     * e.removeClass('foo bar'); // removes classes foo and bar
     * e.attr('class'); // -> ''
     *
     * @param {String} cls classes to be removed from element
     *
     * @return {snapsvg.Element} the element (this)
     */
    Element.prototype.removeClass = function(cls) {
      var current = getClasses(this),
          remove = split(cls),
          i, e, idx;
  
      for (i = 0, e; !!(e = remove[i]); i++) {
        idx = current.indexOf(e);
  
        if (idx !== -1) {
          // remove element from array
          current.splice(idx, 1);
        }
      }
  
      setClasses(this, current);
  
      return this;
    };
  
  });
  
  /**
   * @class TranslatePlugin
   *
   * Extends snapsvg with methods to translate elements
   */
  snapsvg.plugin(function (Snap, Element, Paper, global) {
  
    /*
     * @method snapsvg.Element#translate
     *
     * @example
     *
     * e.translate(10, 20);
     *
     * // sets transform matrix to translate(10, 20)
     *
     * @param {Number} x translation
     * @param {Number} y translation
     *
     * @return {snapsvg.Element} the element (this)
     */
    Element.prototype.translate = function(x, y) {
      var matrix = new Snap.Matrix();
      matrix.translate(x, y);
      return this.transform(matrix);
    };
  });
  
  
  /**
   * @class CreatePlugin
   *
   * Create an svg element without attaching it to the dom
   */
  snapsvg.plugin(function(Snap) {
  
    Snap.create = function(name, attrs) {
      return Snap._.wrap(Snap._.$(name, attrs));
    };
  });
  
  
  /**
   * @class CreatSnapAtPlugin
   *
   * Extends snap.svg with a method to create a SVG element
   * at a specific position in the DOM.
   */
  snapsvg.plugin(function(Snap, Element, Paper, global) {
  
    /*
     * @method snapsvg.createSnapAt
     *
     * @example
     *
     * snapsvg.createSnapAt(parentNode, 200, 200);
     *
     * @param {Number} width of svg
     * @param {Number} height of svg
     * @param {Object} parentNode svg Element will be child of this
     *
     * @return {snapsvg.Element} the newly created wrapped SVG element instance
     */
    Snap.createSnapAt = function(width, height, parentNode) {
  
      var svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
      svg.setAttribute('width', width);
      svg.setAttribute('height', height);
      if (!parentNode) {
        parentNode = document.body;
      }
      parentNode.appendChild(svg);
  
      return new Snap(svg);
    };
  });
  },{"66":66}],68:[function(_dereq_,module,exports){
  
  var isArray = function(obj) {
    return Object.prototype.toString.call(obj) === '[object Array]';
  };
  
  var annotate = function() {
    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))) */}
  
  var FN_ARGS = /^function\s*[^\(]*\(\s*([^\)]*)\)/m;
  var FN_ARG = /\/\*([^\*]*)\*\//m;
  
  var parse = function(fn) {
    if (typeof fn !== 'function') {
      throw new Error('Cannot annotate "' + fn + '". Expected a function!');
    }
  
    var match = fn.toString().match(FN_ARGS);
    return match[1] && match[1].split(',').map(function(arg) {
      match = arg.match(FN_ARG);
      return match ? match[1].trim() : arg.trim();
    }) || [];
  };
  
  
  exports.annotate = annotate;
  exports.parse = parse;
  exports.isArray = isArray;
  
  },{}],69:[function(_dereq_,module,exports){
  module.exports = {
    annotate: _dereq_(68).annotate,
    Module: _dereq_(71),
    Injector: _dereq_(70)
  };
  
  },{"68":68,"70":70,"71":71}],70:[function(_dereq_,module,exports){
  var Module = _dereq_(71);
  var autoAnnotate = _dereq_(68).parse;
  var annotate = _dereq_(68).annotate;
  var isArray = _dereq_(68).isArray;
  
  
  var Injector = function(modules, parent) {
    parent = parent || {
      get: function(name) {
        currentlyResolving.push(name);
        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);
    };
  
    var get = function(name) {
      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 (Object.hasOwnProperty.call(instances, name)) {
        return instances[name];
      }
  
      if (Object.hasOwnProperty.call(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);
    };
  
    var instantiate = function(Type) {
      var instance = Object.create(Type.prototype);
      var returned = invoke(Type, instance);
  
      return typeof returned === 'object' ? returned : instance;
    };
  
    var invoke = function(fn, context) {
      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 && fn.$inject || autoAnnotate(fn);
      var dependencies = inject.map(function(dep) {
        return get(dep);
      });
  
      // TODO(vojta): optimize without apply
      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) {
            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(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;
  };
  
  module.exports = Injector;
  
  },{"68":68,"71":71}],71:[function(_dereq_,module,exports){
  var Module = function() {
    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);
    };
  };
  
  module.exports = Module;
  
  },{}],72:[function(_dereq_,module,exports){
  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.prototype = superCtor.prototype
      ctor.prototype = new TempCtor()
      ctor.prototype.constructor = ctor
    }
  }
  
  },{}],73:[function(_dereq_,module,exports){
  /**
   * 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;
  
  },{}],74:[function(_dereq_,module,exports){
  var arrayEvery = _dereq_(90),
      baseCallback = _dereq_(98),
      baseEvery = _dereq_(103),
      isArray = _dereq_(159),
      isIterateeCall = _dereq_(148);
  
  /**
   * Checks if `predicate` returns truthy for **all** elements of `collection`.
   * 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 all
   * @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 {boolean} Returns `true` if all elements pass the predicate check,
   *  else `false`.
   * @example
   *
   * _.every([true, 1, null, 'yes'], Boolean);
   * // => false
   *
   * var users = [
   *   { 'user': 'barney', 'active': false },
   *   { 'user': 'fred',   'active': false }
   * ];
   *
   * // using the `_.matches` callback shorthand
   * _.every(users, { 'user': 'barney', 'active': false });
   * // => false
   *
   * // using the `_.matchesProperty` callback shorthand
   * _.every(users, 'active', false);
   * // => true
   *
   * // using the `_.property` callback shorthand
   * _.every(users, 'active');
   * // => false
   */
  function every(collection, predicate, thisArg) {
    var func = isArray(collection) ? arrayEvery : baseEvery;
    if (thisArg && isIterateeCall(collection, predicate, thisArg)) {
      predicate = undefined;
    }
    if (typeof predicate != 'function' || thisArg !== undefined) {
      predicate = baseCallback(predicate, thisArg, 3);
    }
    return func(collection, predicate);
  }
  
  module.exports = every;
  
  },{"103":103,"148":148,"159":159,"90":90,"98":98}],75:[function(_dereq_,module,exports){
  var arrayFilter = _dereq_(91),
      baseCallback = _dereq_(98),
      baseFilter = _dereq_(104),
      isArray = _dereq_(159);
  
  /**
   * 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;
  
  },{"104":104,"159":159,"91":91,"98":98}],76:[function(_dereq_,module,exports){
  var baseEach = _dereq_(102),
      createFind = _dereq_(136);
  
  /**
   * 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;
  
  },{"102":102,"136":136}],77:[function(_dereq_,module,exports){
  var arrayEach = _dereq_(89),
      baseEach = _dereq_(102),
      createForEach = _dereq_(137);
  
  /**
   * 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;
  
  },{"102":102,"137":137,"89":89}],78:[function(_dereq_,module,exports){
  var createAggregator = _dereq_(131);
  
  /** Used for native method references. */
  var objectProto = Object.prototype;
  
  /** Used to check objects for own properties. */
  var hasOwnProperty = objectProto.hasOwnProperty;
  
  /**
   * 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 an array of the elements responsible for generating the key.
   * 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`.
   *
   * @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
   *
   * _.groupBy([4.2, 6.1, 6.4], function(n) {
   *   return Math.floor(n);
   * });
   * // => { '4': [4.2], '6': [6.1, 6.4] }
   *
   * _.groupBy([4.2, 6.1, 6.4], function(n) {
   *   return this.floor(n);
   * }, Math);
   * // => { '4': [4.2], '6': [6.1, 6.4] }
   *
   * // using the `_.property` callback shorthand
   * _.groupBy(['one', 'two', 'three'], 'length');
   * // => { '3': ['one', 'two'], '5': ['three'] }
   */
  var groupBy = createAggregator(function(result, value, key) {
    if (hasOwnProperty.call(result, key)) {
      result[key].push(value);
    } else {
      result[key] = [value];
    }
  });
  
  module.exports = groupBy;
  
  },{"131":131}],79:[function(_dereq_,module,exports){
  var baseIndexOf = _dereq_(112),
      getLength = _dereq_(142),
      isArray = _dereq_(159),
      isIterateeCall = _dereq_(148),
      isLength = _dereq_(150),
      isString = _dereq_(165),
      values = _dereq_(175);
  
  /* Native method references for those with the same name as other `lodash` methods. */
  var nativeMax = Math.max;
  
  /**
   * Checks if `target` is in `collection` using
   * [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero)
   * for equality comparisons. If `fromIndex` is negative, it's used as the offset
   * from the end of `collection`.
   *
   * @static
   * @memberOf _
   * @alias contains, include
   * @category Collection
   * @param {Array|Object|string} collection The collection to search.
   * @param {*} target The value to search for.
   * @param {number} [fromIndex=0] The index to search from.
   * @param- {Object} [guard] Enables use as a callback for functions like `_.reduce`.
   * @returns {boolean} Returns `true` if a matching element is found, else `false`.
   * @example
   *
   * _.includes([1, 2, 3], 1);
   * // => true
   *
   * _.includes([1, 2, 3], 1, 2);
   * // => false
   *
   * _.includes({ 'user': 'fred', 'age': 40 }, 'fred');
   * // => true
   *
   * _.includes('pebbles', 'eb');
   * // => true
   */
  function includes(collection, target, fromIndex, guard) {
    var length = collection ? getLength(collection) : 0;
    if (!isLength(length)) {
      collection = values(collection);
      length = collection.length;
    }
    if (typeof fromIndex != 'number' || (guard && isIterateeCall(target, fromIndex, guard))) {
      fromIndex = 0;
    } else {
      fromIndex = fromIndex < 0 ? nativeMax(length + fromIndex, 0) : (fromIndex || 0);
    }
    return (typeof collection == 'string' || !isArray(collection) && isString(collection))
      ? (fromIndex <= length && collection.indexOf(target, fromIndex) > -1)
      : (!!length && baseIndexOf(collection, target, fromIndex) > -1);
  }
  
  module.exports = includes;
  
  },{"112":112,"142":142,"148":148,"150":150,"159":159,"165":165,"175":175}],80:[function(_dereq_,module,exports){
  var arrayMap = _dereq_(92),
      baseCallback = _dereq_(98),
      baseMap = _dereq_(116),
      isArray = _dereq_(159);
  
  /**
   * 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;
  
  },{"116":116,"159":159,"92":92,"98":98}],81:[function(_dereq_,module,exports){
  var arrayReduce = _dereq_(94),
      baseEach = _dereq_(102),
      createReduce = _dereq_(138);
  
  /**
   * Reduces `collection` to a value which is the accumulated result of running
   * each element in `collection` through `iteratee`, where each successive
   * invocation is supplied the return value of the previous. If `accumulator`
   * is not provided the first element of `collection` is used as the initial
   * value. The `iteratee` is bound to `thisArg` and invoked with four arguments:
   * (accumulator, value, index|key, collection).
   *
   * Many lodash methods are guarded to work as iteratees for methods like
   * `_.reduce`, `_.reduceRight`, and `_.transform`.
   *
   * The guarded methods are:
   * `assign`, `defaults`, `defaultsDeep`, `includes`, `merge`, `sortByAll`,
   * and `sortByOrder`
   *
   * @static
   * @memberOf _
   * @alias foldl, inject
   * @category Collection
   * @param {Array|Object|string} collection The collection to iterate over.
   * @param {Function} [iteratee=_.identity] The function invoked per iteration.
   * @param {*} [accumulator] The initial value.
   * @param {*} [thisArg] The `this` binding of `iteratee`.
   * @returns {*} Returns the accumulated value.
   * @example
   *
   * _.reduce([1, 2], function(total, n) {
   *   return total + n;
   * });
   * // => 3
   *
   * _.reduce({ 'a': 1, 'b': 2 }, function(result, n, key) {
   *   result[key] = n * 3;
   *   return result;
   * }, {});
   * // => { 'a': 3, 'b': 6 } (iteration order is not guaranteed)
   */
  var reduce = createReduce(arrayReduce, baseEach);
  
  module.exports = reduce;
  
  },{"102":102,"138":138,"94":94}],82:[function(_dereq_,module,exports){
  var arraySome = _dereq_(95),
      baseCallback = _dereq_(98),
      baseSome = _dereq_(125),
      isArray = _dereq_(159),
      isIterateeCall = _dereq_(148);
  
  /**
   * Checks if `predicate` returns truthy for **any** element of `collection`.
   * The function returns as soon as it finds a passing value and does not iterate
   * over the entire collection. 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 any
   * @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 {boolean} Returns `true` if any element passes the predicate check,
   *  else `false`.
   * @example
   *
   * _.some([null, 0, 'yes', false], Boolean);
   * // => true
   *
   * var users = [
   *   { 'user': 'barney', 'active': true },
   *   { 'user': 'fred',   'active': false }
   * ];
   *
   * // using the `_.matches` callback shorthand
   * _.some(users, { 'user': 'barney', 'active': false });
   * // => false
   *
   * // using the `_.matchesProperty` callback shorthand
   * _.some(users, 'active', false);
   * // => true
   *
   * // using the `_.property` callback shorthand
   * _.some(users, 'active');
   * // => true
   */
  function some(collection, predicate, thisArg) {
    var func = isArray(collection) ? arraySome : baseSome;
    if (thisArg && isIterateeCall(collection, predicate, thisArg)) {
      predicate = undefined;
    }
    if (typeof predicate != 'function' || thisArg !== undefined) {
      predicate = baseCallback(predicate, thisArg, 3);
    }
    return func(collection, predicate);
  }
  
  module.exports = some;
  
  },{"125":125,"148":148,"159":159,"95":95,"98":98}],83:[function(_dereq_,module,exports){
  var getNative = _dereq_(144);
  
  /* 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;
  
  },{"144":144}],84:[function(_dereq_,module,exports){
  var isObject = _dereq_(163),
      now = _dereq_(83);
  
  /** 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;
  
  },{"163":163,"83":83}],85:[function(_dereq_,module,exports){
  var baseDelay = _dereq_(100),
      restParam = _dereq_(86);
  
  /**
   * Defers invoking the `func` until the current call stack has cleared. Any
   * additional arguments are provided to `func` when it's invoked.
   *
   * @static
   * @memberOf _
   * @category Function
   * @param {Function} func The function to defer.
   * @param {...*} [args] The arguments to invoke the function with.
   * @returns {number} Returns the timer id.
   * @example
   *
   * _.defer(function(text) {
   *   console.log(text);
   * }, 'deferred');
   * // logs 'deferred' after one or more milliseconds
   */
  var defer = restParam(function(func, args) {
    return baseDelay(func, 1, args);
  });
  
  module.exports = defer;
  
  },{"100":100,"86":86}],86:[function(_dereq_,module,exports){
  /** 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;
  
  },{}],87:[function(_dereq_,module,exports){
  (function (global){
  var cachePush = _dereq_(130),
      getNative = _dereq_(144);
  
  /** 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 : {})
  //# sourceMappingURL=data:application/json;charset:utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIm5vZGVfbW9kdWxlcy9sb2Rhc2gvaW50ZXJuYWwvU2V0Q2FjaGUuanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQSIsImZpbGUiOiJnZW5lcmF0ZWQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlc0NvbnRlbnQiOlsidmFyIGNhY2hlUHVzaCA9IHJlcXVpcmUoJy4vY2FjaGVQdXNoJyksXG4gICAgZ2V0TmF0aXZlID0gcmVxdWlyZSgnLi9nZXROYXRpdmUnKTtcblxuLyoqIE5hdGl2ZSBtZXRob2QgcmVmZXJlbmNlcy4gKi9cbnZhciBTZXQgPSBnZXROYXRpdmUoZ2xvYmFsLCAnU2V0Jyk7XG5cbi8qIE5hdGl2ZSBtZXRob2QgcmVmZXJlbmNlcyBmb3IgdGhvc2Ugd2l0aCB0aGUgc2FtZSBuYW1lIGFzIG90aGVyIGBsb2Rhc2hgIG1ldGhvZHMuICovXG52YXIgbmF0aXZlQ3JlYXRlID0gZ2V0TmF0aXZlKE9iamVjdCwgJ2NyZWF0ZScpO1xuXG4vKipcbiAqXG4gKiBDcmVhdGVzIGEgY2FjaGUgb2JqZWN0IHRvIHN0b3JlIHVuaXF1ZSB2YWx1ZXMuXG4gKlxuICogQHByaXZhdGVcbiAqIEBwYXJhbSB7QXJyYXl9IFt2YWx1ZXNdIFRoZSB2YWx1ZXMgdG8gY2FjaGUuXG4gKi9cbmZ1bmN0aW9uIFNldENhY2hlKHZhbHVlcykge1xuICB2YXIgbGVuZ3RoID0gdmFsdWVzID8gdmFsdWVzLmxlbmd0aCA6IDA7XG5cbiAgdGhpcy5kYXRhID0geyAnaGFzaCc6IG5hdGl2ZUNyZWF0ZShudWxsKSwgJ3NldCc6IG5ldyBTZXQgfTtcbiAgd2hpbGUgKGxlbmd0aC0tKSB7XG4gICAgdGhpcy5wdXNoKHZhbHVlc1tsZW5ndGhdKTtcbiAgfVxufVxuXG4vLyBBZGQgZnVuY3Rpb25zIHRvIHRoZSBgU2V0YCBjYWNoZS5cblNldENhY2hlLnByb3RvdHlwZS5wdXNoID0gY2FjaGVQdXNoO1xuXG5tb2R1bGUuZXhwb3J0cyA9IFNldENhY2hlO1xuIl19
  },{"130":130,"144":144}],88:[function(_dereq_,module,exports){
  /**
   * Copies the values of `source` to `array`.
   *
   * @private
   * @param {Array} source The array to copy values from.
   * @param {Array} [array=[]] The array to copy values to.
   * @returns {Array} Returns `array`.
   */
  function arrayCopy(source, array) {
    var index = -1,
        length = source.length;
  
    array || (array = Array(length));
    while (++index < length) {
      array[index] = source[index];
    }
    return array;
  }
  
  module.exports = arrayCopy;
  
  },{}],89:[function(_dereq_,module,exports){
  /**
   * 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;
  
  },{}],90:[function(_dereq_,module,exports){
  /**
   * A specialized version of `_.every` 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 all elements pass the predicate check,
   *  else `false`.
   */
  function arrayEvery(array, predicate) {
    var index = -1,
        length = array.length;
  
    while (++index < length) {
      if (!predicate(array[index], index, array)) {
        return false;
      }
    }
    return true;
  }
  
  module.exports = arrayEvery;
  
  },{}],91:[function(_dereq_,module,exports){
  /**
   * 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;
  
  },{}],92:[function(_dereq_,module,exports){
  /**
   * 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;
  
  },{}],93:[function(_dereq_,module,exports){
  /**
   * 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;
  
  },{}],94:[function(_dereq_,module,exports){
  /**
   * A specialized version of `_.reduce` 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.
   * @param {*} [accumulator] The initial value.
   * @param {boolean} [initFromArray] Specify using the first element of `array`
   *  as the initial value.
   * @returns {*} Returns the accumulated value.
   */
  function arrayReduce(array, iteratee, accumulator, initFromArray) {
    var index = -1,
        length = array.length;
  
    if (initFromArray && length) {
      accumulator = array[++index];
    }
    while (++index < length) {
      accumulator = iteratee(accumulator, array[index], index, array);
    }
    return accumulator;
  }
  
  module.exports = arrayReduce;
  
  },{}],95:[function(_dereq_,module,exports){
  /**
   * 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;
  
  },{}],96:[function(_dereq_,module,exports){
  var keys = _dereq_(169);
  
  /**
   * 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;
  
  },{"169":169}],97:[function(_dereq_,module,exports){
  var baseCopy = _dereq_(99),
      keys = _dereq_(169);
  
  /**
   * 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;
  
  },{"169":169,"99":99}],98:[function(_dereq_,module,exports){
  var baseMatches = _dereq_(117),
      baseMatchesProperty = _dereq_(118),
      bindCallback = _dereq_(128),
      identity = _dereq_(176),
      property = _dereq_(177);
  
  /**
   * 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;
    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;
  
  },{"117":117,"118":118,"128":128,"176":176,"177":177}],99:[function(_dereq_,module,exports){
  /**
   * 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;
  
  },{}],100:[function(_dereq_,module,exports){
  /** Used as the `TypeError` message for "Functions" methods. */
  var FUNC_ERROR_TEXT = 'Expected a function';
  
  /**
   * The base implementation of `_.delay` and `_.defer` which accepts an index
   * of where to slice the arguments to provide to `func`.
   *
   * @private
   * @param {Function} func The function to delay.
   * @param {number} wait The number of milliseconds to delay invocation.
   * @param {Object} args The arguments provide to `func`.
   * @returns {number} Returns the timer id.
   */
  function baseDelay(func, wait, args) {
    if (typeof func != 'function') {
      throw new TypeError(FUNC_ERROR_TEXT);
    }
    return setTimeout(function() { func.apply(undefined, args); }, wait);
  }
  
  module.exports = baseDelay;
  
  },{}],101:[function(_dereq_,module,exports){
  var baseIndexOf = _dereq_(112),
      cacheIndexOf = _dereq_(129),
      createCache = _dereq_(135);
  
  /** 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;
  
  },{"112":112,"129":129,"135":135}],102:[function(_dereq_,module,exports){
  var baseForOwn = _dereq_(110),
      createBaseEach = _dereq_(133);
  
  /**
   * 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;
  
  },{"110":110,"133":133}],103:[function(_dereq_,module,exports){
  var baseEach = _dereq_(102);
  
  /**
   * The base implementation of `_.every` 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 {boolean} Returns `true` if all elements pass the predicate check,
   *  else `false`
   */
  function baseEvery(collection, predicate) {
    var result = true;
    baseEach(collection, function(value, index, collection) {
      result = !!predicate(value, index, collection);
      return result;
    });
    return result;
  }
  
  module.exports = baseEvery;
  
  },{"102":102}],104:[function(_dereq_,module,exports){
  var baseEach = _dereq_(102);
  
  /**
   * 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;
  
  },{"102":102}],105:[function(_dereq_,module,exports){
  /**
   * 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;
  
  },{}],106:[function(_dereq_,module,exports){
  /**
   * 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;
  
  },{}],107:[function(_dereq_,module,exports){
  var arrayPush = _dereq_(93),
      isArguments = _dereq_(158),
      isArray = _dereq_(159),
      isArrayLike = _dereq_(146),
      isObjectLike = _dereq_(151);
  
  /**
   * 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;
  
  },{"146":146,"151":151,"158":158,"159":159,"93":93}],108:[function(_dereq_,module,exports){
  var createBaseFor = _dereq_(134);
  
  /**
   * 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;
  
  },{"134":134}],109:[function(_dereq_,module,exports){
  var baseFor = _dereq_(108),
      keysIn = _dereq_(170);
  
  /**
   * The base implementation of `_.forIn` 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 baseForIn(object, iteratee) {
    return baseFor(object, iteratee, keysIn);
  }
  
  module.exports = baseForIn;
  
  },{"108":108,"170":170}],110:[function(_dereq_,module,exports){
  var baseFor = _dereq_(108),
      keys = _dereq_(169);
  
  /**
   * 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;
  
  },{"108":108,"169":169}],111:[function(_dereq_,module,exports){
  var toObject = _dereq_(156);
  
  /**
   * 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;
  
  },{"156":156}],112:[function(_dereq_,module,exports){
  var indexOfNaN = _dereq_(145);
  
  /**
   * 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;
  
  },{"145":145}],113:[function(_dereq_,module,exports){
  var baseIsEqualDeep = _dereq_(114),
      isObject = _dereq_(163),
      isObjectLike = _dereq_(151);
  
  /**
   * 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;
  
  },{"114":114,"151":151,"163":163}],114:[function(_dereq_,module,exports){
  var equalArrays = _dereq_(139),
      equalByTag = _dereq_(140),
      equalObjects = _dereq_(141),
      isArray = _dereq_(159),
      isTypedArray = _dereq_(166);
  
  /** `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;
  
  },{"139":139,"140":140,"141":141,"159":159,"166":166}],115:[function(_dereq_,module,exports){
  var baseIsEqual = _dereq_(113),
      toObject = _dereq_(156);
  
  /**
   * 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;
  
  },{"113":113,"156":156}],116:[function(_dereq_,module,exports){
  var baseEach = _dereq_(102),
      isArrayLike = _dereq_(146);
  
  /**
   * 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;
  
  },{"102":102,"146":146}],117:[function(_dereq_,module,exports){
  var baseIsMatch = _dereq_(115),
      getMatchData = _dereq_(143),
      toObject = _dereq_(156);
  
  /**
   * 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;
  
  },{"115":115,"143":143,"156":156}],118:[function(_dereq_,module,exports){
  var baseGet = _dereq_(111),
      baseIsEqual = _dereq_(113),
      baseSlice = _dereq_(124),
      isArray = _dereq_(159),
      isKey = _dereq_(149),
      isStrictComparable = _dereq_(152),
      last = _dereq_(73),
      toObject = _dereq_(156),
      toPath = _dereq_(157);
  
  /**
   * 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;
  
  },{"111":111,"113":113,"124":124,"149":149,"152":152,"156":156,"157":157,"159":159,"73":73}],119:[function(_dereq_,module,exports){
  var arrayEach = _dereq_(89),
      baseMergeDeep = _dereq_(120),
      isArray = _dereq_(159),
      isArrayLike = _dereq_(146),
      isObject = _dereq_(163),
      isObjectLike = _dereq_(151),
      isTypedArray = _dereq_(166),
      keys = _dereq_(169);
  
  /**
   * The base implementation of `_.merge` 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 merged values.
   * @param {Array} [stackA=[]] Tracks traversed source objects.
   * @param {Array} [stackB=[]] Associates values with source counterparts.
   * @returns {Object} Returns `object`.
   */
  function baseMerge(object, source, customizer, stackA, stackB) {
    if (!isObject(object)) {
      return object;
    }
    var isSrcArr = isArrayLike(source) && (isArray(source) || isTypedArray(source)),
        props = isSrcArr ? undefined : keys(source);
  
    arrayEach(props || source, function(srcValue, key) {
      if (props) {
        key = srcValue;
        srcValue = source[key];
      }
      if (isObjectLike(srcValue)) {
        stackA || (stackA = []);
        stackB || (stackB = []);
        baseMergeDeep(object, source, key, baseMerge, customizer, stackA, stackB);
      }
      else {
        var value = object[key],
            result = customizer ? customizer(value, srcValue, key, object, source) : undefined,
            isCommon = result === undefined;
  
        if (isCommon) {
          result = srcValue;
        }
        if ((result !== undefined || (isSrcArr && !(key in object))) &&
            (isCommon || (result === result ? (result !== value) : (value === value)))) {
          object[key] = result;
        }
      }
    });
    return object;
  }
  
  module.exports = baseMerge;
  
  },{"120":120,"146":146,"151":151,"159":159,"163":163,"166":166,"169":169,"89":89}],120:[function(_dereq_,module,exports){
  var arrayCopy = _dereq_(88),
      isArguments = _dereq_(158),
      isArray = _dereq_(159),
      isArrayLike = _dereq_(146),
      isPlainObject = _dereq_(164),
      isTypedArray = _dereq_(166),
      toPlainObject = _dereq_(167);
  
  /**
   * A specialized version of `baseMerge` for arrays and objects which performs
   * deep merges and tracks traversed objects enabling objects with circular
   * references to be merged.
   *
   * @private
   * @param {Object} object The destination object.
   * @param {Object} source The source object.
   * @param {string} key The key of the value to merge.
   * @param {Function} mergeFunc The function to merge values.
   * @param {Function} [customizer] The function to customize merged values.
   * @param {Array} [stackA=[]] Tracks traversed source objects.
   * @param {Array} [stackB=[]] Associates values with source counterparts.
   * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
   */
  function baseMergeDeep(object, source, key, mergeFunc, customizer, stackA, stackB) {
    var length = stackA.length,
        srcValue = source[key];
  
    while (length--) {
      if (stackA[length] == srcValue) {
        object[key] = stackB[length];
        return;
      }
    }
    var value = object[key],
        result = customizer ? customizer(value, srcValue, key, object, source) : undefined,
        isCommon = result === undefined;
  
    if (isCommon) {
      result = srcValue;
      if (isArrayLike(srcValue) && (isArray(srcValue) || isTypedArray(srcValue))) {
        result = isArray(value)
          ? value
          : (isArrayLike(value) ? arrayCopy(value) : []);
      }
      else if (isPlainObject(srcValue) || isArguments(srcValue)) {
        result = isArguments(value)
          ? toPlainObject(value)
          : (isPlainObject(value) ? value : {});
      }
      else {
        isCommon = false;
      }
    }
    // Add the source value to the stack of traversed objects and associate
    // it with its merged value.
    stackA.push(srcValue);
    stackB.push(result);
  
    if (isCommon) {
      // Recursively merge objects and arrays (susceptible to call stack limits).
      object[key] = mergeFunc(result, srcValue, customizer, stackA, stackB);
    } else if (result === result ? (result !== value) : (value === value)) {
      object[key] = result;
    }
  }
  
  module.exports = baseMergeDeep;
  
  },{"146":146,"158":158,"159":159,"164":164,"166":166,"167":167,"88":88}],121:[function(_dereq_,module,exports){
  /**
   * 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;
  
  },{}],122:[function(_dereq_,module,exports){
  var baseGet = _dereq_(111),
      toPath = _dereq_(157);
  
  /**
   * 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;
  
  },{"111":111,"157":157}],123:[function(_dereq_,module,exports){
  /**
   * The base implementation of `_.reduce` and `_.reduceRight` 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 iterate over.
   * @param {Function} iteratee The function invoked per iteration.
   * @param {*} accumulator The initial value.
   * @param {boolean} initFromCollection Specify using the first or last element
   *  of `collection` as the initial value.
   * @param {Function} eachFunc The function to iterate over `collection`.
   * @returns {*} Returns the accumulated value.
   */
  function baseReduce(collection, iteratee, accumulator, initFromCollection, eachFunc) {
    eachFunc(collection, function(value, index, collection) {
      accumulator = initFromCollection
        ? (initFromCollection = false, value)
        : iteratee(accumulator, value, index, collection);
    });
    return accumulator;
  }
  
  module.exports = baseReduce;
  
  },{}],124:[function(_dereq_,module,exports){
  /**
   * 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;
  
  },{}],125:[function(_dereq_,module,exports){
  var baseEach = _dereq_(102);
  
  /**
   * The base implementation of `_.some` 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 {boolean} Returns `true` if any element passes the predicate check,
   *  else `false`.
   */
  function baseSome(collection, predicate) {
    var result;
  
    baseEach(collection, function(value, index, collection) {
      result = predicate(value, index, collection);
      return !result;
    });
    return !!result;
  }
  
  module.exports = baseSome;
  
  },{"102":102}],126:[function(_dereq_,module,exports){
  /**
   * 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;
  
  },{}],127:[function(_dereq_,module,exports){
  /**
   * 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;
  
  },{}],128:[function(_dereq_,module,exports){
  var identity = _dereq_(176);
  
  /**
   * 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;
  
  },{"176":176}],129:[function(_dereq_,module,exports){
  var isObject = _dereq_(163);
  
  /**
   * 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;
  
  },{"163":163}],130:[function(_dereq_,module,exports){
  var isObject = _dereq_(163);
  
  /**
   * 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;
  
  },{"163":163}],131:[function(_dereq_,module,exports){
  var baseCallback = _dereq_(98),
      baseEach = _dereq_(102),
      isArray = _dereq_(159);
  
  /**
   * 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;
  
  },{"102":102,"159":159,"98":98}],132:[function(_dereq_,module,exports){
  var bindCallback = _dereq_(128),
      isIterateeCall = _dereq_(148),
      restParam = _dereq_(86);
  
  /**
   * 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;
  
  },{"128":128,"148":148,"86":86}],133:[function(_dereq_,module,exports){
  var getLength = _dereq_(142),
      isLength = _dereq_(150),
      toObject = _dereq_(156);
  
  /**
   * 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;
  
  },{"142":142,"150":150,"156":156}],134:[function(_dereq_,module,exports){
  var toObject = _dereq_(156);
  
  /**
   * 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;
  
  },{"156":156}],135:[function(_dereq_,module,exports){
  (function (global){
  var SetCache = _dereq_(87),
      getNative = _dereq_(144);
  
  /** 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 : {})
  //# sourceMappingURL=data:application/json;charset:utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIm5vZGVfbW9kdWxlcy9sb2Rhc2gvaW50ZXJuYWwvY3JlYXRlQ2FjaGUuanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBIiwiZmlsZSI6ImdlbmVyYXRlZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJ2YXIgU2V0Q2FjaGUgPSByZXF1aXJlKCcuL1NldENhY2hlJyksXG4gICAgZ2V0TmF0aXZlID0gcmVxdWlyZSgnLi9nZXROYXRpdmUnKTtcblxuLyoqIE5hdGl2ZSBtZXRob2QgcmVmZXJlbmNlcy4gKi9cbnZhciBTZXQgPSBnZXROYXRpdmUoZ2xvYmFsLCAnU2V0Jyk7XG5cbi8qIE5hdGl2ZSBtZXRob2QgcmVmZXJlbmNlcyBmb3IgdGhvc2Ugd2l0aCB0aGUgc2FtZSBuYW1lIGFzIG90aGVyIGBsb2Rhc2hgIG1ldGhvZHMuICovXG52YXIgbmF0aXZlQ3JlYXRlID0gZ2V0TmF0aXZlKE9iamVjdCwgJ2NyZWF0ZScpO1xuXG4vKipcbiAqIENyZWF0ZXMgYSBgU2V0YCBjYWNoZSBvYmplY3QgdG8gb3B0aW1pemUgbGluZWFyIHNlYXJjaGVzIG9mIGxhcmdlIGFycmF5cy5cbiAqXG4gKiBAcHJpdmF0ZVxuICogQHBhcmFtIHtBcnJheX0gW3ZhbHVlc10gVGhlIHZhbHVlcyB0byBjYWNoZS5cbiAqIEByZXR1cm5zIHtudWxsfE9iamVjdH0gUmV0dXJucyB0aGUgbmV3IGNhY2hlIG9iamVjdCBpZiBgU2V0YCBpcyBzdXBwb3J0ZWQsIGVsc2UgYG51bGxgLlxuICovXG5mdW5jdGlvbiBjcmVhdGVDYWNoZSh2YWx1ZXMpIHtcbiAgcmV0dXJuIChuYXRpdmVDcmVhdGUgJiYgU2V0KSA/IG5ldyBTZXRDYWNoZSh2YWx1ZXMpIDogbnVsbDtcbn1cblxubW9kdWxlLmV4cG9ydHMgPSBjcmVhdGVDYWNoZTtcbiJdfQ==
  },{"144":144,"87":87}],136:[function(_dereq_,module,exports){
  var baseCallback = _dereq_(98),
      baseFind = _dereq_(105),
      baseFindIndex = _dereq_(106),
      isArray = _dereq_(159);
  
  /**
   * 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;
  
  },{"105":105,"106":106,"159":159,"98":98}],137:[function(_dereq_,module,exports){
  var bindCallback = _dereq_(128),
      isArray = _dereq_(159);
  
  /**
   * 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;
  
  },{"128":128,"159":159}],138:[function(_dereq_,module,exports){
  var baseCallback = _dereq_(98),
      baseReduce = _dereq_(123),
      isArray = _dereq_(159);
  
  /**
   * Creates a function for `_.reduce` or `_.reduceRight`.
   *
   * @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 createReduce(arrayFunc, eachFunc) {
    return function(collection, iteratee, accumulator, thisArg) {
      var initFromArray = arguments.length < 3;
      return (typeof iteratee == 'function' && thisArg === undefined && isArray(collection))
        ? arrayFunc(collection, iteratee, accumulator, initFromArray)
        : baseReduce(collection, baseCallback(iteratee, thisArg, 4), accumulator, initFromArray, eachFunc);
    };
  }
  
  module.exports = createReduce;
  
  },{"123":123,"159":159,"98":98}],139:[function(_dereq_,module,exports){
  var arraySome = _dereq_(95);
  
  /**
   * 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;
  
  },{"95":95}],140:[function(_dereq_,module,exports){
  /** `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;
  
  },{}],141:[function(_dereq_,module,exports){
  var keys = _dereq_(169);
  
  /** 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;
  
  },{"169":169}],142:[function(_dereq_,module,exports){
  var baseProperty = _dereq_(121);
  
  /**
   * 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;
  
  },{"121":121}],143:[function(_dereq_,module,exports){
  var isStrictComparable = _dereq_(152),
      pairs = _dereq_(173);
  
  /**
   * 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;
  
  },{"152":152,"173":173}],144:[function(_dereq_,module,exports){
  var isNative = _dereq_(161);
  
  /**
   * 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;
  
  },{"161":161}],145:[function(_dereq_,module,exports){
  /**
   * 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;
  
  },{}],146:[function(_dereq_,module,exports){
  var getLength = _dereq_(142),
      isLength = _dereq_(150);
  
  /**
   * 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;
  
  },{"142":142,"150":150}],147:[function(_dereq_,module,exports){
  /** 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;
  
  },{}],148:[function(_dereq_,module,exports){
  var isArrayLike = _dereq_(146),
      isIndex = _dereq_(147),
      isObject = _dereq_(163);
  
  /**
   * 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;
    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;
  
  },{"146":146,"147":147,"163":163}],149:[function(_dereq_,module,exports){
  var isArray = _dereq_(159),
      toObject = _dereq_(156);
  
  /** 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;
    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;
  
  },{"156":156,"159":159}],150:[function(_dereq_,module,exports){
  /**
   * 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;
  
  },{}],151:[function(_dereq_,module,exports){
  /**
   * 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 == 'object';
  }
  
  module.exports = isObjectLike;
  
  },{}],152:[function(_dereq_,module,exports){
  var isObject = _dereq_(163);
  
  /**
   * 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;
  
  },{"163":163}],153:[function(_dereq_,module,exports){
  var toObject = _dereq_(156);
  
  /**
   * A specialized version of `_.pick` which picks `object` properties specified
   * by `props`.
   *
   * @private
   * @param {Object} object The source object.
   * @param {string[]} props The property names to pick.
   * @returns {Object} Returns the new object.
   */
  function pickByArray(object, props) {
    object = toObject(object);
  
    var index = -1,
        length = props.length,
        result = {};
  
    while (++index < length) {
      var key = props[index];
      if (key in object) {
        result[key] = object[key];
      }
    }
    return result;
  }
  
  module.exports = pickByArray;
  
  },{"156":156}],154:[function(_dereq_,module,exports){
  var baseForIn = _dereq_(109);
  
  /**
   * A specialized version of `_.pick` which picks `object` properties `predicate`
   * returns truthy for.
   *
   * @private
   * @param {Object} object The source object.
   * @param {Function} predicate The function invoked per iteration.
   * @returns {Object} Returns the new object.
   */
  function pickByCallback(object, predicate) {
    var result = {};
    baseForIn(object, function(value, key, object) {
      if (predicate(value, key, object)) {
        result[key] = value;
      }
    });
    return result;
  }
  
  module.exports = pickByCallback;
  
  },{"109":109}],155:[function(_dereq_,module,exports){
  var isArguments = _dereq_(158),
      isArray = _dereq_(159),
      isIndex = _dereq_(147),
      isLength = _dereq_(150),
      keysIn = _dereq_(170);
  
  /** 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;
  
  },{"147":147,"150":150,"158":158,"159":159,"170":170}],156:[function(_dereq_,module,exports){
  var isObject = _dereq_(163);
  
  /**
   * 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;
  
  },{"163":163}],157:[function(_dereq_,module,exports){
  var baseToString = _dereq_(126),
      isArray = _dereq_(159);
  
  /** 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;
  
  },{"126":126,"159":159}],158:[function(_dereq_,module,exports){
  var isArrayLike = _dereq_(146),
      isObjectLike = _dereq_(151);
  
  /** 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;
  
  },{"146":146,"151":151}],159:[function(_dereq_,module,exports){
  var getNative = _dereq_(144),
      isLength = _dereq_(150),
      isObjectLike = _dereq_(151);
  
  /** `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;
  
  },{"144":144,"150":150,"151":151}],160:[function(_dereq_,module,exports){
  var isObject = _dereq_(163);
  
  /** `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;
  
  },{"163":163}],161:[function(_dereq_,module,exports){
  var isFunction = _dereq_(160),
      isObjectLike = _dereq_(151);
  
  /** 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;
  
  },{"151":151,"160":160}],162:[function(_dereq_,module,exports){
  var isObjectLike = _dereq_(151);
  
  /** `Object#toString` result references. */
  var numberTag = '[object Number]';
  
  /** 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 `Number` primitive or object.
   *
   * **Note:** To exclude `Infinity`, `-Infinity`, and `NaN`, which are classified
   * as numbers, use the `_.isFinite` method.
   *
   * @static
   * @memberOf _
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
   * @example
   *
   * _.isNumber(8.4);
   * // => true
   *
   * _.isNumber(NaN);
   * // => true
   *
   * _.isNumber('8.4');
   * // => false
   */
  function isNumber(value) {
    return typeof value == 'number' || (isObjectLike(value) && objToString.call(value) == numberTag);
  }
  
  module.exports = isNumber;
  
  },{"151":151}],163:[function(_dereq_,module,exports){
  /**
   * 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;
    return !!value && (type == 'object' || type == 'function');
  }
  
  module.exports = isObject;
  
  },{}],164:[function(_dereq_,module,exports){
  var baseForIn = _dereq_(109),
      isArguments = _dereq_(158),
      isObjectLike = _dereq_(151);
  
  /** `Object#toString` result references. */
  var 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;
  
  /**
   * Checks if `value` is a plain object, that is, an object created by the
   * `Object` constructor or one with a `[[Prototype]]` of `null`.
   *
   * **Note:** This method assumes objects created by the `Object` constructor
   * have no inherited enumerable properties.
   *
   * @static
   * @memberOf _
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
   * @example
   *
   * function Foo() {
   *   this.a = 1;
   * }
   *
   * _.isPlainObject(new Foo);
   * // => false
   *
   * _.isPlainObject([1, 2, 3]);
   * // => false
   *
   * _.isPlainObject({ 'x': 0, 'y': 0 });
   * // => true
   *
   * _.isPlainObject(Object.create(null));
   * // => true
   */
  function isPlainObject(value) {
    var Ctor;
  
    // Exit early for non `Object` objects.
    if (!(isObjectLike(value) && objToString.call(value) == objectTag && !isArguments(value)) ||
        (!hasOwnProperty.call(value, 'constructor') && (Ctor = value.constructor, typeof Ctor == 'function' && !(Ctor instanceof Ctor)))) {
      return false;
    }
    // IE < 9 iterates inherited properties before own properties. If the first
    // iterated property is an object's own property then there are no inherited
    // enumerable properties.
    var result;
    // In most environments an object's own properties are iterated before
    // its inherited properties. If the last iterated property is an object's
    // own property then there are no inherited enumerable properties.
    baseForIn(value, function(subValue, key) {
      result = key;
    });
    return result === undefined || hasOwnProperty.call(value, result);
  }
  
  module.exports = isPlainObject;
  
  },{"109":109,"151":151,"158":158}],165:[function(_dereq_,module,exports){
  var isObjectLike = _dereq_(151);
  
  /** `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;
  
  },{"151":151}],166:[function(_dereq_,module,exports){
  var isLength = _dereq_(150),
      isObjectLike = _dereq_(151);
  
  /** `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;
  
  },{"150":150,"151":151}],167:[function(_dereq_,module,exports){
  var baseCopy = _dereq_(99),
      keysIn = _dereq_(170);
  
  /**
   * Converts `value` to a plain object flattening inherited enumerable
   * properties of `value` to own properties of the plain object.
   *
   * @static
   * @memberOf _
   * @category Lang
   * @param {*} value The value to convert.
   * @returns {Object} Returns the converted plain object.
   * @example
   *
   * function Foo() {
   *   this.b = 2;
   * }
   *
   * Foo.prototype.c = 3;
   *
   * _.assign({ 'a': 1 }, new Foo);
   * // => { 'a': 1, 'b': 2 }
   *
   * _.assign({ 'a': 1 }, _.toPlainObject(new Foo));
   * // => { 'a': 1, 'b': 2, 'c': 3 }
   */
  function toPlainObject(value) {
    return baseCopy(value, keysIn(value));
  }
  
  module.exports = toPlainObject;
  
  },{"170":170,"99":99}],168:[function(_dereq_,module,exports){
  var assignWith = _dereq_(96),
      baseAssign = _dereq_(97),
      createAssigner = _dereq_(132);
  
  /**
   * 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;
  
  },{"132":132,"96":96,"97":97}],169:[function(_dereq_,module,exports){
  var getNative = _dereq_(144),
      isArrayLike = _dereq_(146),
      isObject = _dereq_(163),
      shimKeys = _dereq_(155);
  
  /* 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;
  
  },{"144":144,"146":146,"155":155,"163":163}],170:[function(_dereq_,module,exports){
  var isArguments = _dereq_(158),
      isArray = _dereq_(159),
      isIndex = _dereq_(147),
      isLength = _dereq_(150),
      isObject = _dereq_(163);
  
  /** 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;
  
  },{"147":147,"150":150,"158":158,"159":159,"163":163}],171:[function(_dereq_,module,exports){
  var baseMerge = _dereq_(119),
      createAssigner = _dereq_(132);
  
  /**
   * Recursively merges own enumerable properties of the source object(s), that
   * don't resolve to `undefined` into the destination object. Subsequent sources
   * overwrite property assignments of previous sources. If `customizer` is
   * provided it's invoked to produce the merged values of the destination and
   * source properties. If `customizer` returns `undefined` merging is handled
   * by the method instead. The `customizer` is bound to `thisArg` and invoked
   * with five arguments: (objectValue, sourceValue, key, object, source).
   *
   * @static
   * @memberOf _
   * @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
   *
   * var users = {
   *   'data': [{ 'user': 'barney' }, { 'user': 'fred' }]
   * };
   *
   * var ages = {
   *   'data': [{ 'age': 36 }, { 'age': 40 }]
   * };
   *
   * _.merge(users, ages);
   * // => { 'data': [{ 'user': 'barney', 'age': 36 }, { 'user': 'fred', 'age': 40 }] }
   *
   * // using a customizer callback
   * var object = {
   *   'fruits': ['apple'],
   *   'vegetables': ['beet']
   * };
   *
   * var other = {
   *   'fruits': ['banana'],
   *   'vegetables': ['carrot']
   * };
   *
   * _.merge(object, other, function(a, b) {
   *   if (_.isArray(a)) {
   *     return a.concat(b);
   *   }
   * });
   * // => { 'fruits': ['apple', 'banana'], 'vegetables': ['beet', 'carrot'] }
   */
  var merge = createAssigner(baseMerge);
  
  module.exports = merge;
  
  },{"119":119,"132":132}],172:[function(_dereq_,module,exports){
  var arrayMap = _dereq_(92),
      baseDifference = _dereq_(101),
      baseFlatten = _dereq_(107),
      bindCallback = _dereq_(128),
      keysIn = _dereq_(170),
      pickByArray = _dereq_(153),
      pickByCallback = _dereq_(154),
      restParam = _dereq_(86);
  
  /**
   * The opposite of `_.pick`; this method creates an object composed of the
   * own and inherited enumerable properties of `object` that are not omitted.
   *
   * @static
   * @memberOf _
   * @category Object
   * @param {Object} object The source object.
   * @param {Function|...(string|string[])} [predicate] The function invoked per
   *  iteration or property names to omit, specified as individual property
   *  names or arrays of property names.
   * @param {*} [thisArg] The `this` binding of `predicate`.
   * @returns {Object} Returns the new object.
   * @example
   *
   * var object = { 'user': 'fred', 'age': 40 };
   *
   * _.omit(object, 'age');
   * // => { 'user': 'fred' }
   *
   * _.omit(object, _.isNumber);
   * // => { 'user': 'fred' }
   */
  var omit = restParam(function(object, props) {
    if (object == null) {
      return {};
    }
    if (typeof props[0] != 'function') {
      var props = arrayMap(baseFlatten(props), String);
      return pickByArray(object, baseDifference(keysIn(object), props));
    }
    var predicate = bindCallback(props[0], props[1], 3);
    return pickByCallback(object, function(value, key, object) {
      return !predicate(value, key, object);
    });
  });
  
  module.exports = omit;
  
  },{"101":101,"107":107,"128":128,"153":153,"154":154,"170":170,"86":86,"92":92}],173:[function(_dereq_,module,exports){
  var keys = _dereq_(169),
      toObject = _dereq_(156);
  
  /**
   * 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;
  
  },{"156":156,"169":169}],174:[function(_dereq_,module,exports){
  var baseFlatten = _dereq_(107),
      bindCallback = _dereq_(128),
      pickByArray = _dereq_(153),
      pickByCallback = _dereq_(154),
      restParam = _dereq_(86);
  
  /**
   * Creates an object composed of the picked `object` properties. Property
   * names may be specified as individual arguments or as arrays of property
   * names. If `predicate` is provided it's invoked for each property of `object`
   * picking the properties `predicate` returns truthy for. The predicate is
   * bound to `thisArg` and invoked with three arguments: (value, key, object).
   *
   * @static
   * @memberOf _
   * @category Object
   * @param {Object} object The source object.
   * @param {Function|...(string|string[])} [predicate] The function invoked per
   *  iteration or property names to pick, specified as individual property
   *  names or arrays of property names.
   * @param {*} [thisArg] The `this` binding of `predicate`.
   * @returns {Object} Returns the new object.
   * @example
   *
   * var object = { 'user': 'fred', 'age': 40 };
   *
   * _.pick(object, 'user');
   * // => { 'user': 'fred' }
   *
   * _.pick(object, _.isString);
   * // => { 'user': 'fred' }
   */
  var pick = restParam(function(object, props) {
    if (object == null) {
      return {};
    }
    return typeof props[0] == 'function'
      ? pickByCallback(object, bindCallback(props[0], props[1], 3))
      : pickByArray(object, baseFlatten(props));
  });
  
  module.exports = pick;
  
  },{"107":107,"128":128,"153":153,"154":154,"86":86}],175:[function(_dereq_,module,exports){
  var baseValues = _dereq_(127),
      keys = _dereq_(169);
  
  /**
   * 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;
  
  },{"127":127,"169":169}],176:[function(_dereq_,module,exports){
  /**
   * 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;
  
  },{}],177:[function(_dereq_,module,exports){
  var baseProperty = _dereq_(121),
      basePropertyDeep = _dereq_(122),
      isKey = _dereq_(149);
  
  /**
   * 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;
  
  },{"121":121,"122":122,"149":149}],178:[function(_dereq_,module,exports){
  module.exports = _dereq_(184);
  },{"184":184}],179:[function(_dereq_,module,exports){
  module.exports = function(el) {
  
    var c;
  
    while (el.childNodes.length) {
      c = el.childNodes[0];
      el.removeChild(c);
    }
  
    return el;
  };
  },{}],180:[function(_dereq_,module,exports){
  module.exports = _dereq_(187);
  },{"187":187}],181:[function(_dereq_,module,exports){
  module.exports = _dereq_(191);
  },{"191":191}],182:[function(_dereq_,module,exports){
  module.exports = _dereq_(190);
  },{"190":190}],183:[function(_dereq_,module,exports){
  module.exports = function(el) {
    el.parentNode && el.parentNode.removeChild(el);
  };
  },{}],184:[function(_dereq_,module,exports){
  /**
   * Module dependencies.
   */
  
  var index = _dereq_(185);
  
  /**
   * 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);
  };
  
  },{"185":185}],185:[function(_dereq_,module,exports){
  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;
  };
  },{}],186:[function(_dereq_,module,exports){
  var matches = _dereq_(189)
  
  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
    }
  }
  
  },{"189":189}],187:[function(_dereq_,module,exports){
  /**
   * Module dependencies.
   */
  
  var closest = _dereq_(186)
    , event = _dereq_(188);
  
  /**
   * 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);
  };
  
  },{"186":186,"188":188}],188:[function(_dereq_,module,exports){
  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;
  };
  },{}],189:[function(_dereq_,module,exports){
  /**
   * Module dependencies.
   */
  
  var query = _dereq_(190);
  
  /**
   * 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;
  }
  
  },{"190":190}],190:[function(_dereq_,module,exports){
  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;
  };
  
  },{}],191:[function(_dereq_,module,exports){
  
  /**
   * Expose `parse`.
   */
  
  module.exports = parse;
  
  /**
   * Tests for browser support.
   */
  
  var div = document.createElement('div');
  // Setup
  div.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
  var innerHTMLBug = !div.getElementsByTagName('link').length;
  div = 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;
  }
  
  },{}],192:[function(_dereq_,module,exports){
  module.exports = _dereq_(194);
  
  module.exports.Collection = _dereq_(193);
  },{"193":193,"194":194}],193:[function(_dereq_,module,exports){
  'use strict';
  
  /**
   * An empty collection stub. Use {@link RefsCollection.extend} to extend a
   * collection with ref semantics.
   *
   * @classdesc A change and inverse-reference aware collection with set semantics.
   *
   * @class RefsCollection
   */
  function 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
     */
    collection.remove = function(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
     */
    collection.contains = function(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
     */
    collection.add = function(element) {
  
      if (!this.contains(element)) {
        this.push(element);
  
        // set inverse
        refs.set(element, inverseProperty, target);
      }
    };
  
    return collection;
  }
  
  
  module.exports.extend = extend;
  },{}],194:[function(_dereq_,module,exports){
  'use strict';
  
  var Collection = _dereq_(193);
  
  function hasOwnProperty(e, property) {
    return Object.prototype.hasOwnProperty.call(e, property.name || property);
  }
  
  
  function defineCollectionProperty(ref, property, target) {
    Object.defineProperty(target, property.name, {
      enumerable: property.enumerable,
      value: Collection.extend(target[property.name] || [], ref, property, target)
    });
  }
  
  
  function defineProperty(ref, property, target) {
  
    var inverseProperty = property.inverse;
  
    var _value = target[property.name];
  
    Object.defineProperty(target, property.name, {
      enumerable: property.enumerable,
  
      get: function() {
        return _value;
      },
  
      set: function(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.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) {
        target[property.name].remove(value);
      } else {
        target[property.name] = undefined;
      }
    }
  };
  
  Refs.prototype.set = function(target, property, value) {
  
    if (target) {
      this.ensureBound(target, property);
  
      if (property.collection) {
        target[property.name].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]
   */
  },{"193":193}]},{},[1])(1)
  });
  //# sourceMappingURL=bpmn-viewer.js.map