(function webpackUniversalModuleDefinition(root, factory) {
  if (typeof exports === 'object' && typeof module === 'object')
    module.exports = factory(require("webcola"));
  else if (typeof define === 'function' && define.amd)
    define(["webcola"], factory);
  else if (typeof exports === 'object')
    exports["cytoscapeCola"] = factory(require("webcola"));
  else
    root["cytoscapeCola"] = factory(root["webcola"]);
})(this, function (__WEBPACK_EXTERNAL_MODULE_5__) {
  return /******/ (function (modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};
/******/
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/
/******/ 		// Check if module is in cache
/******/ 		if (installedModules[moduleId]) {
/******/ 			return installedModules[moduleId].exports;
        /******/
      }
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			i: moduleId,
/******/ 			l: false,
/******/ 			exports: {}
        /******/
      };
/******/
/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ 		// Flag the module as loaded
/******/ 		module.l = true;
/******/
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
      /******/
    }
/******/
/******/
/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;
/******/
/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;
/******/
/******/ 	// identity function for calling harmony imports with the correct context
/******/ 	__webpack_require__.i = function (value) { return value; };
/******/
/******/ 	// define getter function for harmony exports
/******/ 	__webpack_require__.d = function (exports, name, getter) {
/******/ 		if (!__webpack_require__.o(exports, name)) {
/******/ 			Object.defineProperty(exports, name, {
/******/ 				configurable: false,
/******/ 				enumerable: true,
/******/ 				get: getter
      /******/
    });
        /******/
      }
      /******/
    };
/******/
/******/ 	// getDefaultExport function for compatibility with non-harmony modules
/******/ 	__webpack_require__.n = function (module) {
/******/ 		var getter = module && module.__esModule ?
/******/ 			function getDefault() { return module['default']; } :
/******/ 			function getModuleExports() { return module; };
/******/ 		__webpack_require__.d(getter, 'a', getter);
/******/ 		return getter;
      /******/
    };
/******/
/******/ 	// Object.prototype.hasOwnProperty.call
/******/ 	__webpack_require__.o = function (object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";
/******/
/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(__webpack_require__.s = 3);
    /******/
  })
/************************************************************************/
/******/([
/* 0 */
/***/ (function (module, exports, __webpack_require__) {

      "use strict";


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

      var assign = __webpack_require__(1);
      var defaults = __webpack_require__(2);
      var cola = __webpack_require__(5) || (typeof window !== 'undefined' ? window.cola : null);
      var raf = __webpack_require__(4);
      var isString = function isString(o) {
        return (typeof o === 'undefined' ? 'undefined' : _typeof(o)) === _typeof('');
      };
      var isNumber = function isNumber(o) {
        return (typeof o === 'undefined' ? 'undefined' : _typeof(o)) === _typeof(0);
      };
      var isObject = function isObject(o) {
        return o != null && (typeof o === 'undefined' ? 'undefined' : _typeof(o)) === _typeof({});
      };
      var isFunction = function isFunction(o) {
        return o != null && (typeof o === 'undefined' ? 'undefined' : _typeof(o)) === _typeof(function () { });
      };
      var nop = function nop() { };

      var getOptVal = function getOptVal(val, ele) {
        if (isFunction(val)) {
          var fn = val;
          return fn.apply(ele, [ele]);
        } else {
          return val;
        }
      };

      // constructor
      // options : object containing layout options
      function ColaLayout(options) {
        this.options = assign({}, defaults, options);
      }

      // runs the layout
      ColaLayout.prototype.run = function () {
        var layout = this;
        var options = this.options;

        layout.manuallyStopped = false;

        var cy = options.cy; // cy is automatically populated for us in the constructor
        var eles = options.eles;
        var nodes = eles.nodes();
        var edges = eles.edges();
        var ready = false;

        var isParent = function isParent(ele) {
          return ele.isParent();
        };

        var parentNodes = nodes.filter(isParent);

        var nonparentNodes = nodes.subtract(parentNodes);

        var bb = options.boundingBox || { x1: 0, y1: 0, w: cy.width(), h: cy.height() };
        if (bb.x2 === undefined) {
          bb.x2 = bb.x1 + bb.w;
        }
        if (bb.w === undefined) {
          bb.w = bb.x2 - bb.x1;
        }
        if (bb.y2 === undefined) {
          bb.y2 = bb.y1 + bb.h;
        }
        if (bb.h === undefined) {
          bb.h = bb.y2 - bb.y1;
        }

        var updateNodePositions = function updateNodePositions() {
          for (var i = 0; i < nodes.length; i++) {
            var node = nodes[i];
            var dimensions = node.layoutDimensions(options);
            var scratch = node.scratch('cola');

            // update node dims
            if (!scratch.updatedDims) {
              var padding = getOptVal(options.nodeSpacing, node);

              scratch.width = dimensions.w + 2 * padding;
              scratch.height = dimensions.h + 2 * padding;
            }
          }

          nodes.positions(function (node) {
            var scratch = node.scratch().cola;
            var retPos = void 0;

            if (!node.grabbed() && nonparentNodes.contains(node)) {
              retPos = {
                x: bb.x1 + scratch.x,
                y: bb.y1 + scratch.y
              };

              if (!isNumber(retPos.x) || !isNumber(retPos.y)) {
                retPos = undefined;
              }
            }

            return retPos;
          });

          nodes.updateCompoundBounds(); // because the way this layout sets positions is buggy for some reason; ref #878

          if (!ready) {
            onReady();
            ready = true;
          }

          if (options.fit) {
            cy.fit(options.padding);
          }
        };

        var onDone = function onDone() {
          if (options.ungrabifyWhileSimulating) {
            grabbableNodes.grabify();
          }

          cy.off('destroy', destroyHandler);

          nodes.off('grab free position', grabHandler);
          nodes.off('lock unlock', lockHandler);

          // trigger layoutstop when the layout stops (e.g. finishes)
          layout.one('layoutstop', options.stop);
          layout.trigger({ type: 'layoutstop', layout: layout });
        };

        var onReady = function onReady() {
          // trigger layoutready when each node has had its position set at least once
          layout.one('layoutready', options.ready);
          layout.trigger({ type: 'layoutready', layout: layout });
        };

        var ticksPerFrame = options.refresh;

        if (options.refresh < 0) {
          ticksPerFrame = 1;
        } else {
          ticksPerFrame = Math.max(1, ticksPerFrame); // at least 1
        }

        var adaptor = layout.adaptor = cola.adaptor({
          trigger: function trigger(e) {
            // on sim event
            var TICK = cola.EventType ? cola.EventType.tick : null;
            var END = cola.EventType ? cola.EventType.end : null;

            switch (e.type) {
              case 'tick':
              case TICK:
                if (options.animate) {
                  updateNodePositions();
                }
                break;

              case 'end':
              case END:
                updateNodePositions();
                if (!options.infinite) {
                  onDone();
                }
                break;
            }
          },

          kick: function kick() {
            // kick off the simulation
            //let skip = 0;

            var firstTick = true;

            var inftick = function inftick() {
              if (layout.manuallyStopped) {
                onDone();

                return true;
              }

              var ret = adaptor.tick();

              if (!options.infinite && !firstTick) {
                adaptor.convergenceThreshold(options.convergenceThreshold);
              }

              firstTick = false;

              if (ret && options.infinite) {
                // resume layout if done
                adaptor.resume(); // resume => new kick
              }

              return ret; // allow regular finish b/c of new kick
            };

            var multitick = function multitick() {
              // multiple ticks in a row
              var ret = void 0;

              for (var i = 0; i < ticksPerFrame && !ret; i++) {
                ret = ret || inftick(); // pick up true ret vals => sim done
              }

              return ret;
            };

            if (options.animate) {
              var frame = function frame() {
                if (multitick()) {
                  return;
                }

                raf(frame);
              };

              raf(frame);
            } else {
              while (!inftick()) {
                // keep going...
              }
            }
          },

          on: nop, // dummy; not needed

          drag: nop // not needed for our case
        });
        layout.adaptor = adaptor;

        // if set no grabbing during layout
        var grabbableNodes = nodes.filter(':grabbable');
        if (options.ungrabifyWhileSimulating) {
          grabbableNodes.ungrabify();
        }

        var destroyHandler = void 0;
        cy.one('destroy', destroyHandler = function destroyHandler() {
          layout.stop();
        });

        // handle node dragging
        var grabHandler = void 0;
        nodes.on('grab free position', grabHandler = function grabHandler(e) {
          var node = this;
          var scrCola = node.scratch().cola;
          var pos = node.position();
          var nodeIsTarget = e.cyTarget === node || e.target === node;

          if (!nodeIsTarget) {
            return;
          }

          switch (e.type) {
            case 'grab':
              adaptor.dragstart(scrCola);
              break;
            case 'free':
              adaptor.dragend(scrCola);
              break;
            case 'position':
              // only update when different (i.e. manual .position() call or drag) so we don't loop needlessly
              if (scrCola.px !== pos.x - bb.x1 || scrCola.py !== pos.y - bb.y1) {
                scrCola.px = pos.x - bb.x1;
                scrCola.py = pos.y - bb.y1;
              }
              break;
          }
        });

        var lockHandler = void 0;
        nodes.on('lock unlock', lockHandler = function lockHandler() {
          var node = this;
          var scrCola = node.scratch().cola;

          scrCola.fixed = node.locked();

          if (node.locked()) {
            adaptor.dragstart(scrCola);
          } else {
            adaptor.dragend(scrCola);
          }
        });

        // add nodes to cola
        adaptor.nodes(nonparentNodes.map(function (node, i) {
          var padding = getOptVal(options.nodeSpacing, node);
          var pos = node.position();
          var dimensions = node.layoutDimensions(options);

          var struct = node.scratch().cola = {
            x: options.randomize && !node.locked() || pos.x === undefined ? Math.round(Math.random() * bb.w) : pos.x,
            y: options.randomize && !node.locked() || pos.y === undefined ? Math.round(Math.random() * bb.h) : pos.y,
            width: dimensions.w + 2 * padding,
            height: dimensions.h + 2 * padding,
            index: i,
            fixed: node.locked()
          };

          return struct;
        }));

        // the constraints to be added on nodes
        var constraints = [];

        if (options.alignment) {
          // then set alignment constraints

          if (options.alignment.vertical) {
            var verticalAlignments = options.alignment.vertical;
            verticalAlignments.forEach(function (alignment) {
              var offsetsX = [];
              alignment.forEach(function (nodeData) {
                var node = nodeData.node;
                var scrCola = node.scratch().cola;
                var index = scrCola.index;
                offsetsX.push({
                  node: index,
                  offset: nodeData.offset ? nodeData.offset : 0
                });
              });
              constraints.push({
                type: 'alignment',
                axis: 'x',
                offsets: offsetsX
              });
            });
          }

          if (options.alignment.horizontal) {
            var horizontalAlignments = options.alignment.horizontal;
            horizontalAlignments.forEach(function (alignment) {
              var offsetsY = [];
              alignment.forEach(function (nodeData) {
                var node = nodeData.node;
                var scrCola = node.scratch().cola;
                var index = scrCola.index;
                offsetsY.push({
                  node: index,
                  offset: nodeData.offset ? nodeData.offset : 0
                });
              });
              constraints.push({
                type: 'alignment',
                axis: 'y',
                offsets: offsetsY
              });
            });
          }
        }

        // if gapInequalities variable is set add each inequality constraint to list of constraints
        if (options.gapInequalities) {
          options.gapInequalities.forEach(function (inequality) {

            // for the constraints to be passed to cola layout adaptor use indices of nodes,
            // not the nodes themselves
            var leftIndex = inequality.left.scratch().cola.index;
            var rightIndex = inequality.right.scratch().cola.index;

            constraints.push({
              axis: inequality.axis,
              left: leftIndex,
              right: rightIndex,
              gap: inequality.gap,
              equality: inequality.equality
            });
          });
        }

        // add constraints if any
        if (constraints.length > 0) {
          adaptor.constraints(constraints);
        }

        // add compound nodes to cola
        adaptor.groups(parentNodes.map(function (node, i) {
          // add basic group incl leaf nodes
          var optPadding = getOptVal(options.nodeSpacing, node);
          var getPadding = function getPadding(d) {
            return parseFloat(node.style('padding-' + d));
          };

          var pleft = getPadding('left') + optPadding;
          var pright = getPadding('right') + optPadding;
          var ptop = getPadding('top') + optPadding;
          var pbottom = getPadding('bottom') + optPadding;

          node.scratch().cola = {
            index: i,

            padding: Math.max(pleft, pright, ptop, pbottom),

            // leaves should only contain direct descendants (children),
            // not the leaves of nested compound nodes or any nodes that are compounds themselves
            leaves: node.children().intersection(nonparentNodes).map(function (child) {
              return child[0].scratch().cola.index;
            }),

            fixed: node.locked()
          };

          return node;
        }).map(function (node) {
          // add subgroups
          node.scratch().cola.groups = node.children().intersection(parentNodes).map(function (child) {
            return child.scratch().cola.index;
          });

          return node.scratch().cola;
        }));

        // get the edge length setting mechanism
        var length = void 0;
        var lengthFnName = void 0;
        if (options.edgeLength != null) {
          length = options.edgeLength;
          lengthFnName = 'linkDistance';
        } else if (options.edgeSymDiffLength != null) {
          length = options.edgeSymDiffLength;
          lengthFnName = 'symmetricDiffLinkLengths';
        } else if (options.edgeJaccardLength != null) {
          length = options.edgeJaccardLength;
          lengthFnName = 'jaccardLinkLengths';
        } else {
          length = 100;
          lengthFnName = 'linkDistance';
        }

        var lengthGetter = function lengthGetter(link) {
          return link.calcLength;
        };

        // add the edges to cola
        adaptor.links(edges.stdFilter(function (edge) {
          return nonparentNodes.contains(edge.source()) && nonparentNodes.contains(edge.target());
        }).map(function (edge) {
          var c = edge.scratch().cola = {
            source: edge.source()[0].scratch().cola.index,
            target: edge.target()[0].scratch().cola.index
          };

          if (length != null) {
            c.calcLength = getOptVal(length, edge);
          }

          return c;
        }));

        adaptor.size([bb.w, bb.h]);

        if (length != null) {
          adaptor[lengthFnName](lengthGetter);
        }

        // set the flow of cola
        if (options.flow) {
          var flow = void 0;
          var defAxis = 'y';
          var defMinSep = 50;

          if (isString(options.flow)) {
            flow = {
              axis: options.flow,
              minSeparation: defMinSep
            };
          } else if (isNumber(options.flow)) {
            flow = {
              axis: defAxis,
              minSeparation: options.flow
            };
          } else if (isObject(options.flow)) {
            flow = options.flow;

            flow.axis = flow.axis || defAxis;
            flow.minSeparation = flow.minSeparation != null ? flow.minSeparation : defMinSep;
          } else {
            // e.g. options.flow: true
            flow = {
              axis: defAxis,
              minSeparation: defMinSep
            };
          }

          adaptor.flowLayout(flow.axis, flow.minSeparation);
        }

        layout.trigger({ type: 'layoutstart', layout: layout });

        adaptor.avoidOverlaps(options.avoidOverlap).handleDisconnected(options.handleDisconnected).start(options.unconstrIter, options.userConstIter, options.allConstIter, undefined, // gridSnapIterations = 0
          undefined, // keepRunning = true
          options.centerGraph);

        if (!options.infinite) {
          setTimeout(function () {
            if (!layout.manuallyStopped) {
              adaptor.stop();
            }
          }, options.maxSimulationTime);
        }

        return this; // chaining
      };

      // called on continuous layouts to stop them before they finish
      ColaLayout.prototype.stop = function () {
        if (this.adaptor) {
          this.manuallyStopped = true;
          this.adaptor.stop();
        }

        return this; // chaining
      };

      module.exports = ColaLayout;

      /***/
    }),
/* 1 */
/***/ (function (module, exports, __webpack_require__) {

      "use strict";


      // Simple, internal Object.assign() polyfill for options objects etc.

      module.exports = Object.assign != null ? Object.assign.bind(Object) : function (tgt) {
        for (var _len = arguments.length, srcs = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
          srcs[_key - 1] = arguments[_key];
        }

        srcs.filter(function (src) {
          return src != null;
        }).forEach(function (src) {
          Object.keys(src).forEach(function (k) {
            return tgt[k] = src[k];
          });
        });

        return tgt;
      };

      /***/
    }),
/* 2 */
/***/ (function (module, exports, __webpack_require__) {

      "use strict";


      // default layout options
      var defaults = {
        animate: true, // whether to show the layout as it's running
        refresh: 1, // number of ticks per frame; higher is faster but more jerky
        maxSimulationTime: 4000, // max length in ms to run the layout
        ungrabifyWhileSimulating: false, // so you can't drag nodes during layout
        fit: true, // on every layout reposition of nodes, fit the viewport
        padding: 30, // padding around the simulation
        boundingBox: undefined, // constrain layout bounds; { x1, y1, x2, y2 } or { x1, y1, w, h }
        nodeDimensionsIncludeLabels: false, // whether labels should be included in determining the space used by a node

        // layout event callbacks
        ready: function ready() { }, // on layoutready
        stop: function stop() { }, // on layoutstop

        // positioning options
        randomize: false, // use random node positions at beginning of layout
        avoidOverlap: true, // if true, prevents overlap of node bounding boxes
        handleDisconnected: true, // if true, avoids disconnected components from overlapping
        convergenceThreshold: 0.01, // when the alpha value (system energy) falls below this value, the layout stops
        nodeSpacing: function nodeSpacing(node) {
          return 10;
        }, // extra spacing around nodes
        flow: undefined, // use DAG/tree flow layout if specified, e.g. { axis: 'y', minSeparation: 30 }
        alignment: undefined, // relative alignment constraints on nodes, e.g. function( node ){ return { x: 0, y: 1 } }
        gapInequalities: undefined, // list of inequality constraints for the gap between the nodes, e.g. [{"axis":"y", "left":node1, "right":node2, "gap":25}]
        centerGraph: true, // adjusts the node positions initially to center the graph (pass false if you want to start the layout from the current position)


        // different methods of specifying edge length
        // each can be a constant numerical value or a function like `function( edge ){ return 2; }`
        edgeLength: undefined, // sets edge length directly in simulation
        edgeSymDiffLength: undefined, // symmetric diff edge length in simulation
        edgeJaccardLength: undefined, // jaccard edge length in simulation

        // iterations of cola algorithm; uses default values on undefined
        unconstrIter: undefined, // unconstrained initial layout iterations
        userConstIter: undefined, // initial layout iterations with user-specified constraints
        allConstIter: undefined, // initial layout iterations with all constraints including non-overlap

        // infinite layout options
        infinite: false // overrides all other options for a forces-all-the-time mode
      };

      module.exports = defaults;

      /***/
    }),
/* 3 */
/***/ (function (module, exports, __webpack_require__) {

      "use strict";


      var impl = __webpack_require__(0);

      // registers the extension on a cytoscape lib ref
      var register = function register(cytoscape) {
        if (!cytoscape) {
          return;
        } // can't register if cytoscape unspecified

        cytoscape('layout', 'cola', impl); // register with cytoscape.js
      };

      if (typeof cytoscape !== 'undefined') {
        // expose to global cytoscape (i.e. window.cytoscape)
        register(cytoscape);
      }

      module.exports = register;

      /***/
    }),
/* 4 */
/***/ (function (module, exports, __webpack_require__) {

      "use strict";


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

      var raf = void 0;

      if ((typeof window === "undefined" ? "undefined" : _typeof(window)) !== (true ? "undefined" : _typeof(undefined))) {
        raf = window.requestAnimationFrame || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame || window.msRequestAnimationFrame || function (fn) {
          return setTimeout(fn, 16);
        };
      } else {
        // if not available, all you get is immediate calls
        raf = function raf(cb) {
          cb();
        };
      }

      module.exports = raf;

      /***/
    }),
/* 5 */
/***/ (function (module, exports) {

      module.exports = __WEBPACK_EXTERNAL_MODULE_5__;

      /***/
    })
/******/]);
});