chise.js

(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.sbgnviz = f()}})(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){
(function (global){
/**
 * Lodash (Custom Build) <https://lodash.com/>
 * Build: `lodash modularize exports="npm" -o ./`
 * Copyright JS Foundation and other contributors <https://js.foundation/>
 * Released under MIT license <https://lodash.com/license>
 * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
 * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
 */

/** Used as the size to enable large array optimizations. */
var LARGE_ARRAY_SIZE = 200;

/** Used to stand-in for `undefined` hash values. */
var HASH_UNDEFINED = '__lodash_hash_undefined__';

/** Used to compose bitmasks for value comparisons. */
var COMPARE_PARTIAL_FLAG = 1,
    COMPARE_UNORDERED_FLAG = 2;

/** Used as references for various `Number` constants. */
var MAX_SAFE_INTEGER = 9007199254740991;

/** `Object#toString` result references. */
var argsTag = '[object Arguments]',
    arrayTag = '[object Array]',
    asyncTag = '[object AsyncFunction]',
    boolTag = '[object Boolean]',
    dateTag = '[object Date]',
    errorTag = '[object Error]',
    funcTag = '[object Function]',
    genTag = '[object GeneratorFunction]',
    mapTag = '[object Map]',
    numberTag = '[object Number]',
    nullTag = '[object Null]',
    objectTag = '[object Object]',
    promiseTag = '[object Promise]',
    proxyTag = '[object Proxy]',
    regexpTag = '[object RegExp]',
    setTag = '[object Set]',
    stringTag = '[object String]',
    symbolTag = '[object Symbol]',
    undefinedTag = '[object Undefined]',
    weakMapTag = '[object WeakMap]';

var arrayBufferTag = '[object ArrayBuffer]',
    dataViewTag = '[object DataView]',
    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 match `RegExp`
 * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
 */
var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;

/** Used to detect host constructors (Safari). */
var reIsHostCtor = /^\[object .+?Constructor\]$/;

/** Used to detect unsigned integer values. */
var reIsUint = /^(?:0|[1-9]\d*)$/;

/** 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[dataViewTag] = typedArrayTags[dateTag] =
typedArrayTags[errorTag] = typedArrayTags[funcTag] =
typedArrayTags[mapTag] = typedArrayTags[numberTag] =
typedArrayTags[objectTag] = typedArrayTags[regexpTag] =
typedArrayTags[setTag] = typedArrayTags[stringTag] =
typedArrayTags[weakMapTag] = false;

/** Detect free variable `global` from Node.js. */
var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;

/** Detect free variable `self`. */
var freeSelf = typeof self == 'object' && self && self.Object === Object && self;

/** Used as a reference to the global object. */
var root = freeGlobal || freeSelf || Function('return this')();

/** Detect free variable `exports`. */
var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;

/** Detect free variable `module`. */
var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;

/** Detect the popular CommonJS extension `module.exports`. */
var moduleExports = freeModule && freeModule.exports === freeExports;

/** Detect free variable `process` from Node.js. */
var freeProcess = moduleExports && freeGlobal.process;

/** Used to access faster Node.js helpers. */
var nodeUtil = (function() {
  try {
    return freeProcess && freeProcess.binding && freeProcess.binding('util');
  } catch (e) {}
}());

/* Node.js helper references. */
var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;

/**
 * A specialized version of `_.filter` for arrays without support for
 * iteratee shorthands.
 *
 * @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 == null ? 0 : array.length,
      resIndex = 0,
      result = [];

  while (++index < length) {
    var value = array[index];
    if (predicate(value, index, array)) {
      result[resIndex++] = value;
    }
  }
  return result;
}

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

/**
 * A specialized version of `_.some` for arrays without support for iteratee
 * shorthands.
 *
 * @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 == null ? 0 : array.length;

  while (++index < length) {
    if (predicate(array[index], index, array)) {
      return true;
    }
  }
  return false;
}

/**
 * The base implementation of `_.times` without support for iteratee shorthands
 * or max array length checks.
 *
 * @private
 * @param {number} n The number of times to invoke `iteratee`.
 * @param {Function} iteratee The function invoked per iteration.
 * @returns {Array} Returns the array of results.
 */
function baseTimes(n, iteratee) {
  var index = -1,
      result = Array(n);

  while (++index < n) {
    result[index] = iteratee(index);
  }
  return result;
}

/**
 * The base implementation of `_.unary` without support for storing metadata.
 *
 * @private
 * @param {Function} func The function to cap arguments for.
 * @returns {Function} Returns the new capped function.
 */
function baseUnary(func) {
  return function(value) {
    return func(value);
  };
}

/**
 * Checks if a `cache` value for `key` exists.
 *
 * @private
 * @param {Object} cache The cache to query.
 * @param {string} key The key of the entry to check.
 * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
 */
function cacheHas(cache, key) {
  return cache.has(key);
}

/**
 * Gets the value at `key` of `object`.
 *
 * @private
 * @param {Object} [object] The object to query.
 * @param {string} key The key of the property to get.
 * @returns {*} Returns the property value.
 */
function getValue(object, key) {
  return object == null ? undefined : object[key];
}

/**
 * Converts `map` to its key-value pairs.
 *
 * @private
 * @param {Object} map The map to convert.
 * @returns {Array} Returns the key-value pairs.
 */
function mapToArray(map) {
  var index = -1,
      result = Array(map.size);

  map.forEach(function(value, key) {
    result[++index] = [key, value];
  });
  return result;
}

/**
 * Creates a unary function that invokes `func` with its argument transformed.
 *
 * @private
 * @param {Function} func The function to wrap.
 * @param {Function} transform The argument transform.
 * @returns {Function} Returns the new function.
 */
function overArg(func, transform) {
  return function(arg) {
    return func(transform(arg));
  };
}

/**
 * Converts `set` to an array of its values.
 *
 * @private
 * @param {Object} set The set to convert.
 * @returns {Array} Returns the values.
 */
function setToArray(set) {
  var index = -1,
      result = Array(set.size);

  set.forEach(function(value) {
    result[++index] = value;
  });
  return result;
}

/** Used for built-in method references. */
var arrayProto = Array.prototype,
    funcProto = Function.prototype,
    objectProto = Object.prototype;

/** Used to detect overreaching core-js shims. */
var coreJsData = root['__core-js_shared__'];

/** Used to resolve the decompiled source of functions. */
var funcToString = funcProto.toString;

/** Used to check objects for own properties. */
var hasOwnProperty = objectProto.hasOwnProperty;

/** Used to detect methods masquerading as native. */
var maskSrcKey = (function() {
  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');
  return uid ? ('Symbol(src)_1.' + uid) : '';
}());

/**
 * Used to resolve the
 * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
 * of values.
 */
var nativeObjectToString = objectProto.toString;

/** Used to detect if a method is native. */
var reIsNative = RegExp('^' +
  funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&')
  .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
);

/** Built-in value references. */
var Buffer = moduleExports ? root.Buffer : undefined,
    Symbol = root.Symbol,
    Uint8Array = root.Uint8Array,
    propertyIsEnumerable = objectProto.propertyIsEnumerable,
    splice = arrayProto.splice,
    symToStringTag = Symbol ? Symbol.toStringTag : undefined;

/* Built-in method references for those with the same name as other `lodash` methods. */
var nativeGetSymbols = Object.getOwnPropertySymbols,
    nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined,
    nativeKeys = overArg(Object.keys, Object);

/* Built-in method references that are verified to be native. */
var DataView = getNative(root, 'DataView'),
    Map = getNative(root, 'Map'),
    Promise = getNative(root, 'Promise'),
    Set = getNative(root, 'Set'),
    WeakMap = getNative(root, 'WeakMap'),
    nativeCreate = getNative(Object, 'create');

/** Used to detect maps, sets, and weakmaps. */
var dataViewCtorString = toSource(DataView),
    mapCtorString = toSource(Map),
    promiseCtorString = toSource(Promise),
    setCtorString = toSource(Set),
    weakMapCtorString = toSource(WeakMap);

/** Used to convert symbols to primitives and strings. */
var symbolProto = Symbol ? Symbol.prototype : undefined,
    symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;

/**
 * Creates a hash object.
 *
 * @private
 * @constructor
 * @param {Array} [entries] The key-value pairs to cache.
 */
function Hash(entries) {
  var index = -1,
      length = entries == null ? 0 : entries.length;

  this.clear();
  while (++index < length) {
    var entry = entries[index];
    this.set(entry[0], entry[1]);
  }
}

/**
 * Removes all key-value entries from the hash.
 *
 * @private
 * @name clear
 * @memberOf Hash
 */
function hashClear() {
  this.__data__ = nativeCreate ? nativeCreate(null) : {};
  this.size = 0;
}

/**
 * Removes `key` and its value from the hash.
 *
 * @private
 * @name delete
 * @memberOf Hash
 * @param {Object} hash The hash to modify.
 * @param {string} key The key of the value to remove.
 * @returns {boolean} Returns `true` if the entry was removed, else `false`.
 */
function hashDelete(key) {
  var result = this.has(key) && delete this.__data__[key];
  this.size -= result ? 1 : 0;
  return result;
}

/**
 * Gets the hash value for `key`.
 *
 * @private
 * @name get
 * @memberOf Hash
 * @param {string} key The key of the value to get.
 * @returns {*} Returns the entry value.
 */
function hashGet(key) {
  var data = this.__data__;
  if (nativeCreate) {
    var result = data[key];
    return result === HASH_UNDEFINED ? undefined : result;
  }
  return hasOwnProperty.call(data, key) ? data[key] : undefined;
}

/**
 * Checks if a hash value for `key` exists.
 *
 * @private
 * @name has
 * @memberOf Hash
 * @param {string} key The key of the entry to check.
 * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
 */
function hashHas(key) {
  var data = this.__data__;
  return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);
}

/**
 * Sets the hash `key` to `value`.
 *
 * @private
 * @name set
 * @memberOf Hash
 * @param {string} key The key of the value to set.
 * @param {*} value The value to set.
 * @returns {Object} Returns the hash instance.
 */
function hashSet(key, value) {
  var data = this.__data__;
  this.size += this.has(key) ? 0 : 1;
  data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;
  return this;
}

// Add methods to `Hash`.
Hash.prototype.clear = hashClear;
Hash.prototype['delete'] = hashDelete;
Hash.prototype.get = hashGet;
Hash.prototype.has = hashHas;
Hash.prototype.set = hashSet;

/**
 * Creates an list cache object.
 *
 * @private
 * @constructor
 * @param {Array} [entries] The key-value pairs to cache.
 */
function ListCache(entries) {
  var index = -1,
      length = entries == null ? 0 : entries.length;

  this.clear();
  while (++index < length) {
    var entry = entries[index];
    this.set(entry[0], entry[1]);
  }
}

/**
 * Removes all key-value entries from the list cache.
 *
 * @private
 * @name clear
 * @memberOf ListCache
 */
function listCacheClear() {
  this.__data__ = [];
  this.size = 0;
}

/**
 * Removes `key` and its value from the list cache.
 *
 * @private
 * @name delete
 * @memberOf ListCache
 * @param {string} key The key of the value to remove.
 * @returns {boolean} Returns `true` if the entry was removed, else `false`.
 */
function listCacheDelete(key) {
  var data = this.__data__,
      index = assocIndexOf(data, key);

  if (index < 0) {
    return false;
  }
  var lastIndex = data.length - 1;
  if (index == lastIndex) {
    data.pop();
  } else {
    splice.call(data, index, 1);
  }
  --this.size;
  return true;
}

/**
 * Gets the list cache value for `key`.
 *
 * @private
 * @name get
 * @memberOf ListCache
 * @param {string} key The key of the value to get.
 * @returns {*} Returns the entry value.
 */
function listCacheGet(key) {
  var data = this.__data__,
      index = assocIndexOf(data, key);

  return index < 0 ? undefined : data[index][1];
}

/**
 * Checks if a list cache value for `key` exists.
 *
 * @private
 * @name has
 * @memberOf ListCache
 * @param {string} key The key of the entry to check.
 * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
 */
function listCacheHas(key) {
  return assocIndexOf(this.__data__, key) > -1;
}

/**
 * Sets the list cache `key` to `value`.
 *
 * @private
 * @name set
 * @memberOf ListCache
 * @param {string} key The key of the value to set.
 * @param {*} value The value to set.
 * @returns {Object} Returns the list cache instance.
 */
function listCacheSet(key, value) {
  var data = this.__data__,
      index = assocIndexOf(data, key);

  if (index < 0) {
    ++this.size;
    data.push([key, value]);
  } else {
    data[index][1] = value;
  }
  return this;
}

// Add methods to `ListCache`.
ListCache.prototype.clear = listCacheClear;
ListCache.prototype['delete'] = listCacheDelete;
ListCache.prototype.get = listCacheGet;
ListCache.prototype.has = listCacheHas;
ListCache.prototype.set = listCacheSet;

/**
 * Creates a map cache object to store key-value pairs.
 *
 * @private
 * @constructor
 * @param {Array} [entries] The key-value pairs to cache.
 */
function MapCache(entries) {
  var index = -1,
      length = entries == null ? 0 : entries.length;

  this.clear();
  while (++index < length) {
    var entry = entries[index];
    this.set(entry[0], entry[1]);
  }
}

/**
 * Removes all key-value entries from the map.
 *
 * @private
 * @name clear
 * @memberOf MapCache
 */
function mapCacheClear() {
  this.size = 0;
  this.__data__ = {
    'hash': new Hash,
    'map': new (Map || ListCache),
    'string': new Hash
  };
}

/**
 * Removes `key` and its value from the map.
 *
 * @private
 * @name delete
 * @memberOf MapCache
 * @param {string} key The key of the value to remove.
 * @returns {boolean} Returns `true` if the entry was removed, else `false`.
 */
function mapCacheDelete(key) {
  var result = getMapData(this, key)['delete'](key);
  this.size -= result ? 1 : 0;
  return result;
}

/**
 * Gets the map value for `key`.
 *
 * @private
 * @name get
 * @memberOf MapCache
 * @param {string} key The key of the value to get.
 * @returns {*} Returns the entry value.
 */
function mapCacheGet(key) {
  return getMapData(this, key).get(key);
}

/**
 * Checks if a map value for `key` exists.
 *
 * @private
 * @name has
 * @memberOf MapCache
 * @param {string} key The key of the entry to check.
 * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
 */
function mapCacheHas(key) {
  return getMapData(this, key).has(key);
}

/**
 * Sets the map `key` to `value`.
 *
 * @private
 * @name set
 * @memberOf MapCache
 * @param {string} key The key of the value to set.
 * @param {*} value The value to set.
 * @returns {Object} Returns the map cache instance.
 */
function mapCacheSet(key, value) {
  var data = getMapData(this, key),
      size = data.size;

  data.set(key, value);
  this.size += data.size == size ? 0 : 1;
  return this;
}

// Add methods to `MapCache`.
MapCache.prototype.clear = mapCacheClear;
MapCache.prototype['delete'] = mapCacheDelete;
MapCache.prototype.get = mapCacheGet;
MapCache.prototype.has = mapCacheHas;
MapCache.prototype.set = mapCacheSet;

/**
 *
 * Creates an array cache object to store unique values.
 *
 * @private
 * @constructor
 * @param {Array} [values] The values to cache.
 */
function SetCache(values) {
  var index = -1,
      length = values == null ? 0 : values.length;

  this.__data__ = new MapCache;
  while (++index < length) {
    this.add(values[index]);
  }
}

/**
 * Adds `value` to the array cache.
 *
 * @private
 * @name add
 * @memberOf SetCache
 * @alias push
 * @param {*} value The value to cache.
 * @returns {Object} Returns the cache instance.
 */
function setCacheAdd(value) {
  this.__data__.set(value, HASH_UNDEFINED);
  return this;
}

/**
 * Checks if `value` is in the array cache.
 *
 * @private
 * @name has
 * @memberOf SetCache
 * @param {*} value The value to search for.
 * @returns {number} Returns `true` if `value` is found, else `false`.
 */
function setCacheHas(value) {
  return this.__data__.has(value);
}

// Add methods to `SetCache`.
SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
SetCache.prototype.has = setCacheHas;

/**
 * Creates a stack cache object to store key-value pairs.
 *
 * @private
 * @constructor
 * @param {Array} [entries] The key-value pairs to cache.
 */
function Stack(entries) {
  var data = this.__data__ = new ListCache(entries);
  this.size = data.size;
}

/**
 * Removes all key-value entries from the stack.
 *
 * @private
 * @name clear
 * @memberOf Stack
 */
function stackClear() {
  this.__data__ = new ListCache;
  this.size = 0;
}

/**
 * Removes `key` and its value from the stack.
 *
 * @private
 * @name delete
 * @memberOf Stack
 * @param {string} key The key of the value to remove.
 * @returns {boolean} Returns `true` if the entry was removed, else `false`.
 */
function stackDelete(key) {
  var data = this.__data__,
      result = data['delete'](key);

  this.size = data.size;
  return result;
}

/**
 * Gets the stack value for `key`.
 *
 * @private
 * @name get
 * @memberOf Stack
 * @param {string} key The key of the value to get.
 * @returns {*} Returns the entry value.
 */
function stackGet(key) {
  return this.__data__.get(key);
}

/**
 * Checks if a stack value for `key` exists.
 *
 * @private
 * @name has
 * @memberOf Stack
 * @param {string} key The key of the entry to check.
 * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
 */
function stackHas(key) {
  return this.__data__.has(key);
}

/**
 * Sets the stack `key` to `value`.
 *
 * @private
 * @name set
 * @memberOf Stack
 * @param {string} key The key of the value to set.
 * @param {*} value The value to set.
 * @returns {Object} Returns the stack cache instance.
 */
function stackSet(key, value) {
  var data = this.__data__;
  if (data instanceof ListCache) {
    var pairs = data.__data__;
    if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {
      pairs.push([key, value]);
      this.size = ++data.size;
      return this;
    }
    data = this.__data__ = new MapCache(pairs);
  }
  data.set(key, value);
  this.size = data.size;
  return this;
}

// Add methods to `Stack`.
Stack.prototype.clear = stackClear;
Stack.prototype['delete'] = stackDelete;
Stack.prototype.get = stackGet;
Stack.prototype.has = stackHas;
Stack.prototype.set = stackSet;

/**
 * Creates an array of the enumerable property names of the array-like `value`.
 *
 * @private
 * @param {*} value The value to query.
 * @param {boolean} inherited Specify returning inherited property names.
 * @returns {Array} Returns the array of property names.
 */
function arrayLikeKeys(value, inherited) {
  var isArr = isArray(value),
      isArg = !isArr && isArguments(value),
      isBuff = !isArr && !isArg && isBuffer(value),
      isType = !isArr && !isArg && !isBuff && isTypedArray(value),
      skipIndexes = isArr || isArg || isBuff || isType,
      result = skipIndexes ? baseTimes(value.length, String) : [],
      length = result.length;

  for (var key in value) {
    if ((inherited || hasOwnProperty.call(value, key)) &&
        !(skipIndexes && (
           // Safari 9 has enumerable `arguments.length` in strict mode.
           key == 'length' ||
           // Node.js 0.10 has enumerable non-index properties on buffers.
           (isBuff && (key == 'offset' || key == 'parent')) ||
           // PhantomJS 2 has enumerable non-index properties on typed arrays.
           (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||
           // Skip index properties.
           isIndex(key, length)
        ))) {
      result.push(key);
    }
  }
  return result;
}

/**
 * Gets the index at which the `key` is found in `array` of key-value pairs.
 *
 * @private
 * @param {Array} array The array to inspect.
 * @param {*} key The key to search for.
 * @returns {number} Returns the index of the matched value, else `-1`.
 */
function assocIndexOf(array, key) {
  var length = array.length;
  while (length--) {
    if (eq(array[length][0], key)) {
      return length;
    }
  }
  return -1;
}

/**
 * The base implementation of `getAllKeys` and `getAllKeysIn` which uses
 * `keysFunc` and `symbolsFunc` to get the enumerable property names and
 * symbols of `object`.
 *
 * @private
 * @param {Object} object The object to query.
 * @param {Function} keysFunc The function to get the keys of `object`.
 * @param {Function} symbolsFunc The function to get the symbols of `object`.
 * @returns {Array} Returns the array of property names and symbols.
 */
function baseGetAllKeys(object, keysFunc, symbolsFunc) {
  var result = keysFunc(object);
  return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
}

/**
 * The base implementation of `getTag` without fallbacks for buggy environments.
 *
 * @private
 * @param {*} value The value to query.
 * @returns {string} Returns the `toStringTag`.
 */
function baseGetTag(value) {
  if (value == null) {
    return value === undefined ? undefinedTag : nullTag;
  }
  return (symToStringTag && symToStringTag in Object(value))
    ? getRawTag(value)
    : objectToString(value);
}

/**
 * The base implementation of `_.isArguments`.
 *
 * @private
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is an `arguments` object,
 */
function baseIsArguments(value) {
  return isObjectLike(value) && baseGetTag(value) == argsTag;
}

/**
 * The base implementation of `_.isEqual` which supports partial comparisons
 * and tracks traversed objects.
 *
 * @private
 * @param {*} value The value to compare.
 * @param {*} other The other value to compare.
 * @param {boolean} bitmask The bitmask flags.
 *  1 - Unordered comparison
 *  2 - Partial comparison
 * @param {Function} [customizer] The function to customize comparisons.
 * @param {Object} [stack] Tracks traversed `value` and `other` objects.
 * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
 */
function baseIsEqual(value, other, bitmask, customizer, stack) {
  if (value === other) {
    return true;
  }
  if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) {
    return value !== value && other !== other;
  }
  return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
}

/**
 * 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 {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
 * @param {Function} customizer The function to customize comparisons.
 * @param {Function} equalFunc The function to determine equivalents of values.
 * @param {Object} [stack] Tracks traversed `object` and `other` objects.
 * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
 */
function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
  var objIsArr = isArray(object),
      othIsArr = isArray(other),
      objTag = objIsArr ? arrayTag : getTag(object),
      othTag = othIsArr ? arrayTag : getTag(other);

  objTag = objTag == argsTag ? objectTag : objTag;
  othTag = othTag == argsTag ? objectTag : othTag;

  var objIsObj = objTag == objectTag,
      othIsObj = othTag == objectTag,
      isSameTag = objTag == othTag;

  if (isSameTag && isBuffer(object)) {
    if (!isBuffer(other)) {
      return false;
    }
    objIsArr = true;
    objIsObj = false;
  }
  if (isSameTag && !objIsObj) {
    stack || (stack = new Stack);
    return (objIsArr || isTypedArray(object))
      ? equalArrays(object, other, bitmask, customizer, equalFunc, stack)
      : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
  }
  if (!(bitmask & COMPARE_PARTIAL_FLAG)) {
    var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),
        othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');

    if (objIsWrapped || othIsWrapped) {
      var objUnwrapped = objIsWrapped ? object.value() : object,
          othUnwrapped = othIsWrapped ? other.value() : other;

      stack || (stack = new Stack);
      return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
    }
  }
  if (!isSameTag) {
    return false;
  }
  stack || (stack = new Stack);
  return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
}

/**
 * The base implementation of `_.isNative` without bad shim checks.
 *
 * @private
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a native function,
 *  else `false`.
 */
function baseIsNative(value) {
  if (!isObject(value) || isMasked(value)) {
    return false;
  }
  var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
  return pattern.test(toSource(value));
}

/**
 * The base implementation of `_.isTypedArray` without Node.js optimizations.
 *
 * @private
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
 */
function baseIsTypedArray(value) {
  return isObjectLike(value) &&
    isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
}

/**
 * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.
 *
 * @private
 * @param {Object} object The object to query.
 * @returns {Array} Returns the array of property names.
 */
function baseKeys(object) {
  if (!isPrototype(object)) {
    return nativeKeys(object);
  }
  var result = [];
  for (var key in Object(object)) {
    if (hasOwnProperty.call(object, key) && key != 'constructor') {
      result.push(key);
    }
  }
  return result;
}

/**
 * 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 {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
 * @param {Function} customizer The function to customize comparisons.
 * @param {Function} equalFunc The function to determine equivalents of values.
 * @param {Object} stack Tracks traversed `array` and `other` objects.
 * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.
 */
function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
  var isPartial = bitmask & COMPARE_PARTIAL_FLAG,
      arrLength = array.length,
      othLength = other.length;

  if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
    return false;
  }
  // Assume cyclic values are equal.
  var stacked = stack.get(array);
  if (stacked && stack.get(other)) {
    return stacked == other;
  }
  var index = -1,
      result = true,
      seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined;

  stack.set(array, other);
  stack.set(other, array);

  // Ignore non-index properties.
  while (++index < arrLength) {
    var arrValue = array[index],
        othValue = other[index];

    if (customizer) {
      var compared = isPartial
        ? customizer(othValue, arrValue, index, other, array, stack)
        : customizer(arrValue, othValue, index, array, other, stack);
    }
    if (compared !== undefined) {
      if (compared) {
        continue;
      }
      result = false;
      break;
    }
    // Recursively compare arrays (susceptible to call stack limits).
    if (seen) {
      if (!arraySome(other, function(othValue, othIndex) {
            if (!cacheHas(seen, othIndex) &&
                (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
              return seen.push(othIndex);
            }
          })) {
        result = false;
        break;
      }
    } else if (!(
          arrValue === othValue ||
            equalFunc(arrValue, othValue, bitmask, customizer, stack)
        )) {
      result = false;
      break;
    }
  }
  stack['delete'](array);
  stack['delete'](other);
  return result;
}

/**
 * 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.
 * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
 * @param {Function} customizer The function to customize comparisons.
 * @param {Function} equalFunc The function to determine equivalents of values.
 * @param {Object} stack Tracks traversed `object` and `other` objects.
 * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
 */
function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
  switch (tag) {
    case dataViewTag:
      if ((object.byteLength != other.byteLength) ||
          (object.byteOffset != other.byteOffset)) {
        return false;
      }
      object = object.buffer;
      other = other.buffer;

    case arrayBufferTag:
      if ((object.byteLength != other.byteLength) ||
          !equalFunc(new Uint8Array(object), new Uint8Array(other))) {
        return false;
      }
      return true;

    case boolTag:
    case dateTag:
    case numberTag:
      // Coerce booleans to `1` or `0` and dates to milliseconds.
      // Invalid dates are coerced to `NaN`.
      return eq(+object, +other);

    case errorTag:
      return object.name == other.name && object.message == other.message;

    case regexpTag:
    case stringTag:
      // Coerce regexes to strings and treat strings, primitives and objects,
      // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring
      // for more details.
      return object == (other + '');

    case mapTag:
      var convert = mapToArray;

    case setTag:
      var isPartial = bitmask & COMPARE_PARTIAL_FLAG;
      convert || (convert = setToArray);

      if (object.size != other.size && !isPartial) {
        return false;
      }
      // Assume cyclic values are equal.
      var stacked = stack.get(object);
      if (stacked) {
        return stacked == other;
      }
      bitmask |= COMPARE_UNORDERED_FLAG;

      // Recursively compare objects (susceptible to call stack limits).
      stack.set(object, other);
      var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
      stack['delete'](object);
      return result;

    case symbolTag:
      if (symbolValueOf) {
        return symbolValueOf.call(object) == symbolValueOf.call(other);
      }
  }
  return false;
}

/**
 * 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 {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
 * @param {Function} customizer The function to customize comparisons.
 * @param {Function} equalFunc The function to determine equivalents of values.
 * @param {Object} stack Tracks traversed `object` and `other` objects.
 * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
 */
function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
  var isPartial = bitmask & COMPARE_PARTIAL_FLAG,
      objProps = getAllKeys(object),
      objLength = objProps.length,
      othProps = getAllKeys(other),
      othLength = othProps.length;

  if (objLength != othLength && !isPartial) {
    return false;
  }
  var index = objLength;
  while (index--) {
    var key = objProps[index];
    if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {
      return false;
    }
  }
  // Assume cyclic values are equal.
  var stacked = stack.get(object);
  if (stacked && stack.get(other)) {
    return stacked == other;
  }
  var result = true;
  stack.set(object, other);
  stack.set(other, object);

  var skipCtor = isPartial;
  while (++index < objLength) {
    key = objProps[index];
    var objValue = object[key],
        othValue = other[key];

    if (customizer) {
      var compared = isPartial
        ? customizer(othValue, objValue, key, other, object, stack)
        : customizer(objValue, othValue, key, object, other, stack);
    }
    // Recursively compare objects (susceptible to call stack limits).
    if (!(compared === undefined
          ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack))
          : compared
        )) {
      result = false;
      break;
    }
    skipCtor || (skipCtor = key == 'constructor');
  }
  if (result && !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)) {
      result = false;
    }
  }
  stack['delete'](object);
  stack['delete'](other);
  return result;
}

/**
 * Creates an array of own enumerable property names and symbols of `object`.
 *
 * @private
 * @param {Object} object The object to query.
 * @returns {Array} Returns the array of property names and symbols.
 */
function getAllKeys(object) {
  return baseGetAllKeys(object, keys, getSymbols);
}

/**
 * Gets the data for `map`.
 *
 * @private
 * @param {Object} map The map to query.
 * @param {string} key The reference key.
 * @returns {*} Returns the map data.
 */
function getMapData(map, key) {
  var data = map.__data__;
  return isKeyable(key)
    ? data[typeof key == 'string' ? 'string' : 'hash']
    : data.map;
}

/**
 * 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 = getValue(object, key);
  return baseIsNative(value) ? value : undefined;
}

/**
 * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
 *
 * @private
 * @param {*} value The value to query.
 * @returns {string} Returns the raw `toStringTag`.
 */
function getRawTag(value) {
  var isOwn = hasOwnProperty.call(value, symToStringTag),
      tag = value[symToStringTag];

  try {
    value[symToStringTag] = undefined;
    var unmasked = true;
  } catch (e) {}

  var result = nativeObjectToString.call(value);
  if (unmasked) {
    if (isOwn) {
      value[symToStringTag] = tag;
    } else {
      delete value[symToStringTag];
    }
  }
  return result;
}

/**
 * Creates an array of the own enumerable symbols of `object`.
 *
 * @private
 * @param {Object} object The object to query.
 * @returns {Array} Returns the array of symbols.
 */
var getSymbols = !nativeGetSymbols ? stubArray : function(object) {
  if (object == null) {
    return [];
  }
  object = Object(object);
  return arrayFilter(nativeGetSymbols(object), function(symbol) {
    return propertyIsEnumerable.call(object, symbol);
  });
};

/**
 * Gets the `toStringTag` of `value`.
 *
 * @private
 * @param {*} value The value to query.
 * @returns {string} Returns the `toStringTag`.
 */
var getTag = baseGetTag;

// Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.
if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||
    (Map && getTag(new Map) != mapTag) ||
    (Promise && getTag(Promise.resolve()) != promiseTag) ||
    (Set && getTag(new Set) != setTag) ||
    (WeakMap && getTag(new WeakMap) != weakMapTag)) {
  getTag = function(value) {
    var result = baseGetTag(value),
        Ctor = result == objectTag ? value.constructor : undefined,
        ctorString = Ctor ? toSource(Ctor) : '';

    if (ctorString) {
      switch (ctorString) {
        case dataViewCtorString: return dataViewTag;
        case mapCtorString: return mapTag;
        case promiseCtorString: return promiseTag;
        case setCtorString: return setTag;
        case weakMapCtorString: return weakMapTag;
      }
    }
    return result;
  };
}

/**
 * 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) {
  length = length == null ? MAX_SAFE_INTEGER : length;
  return !!length &&
    (typeof value == 'number' || reIsUint.test(value)) &&
    (value > -1 && value % 1 == 0 && value < length);
}

/**
 * Checks if `value` is suitable for use as unique object key.
 *
 * @private
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is suitable, else `false`.
 */
function isKeyable(value) {
  var type = typeof value;
  return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')
    ? (value !== '__proto__')
    : (value === null);
}

/**
 * Checks if `func` has its source masked.
 *
 * @private
 * @param {Function} func The function to check.
 * @returns {boolean} Returns `true` if `func` is masked, else `false`.
 */
function isMasked(func) {
  return !!maskSrcKey && (maskSrcKey in func);
}

/**
 * Checks if `value` is likely a prototype object.
 *
 * @private
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.
 */
function isPrototype(value) {
  var Ctor = value && value.constructor,
      proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;

  return value === proto;
}

/**
 * Converts `value` to a string using `Object.prototype.toString`.
 *
 * @private
 * @param {*} value The value to convert.
 * @returns {string} Returns the converted string.
 */
function objectToString(value) {
  return nativeObjectToString.call(value);
}

/**
 * Converts `func` to its source code.
 *
 * @private
 * @param {Function} func The function to convert.
 * @returns {string} Returns the source code.
 */
function toSource(func) {
  if (func != null) {
    try {
      return funcToString.call(func);
    } catch (e) {}
    try {
      return (func + '');
    } catch (e) {}
  }
  return '';
}

/**
 * Performs a
 * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
 * comparison between two values to determine if they are equivalent.
 *
 * @static
 * @memberOf _
 * @since 4.0.0
 * @category Lang
 * @param {*} value The value to compare.
 * @param {*} other The other value to compare.
 * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
 * @example
 *
 * var object = { 'a': 1 };
 * var other = { 'a': 1 };
 *
 * _.eq(object, object);
 * // => true
 *
 * _.eq(object, other);
 * // => false
 *
 * _.eq('a', 'a');
 * // => true
 *
 * _.eq('a', Object('a'));
 * // => false
 *
 * _.eq(NaN, NaN);
 * // => true
 */
function eq(value, other) {
  return value === other || (value !== value && other !== other);
}

/**
 * Checks if `value` is likely an `arguments` object.
 *
 * @static
 * @memberOf _
 * @since 0.1.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is an `arguments` object,
 *  else `false`.
 * @example
 *
 * _.isArguments(function() { return arguments; }());
 * // => true
 *
 * _.isArguments([1, 2, 3]);
 * // => false
 */
var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {
  return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&
    !propertyIsEnumerable.call(value, 'callee');
};

/**
 * Checks if `value` is classified as an `Array` object.
 *
 * @static
 * @memberOf _
 * @since 0.1.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is an array, else `false`.
 * @example
 *
 * _.isArray([1, 2, 3]);
 * // => true
 *
 * _.isArray(document.body.children);
 * // => false
 *
 * _.isArray('abc');
 * // => false
 *
 * _.isArray(_.noop);
 * // => false
 */
var isArray = Array.isArray;

/**
 * Checks if `value` is array-like. A value is considered array-like if it's
 * not a function and has a `value.length` that's an integer greater than or
 * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
 *
 * @static
 * @memberOf _
 * @since 4.0.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
 * @example
 *
 * _.isArrayLike([1, 2, 3]);
 * // => true
 *
 * _.isArrayLike(document.body.children);
 * // => true
 *
 * _.isArrayLike('abc');
 * // => true
 *
 * _.isArrayLike(_.noop);
 * // => false
 */
function isArrayLike(value) {
  return value != null && isLength(value.length) && !isFunction(value);
}

/**
 * Checks if `value` is a buffer.
 *
 * @static
 * @memberOf _
 * @since 4.3.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.
 * @example
 *
 * _.isBuffer(new Buffer(2));
 * // => true
 *
 * _.isBuffer(new Uint8Array(2));
 * // => false
 */
var isBuffer = nativeIsBuffer || stubFalse;

/**
 * Performs a deep comparison between two values to determine if they are
 * equivalent.
 *
 * **Note:** This method supports comparing arrays, array buffers, booleans,
 * date objects, error objects, maps, numbers, `Object` objects, regexes,
 * sets, strings, symbols, and typed arrays. `Object` objects are compared
 * by their own, not inherited, enumerable properties. Functions and DOM
 * nodes are compared by strict equality, i.e. `===`.
 *
 * @static
 * @memberOf _
 * @since 0.1.0
 * @category Lang
 * @param {*} value The value to compare.
 * @param {*} other The other value to compare.
 * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
 * @example
 *
 * var object = { 'a': 1 };
 * var other = { 'a': 1 };
 *
 * _.isEqual(object, other);
 * // => true
 *
 * object === other;
 * // => false
 */
function isEqual(value, other) {
  return baseIsEqual(value, other);
}

/**
 * Checks if `value` is classified as a `Function` object.
 *
 * @static
 * @memberOf _
 * @since 0.1.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a function, else `false`.
 * @example
 *
 * _.isFunction(_);
 * // => true
 *
 * _.isFunction(/abc/);
 * // => false
 */
function isFunction(value) {
  if (!isObject(value)) {
    return false;
  }
  // The use of `Object#toString` avoids issues with the `typeof` operator
  // in Safari 9 which returns 'object' for typed arrays and other constructors.
  var tag = baseGetTag(value);
  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
}

/**
 * Checks if `value` is a valid array-like length.
 *
 * **Note:** This method is loosely based on
 * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
 *
 * @static
 * @memberOf _
 * @since 4.0.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
 * @example
 *
 * _.isLength(3);
 * // => true
 *
 * _.isLength(Number.MIN_VALUE);
 * // => false
 *
 * _.isLength(Infinity);
 * // => false
 *
 * _.isLength('3');
 * // => false
 */
function isLength(value) {
  return typeof value == 'number' &&
    value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
}

/**
 * Checks if `value` is the
 * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
 * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
 *
 * @static
 * @memberOf _
 * @since 0.1.0
 * @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(_.noop);
 * // => true
 *
 * _.isObject(null);
 * // => false
 */
function isObject(value) {
  var type = typeof value;
  return value != null && (type == 'object' || type == 'function');
}

/**
 * Checks if `value` is object-like. A value is object-like if it's not `null`
 * and has a `typeof` result of "object".
 *
 * @static
 * @memberOf _
 * @since 4.0.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
 * @example
 *
 * _.isObjectLike({});
 * // => true
 *
 * _.isObjectLike([1, 2, 3]);
 * // => true
 *
 * _.isObjectLike(_.noop);
 * // => false
 *
 * _.isObjectLike(null);
 * // => false
 */
function isObjectLike(value) {
  return value != null && typeof value == 'object';
}

/**
 * Checks if `value` is classified as a typed array.
 *
 * @static
 * @memberOf _
 * @since 3.0.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
 * @example
 *
 * _.isTypedArray(new Uint8Array);
 * // => true
 *
 * _.isTypedArray([]);
 * // => false
 */
var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;

/**
 * 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/7.0/#sec-object.keys)
 * for more details.
 *
 * @static
 * @since 0.1.0
 * @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']
 */
function keys(object) {
  return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
}

/**
 * This method returns a new empty array.
 *
 * @static
 * @memberOf _
 * @since 4.13.0
 * @category Util
 * @returns {Array} Returns the new empty array.
 * @example
 *
 * var arrays = _.times(2, _.stubArray);
 *
 * console.log(arrays);
 * // => [[], []]
 *
 * console.log(arrays[0] === arrays[1]);
 * // => false
 */
function stubArray() {
  return [];
}

/**
 * This method returns `false`.
 *
 * @static
 * @memberOf _
 * @since 4.13.0
 * @category Util
 * @returns {boolean} Returns `false`.
 * @example
 *
 * _.times(2, _.stubFalse);
 * // => [false, false]
 */
function stubFalse() {
  return false;
}

module.exports = isEqual;

}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})

},{}],2:[function(_dereq_,module,exports){
(function(){
  var chise = function(_options) {

    var param = {};

    // Access the libs
    var libs = _dereq_('./utilities/lib-utilities').getLibs();

    var optionUtilities = _dereq_('./utilities/option-utilities-factory')();
    var options = optionUtilities.extendOptions(_options); // Extends the default options with the given options

    // Create an sbgnviz instance
    var sbgnvizInstanceUtilities = _dereq_('./utilities/sbgnviz-instance-utilities-factory')();
    var sbgnvizInstance = sbgnvizInstanceUtilities(options);

    // Register undo/redo actions
    var registerUndoRedoActions = _dereq_('./utilities/register-undo-redo-actions-factory')();

    var mainUtilities = _dereq_('./utilities/main-utilities-factory')();
    var elementUtilitiesExtender = _dereq_('./utilities/element-utilities-extender-factory')();
    var undoRedoActionFunctionsExtender = _dereq_('./utilities/ur-action-functions-extender-factory')();
    var sifTopologyGrouping = _dereq_('./utilities/topology-grouping-factory')();

    var elementUtilities =  sbgnvizInstance.elementUtilities;
    var undoRedoActionFunctions = sbgnvizInstance.undoRedoActionFunctions;

    param.sbgnvizInstanceUtilities = sbgnvizInstanceUtilities;
    param.optionUtilities = optionUtilities;
    param.elementUtilities = elementUtilities;
    param.undoRedoActionFunctions = undoRedoActionFunctions;
    param.sifTopologyGrouping = sifTopologyGrouping;

    var shouldApply = function() {
      return param.elementUtilities.mapType === 'SIF';
    };

    undoRedoActionFunctionsExtender(param);
    elementUtilitiesExtender(param);
    registerUndoRedoActions(param);
    mainUtilities(param);
    sifTopologyGrouping(param, {metaEdgeIdentifier: 'sif-meta', lockGraphTopology: true, shouldApply});

    // Expose the api
    var api = {};

    // Expose the properties inherited from sbgnviz
    // then override some of these properties and expose some new properties
    for (var prop in sbgnvizInstance) {
      api[prop] = sbgnvizInstance[prop];
    }

    // Expose each main utility seperately
    for (var prop in mainUtilities) {
      api[prop] = mainUtilities[prop];
    }

    // Expose getSbgnvizInstance()
    api.getSbgnvizInstance = sbgnvizInstanceUtilities.getInstance;

    // Expose elementUtilities and undoRedoActionFunctions as is
    api.elementUtilities = elementUtilities;
    api.undoRedoActionFunctions = undoRedoActionFunctions;
    api.sifTopologyGrouping = sifTopologyGrouping;

    return api;
  };

  // Register chise with given libraries
  chise.register = function (_libs) {

    var libs = {};
    libs.jQuery = _libs.jQuery || jQuery;
    libs.cytoscape = _libs.cytoscape || cytoscape;
    libs.sbgnviz = _libs.sbgnviz || sbgnviz;
    libs.saveAs = _libs.filesaver ? _libs.filesaver.saveAs : saveAs;

    libs.sbgnviz.register(_libs); // Register sbgnviz with the given libs

    // inherit exposed static properties of sbgnviz other than register
    for (var prop in libs.sbgnviz) {
      if (prop !== 'register') {
        chise[prop] = libs.sbgnviz[prop];
      }
    }

    // Set the libraries to access them from any file
    var libUtilities = _dereq_('./utilities/lib-utilities');
    libUtilities.setLibs(libs);
  };

  if ( typeof module !== 'undefined' && module.exports ) {
    module.exports = chise;
  }
})();

},{"./utilities/element-utilities-extender-factory":3,"./utilities/lib-utilities":4,"./utilities/main-utilities-factory":5,"./utilities/option-utilities-factory":6,"./utilities/register-undo-redo-actions-factory":7,"./utilities/sbgnviz-instance-utilities-factory":8,"./utilities/topology-grouping-factory":9,"./utilities/ur-action-functions-extender-factory":10}],3:[function(_dereq_,module,exports){
// Extends sbgnviz.elementUtilities
var libs = _dereq_('./lib-utilities').getLibs();
var jQuery = $ = libs.jQuery;

module.exports = function () {
  var options, sbgnvizInstance, elementUtilities, cy;

  function elementUtilitiesExtender (param) {
    sbgnvizInstance = param.sbgnvizInstanceUtilities.getInstance();
    options = param.optionUtilities.getOptions();
    elementUtilities = sbgnvizInstance.elementUtilities;
    cy = param.sbgnvizInstanceUtilities.getCy();

    extend();

    // Return the extended elementUtilities
    return elementUtilities;
  }

  // Extends elementUtilities with chise specific facilities
  function extend () {
    // Section Start
    // Add remove utilities

    elementUtilities.addNode = function (x, y, nodeParams, id, parent, visibility) {
      if (typeof nodeParams != 'object'){
        var sbgnclass = nodeParams;
      } else {
          var sbgnclass = nodeParams.class;
          var language = nodeParams.language;
      }

      var css = {};
      // if there is no specific default width or height for
      // sbgnclass these sizes are used
      var defaultWidth = 50;
      var defaultHeight = 50;

      if (visibility) {
        css.visibility = visibility;
      }

      var data = {
        class: sbgnclass,
    	  language: language,
        bbox: {
          w: defaultWidth,
          h: defaultHeight,
          x: x,
          y: y
        },
        statesandinfos: [],
        ports: []
      };

      if(id) {
        data.id = id;
      }
      else {
        data.id = elementUtilities.generateNodeId();
      }

      if (parent) {
        data.parent = parent;
      }

      this.extendNodeDataWithClassDefaults( data, sbgnclass );

      // some defaults are not set by extendNodeDataWithClassDefaults()
      var defaults = this.getDefaultProperties( sbgnclass );

      if ( defaults[ 'multimer' ] ) {
        data.class += ' multimer';
      }

      if ( defaults[ 'clonemarker' ] ) {
        data[ 'clonemarker' ] = true;
      }

      data.bbox[ 'w' ] = defaults[ 'width' ];
      data.bbox[ 'h' ] = defaults[ 'height' ];

      var eles = cy.add({
        group: "nodes",
        data: data,
        css: css,
        position: {
          x: x,
          y: y
        }
      });

      var newNode = eles[eles.length - 1];
      // Get the default ports ordering for the nodes with given sbgnclass
      var ordering = defaults['ports-ordering'];

      // If there is a default ports ordering for the nodes with given sbgnclass and it is different than 'none' set the ports ordering to that ordering
      if (ordering && ordering !== 'none') {
        this.setPortsOrdering(newNode, ordering);
      }

      if (language == "AF" && !elementUtilities.canHaveMultipleUnitOfInformation(newNode)){
        if (sbgnclass != "BA plain") { // if AF node can have label i.e: not plain biological activity
          var uoi_obj = {
            clazz: "unit of information"
          };
          uoi_obj.label = {
            text: ""
          };

          uoi_obj.bbox = {
             w: 12,
             h: 12
          };
          elementUtilities.addStateOrInfoBox(newNode, uoi_obj);
        }
      }

      // node bg image was unexpectedly not rendered until it is clicked
      // use this dirty hack until finding a solution to the problem
      var bgImage = newNode.data('background-image');
      if ( bgImage ) {
        newNode.data( 'background-image', bgImage );
      }

      return newNode;
    };

    //Saves old aux units of given node
    elementUtilities.saveUnits = function(node) {
      var tempData = [];
      var index = 0;
      node.data('statesandinfos').forEach( function(ele) {
        tempData.push({
          x: ele.bbox.x,
          y: ele.bbox.y,
          anchorSide: ele.anchorSide,
        });
        index++;
      });
      return tempData;
    };

    //Restores from given data
    elementUtilities.restoreUnits = function(node, data) {
      var index = 0;
      node.data('statesandinfos').forEach( function(ele) {
        if (data !== undefined) {
          ele.bbox.x = data[index].x;
          ele.bbox.y = data[index].y
          var anchorSide = ele.anchorSide;
          ele.anchorSide = data[index].anchorSide;
          elementUtilities.modifyUnits(node, ele, anchorSide);
          index++;
        }
      });
    };

    //Modify aux unit layouts
    elementUtilities.modifyUnits = function (node, ele, anchorSide) {
      instance.classes.AuxUnitLayout.modifyUnits(node, ele, anchorSide, cy);
    };


    //For reversible reactions both side of the process can be input/output
    //Group ID identifies to which group of nodes the edge is going to be connected for reversible reactions(0: group 1 ID and 1:group 2 ID)
    elementUtilities.addEdge = function (source, target, edgeParams, id, visibility, groupID ) {
      if (typeof edgeParams != 'object'){
        var sbgnclass = edgeParams;
      } else {
          var sbgnclass = edgeParams.class;
          var language = edgeParams.language;
      }

      var css = {};

      if (visibility) {
        css.visibility = visibility;
      }

      var data = {
          source: source,
          target: target,
          class: sbgnclass,
          language: language,
      };

      var defaults = elementUtilities.getDefaultProperties( sbgnclass );

      // extend the data with default properties of edge style
      Object.keys( defaults ).forEach( function( prop ) {
        data[ prop ] = defaults[ prop ];
      } );

      if(id) {
        data.id = id;
      }
      else {
        data.id = elementUtilities.generateEdgeId();
      }

      if(elementUtilities.canHaveSBGNCardinality(sbgnclass)){
        data.cardinality = 0;
      }

      var sourceNode = cy.getElementById(source); // The original source node
      var targetNode = cy.getElementById(target); // The original target node
      var sourceHasPorts = sourceNode.data('ports').length === 2;
      var targetHasPorts = targetNode.data('ports').length === 2;
      // The portsource and porttarget variables
      var portsource;
      var porttarget;

      /*
       * Get input/output port id's of a node with the assumption that the node has valid ports.
       */
      var getIOPortIds = function (node) {
        var nodeInputPortId, nodeOutputPortId;
        var nodePortsOrdering = sbgnvizInstance.elementUtilities.getPortsOrdering(node);
        var nodePorts = node.data('ports');
        if ( nodePortsOrdering === 'L-to-R' || nodePortsOrdering === 'R-to-L' ) {
          var leftPortId = nodePorts[0].x < 0 ? nodePorts[0].id : nodePorts[1].id; // The x value of left port is supposed to be negative
          var rightPortId = nodePorts[0].x > 0 ? nodePorts[0].id : nodePorts[1].id; // The x value of right port is supposed to be positive
          /*
           * If the port ordering is left to right then the input port is the left port and the output port is the right port.
           * Else if it is right to left it is vice versa
           */
          nodeInputPortId = nodePortsOrdering === 'L-to-R' ? leftPortId : rightPortId;
          nodeOutputPortId = nodePortsOrdering === 'R-to-L' ? leftPortId : rightPortId;
        }
        else if ( nodePortsOrdering === 'T-to-B' || nodePortsOrdering === 'B-to-T' ){
          var topPortId = nodePorts[0].y < 0 ? nodePorts[0].id : nodePorts[1].id; // The y value of top port is supposed to be negative
          var bottomPortId = nodePorts[0].y > 0 ? nodePorts[0].id : nodePorts[1].id; // The y value of bottom port is supposed to be positive
          /*
           * If the port ordering is top to bottom then the input port is the top port and the output port is the bottom port.
           * Else if it is right to left it is vice versa
           */
          nodeInputPortId = nodePortsOrdering === 'T-to-B' ? topPortId : bottomPortId;
          nodeOutputPortId = nodePortsOrdering === 'B-to-T' ? topPortId : bottomPortId;
        }

        // Return an object containing the IO ports of the node
        return {
          inputPortId: nodeInputPortId,
          outputPortId: nodeOutputPortId
        };
      };

      // If at least one end of the edge has ports then we should determine the ports where the edge should be connected.
      if (sourceHasPorts || targetHasPorts) {
        var sourceNodeInputPortId, sourceNodeOutputPortId, targetNodeInputPortId, targetNodeOutputPortId;

        // If source node has ports set the variables dedicated for its IO ports
        if ( sourceHasPorts ) {
          var ioPorts = getIOPortIds(sourceNode);
          sourceNodeInputPortId = ioPorts.inputPortId;
          sourceNodeOutputPortId = ioPorts.outputPortId;
        }

        // If target node has ports set the variables dedicated for its IO ports
        if ( targetHasPorts ) {
          var ioPorts = getIOPortIds(targetNode);
          targetNodeInputPortId = ioPorts.inputPortId;
          targetNodeOutputPortId = ioPorts.outputPortId;
        }

        if (sbgnclass === 'consumption') {
          // A consumption edge should be connected to the input port of the target node which is supposed to be a process (any kind of)
          portsource = sourceNodeOutputPortId;
          porttarget = targetNodeInputPortId;
        }
        else if (sbgnclass === 'production') {
          // A production edge should be connected to the output port of the source node which is supposed to be a process (any kind of)
          // A modulation edge may have a logical operator as source node in this case the edge should be connected to the output port of it
          // The below assignment satisfy all of these condition
          if(groupID == 0 || groupID == undefined) { // groupID 0 for reversible reactions group 0
            portsource = sourceNodeOutputPortId;
            porttarget = targetNodeInputPortId;
          }
          else { //if reaction is reversible and edge belongs to group 1
            portsource = sourceNodeInputPortId;
          }
        }
        else if(elementUtilities.isModulationArcClass(sbgnclass) || elementUtilities.isAFArcClass(sbgnclass)){
          portsource = sourceNodeOutputPortId;
        }
        else if (sbgnclass === 'logic arc') {
          var srcClass = sourceNode.data('class');
          var tgtClass = targetNode.data('class');
          var isSourceLogicalOp = srcClass === 'and' || srcClass === 'or' || srcClass === 'not';
          var isTargetLogicalOp = tgtClass === 'and' || tgtClass === 'or' || tgtClass === 'not';

          if (isSourceLogicalOp && isTargetLogicalOp) {
            // If both end are logical operators then the edge should be connected to the input port of the target and the output port of the input
            porttarget = targetNodeInputPortId;
            portsource = sourceNodeOutputPortId;
          }// If just one end of logical operator then the edge should be connected to the input port of the logical operator
          else if (isSourceLogicalOp) {
            portsource = sourceNodeInputPortId;
            porttarget = targetNodeOutputPortId;
          }
          else if (isTargetLogicalOp) {
            portsource = sourceNodeOutputPortId;
            porttarget = targetNodeInputPortId;
          }
        }
      }

      // The default portsource/porttarget are the source/target themselves. If they are not set use these defaults.
      // The portsource and porttarget are determined set them in data object.
      data.portsource = portsource || source;
      data.porttarget = porttarget || target;

      var eles = cy.add({
        group: "edges",
        data: data,
        css: css
      });

      var newEdge = eles[eles.length - 1];

      return newEdge;
    };

    elementUtilities.addProcessWithConvenientEdges = function(_source, _target, nodeParams) {
      // If source and target IDs are given get the elements by IDs
      var source = typeof _source === 'string' ? cy.getElementById(_source) : _source;
      var target = typeof _target === 'string' ? cy.getElementById(_target) : _target;

      // Process parent should be the closest common ancestor of the source and target nodes
      var processParent = cy.collection([source[0], target[0]]).commonAncestors().first();

      // Process should be at the middle of the source and target nodes
      var x = ( source.position('x') + target.position('x') ) / 2;
      var y = ( source.position('y') + target.position('y') ) / 2;

      // Create the process with given/calculated variables
      var process = elementUtilities.addNode(x, y, nodeParams, undefined, processParent.id());
        var xdiff = source.position('x') - target.position('x');
        var ydiff = source.position('y') - target.position('y')
        if (Math.abs(xdiff) >= Math.abs(ydiff))
        {
            if (xdiff < 0)
                elementUtilities.setPortsOrdering(process, 'L-to-R');
            else
                elementUtilities.setPortsOrdering(process, 'R-to-L');
        }
        else
        {
            if (ydiff < 0)
                elementUtilities.setPortsOrdering(process, 'T-to-B');
            else
                elementUtilities.setPortsOrdering(process, 'B-to-T');
        }


      // Create the edges one is between the process and the source node (which should be a consumption),
      // the other one is between the process and the target node (which should be a production).
      // For more information please refer to SBGN-PD reference card.
      var edgeBtwSrc = elementUtilities.addEdge(source.id(), process.id(), {class : 'consumption', language : nodeParams.language});
      var edgeBtwTgt = elementUtilities.addEdge(process.id(), target.id(), {class : 'production', language : nodeParams.language});

      // Create a collection including the elements and to be returned
      var collection = cy.collection([process[0], edgeBtwSrc[0], edgeBtwTgt[0]]);
      return collection;
    };

    /*
     * This method assumes that param.nodesToMakeCompound contains at least one node
     * and all of the nodes including in it have the same parent. It creates a compound fot the given nodes an having the given type.
     */
    elementUtilities.createCompoundForGivenNodes = function (nodesToMakeCompound, compoundType) {
      var oldParentId = nodesToMakeCompound[0].data("parent");
      var language = nodesToMakeCompound[0].data("language");
      // if nodesToMakeCompound contain both PD and AF nodes, then set language of compound as Unknown
      for( var i=1; i<nodesToMakeCompound.length; i++){
        if(nodesToMakeCompound[i] != language){
          language = "Unknown";
          break;
        }
      }
      // The parent of new compound will be the old parent of the nodes to make compound. x, y and id parameters are not set.
      var newCompound = elementUtilities.addNode(undefined, undefined, {class : compoundType, language : language}, undefined, oldParentId);
      var newCompoundId = newCompound.id();
      var newEles = elementUtilities.changeParent(nodesToMakeCompound, newCompoundId);
      newEles = newEles.union(newCompound);
      return newEles;
    };

    /*
     * Creates a template reaction with given parameters. Requires cose-bilkent layout to tile the free macromolecules included
     * in the complex. Parameters are explained below.
     * templateType: The type of the template reaction. It may be 'association' or 'dissociation' for now.
     * nodeList: The list of the names and types of molecules which will involve in the reaction.
     * complexName: The name of the complex in the reaction.
     * processPosition: The modal position of the process in the reaction. The default value is the center of the canvas.
     * tilingPaddingVertical: This option will be passed to the cose-bilkent layout with the same name. The default value is 15.
     * tilingPaddingHorizontal: This option will be passed to the cose-bilkent layout with the same name. The default value is 15.
     * edgeLength: The distance between the process and the macromolecules at the both sides.
     */
    elementUtilities.createTemplateReaction = function (templateType, nodeList, complexName, processPosition, tilingPaddingVertical, tilingPaddingHorizontal, edgeLength, layoutParam) {

      var defaultMacromoleculProperties = elementUtilities.getDefaultProperties( "macromolecule" );
      var defaultSimpleChemicalProperties = elementUtilities.getDefaultProperties( "simple chemical" );
      var defaultProcessProperties = elementUtilities.getDefaultProperties( templateType );
      var processWidth = defaultProcessProperties.width || 50;
      var macromoleculeWidth = defaultMacromoleculProperties.width || 50;
      var macromoleculeHeight = defaultMacromoleculProperties.height || 50;
      var simpleChemicalWidth = defaultSimpleChemicalProperties.width || 35;
      var simpleChemicalHeight = defaultSimpleChemicalProperties.height || 35;
      var processPosition = processPosition || elementUtilities.convertToModelPosition({x: cy.width() / 2, y: cy.height() / 2});
      var nodeList = nodeList;
      var complexName = complexName;
      var numOfMolecules = nodeList.length;
      var tilingPaddingVertical = tilingPaddingVertical || 15;
      var tilingPaddingHorizontal = tilingPaddingHorizontal || 15;
      var edgeLength = edgeLength || 60;

      cy.startBatch();

      var xPositionOfFreeMacromolecules;
      var xPositionOfInputMacromolecules;
      if (!elementUtilities.getMapType()) {
        elementUtilities.setMapType("PD");
      }
      if (templateType === 'association') {
        xPositionOfFreeMacromolecules = processPosition.x - edgeLength - processWidth / 2 - macromoleculeWidth / 2;
       
      }
      else if(templateType === 'dissociation'){
        xPositionOfFreeMacromolecules = processPosition.x + edgeLength + processWidth / 2 + macromoleculeWidth / 2;
       
      }
      else{
        
        xPositionOfFreeMacromolecules = processPosition.x - edgeLength - processWidth / 2 - macromoleculeWidth / 2;
        xPositionOfInputMacromolecules = processPosition.x + edgeLength + processWidth / 2 + macromoleculeWidth / 2;
      }

      //Create the process in template type
      var process;
      if (templateType === 'reversible') {
        process = elementUtilities.addNode(processPosition.x, processPosition.y, {class : 'process', language : 'PD'});
        elementUtilities.setPortsOrdering(process, 'L-to-R');
      }
      else{
        process = elementUtilities.addNode(processPosition.x, processPosition.y, {class : templateType, language : 'PD'});
        elementUtilities.setPortsOrdering(process, 'L-to-R');
      }
      process.data('justAdded', true);

      //Define the starting y position
      var yPosition = processPosition.y - ((numOfMolecules - 1) / 2) * (macromoleculeHeight + tilingPaddingVertical);

      //Create the free molecules
      for (var i = 0; i < numOfMolecules; i++) {
        // node addition operation is determined by molecule type
        if(nodeList[i].type == "Simple Chemical"){
          var newNode = elementUtilities.addNode(xPositionOfFreeMacromolecules, yPosition, {class : 'simple chemical', language : 'PD'});
          //update the y position
          yPosition += simpleChemicalHeight + tilingPaddingVertical;
        }
        else{
          var newNode = elementUtilities.addNode(xPositionOfFreeMacromolecules, yPosition, {class : 'macromolecule', language : 'PD'});
          //update the y position
          yPosition += macromoleculeHeight + tilingPaddingVertical;
        }
        newNode.data('justAdded', true);
        newNode.data('label', nodeList[i].name);

        //create the edge connected to the new molecule
        var newEdge;
        if (templateType === 'association') {
          newEdge = elementUtilities.addEdge(newNode.id(), process.id(), {class : 'consumption', language : 'PD'});
        }
        else if(templateType === 'dissociation'){
          newEdge = elementUtilities.addEdge(process.id(), newNode.id(), {class : 'production', language : 'PD'});
        }
        else{
          //Group right or top elements in group id 1
          newEdge = elementUtilities.addEdge(process.id(), newNode.id(), {class : 'production', language : 'PD'}, undefined, undefined, 1);
        }

        newEdge.data('justAdded', true);
      }

      if(templateType === 'association' || templateType == 'dissociation'){
        //Create the complex including macromolecules inside of it
        //Temprorarily add it to the process position we will move it according to the last size of it
        var complex = elementUtilities.addNode(processPosition.x, processPosition.y, {class : 'complex', language : 'PD'});
        complex.data('justAdded', true);
        complex.data('justAddedLayoutNode', true);

        //If a name is specified for the complex set its label accordingly
        if (complexName) {
          complex.data('label', complexName);
        }

        //create the edge connnected to the complex
        var edgeOfComplex;

        if (templateType === 'association') {
          edgeOfComplex = elementUtilities.addEdge(process.id(), complex.id(), {class : 'production', language : 'PD'});
        }
        else {
          edgeOfComplex = elementUtilities.addEdge(complex.id(), process.id(), {class : 'consumption', language : 'PD'});
        }

        edgeOfComplex.data('justAdded', true);

        for (var i = 0; i < numOfMolecules; i++) {

          // Add a molecule(dependent on it's type) not having a previously defined id and having the complex created in this reaction as parent
          if(nodeList[i].type == 'Simple Chemical'){
            var newNode = elementUtilities.addNode(complex.position('x'), complex.position('y'), {class : 'simple chemical', language : 'PD'}, undefined, complex.id());
          }
          else{
            var newNode = elementUtilities.addNode(complex.position('x'), complex.position('y'), {class : 'macromolecule', language : 'PD'}, undefined, complex.id());
          }

          newNode.data('justAdded', true);
          newNode.data('label', nodeList[i].name);
          newNode.data('justAddedLayoutNode', true);
        }
      }
      else{

        //Create the input macromolecules
        var numOfInputMacromolecules = complexName.length;
        yPosition = processPosition.y - ((numOfInputMacromolecules - 1) / 2) * (macromoleculeHeight + tilingPaddingVertical);

        for (var i = 0; i < numOfInputMacromolecules; i++) {

          if(complexName[i].type == 'Simple Chemical'){
            var newNode = elementUtilities.addNode(xPositionOfInputMacromolecules, yPosition, {class : 'simple chemical', language : 'PD'});
            yPosition += simpleChemicalHeight + tilingPaddingVertical;
          }
          else{
            var newNode = elementUtilities.addNode(xPositionOfInputMacromolecules, yPosition, {class : 'macromolecule', language : 'PD'});
            yPosition += macromoleculeHeight + tilingPaddingVertical;
          }

          newNode.data('justAdded', true);
          newNode.data('label', complexName[i].name);

          //create the edge connected to the new macromolecule
          var newEdge;

          //Group the left or bottom elements in group id 0
          newEdge = elementUtilities.addEdge(process.id(), newNode.id(), {class : 'production', language : 'PD'}, undefined, undefined, 0);
          newEdge.data('justAdded', true);

        }
      }

      cy.endBatch();

      var layoutNodes = cy.nodes('[justAddedLayoutNode]');
      layoutNodes.removeData('justAddedLayoutNode');
      var layout = layoutNodes.layout({
        name: layoutParam.name,
        randomize: false,
        fit: false,
        animate: false,
        tilingPaddingVertical: tilingPaddingVertical,
        tilingPaddingHorizontal: tilingPaddingHorizontal,
        stop: function () {
          //If it is a reversible reaction no need to re-position complexes
          if(templateType === 'reversible')
            return;
          //re-position the nodes inside the complex
          var supposedXPosition;
          var supposedYPosition = processPosition.y;

          if (templateType === 'association') {
            supposedXPosition = processPosition.x + edgeLength + processWidth / 2 + complex.outerWidth() / 2;
          }
          else {
            supposedXPosition = processPosition.x - edgeLength - processWidth / 2 - complex.outerWidth() / 2;
          }

          var positionDiffX = (supposedXPosition - complex.position('x')) / 2;
          var positionDiffY = (supposedYPosition - complex.position('y')) / 2;
          elementUtilities.moveNodes({x: positionDiffX, y: positionDiffY}, complex);
        }
      });

      // Do this check for cytoscape.js backward compatibility
      if (layout && layout.run && templateType !== 'reversible') {
        layout.run();
      }

      //filter the just added elememts to return them and remove just added mark
      var eles = cy.elements('[justAdded]');
      eles.removeData('justAdded');

      cy.elements().unselect();
      eles.select();

      return eles; // Return the just added elements
    };

    /*
     * Move the nodes to a new parent and change their position if possDiff params are set.
     */
    elementUtilities.changeParent = function(nodes, newParent, posDiffX, posDiffY) {
      var newParentId = newParent == undefined || typeof newParent === 'string' ? newParent : newParent.id();
      var movedEles = nodes.move({"parent": newParentId});
      if(typeof posDiffX != 'undefined' || typeof posDiffY != 'undefined') {
        elementUtilities.moveNodes({x: posDiffX, y: posDiffY}, nodes);
      }
      elementUtilities.maintainPointer(movedEles);
      return movedEles;
    };

    elementUtilities.updateInfoboxStyle = function( node, index, newProps ) {
      var infoboxObj = node.data('statesandinfos')[index];
      $.extend( infoboxObj.style, newProps );
      cy.style().update();
    };

    elementUtilities.updateInfoboxObj = function( node, index, newProps ) {
      var infoboxObj = node.data('statesandinfos')[index];
      $.extend( infoboxObj, newProps );
    };

    // Resize given nodes if useAspectRatio is truthy one of width or height should not be set.
    elementUtilities.resizeNodes = function (nodes, width, height, useAspectRatio, preserveRelativePos) {
      for (var i = 0; i < nodes.length; i++) {

        var node = nodes[i];
        var ratio = undefined;
        var eleMustBeSquare = elementUtilities.mustBeSquare(node.data('class'));

        if (preserveRelativePos === true) {
          var oldWidth = node.data("bbox").w;
          var oldHeight = node.data("bbox").h;
        }

        // Note that both width and height should not be set if useAspectRatio is truthy
        if(!node.isParent()){
          if (width) {
            if (useAspectRatio || eleMustBeSquare) {
              ratio = width / node.width();
            }
  
            node.data("bbox").w = width;
          }
  
          if (height) {
            if (useAspectRatio || eleMustBeSquare) {
              ratio = height / node.height();
            }
  
            node.data("bbox").h = height;
          }
  
          if (ratio && !height) {
            node.data("bbox").h = node.height() * ratio;
          }
          else if (ratio && !width) {
            node.data("bbox").w = node.width() * ratio;
          }
        }else{
          node.data("minHeight" , ""+ height);
          node.data("minWidth" , ""+ width);
          node.data("minWidthBiasLeft", "50%");
          node.data("minWidthBiasRight", "50%");
          node.data("minHeightBiasTop", "50%" );
          node.data("minHeightBiasBottom", "50%");
        }
        

     /*    if (preserveRelativePos === true) {
          var statesandinfos = node.data('statesandinfos');
          var topBottom = statesandinfos.filter(box => (box.anchorSide === "top" || box.anchorSide === "bottom"));
          var rightLeft = statesandinfos.filter(box => (box.anchorSide === "right" || box.anchorSide === "left"));

          topBottom.forEach(function(box){
            if (box.bbox.x < 0) {
              box.bbox.x = 0;
            }
            else if (box.bbox.x > oldWidth) {
              box.bbox.x = oldWidth;
            }
            box.bbox.x = node.data("bbox").w * box.bbox.x / oldWidth;
          });

          rightLeft.forEach(function(box){
            if (box.bbox.y < 0) {
              box.bbox.y = 0;
            }
            else if (box.bbox.y > oldHeight) {
              box.bbox.y = oldHeight;
            }
            box.bbox.y = node.data("bbox").h * box.bbox.y / oldHeight;
          });
        } */
      }
    };

    elementUtilities.calculateMinWidth = function(node) {

        var defaultWidth = this.getDefaultProperties(node.data('class')).width;

        // Label width calculation
        var style = node.style();

        var fontFamiliy = style['font-family'];
        var fontSize = style['font-size'];
        var labelText = style['label'];

        var labelWidth = elementUtilities.getWidthByContent( labelText, fontFamiliy, fontSize );

        var statesandinfos = node.data('statesandinfos');
        //Top and bottom infoBoxes
        //var topInfoBoxes = statesandinfos.filter(box => (box.anchorSide === "top" || ((box.anchorSide === "right" || box.anchorSide === "left") && (box.bbox.y <= 12))));
        //var bottomInfoBoxes = statesandinfos.filter(box => (box.anchorSide === "bottom" || ((box.anchorSide === "right" || box.anchorSide === "left") && (box.bbox.y >= node.data('bbox').h - 12))));
        var unitGap = 5;
        var topIdealWidth = unitGap;
        var bottomIdealWidth = unitGap;        
        var rightMaxWidth = 0;
        var leftMaxWidth =0;
        statesandinfos.forEach(function(box){
          if(box.anchorSide === "top"){
            topIdealWidth += box.bbox.w + unitGap;

          }else if(box.anchorSide === "bottom"){
            bottomIdealWidth += box.bbox.w + unitGap;

          }else if(box.anchorSide === "right")
          {           
            rightMaxWidth = (box.bbox.w > rightMaxWidth) ? box.bbox.w : rightMaxWidth;
          }else{
            
            leftMaxWidth = (box.bbox.w > leftMaxWidth) ? box.bbox.w : leftMaxWidth;
          }
        });      

        var middleWidth = labelWidth + 2 * Math.max(rightMaxWidth/2, leftMaxWidth/2);

        var compoundWidth = 0;
        if(node.isParent()){
          compoundWidth = node.children().boundingBox().w;
        }
        return Math.max(middleWidth, defaultWidth/2, topIdealWidth, bottomIdealWidth, compoundWidth);
    }

    elementUtilities.calculateMinHeight = function(node) {
        var statesandinfos = node.data('statesandinfos');
        var margin = 7;
        var unitGap = 5;
        var defaultHeight = this.getDefaultProperties(node.data('class')).height;
        var leftInfoBoxes = statesandinfos.filter(box => box.anchorSide === "left");        
        var leftHeight = unitGap; 
        leftInfoBoxes.forEach(function(box){
            leftHeight += box.bbox.h + unitGap;
           
        });      
        var rightInfoBoxes = statesandinfos.filter(box => box.anchorSide === "right");
        var rightHeight = unitGap;        
        rightInfoBoxes.forEach(function(box){
            rightHeight += box.bbox.h + unitGap;           
        });       
        var style = node.style();
        var labelText = ((style['label']).split("\n")).filter( text => text !== '');
        var fontSize = parseFloat(style['font-size'].substring(0, style['font-size'].length - 2));
        var totalHeight = labelText.length * fontSize + 2 * margin;

        

        var compoundHeight = 0;
        if(node.isParent()){
          compoundHeight = node.children().boundingBox().h;
        }
        return Math.max(totalHeight, defaultHeight/2, leftHeight, rightHeight, compoundHeight);
    }

    elementUtilities.isResizedToContent = function (node) {
      if(!node || !node.isNode() || !node.data('bbox')){
        return false;
      }

      //var w = node.data('bbox').w;
      //var h = node.data('bbox').h;
      var w = node.width();
      var h = node.height();

      var minW = elementUtilities.calculateMinWidth(node);
      var minH = elementUtilities.calculateMinHeight(node);

      if(w === minW && h === minH)
        return true;
      else
        return false;
    }

    // Section End
    // Add remove utilities

    // Relocates state and info boxes. This function is expected to be called after add/remove state and info boxes
    elementUtilities.relocateStateAndInfos = function (ele) {
      var stateAndInfos = (ele.isNode && ele.isNode()) ? ele.data('statesandinfos') : ele;
      var length = stateAndInfos.length;
      if (length == 0) {
        return;
      }
      else if (length == 1) {
        stateAndInfos[0].bbox.x = 0;
        stateAndInfos[0].bbox.y = -50;
      }
      else if (length == 2) {
        stateAndInfos[0].bbox.x = 0;
        stateAndInfos[0].bbox.y = -50;

        stateAndInfos[1].bbox.x = 0;
        stateAndInfos[1].bbox.y = 50;
      }
      else if (length == 3) {
        stateAndInfos[0].bbox.x = -25;
        stateAndInfos[0].bbox.y = -50;

        stateAndInfos[1].bbox.x = 25;
        stateAndInfos[1].bbox.y = -50;

        stateAndInfos[2].bbox.x = 0;
        stateAndInfos[2].bbox.y = 50;
      }
      else {
        stateAndInfos[0].bbox.x = -25;
        stateAndInfos[0].bbox.y = -50;

        stateAndInfos[1].bbox.x = 25;
        stateAndInfos[1].bbox.y = -50;

        stateAndInfos[2].bbox.x = -25;
        stateAndInfos[2].bbox.y = 50;

        stateAndInfos[3].bbox.x = 25;
        stateAndInfos[3].bbox.y = 50;
      }
    };

    // Change state value or unit of information box of given nodes with given index.
    // Type parameter indicates whether to change value or variable, it is valid if the box at the given index is a state variable.
    // Value parameter is the new value to set.
    // This method returns the old value of the changed data (We assume that the old value of the changed data was the same for all nodes).
    // Each character assumed to occupy 8 unit
    // Each infobox can have at most 32 units of width
    elementUtilities.changeStateOrInfoBox = function (nodes, index, value, type) {
      var result;
      for (var i = 0; i < nodes.length; i++) {
        var node = nodes[i];
        var sbgnclass = node.data('class');
        var stateAndInfos = node.data('statesandinfos');
        var box = stateAndInfos[index];
        var oldLength = box.bbox.w;
        var newLength = 0;

        var content = '';
        if (box.clazz == "state variable") {
          if (!result) {
            result = box.state[type];
          }

          box.state[type] = value;
          if (box.state["value"] !== undefined) {
            content += box.state["value"];
          }
          if (box.state["variable"] !== undefined && box.state["variable"].length > 0) {
            content += box.state["variable"] + "@";
          }

        }
        else if (box.clazz == "unit of information") {
          if (!result) {
            result = box.label.text;
          }
          content += value;
          box.label.text = value;
        }

        var min = ( sbgnclass === 'SIF macromolecule' || sbgnclass === 'SIF simple chemical' ) ? 15 : 12;
        var fontFamily = box.style[ 'font-family' ];
        var fontSize = box.style[ 'font-size' ];
        var borderWidth = box.style[ 'border-width' ];
        var opts = {
          min,
          max: 48,
          margin: borderWidth / 2 + 0.5
        };
        var previousWidth = box.bbox.w;
        box.bbox.w = elementUtilities.getWidthByContent( content, fontFamily, fontSize, opts );

        if(box.anchorSide == "top" || box.anchorSide == "bottom"){
          var unitLayout = node.data()["auxunitlayouts"][box.anchorSide];
          if(unitLayout.units[unitLayout.units.length-1].id == box.id){
             
            var borderWidth = node.data()['border-width'];
            var shiftAmount = (((box.bbox.w - previousWidth) / 2) * 100 )/ (node.outerWidth() - borderWidth);
           
            if(shiftAmount >= 0){
            
              if(box.bbox.x + shiftAmount <= 100){
                box.bbox.x = box.bbox.x + shiftAmount;
              }
            }
           /*  else{
              var previousInfoBbox = {x : 0, w:0};
              if(unitLayout.units.length > 1){
                previousInfoBbox= unitLayout.units[unitLayout.units.length-2].bbox;      
              }

              
              
              sbgnvizInstance.classes.AuxUnitLayout.setIdealGap(node, box.anchorSide);
              var idealGap = sbgnvizInstance.classes.AuxUnitLayout.getCurrentGap(box.anchorSide);
              var newPosition = previousInfoBbox.x + (previousInfoBbox.w/2 + idealGap + box.bbox.w/2)*100 / (node.outerWidth() - borderWidth);
              box.bbox.x = newPosition;
              
            } */
           
           
          }
        }
        
        
        /* if (box.anchorSide === "top" || box.anchorSide === "bottom") {
          box.bbox.x += (box.bbox.w - oldLength) / 2;
          var units = (node.data('auxunitlayouts')[box.anchorSide]).units;
          var shiftIndex = 0;
          for (var i = 0; i < units.length; i++) {
            if(units[i] === box){
              shiftIndex = i;
              break;
            }
          }
          for (var j = shiftIndex+1; j < units.length; j++) {
              units[j].bbox.x += (box.bbox.w - oldLength);
          }
        } */

      }

      //TODO find a way to elimate this redundancy to update info-box positions
      node.data('border-width', node.data('border-width'));

      return result;
    };

    // Add a new state or info box to given nodes.
    // The box is represented by the parameter obj.
    // This method returns the index of the just added box.
    elementUtilities.addStateOrInfoBox = function (nodes, obj) {
      for (var i = 0; i < nodes.length; i++) {
        var node = nodes[i];
        var locationObj;

        var defaultProps = elementUtilities.getDefaultProperties( node.data('class') );
        var infoboxProps = defaultProps[ obj.clazz ];
        var bbox = obj.bbox || { w: infoboxProps.width, h: infoboxProps.height };        
        var style = elementUtilities.getDefaultInfoboxStyle( node.data('class'), obj.clazz );
        if(obj.style){
          $.extend( style, obj.style );
        }
       
        if(obj.clazz == "unit of information") {
          locationObj = sbgnvizInstance.classes.UnitOfInformation.create(node, cy, obj.label.text, bbox, obj.location, obj.position, style, obj.index, obj.id);
        }
        else if (obj.clazz == "state variable") {
          locationObj = sbgnvizInstance.classes.StateVariable.create(node, cy, obj.state.value, obj.state.variable, bbox, obj.location, obj.position, style, obj.index, obj.id);
        }
      }
      return locationObj;
    };

    // Remove the state or info boxes of the given nodes at given index.
    // Returns the removed box.
    elementUtilities.removeStateOrInfoBox = function (nodes, locationObj) {
      var obj;
      for (var i = 0; i < nodes.length; i++) {
        var node = nodes[i];
        var stateAndInfos = node.data('statesandinfos');
        var unit = stateAndInfos[locationObj.index];

        var unitClass = sbgnvizInstance.classes.getAuxUnitClass(unit);

        obj = unitClass.remove(unit, cy);
      }

      return obj;
    };


    //Tiles informations boxes for given anchorSides
    elementUtilities.fitUnits = function (node, locations) {
      var obj = [];
      node.data('statesandinfos').forEach( function (ele) {
        obj.push({
          x: ele.bbox.x,
          y: ele.bbox.y,
          anchorSide: ele.anchorSide
        });
      });
      sbgnvizInstance.classes.AuxUnitLayout.fitUnits(node, cy, locations);
      return obj;
    };

    //Check which anchorsides fits
    elementUtilities.checkFit = function (node, location) { //if no location given, it checks all possible locations
      return sbgnvizInstance.classes.AuxUnitLayout.checkFit(node, cy, location);
    };

    //Modify array of aux layout units
    elementUtilities.modifyUnits = function (node, unit, anchorSide) {
      sbgnvizInstance.classes.AuxUnitLayout.modifyUnits(node, unit, anchorSide, cy);
    };

    // Set multimer status of the given nodes to the given status.
    elementUtilities.setMultimerStatus = function (nodes, status) {
      for (var i = 0; i < nodes.length; i++) {
        var node = nodes[i];
        var sbgnclass = node.data('class');
        var isMultimer = node.data('class').endsWith(' multimer');

        if (status) { // Make multimer status true
          if (!isMultimer) {
            node.data('class', sbgnclass + ' multimer');
          }
        }
        else { // Make multimer status false
          if (isMultimer) {
            node.data('class', sbgnclass.replace(' multimer', ''));
          }
        }
      }
    };

    // Change font properties of the given elements with given font data
    elementUtilities.changeFontProperties = function (eles, data) {
      for (var prop in data) {
        eles.data(prop, data[prop]);
      }
    };

    // This function gets an edge, and ends of that edge (Optionally it may take just the classes of the edge as well) as parameters.
    // It may return 'valid' (that ends is valid for that edge), 'reverse' (that ends is not valid for that edge but they would be valid
    // if you reverse the source and target), 'invalid' (that ends are totally invalid for that edge).
    elementUtilities.validateArrowEnds = function (edge, source, target) {
      // if map type is Unknown -- no rules applied
      if (elementUtilities.getMapType() == "HybridAny" || elementUtilities.getMapType() == "HybridSbgn" || !elementUtilities.getMapType())
        return "valid";

      var edgeclass = typeof edge === 'string' ? edge : edge.data('class');
      var sourceclass = source.data('class');
      var targetclass = target.data('class');
      var mapType = elementUtilities.getMapType();
      var edgeConstraints = elementUtilities[mapType].connectivityConstraints[edgeclass];

      if (mapType == "AF"){
        if (sourceclass.startsWith("BA")) // we have separate classes for each biological activity
          sourceclass = "biological activity"; // but same rule applies to all of them

        if (targetclass.startsWith("BA")) // we have separate classes for each biological activity
          targetclass = "biological activity"; // but same rule applies to all of them
      }
      else if (mapType == "PD"){
        sourceclass = sourceclass.replace(/\s*multimer$/, '');
        targetclass = targetclass.replace(/\s*multimer$/, '');
      }

      // given a node, acting as source or target, returns boolean wether or not it has too many edges already
      function hasTooManyEdges(node, sourceOrTarget) {
        var nodeclass = node.data('class');
        nodeclass = nodeclass.replace(/\s*multimer$/, '');
        if (nodeclass.startsWith("BA"))
          nodeclass = "biological activity";

        var totalTooMany = true;
        var edgeTooMany = true;
        if (sourceOrTarget == "source") {
            var sameEdgeCountOut = node.outgoers('edge[class="'+edgeclass+'"]').size();
            var totalEdgeCountOut = node.outgoers('edge').size();
            // check that the total edge count is within the limits
            if (typeof edgeConstraints[nodeclass].asSource.maxTotal == 'undefined'
                || totalEdgeCountOut < edgeConstraints[nodeclass].asSource.maxTotal ) {
                totalTooMany = false;
            }
            // then check limits for this specific edge class
            if (typeof edgeConstraints[nodeclass].asSource.maxEdge == 'undefined'
                || sameEdgeCountOut < edgeConstraints[nodeclass].asSource.maxEdge ) {
                edgeTooMany = false;
            }
            // if only one of the limits is reached then edge is invalid
            return totalTooMany || edgeTooMany;
        }
        else { // node is used as target
            var sameEdgeCountIn = node.incomers('edge[class="'+edgeclass+'"]').size();
            var totalEdgeCountIn = node.incomers('edge').size();
            if (typeof edgeConstraints[nodeclass].asTarget.maxTotal == 'undefined'
                || totalEdgeCountIn < edgeConstraints[nodeclass].asTarget.maxTotal ) {
                totalTooMany = false;
            }
            if (typeof edgeConstraints[nodeclass].asTarget.maxEdge == 'undefined'
                || sameEdgeCountIn < edgeConstraints[nodeclass].asTarget.maxEdge ) {
                edgeTooMany = false;
            }
            return totalTooMany || edgeTooMany;
        }
        return false;
      }

      function isInComplex(node) {
        var parentClass = node.parent().data('class');
        return parentClass && parentClass.startsWith('complex');
      }

      if (isInComplex(source) || isInComplex(target)) { // subunits of a complex are no longer EPNs, no connection allowed
        return 'invalid';
      }

      // check nature of connection
      if (edgeConstraints[sourceclass].asSource.isAllowed && edgeConstraints[targetclass].asTarget.isAllowed) {
        // check amount of connections
        if (!hasTooManyEdges(source, "source") && !hasTooManyEdges(target, "target") ) {
          return 'valid';
        }
      }
      // try to reverse
      if (edgeConstraints[targetclass].asSource.isAllowed && edgeConstraints[sourceclass].asTarget.isAllowed) {
        if (!hasTooManyEdges(target, "source") && !hasTooManyEdges(source, "target") ) {
          return 'reverse';
        }
      }
      return 'invalid';
    };

    /*
     * Hide given eles and perform given layout afterward. Layout parameter may be layout options
     * or a function to call.
     */
    elementUtilities.hideAndPerformLayout = function(eles, layoutparam) {
        var result = cy.viewUtilities().hide(eles); // Hide given eles
        if (typeof layoutparam === 'function') {
            layoutparam(); // If layoutparam is a function execute it
        }
        else {
            var layout = cy.layout(layoutparam); // If layoutparam is layout options call layout with that options.

            // Do this check for cytoscape.js backward compatibility
            if (layout && layout.run) {
                layout.run();
            }
        }

        return result;
    };

    /*
     * Unhide given eles and perform given layout afterward. Layout parameter may be layout options
     * or a function to call.
     */
    elementUtilities.showAndPerformLayout = function(eles, layoutparam) {
      var result = cy.viewUtilities().show(eles); // Show given eles
      if (typeof layoutparam === 'function') {
        layoutparam(); // If layoutparam is a function execute it
      }
      else {
        var layout = cy.layout(layoutparam); // If layoutparam is layout options call layout with that options.

        // Do this check for cytoscape.js backward compatibility
        if (layout && layout.run) {
          layout.run();
        }
      }

      return result;
    };

    /*
     * Change style/css of given eles by setting getting property name to the given value/values (Note that valueMap parameter may be
     * a single string or an id to value map).
     */
    elementUtilities.changeCss = function(eles, name, valueMap) {
      if ( typeof valueMap === 'object' ) {
        cy.startBatch();
        for (var i = 0; i < eles.length; i++) {
          var ele = cy.getElementById(eles[i].id());
          ele.css(name, valueMap[ele.id()]); // valueMap is an id to value map use it in this way
        }
        cy.endBatch();
      }
      else {
        eles.css(name, valueMap); // valueMap is just a string set css('name') for all eles to this value
      }
    };

    /*
     * Change data of given eles by setting getting property name to the given value/values (Note that valueMap parameter may be
     * a single string or an id to value map).
     */
    elementUtilities.changeData = function(eles, name, valueMap) {
      if ( typeof valueMap === 'object' ) {
        cy.startBatch();
        for (var i = 0; i < eles.length; i++) {
          var ele = cy.getElementById(eles[i].id());
          ele.data(name, valueMap[ele.id()]); // valueMap is an id to value map use it in this way
        }
        cy.endBatch();
      }
      else {
        eles.data(name, valueMap); // valueMap is just a string set css('name') for all eles to this value
      }
    };

    elementUtilities.updateSetField = function(ele, fieldName, toDelete, toAdd, callback) {
      var set = ele.data( fieldName );
      if ( !set ) {
        return;
      }
      var updates = {};

      if ( toDelete != null && set[ toDelete ] ) {
        delete set[ toDelete ];
        updates.deleted = toDelete;
      }

      if ( toAdd != null ) {
        set[ toAdd ] = true;
        updates.added = toAdd;
      }

      if ( callback && ( updates[ 'deleted' ] != null || updates[ 'added' ] != null ) ) {
        callback();
      }

      return updates;
    };

    /*
     * Return the set of all nodes present under the given position
     * renderedPos must be a point defined relatively to cytoscape container
     * (like renderedPosition field of a node)
     */
    elementUtilities.getNodesAt = function(renderedPos) {
      var nodes = cy.nodes();
      var x = renderedPos.x;
      var y = renderedPos.y;
      var resultNodes = [];
      for(var i = 0; i < nodes.length; i++) {
        var node = nodes[i];
        var renderedBbox = node.renderedBoundingBox({
          includeNodes: true,
          includeEdges: false,
          includeLabels: false,
          includeShadows: false
        });
        if (x >= renderedBbox.x1 && x <= renderedBbox.x2) {
          if (y >= renderedBbox.y1 && y <= renderedBbox.y2) {
            resultNodes.push(node);
          }
        }
      }
      return resultNodes;
    };

    elementUtilities.demultimerizeClass = function(sbgnclass) {
      return sbgnclass.replace(" multimer", "");
    };

    /**
     * @param mapType - type of the current map (PD, AF or Unknown)
     */
    elementUtilities.setMapType = function(mapType){
      elementUtilities.mapType = mapType;
      return mapType;
    }

    /**
     * return - map type
     */
    elementUtilities.getMapType = function(){
        return elementUtilities.mapType;
    }
    /**
     * Resets map type
     */
    elementUtilities.resetMapType = function(){
        elementUtilities.mapType = undefined;
    }

    /**
     * Keep consistency of links to self inside the data() structure.
     * This is needed whenever a node changes parents, for example,
     * as it is destroyed and recreated. But the data() stays identical.
     * This creates inconsistencies for the pointers stored in data(),
     * as they now point to a deleted node.
     */
    elementUtilities.maintainPointer = function (eles) {
      eles.nodes().forEach(function(ele){
        // restore background images
        ele.emit('data');

        // skip nodes without any auxiliary units
        if(!ele.data('statesandinfos') || ele.data('statesandinfos').length == 0) {
          return;
        }
        for(var side in ele.data('auxunitlayouts')) {
          ele.data('auxunitlayouts')[side].parentNode = ele.id();
        }
        for(var i=0; i < ele.data('statesandinfos').length; i++) {
          ele.data('statesandinfos')[i].parent = ele.id();
        }
      });
    }

    elementUtilities.anyHasBackgroundImage = function (eles) {
      var obj = elementUtilities.getBackgroundImageObjs(eles);
      if(obj === undefined)
        return false;
      else{
        for(var key in obj){
          var value = obj[key];
          if(value && !$.isEmptyObject(value))
            return true;
        }
        return false;
      }
    }

    elementUtilities.hasBackgroundImage = function (ele) {
      if(ele.isNode()){
        var bg = ele.data('background-image') ? ele.data('background-image') : "";
        var cloneImg = 'data:image/svg+xml;utf8,%3Csvg%20width%3D%22100%22%20height%3D%22100%22%20viewBox%3D%220%200%20100%20100%22%20style%3D%22fill%3Anone%3Bstroke%3Ablack%3Bstroke-width%3A0%3B%22%20xmlns%3D%22http%3A//www.w3.org/2000/svg%22%20%3E%3Crect%20x%3D%220%22%20y%3D%220%22%20width%3D%22100%22%20height%3D%22100%22%20style%3D%22fill%3A%23a9a9a9%22/%3E%20%3C/svg%3E';
        if(bg !== "" && !(bg.indexOf(cloneImg) > -1 && bg === cloneImg))
          return true;

      }
      return false;
    }

    elementUtilities.getBackgroundImageURL = function (eles) {
      if(!eles || eles.length < 1)
        return;

      var commonURL = "";
      for(var i = 0; i < eles.length; i++){
        var ele = eles[i];

        if(!ele.isNode() || !elementUtilities.hasBackgroundImage(ele))
          return;

        var url = ele.data('background-image').split(" ").pop();
        if(!url || url.indexOf('http') !== 0 || (commonURL !== "" && commonURL !== url))
          return;
        else if(commonURL === "")
          commonURL = url;
      }

      return commonURL;
    }

    elementUtilities.getBackgroundImageObjs = function (eles) {
      if(!eles || eles.length < 1)
        return;

      var list = {};
      for(var i = 0; i < eles.length; i++){
        var ele = eles[i];
        var obj = getBgObj(ele);
        if(obj === undefined)
          return;

        list[ele.data('id')] = obj;
      }
      return list;

      function getBgObj (ele) {
        if(ele.isNode() && elementUtilities.hasBackgroundImage(ele)){
          var keys = ['background-image', 'background-fit', 'background-image-opacity',
          'background-position-x', 'background-position-y', 'background-height', 'background-width'];

          var obj = {};
          keys.forEach(function(key){
            var arr = ele.data(key);
            obj[key] = arr ? arr : "";
          });

          return obj;
        }
        else if(ele.isNode())
          return {};
      }
    }

    elementUtilities.getBackgroundFitOptions = function (eles) {
      if(!eles || eles.length < 1)
        return;

      var commonFit = "";
      for(var i = 0; i < eles.length; i++){
        var node = eles[i];
        if(!node.isNode())
          return;

        var fit = getFitOption(node);
        if(!fit || (commonFit !== "" && fit !== commonFit))
          return;
        else if(commonFit === "")
          commonFit = fit;
      }

      var options = '<option value="none">None</option>'
                  + '<option value="fit">Fit</option>'
                  + '<option value="cover">Cover</option>'
                  + '<option value="contain">Contain</option>';
      var searchKey = 'value="' + commonFit + '"';
      var index = options.indexOf(searchKey) + searchKey.length;
      return options.substr(0, index) + ' selected' + options.substr(index);

      function getFitOption(node) {
        if(!elementUtilities.hasBackgroundImage(node))
          return;

        var f = node.data('background-fit');
        var h = node.data('background-height');

        if(!f || !h)
          return;

        f = f.split(" ");
        h = h.split(" ");
        if(f[f.length-1] === "none")
          return (h[h.length-1] === "auto" ? "none" : "fit");
        else
          return f[f.length-1];
      }
    }

    elementUtilities.updateBackgroundImage = function (nodes, bgObj) {
      if(!nodes || nodes.length == 0 || !bgObj)
        return;

      for(var i = 0; i < nodes.length; i++){
        var node = nodes[i];
        var obj = bgObj[node.data('id')];
        if(!obj || $.isEmptyObject(obj))
          continue;

        var imgs = node.data('background-image') ? node.data('background-image').split(" ") : [];
        var xPos = node.data('background-position-x') ? node.data('background-position-x').split(" ") : [];
        var yPos = node.data('background-position-y') ? node.data('background-position-y').split(" ") : [];
        var widths = node.data('background-width') ? node.data('background-width').split(" ") : [];
        var heights = node.data('background-height') ? node.data('background-height').split(" ") : [];
        var fits = node.data('background-fit') ? node.data('background-fit').split(" ") : [];
        var opacities = node.data('background-image-opacity') ? ("" + node.data('background-image-opacity')).split(" ") : [];

        var index = -1;
        if(typeof obj['background-image'] === "string")
          index = imgs.indexOf(obj['background-image']);
        else if(Array.isArray(obj['background-image']))
          index = imgs.indexOf(obj['background-image'][0]);

        if(index < 0)
          continue;

        if(obj['background-image'] && imgs.length > index){
          var tmp = imgs[index];
          imgs[index] = obj['background-image'];
          obj['background-image'] = tmp;
        }
        if(obj['background-fit'] && fits.length > index){
          var tmp = fits[index];
          fits[index] = obj['background-fit'];
          obj['background-fit'] = tmp;
        }
        if(obj['background-width'] && widths.length > index){
          var tmp = widths[index];
          widths[index] = obj['background-width'];
          obj['background-width'] = tmp;
        }
        if(obj['background-height'] && heights.length > index){
          var tmp = heights[index];
          heights[index] = obj['background-height'];
          obj['background-height'] = tmp;
        }
        if(obj['background-position-x'] && xPos.length > index){
          var tmp = xPos[index];
          xPos[index] = obj['background-position-x'];
          obj['background-position-x'] = tmp;
        }
        if(obj['background-position-y'] && yPos.length > index){
          var tmp = yPos[index];
          yPos[index] = obj['background-position-y'];
          obj['background-position-y'] = tmp;
        }
        if(obj['background-image-opacity'] && opacities.length > index){
          var tmp = opacities[index];
          opacities[index] = obj['background-image-opacity'];
          obj['background-image-opacity'] = tmp;
        }

        node.data('background-image', imgs.join(" "));
        node.data('background-position-x', xPos.join(" "));
        node.data('background-position-y', yPos.join(" "));
        node.data('background-width', widths.join(" "));
        node.data('background-height', heights.join(" "));
        node.data('background-fit', fits.join(" "));
        node.data('background-image-opacity', opacities.join(" "));
      }

      return bgObj;
    }

    elementUtilities.changeBackgroundImage = function (nodes, oldImg, newImg, firstTime, updateInfo, promptInvalidImage, validateURL) {
      if(!nodes || nodes.length == 0 || !oldImg || !newImg)
        return;

      elementUtilities.removeBackgroundImage(nodes, oldImg);
      for(var key in newImg){
        newImg[key]['firstTime'] = firstTime;
      }
      elementUtilities.addBackgroundImage(nodes, newImg, updateInfo, promptInvalidImage, validateURL);

      return {
        nodes: nodes,
        oldImg: newImg,
        newImg: oldImg,
        firstTime: false,
        promptInvalidImage: promptInvalidImage,
        validateURL: validateURL
      };
    }

    // Add a background image to given nodes.
    elementUtilities.addBackgroundImage = function (nodes, bgObj, updateInfo, promptInvalidImage, validateURL) {
      if(!nodes || nodes.length == 0 || !bgObj)
        return;

      for(var i = 0; i < nodes.length; i++){
        var node = nodes[i];
        var obj = bgObj[node.data('id')];
        if(!obj || $.isEmptyObject(obj))
          continue;

        // Load the image from local, else just put the URL
        if(obj['fromFile'])
        loadBackgroundThenApply(node, obj);
        // Validity of given URL should be checked before applying it
        else if(obj['firstTime']){
          if(typeof validateURL === 'function')
            validateURL(node, obj, applyBackground, promptInvalidImage);
          else
            checkGivenURL(node, obj);
        }
        else
          applyBackground(node, obj);
      }

      function loadBackgroundThenApply(node, bgObj) {
        var reader = new FileReader();
        var imgFile = bgObj['background-image'];

        // Check whether given file is an image file
        if(imgFile.type.indexOf("image") !== 0){
          if(promptInvalidImage)
            promptInvalidImage("Invalid image file is given!");
          return;
        }

        reader.readAsDataURL(imgFile);

        reader.onload = function (e) {
          var img = reader.result;
          if(img){
            bgObj['background-image'] = img;
            bgObj['fromFile'] = false;
            applyBackground(node, bgObj);
          }
          else{
            if(promptInvalidImage)
              promptInvalidImage("Given file could not be read!");
          }
        };
      }

      function checkGivenURL(node, bgObj){
        var url = bgObj['background-image'];
        var extension = (url.split(/[?#]/)[0]).split(".").pop();
        var validExtensions = ["png", "svg", "jpg", "jpeg"];

        if(!validExtensions.includes(extension)){
          if(typeof promptInvalidImage === 'function')
            promptInvalidImage("Invalid URL is given!");
          return;
        }

        $.ajax({
          url: url,
          type: 'GET',
          success: function(result, status, xhr){
            applyBackground(node, bgObj);
          },
          error: function(xhr, status, error){
            if(promptInvalidImage)
              promptInvalidImage("Invalid URL is given!");
          },
        });
      }

      function applyBackground(node, bgObj) {

        if(elementUtilities.hasBackgroundImage(node))
          return;

        var imgs = node.data('background-image') ? node.data('background-image').split(" ") : [];
        var xPos = node.data('background-position-x') ? node.data('background-position-x').split(" ") : [];
        var yPos = node.data('background-position-y') ? node.data('background-position-y').split(" ") : [];
        var widths = node.data('background-width') ? node.data('background-width').split(" ") : [];
        var heights = node.data('background-height') ? node.data('background-height').split(" ") : [];
        var fits = node.data('background-fit') ? node.data('background-fit').split(" ") : [];
        var opacities = node.data('background-image-opacity') ? ("" + node.data('background-image-opacity')).split(" ") : [];

        var indexToInsert = imgs.length;

        // insert to length-1
        if(hasCloneMarker(node, imgs)){
          indexToInsert--;
        }

        imgs.splice(indexToInsert, 0, bgObj['background-image']);
        fits.splice(indexToInsert, 0, bgObj['background-fit']);
        opacities.splice(indexToInsert, 0, bgObj['background-image-opacity']);
        xPos.splice(indexToInsert, 0, bgObj['background-position-x']);
        yPos.splice(indexToInsert, 0, bgObj['background-position-y']);
        widths.splice(indexToInsert, 0, bgObj['background-width']);
        heights.splice(indexToInsert, 0, bgObj['background-height']);

        node.data('background-image', imgs.join(" "));
        node.data('background-position-x', xPos.join(" "));
        node.data('background-position-y', yPos.join(" "));
        node.data('background-width', widths.join(" "));
        node.data('background-height', heights.join(" "));
        node.data('background-fit', fits.join(" "));
        node.data('background-image-opacity', opacities.join(" "));
        bgObj['firstTime'] = false;

        if(updateInfo)
          updateInfo();

      }

      function hasCloneMarker(node, imgs){
        var cloneImg = 'data:image/svg+xml;utf8,%3Csvg%20width%3D%22100%22%20height%3D%22100%22%20viewBox%3D%220%200%20100%20100%22%20style%3D%22fill%3Anone%3Bstroke%3Ablack%3Bstroke-width%3A0%3B%22%20xmlns%3D%22http%3A//www.w3.org/2000/svg%22%20%3E%3Crect%20x%3D%220%22%20y%3D%220%22%20width%3D%22100%22%20height%3D%22100%22%20style%3D%22fill%3A%23a9a9a9%22/%3E%20%3C/svg%3E';
        return (imgs.indexOf(cloneImg) > -1);
      }
    };

    // Remove a background image from given nodes.
    elementUtilities.removeBackgroundImage = function (nodes, bgObj) {
      if(!nodes || nodes.length == 0 || !bgObj)
        return;

      for(var i = 0; i < nodes.length; i++){
        var node = nodes[i];
        var obj = bgObj[node.data('id')];
        if(!obj)
          continue;

        var imgs = node.data('background-image') ? node.data('background-image').split(" ") : [];
        var xPos = node.data('background-position-x') ? node.data('background-position-x').split(" ") : [];
        var yPos = node.data('background-position-y') ? node.data('background-position-y').split(" ") : [];
        var widths = node.data('background-width') ? node.data('background-width').split(" ") : [];
        var heights = node.data('background-height') ? node.data('background-height').split(" ") : [];
        var fits = node.data('background-fit') ? node.data('background-fit').split(" ") : [];
        var opacities = node.data('background-image-opacity') ? ("" + node.data('background-image-opacity')).split(" ") : [];

        var index = -1;
        if(typeof obj['background-image'] === "string")
          index = imgs.indexOf(obj['background-image']);
        else if(Array.isArray(obj['background-image']))
          index = imgs.indexOf(obj['background-image'][0]);

        if(index > -1){
          imgs.splice(index, 1);
          fits.splice(index, 1);
          opacities.splice(index, 1);
          xPos.splice(index, 1);
          yPos.splice(index, 1);
          widths.splice(index, 1);
          heights.splice(index, 1);
        }

        node.data('background-image', imgs.join(" "));
        node.data('background-position-x', xPos.join(" "));
        node.data('background-position-y', yPos.join(" "));
        node.data('background-width', widths.join(" "));
        node.data('background-height', heights.join(" "));
        node.data('background-fit', fits.join(" "));
        node.data('background-image-opacity', opacities.join(" "));
        bgObj['firstTime'] = false;
      }
    };

    elementUtilities.reverseEdge = function(edge){
      var oldSource = edge.source().id();
      var oldTarget = edge.target().id();
      var oldPortSource = edge.data("portsource");
      var oldPortTarget = edge.data("porttarget");
      var segmentPoints = edge.segmentPoints();


      edge.data().source = oldTarget;
      edge.data().target = oldSource;
      edge.data().portsource = oldPortTarget;
      edge.data().porttarget = oldPortSource;
       edge = edge.move({
         target: oldSource,
         source : oldTarget        
      });

      if(Array.isArray(segmentPoints)){
        segmentPoints.reverse();
        edge.data().bendPointPositions = segmentPoints;
        var edgeEditing = cy.edgeEditing('get');
        edgeEditing.initBendPoints(edge);
      }
    

      return edge;
    }

  }

  return elementUtilitiesExtender;
};

},{"./lib-utilities":4}],4:[function(_dereq_,module,exports){
/* 
 * Utility file to get and set the libraries to which sbgnviz is dependent from any file.
 */

var libUtilities = function(){
};

libUtilities.setLibs = function(libs) {
  this.libs = libs;
};

libUtilities.getLibs = function() {
  return this.libs;
};

module.exports = libUtilities;
},{}],5:[function(_dereq_,module,exports){
var libs = _dereq_('./lib-utilities').getLibs();

/*
 * The main utilities to be exposed directly.
 */
module.exports = function () {

  var elementUtilities, options, cy, sbgnvizInstance;

  function mainUtilities (param) {
    elementUtilities = param.elementUtilities;
    options = param.optionUtilities.getOptions();
    cy = param.sbgnvizInstanceUtilities.getCy();
    sbgnvizInstance = param.sbgnvizInstanceUtilities.getInstance();
  };

  /*
   * Adds a new node with the given class and at the given coordinates. Considers undoable option.
   */
  mainUtilities.addNode = function(x, y , nodeParams, id, parent, visibility) {
    if ( elementUtilities.isGraphTopologyLocked() ) {
      return;
    }

    // update map type
    if (typeof nodeParams == 'object'){
/* 
      if (!elementUtilities.getMapType())
        elementUtilities.setMapType(nodeParams.language);
      else if (elementUtilities.getMapType() != nodeParams.language)
        elementUtilities.setMapType("Unknown"); */
    }

    if (!options.undoable) {
      return elementUtilities.addNode(x, y, nodeParams, id, parent, visibility);
    }
    else {
      var param = {
        newNode : {
          x: x,
          y: y,
          class: nodeParams,
          id: id,
          parent: parent,
          visibility: visibility
        }
      };

      cy.undoRedo().do("addNode", param);
    }
  };

  /*
   * Adds a new edge with the given class and having the given source and target ids. Considers undoable option.
   */
  mainUtilities.addEdge = function(source, target, edgeParams, invalidEdgeCallback, id, visibility) {
    if ( elementUtilities.isGraphTopologyLocked() ) {
      return;
    }

    // update map type
    if (typeof edgeParams == 'object'){

     /*  if (!elementUtilities.getMapType())
        elementUtilities.setMapType(edgeParams.language);
      else if (elementUtilities.getMapType() != edgeParams.language)
        elementUtilities.setMapType("HybridAny"); */
    }
    // Get the validation result
    var edgeclass = edgeParams.class ? edgeParams.class : edgeParams;
    var validation = elementUtilities.validateArrowEnds(edgeclass, cy.getElementById(source), cy.getElementById(target));

    // If validation result is 'invalid' cancel the operation
    if (validation === 'invalid') {
      if(typeof invalidEdgeCallback === "function"){
        invalidEdgeCallback();
      }
      return;
    }

    // If validation result is 'reverse' reverse the source-target pair before creating the edge
    if (validation === 'reverse') {
      var temp = source;
      source = target;
      target = temp;
    }

    if (!options.undoable) {
      return elementUtilities.addEdge(source, target, edgeParams, id, visibility);
    }
    else {
      var param = {
        newEdge : {
          source: source,
          target: target,
          class: edgeParams,
          id: id,
          visibility: visibility
        }
      };

      var result = cy.undoRedo().do("addEdge", param);
      return result.eles;
    }
  };

  /*
   * Adds a process with convenient edges. For more information please see 'https://github.com/iVis-at-Bilkent/newt/issues/9'.
   * Considers undoable option.
   */
  mainUtilities.addProcessWithConvenientEdges = function(_source, _target, processType) {
    if ( elementUtilities.isGraphTopologyLocked() ) {
      return;
    }

    // If source and target IDs are given get the elements by IDs
    var source = typeof _source === 'string' ? cy.getElementById(_source) : _source;
    var target = typeof _target === 'string' ? cy.getElementById(_target) : _target;

    // If source or target does not have an EPN class the operation is not valid
    if (!elementUtilities.isEPNClass(source) || !elementUtilities.isEPNClass(target)) {
      return;
    }

    if (!options.undoable) {
      return elementUtilities.addProcessWithConvenientEdges(_source, _target, processType);
    }
    else {
      var param = {
        source: _source,
        target: _target,
        processType: processType
      };

      cy.undoRedo().do("addProcessWithConvenientEdges", param);
    }
  };

  // convert collapsed compound nodes to simple nodes
  // and update port values of pasted nodes and edges
  var cloneCollapsedNodesAndPorts = function (elesBefore){
    if ( elementUtilities.isGraphTopologyLocked() ) {
      return;
    }

    cy.elements().unselect();
    var elesAfter = cy.elements();
    var elesDiff = elesAfter.diff(elesBefore).left;

    // shallow copy collapsed nodes - collapsed compounds become simple nodes
    // data related to collapsed nodes are removed from generated clones
    // related issue: https://github.com/iVis-at-Bilkent/newt/issues/145
    var collapsedNodes = elesDiff.filter('node.cy-expand-collapse-collapsed-node');

    collapsedNodes.connectedEdges().remove();
    collapsedNodes.removeClass('cy-expand-collapse-collapsed-node');
    collapsedNodes.removeData('collapsedChildren');
    collapsedNodes.removeData('position-before-collapse size-before-collapse');
    collapsedNodes.removeData('expandcollapseRenderedCueSize expandcollapseRenderedStartX expandcollapseRenderedStartY');

    // cloning ports
    elesDiff.nodes().forEach(function(_node){
      if(_node.data("ports").length == 2){
          var oldPortName0 = _node.data("ports")[0].id;
          var oldPortName1 = _node.data("ports")[1].id;
          _node.data("ports")[0].id = _node.id() + ".1";
          _node.data("ports")[1].id = _node.id() + ".2";

          _node.outgoers().edges().forEach(function(_edge){
            if(_edge.data("portsource") == oldPortName0){
              _edge.data("portsource", _node.data("ports")[0].id);
            }
            else if(_edge.data("portsource") == oldPortName1){
              _edge.data("portsource", _node.data("ports")[1].id);
            }
            else{
              _edge.data("portsource", _node.id());
            }
          });
          _node.incomers().edges().forEach(function(_edge){
            if(_edge.data("porttarget") == oldPortName0){
              _edge.data("porttarget", _node.data("ports")[0].id);
            }
            else if(_edge.data("porttarget") == oldPortName1){
              _edge.data("porttarget", _node.data("ports")[1].id);
            }
            else{
              _edge.data("porttarget", _node.id());
            }
          });
      }
      else{
        _node.outgoers().edges().forEach(function(_edge){
          _edge.data("portsource", _node.id());
        });
        _node.incomers().edges().forEach(function(_edge){
          _edge.data("porttarget", _node.id());
        });
      }
    });
    elesDiff.select();
  }

  /*
   * Clone given elements. Considers undoable option. Requires cytoscape-clipboard extension.
   */
  mainUtilities.cloneElements = function (eles, pasteAtMouseLoc) {
    if ( elementUtilities.isGraphTopologyLocked() ) {
      return;
    }

    if (eles.length === 0) {
      return;
    }

    this.copyElements(eles);

    this.pasteElements(pasteAtMouseLoc);
  };

  /*
   * Copy given elements to clipboard. Requires cytoscape-clipboard extension.
   */
  mainUtilities.copyElements = function (eles) {
    cy.clipboard().copy(eles);
  };

  /*
   * Paste the elements copied to clipboard. Considers undoable option. Requires cytoscape-clipboard extension.
   */
  mainUtilities.pasteElements = function(pasteAtMouseLoc) {
    if ( elementUtilities.isGraphTopologyLocked() ) {
      return;
    }

    var elesBefore = cy.elements();

    if (options.undoable) {
      cy.undoRedo().do("paste",{pasteAtMouseLoc: pasteAtMouseLoc});
    }
    else {
      cy.clipboard().paste();
    }
    cloneCollapsedNodesAndPorts(elesBefore);
    cy.nodes(":selected").emit('data');
  };

  /*
   * Aligns given nodes in given horizontal and vertical order.
   * Horizontal and vertical parameters may be 'none' or undefined.
   * alignTo parameter indicates the leading node.
   * Requrires cytoscape-grid-guide extension and considers undoable option.
   */
  mainUtilities.align = function (nodes, horizontal, vertical, alignTo) {
    if (nodes.length === 0) {
      return;
    }

    if (options.undoable) {
      cy.undoRedo().do("align", {
        nodes: nodes,
        horizontal: horizontal,
        vertical: vertical,
        alignTo: alignTo
      });
    } else {
      nodes.align(horizontal, vertical, alignTo);
    }

    if(cy.edges(":selected").length == 1 ) {
      cy.edges().unselect();      
    }
    
  };

  /*
   * Create compound for given nodes. compoundType may be 'complex' or 'compartment'.
   * This method considers undoable option.
   */
  mainUtilities.createCompoundForGivenNodes = function (_nodes, compoundType) {
    if ( elementUtilities.isGraphTopologyLocked() ) {
      return;
    }

    var nodes = _nodes;
    /*
     * Eleminate the nodes which cannot have a parent with given compound type
     */
    nodes = _nodes.filter(function (element, i) {
      if(typeof element === "number") {
        element = i;
      }

      var sbgnclass = element.data("class");
      return elementUtilities.isValidParent(sbgnclass, compoundType, element);
    });

    nodes = elementUtilities.getTopMostNodes(nodes);

    // All elements should have the same parent and the common parent should not be a 'complex'
    // if compoundType is 'compartent'
    // because the old common parent will be the parent of the new compartment after this operation and
    // 'complexes' cannot include 'compartments'
    if (nodes.length == 0 || !elementUtilities.allHaveTheSameParent(nodes)
            || ( (compoundType === 'compartment' || compoundType == 'submap') && nodes.parent().data('class')
            && nodes.parent().data('class').startsWith('complex') )) {
      return;
    }

    if (cy.undoRedo()) {
      var param = {
        compoundType: compoundType,
        nodesToMakeCompound: nodes
      };

      cy.undoRedo().do("createCompoundForGivenNodes", param);
    }
    else {
      elementUtilities.createCompoundForGivenNodes(nodes, compoundType);
    }
  };

  /*
   * Move the nodes to a new parent and change their position if possDiff params are set.
   * Considers undoable option and checks if the operation is valid.
   */
  mainUtilities.changeParent = function(nodes, _newParent, posDiffX, posDiffY) {
    if ( elementUtilities.isGraphTopologyLocked() ) {
      return;
    }

    var newParent = typeof _newParent === 'string' ? cy.getElementById(_newParent) : _newParent;
    // New parent is supposed to be one of the root, a complex or a compartment
    if (newParent && !newParent.data("class").startsWith("complex") && newParent.data("class") != "compartment"
            && newParent.data("class") != "submap") {
      return;
    }
    /*
     * Eleminate the nodes which cannot have the newParent as their parent
     */
    nodes = nodes.filter(function (element, i) {
      if(typeof element === "number") {
        element = i;
      }

      var sbgnclass = element.data("class");
      return elementUtilities.isValidParent(sbgnclass, newParent, element);
    });

    // Discard the nodes whose parent is already newParent.
    // Discard the newParent itself if it is among the nodes
    nodes = nodes.filter(function (ele, i) {
      if(typeof ele === "number") {
        ele = i;
      }

      // Discard the newParent if it is among the nodes
      if (newParent && ele.id() === newParent.id()) {
        return false;
      }
      // Discard the nodes whose parent is already newParent
      if (!newParent) {
        return ele.data('parent') != null;
      }
      return ele.data('parent') !== newParent.id();
    });

    // If some nodes are ancestor of new parent eleminate them
    if (newParent) {
      nodes = nodes.difference(newParent.ancestors());
    }

    // If all nodes are eleminated return directly
    if (nodes.length === 0) {
      return;
    }

    // Just move the top most nodes
    nodes = elementUtilities.getTopMostNodes(nodes);

    var parentId = newParent ? newParent.id() : null;

    if (options.undoable) {
      var param = {
        firstTime: true,
        parentData: parentId, // It keeps the newParentId (Just an id for each nodes for the first time)
        nodes: nodes,
        posDiffX: posDiffX,
        posDiffY: posDiffY,
        // This is needed because the changeParent function called is not from elementUtilities
        // but from the undoRedo extension directly, so maintaining pointer is not automatically done.
        callback: elementUtilities.maintainPointer
      };

      cy.undoRedo().do("changeParent", param); // This action is registered by undoRedo extension
    }
    else {
      elementUtilities.changeParent(nodes, parentId, posDiffX, posDiffY);
    }
  };

  /*
   * Creates a template reaction with given parameters. Requires cose-bilkent layout to tile the free macromolecules included
   * in the complex. Considers undoable option. For more information see the same function in elementUtilities
   */
  mainUtilities.createTemplateReaction = function (templateType, macromoleculeList, complexName, processPosition, tilingPaddingVertical, tilingPaddingHorizontal, edgeLength, layoutParam) {
    if ( elementUtilities.isGraphTopologyLocked() ) {
      return;
    }

    if (!options.undoable) {
      elementUtilities.createTemplateReaction(templateType, macromoleculeList, complexName, processPosition, tilingPaddingVertical, tilingPaddingHorizontal, edgeLength, layoutParam);
    }
    else {
      var param = {
        templateType: templateType,
        macromoleculeList: macromoleculeList,
        complexName: complexName,
        processPosition: processPosition,
        tilingPaddingVertical: tilingPaddingVertical,
        tilingPaddingHorizontal: tilingPaddingHorizontal,
        edgeLength: edgeLength,
        layoutParam: layoutParam
      };

      cy.undoRedo().do("createTemplateReaction", param);
    }
  };

  /*
   * Resize given nodes if useAspectRatio is truthy one of width or height should not be set.
   * Considers undoable option.
   */
  mainUtilities.resizeNodes = function(nodes, width, height, useAspectRatio, preserveRelativePos) {
    if (nodes.length === 0) {
      return;
    }

    if (options.undoable) {
      var param = {
        nodes: nodes,
        width: width,
        height: height,
        useAspectRatio: useAspectRatio,
        performOperation: true,
        preserveRelativePos: preserveRelativePos
      };

      cy.undoRedo().do("resizeNodes", param);
    }
    else {
      elementUtilities.resizeNodes(nodes, width, height, useAspectRatio);
      cy.style().update();
    }


  };

    /*
     * Resize given nodes if useAspectRatio is truthy one of width or height should not be set.
     * Considers undoable option.
     */
    mainUtilities.resizeNodesToContent = function(nodes, useAspectRatio) {
        if (nodes.length === 0) {
            return;
        } 
        if (options.undoable) {
          var actions = [];
          nodes.forEach(function(node){
            var width = elementUtilities.calculateMinWidth(node);
            var height = elementUtilities.calculateMinHeight(node);
            actions.push({name: "resizeNodes", param: {
                nodes: node,
                width: width,
                height: height,
                useAspectRatio: useAspectRatio,
                performOperation: true,
                preserveRelativePos: true
            }});

            var stateAndInfos = node.data('statesandinfos');
            var length = stateAndInfos.length;
            if (length != 0) {
              var param = {
                node: node,
                locations: ["top","right","bottom","left"]
              };          
              actions.push({name:"fitUnits",param : param})
             }
  

          });

        
         
          cy.undoRedo().do("batch", actions);
          cy.style().update();
          return actions;
        }
        else {
            nodes.forEach(function(node){
              var width = elementUtilities.calculateMinWidth(node);
              var height = elementUtilities.calculateMinHeight(node);
              
              elementUtilities.resizeNodes(node, width, height, useAspectRatio, true);
            });
        }

        cy.style().update();
    };

  /*
   * Changes the label of the given nodes to the given label. Considers undoable option.
   */
  mainUtilities.changeNodeLabel = function(nodes, label) {
    if (nodes.length === 0) {
      return;
    }

    if (!options.undoable) {
      nodes.data('label', label);
    }
    else {
      var param = {
        nodes: nodes,
        label: label,
        firstTime: true
      };

      cy.undoRedo().do("changeNodeLabel", param);
    }

    cy.style().update();
  };

  /*
   * Change font properties for given nodes use the given font data.
   * Considers undoable option.
   */
  mainUtilities.changeFontProperties = function(eles, data) {
    if (eles.length === 0) {
      return;
    }

    if (options.undoable) {
      var param = {
        eles: eles,
        data: data,
        firstTime: true
      };

      cy.undoRedo().do("changeFontProperties", param);
    }
    else {
      elementUtilities.changeFontProperties(eles, data);
    }

    cy.style().update();
  };

  /*
   * Change state value or unit of information box of given nodes with given index.
   * Considers undoable option.
   * For more information about the parameters see elementUtilities.changeStateOrInfoBox
   */
  mainUtilities.changeStateOrInfoBox = function(nodes, index, value, type) {
    if (nodes.length === 0) {
      return;
    }
    if (options.undoable) {
      var param = {
        index: index,
        value: value,
        type: type,
        nodes: nodes
      };

      cy.undoRedo().do("changeStateOrInfoBox", param);
    }
    else {
      return elementUtilities.changeStateOrInfoBox(nodes, index, value, type);
    }

    cy.style().update();
  };

  // Add a new state or info box to given nodes.
  // The box is represented by the parameter obj.
  // Considers undoable option.
  mainUtilities.addStateOrInfoBox = function(nodes, obj) {
    if (nodes.length === 0) {
      return;
    }

    if (!options.undoable) {
      elementUtilities.addStateOrInfoBox(nodes, obj);
    }
    else {
      var param = {
        obj: obj,
        nodes: nodes
      };

      cy.undoRedo().do("addStateOrInfoBox", param);
    }

    cy.style().update();
  };

  // Remove the state or info boxes of the given nodes at given index.
  // Considers undoable option.
  mainUtilities.removeStateOrInfoBox = function(nodes, index) {
    if (nodes.length === 0) {
      return;
    }

    if (!options.undoable) {
      elementUtilities.removeStateOrInfoBox(nodes, {index: index});
    }
    else {
      var param = {
        locationObj: {index: index},
        nodes: nodes
      };

      cy.undoRedo().do("removeStateOrInfoBox", param);
    }

    cy.style().update();
  };


  //Arrange information boxes
  //If force check is true, it rearranges all information boxes
  mainUtilities.fitUnits = function (node, locations) {
    if (node.data('auxunitlayouts') === undefined || node.data('statesandinfos').length <= 0) {
      return;
    }
    if (locations === undefined || locations.length <= 0) {
      return;
    }

    if (!options.undoable) {
      elementUtilities.fitUnits(node, locations);
    }
    else {
      var param = {
        node: node,
        locations: locations
      };

      cy.undoRedo().do("fitUnits", param);
    }

    cy.style().update();
  };

  /*
   * Set multimer status of the given nodes to the given status.
   * Considers undoable option.
   */
  mainUtilities.setMultimerStatus = function(nodes, status) {
    if (nodes.length === 0) {
      return;
    }

    if (options.undoable) {
      var param = {
        status: status,
        nodes: nodes,
        firstTime: true
      };

      cy.undoRedo().do("setMultimerStatus", param);
    }
    else {
      elementUtilities.setMultimerStatus(nodes, status);
    }

    cy.style().update();
  };

  /*
   * Set clone marker status of given nodes to the given status.
   * Considers undoable option.
   */
  mainUtilities.setCloneMarkerStatus = function(nodes, status) {
    if (nodes.length === 0) {
      return;
    }

    if (options.undoable) {
      var param = {
        status: status,
        nodes: nodes,
        firstTime: true
      };

      cy.undoRedo().do("setCloneMarkerStatus", param);
    }
    else {
      elementUtilities.setCloneMarkerStatus(nodes, status);
    }

    cy.style().update();
  };

  /*
   * Change style/css of given eles by setting getting property name to the given given value/values (Note that valueMap parameter may be
   * a single string or an id to value map). Considers undoable option.
   */
  mainUtilities.changeCss = function(eles, name, valueMap) {
    if (eles.length === 0) {
      return;
    }

    if (!options.undoable) {
      elementUtilities.changeCss(eles, name, valueMap);
    }
    else {
      var param = {
        eles: eles,
        valueMap: valueMap,
        name: name
      };

      cy.undoRedo().do("changeCss", param);
    }

    cy.style().update();
  };

  /*
   * Change data of given eles by setting getting property name to the given given value/values (Note that valueMap parameter may be
   * a single string or an id to value map). Considers undoable option.
   */
  mainUtilities.changeData = function(eles, name, valueMap) {
    if (eles.length === 0) {
      return;
    }

    if (!options.undoable) {
      elementUtilities.changeData(eles, name, valueMap);
    }
    else {
      var param = {
        eles: eles,
        valueMap: valueMap,
        name: name
      };

      cy.undoRedo().do("changeData", param);
    }

    cy.style().update();
  };

  mainUtilities.updateSetField = function(ele, fieldName, toDelete, toAdd, callback) {
    if (!options.undoable) {
      elementUtilities.changeData(ele, fieldName, toDelete, toAdd, callback);
    }
    else {
      var param = {
        ele,
        fieldName,
        toDelete,
        toAdd,
        callback
      };

      cy.undoRedo().do("updateSetField", param);
    }
  };

  mainUtilities.setDefaultProperty = function( _class, name, value ) {
    if (!options.undoable) {
      var propMap = {};
      propMap[ name ] = value;

      elementUtilities.setDefaultProperties(_class, propMap);
    }
    else {
      var param = {
        class: _class,
        name,
        value
      };

      cy.undoRedo().do("setDefaultProperty", param);
    }
  };

  mainUtilities.updateInfoboxStyle = function( node, index, newProps ) {
    if (!options.undoable) {
      elementUtilities.updateInfoboxStyle( node, index, newProps );
    }
    else {
      var param = {
        node: node,
        index: index,
        newProps: newProps
      };

      cy.undoRedo().do("updateInfoboxStyle", param);
    }

    cy.style().update();
  };

  mainUtilities.updateInfoboxObj = function( node, index, newProps ) {
    if (!options.undoable) {
      elementUtilities.updateInfoboxObj( node, index, newProps );
    }
    else {
      var param = {
        node: node,
        index: index,
        newProps: newProps
      };

      cy.undoRedo().do("updateInfoboxObj", param);
    }

    cy.style().update();
  };


  /*
   * Hides given eles (the ones which are selected) and perform given layout afterward. Layout parameter may be layout options
   * or a function to call. Requires viewUtilities extension and considers undoable option.
   */
  mainUtilities.hideAndPerformLayout = function(eles, layoutparam) {
      var nodes = eles.nodes(); // Ensure that nodes list just include nodes

      var allNodes = cy.nodes(":visible");
      var nodesToShow = elementUtilities.extendRemainingNodes(nodes, allNodes);
      var nodesToHide = allNodes.not(nodesToShow);

      if (nodesToHide.length === 0) {
          return;
      }

      if (!options.undoable) {

          var nodesWithHiddenNeighbor = cy.edges(":hidden").connectedNodes(':visible');
          sbgnvizInstance.thinBorder(nodesWithHiddenNeighbor);
          elementUtilities.hideAndPerformLayout(nodesToHide, layoutparam);
          var nodesWithHiddenNeighbor = cy.edges(":hidden").connectedNodes(':visible');
          sbgnvizInstance.thickenBorder(nodesWithHiddenNeighbor);
      }
      else {
          var param = {
              eles: nodesToHide,
              layoutparam: layoutparam,
              firstTime: true
          };

          var ur = cy.undoRedo();
          ur.action("thickenBorder", sbgnvizInstance.thickenBorder, sbgnvizInstance.thinBorder);
          ur.action("thinBorder", sbgnvizInstance.thinBorder, sbgnvizInstance.thickenBorder);

          var actions = [];
          var nodesWithHiddenNeighbor = cy.edges(":hidden").connectedNodes().intersection(nodesToHide);
          actions.push({name: "thinBorder", param: nodesWithHiddenNeighbor});
          actions.push({name: "hideAndPerformLayout", param: param});
          nodesWithHiddenNeighbor = nodesToHide.neighborhood(":visible").nodes().difference(nodesToHide).difference(cy.nodes("[thickBorder]"));
          actions.push({name: "thickenBorder", param: nodesWithHiddenNeighbor});
          cy.undoRedo().do("batch", actions);
      }
  };

  /*
   * Shows all elements (the ones which are hidden if any) and perform given layout afterward. Layout parameter may be layout options
   * or a function to call. Requires viewUtilities extension and considers undoable option.
   */
  mainUtilities.showAllAndPerformLayout = function(layoutparam) {
    var hiddenEles = cy.elements(':hidden');
    if (hiddenEles.length === 0) {
      return;
    }
    if (!options.undoable) {
      var nodesWithHiddenNeighbor = cy.edges(":hidden").connectedNodes(':visible');
      sbgnvizInstance.thinBorder(nodesWithHiddenNeighbor);
      elementUtilities.showAndPerformLayout(hiddenEles, layoutparam);
    }
    else {
      var param = {
        eles: hiddenEles,
        layoutparam: layoutparam,
        firstTime: true
      };

      var ur = cy.undoRedo();
      ur.action("thickenBorder", sbgnvizInstance.thickenBorder, sbgnvizInstance.thinBorder);
      ur.action("thinBorder", sbgnvizInstance.thinBorder, sbgnvizInstance.thickenBorder);

      var actions = [];
      var nodesWithHiddenNeighbor = cy.nodes("[thickBorder]");
      actions.push({name: "thinBorder", param: nodesWithHiddenNeighbor});
      actions.push({name: "showAndPerformLayout", param: param});
      cy.undoRedo().do("batch", actions);
    }
  };

  /*
   * Unhide given eles (the ones which are hidden if any) and perform given layout afterward. Layout parameter may be layout options
   * or a function to call. Requires viewUtilities extension and considers undoable option.
   */
  mainUtilities.showAndPerformLayout = function(mainEle, eles, layoutparam) {
      var hiddenEles = eles.filter(':hidden');
      if (hiddenEles.length === 0) {
          return;
      }
      mainUtilities.closeUpElements(mainEle, hiddenEles.nodes());
      if (!options.undoable) {
          var nodesWithHiddenNeighbor = cy.edges(":hidden").connectedNodes(':visible');
          sbgnvizInstance.thinBorder(nodesWithHiddenNeighbor);
          elementUtilities.showAndPerformLayout(hiddenEles, layoutparam);
          var nodesWithHiddenNeighbor = cy.edges(":hidden").connectedNodes(':visible');
          sbgnvizInstance.thickenBorder(nodesWithHiddenNeighbor);
      }
      else {
          var param = {
              eles: hiddenEles,
              layoutparam: layoutparam,
              firstTime: true
          };

          var ur = cy.undoRedo();
          ur.action("thickenBorder", sbgnvizInstance.thickenBorder, sbgnvizInstance.thinBorder);
          ur.action("thinBorder", sbgnvizInstance.thinBorder, sbgnvizInstance.thickenBorder);

          var actions = [];
          var nodesToThinBorder = (hiddenEles.neighborhood(":visible").nodes("[thickBorder]"))
                  .difference(cy.edges(":hidden").difference(hiddenEles.edges().union(hiddenEles.nodes().connectedEdges())).connectedNodes());
          actions.push({name: "thinBorder", param: nodesToThinBorder});
          actions.push({name: "showAndPerformLayout", param: param});
          var nodesToThickenBorder = hiddenEles.nodes().edgesWith(cy.nodes(":hidden").difference(hiddenEles.nodes()))
  	            .connectedNodes().intersection(hiddenEles.nodes());
          actions.push({name: "thickenBorder", param: nodesToThickenBorder});
          cy.undoRedo().do("batch", actions);
      }
  };

  /*
  * Takes the hidden elements close to the nodes whose neighbors will be shown
  * */
  mainUtilities.closeUpElements = function(mainEle, hiddenEles) {
      var leftX = Number.MAX_VALUE;
      var rightX = Number.MIN_VALUE;
      var topY = Number.MAX_VALUE;
      var bottomY = Number.MIN_VALUE;
      // Check the x and y limits of all hidden elements and store them in the variables above
      hiddenEles.forEach(function( ele ){
          if (ele.data('class') != 'compartment' &&  ele.data('class') != 'complex')
          {
              var halfWidth = ele.outerWidth()/2;
              var halfHeight = ele.outerHeight()/2;
              if (ele.position("x") - halfWidth < leftX)
                  leftX = ele.position("x") - halfWidth;
              if (ele.position("x") + halfWidth > rightX)
                  rightX = ele.position("x") + halfWidth;
              if (ele.position("y") - halfHeight < topY)
                  topY = ele.position("y") - halfHeight;
              if (ele.position("y") + halfHeight > topY)
                  bottomY = ele.position("y") + halfHeight;
          }
      });

      //The coordinates of the old center containing the hidden nodes
      var oldCenterX = (leftX + rightX)/2;
      var oldCenterY = (topY + bottomY)/2;

      //Here we calculate two parameters which define the area in which the hidden elements are placed initially
      var minHorizontalParam = mainEle.outerWidth()/2 + (rightX - leftX)/2;
      var maxHorizontalParam = mainEle.outerWidth() + (rightX - leftX)/2;
      var minVerticalParam = mainEle.outerHeight()/2 + (bottomY - topY)/2;
      var maxVerticalParam = mainEle.outerHeight() + (bottomY - topY)/2;

      //Quadrants is an object of the form {first:"obtained", second:"free", third:"free", fourth:"obtained"}
      // which holds which quadrant are free (that's where hidden nodes will be brought)
      var quadrants = mainUtilities.checkOccupiedQuadrants(mainEle, hiddenEles);
      var freeQuadrants = [];
      for (var property in quadrants) {
          if (quadrants[property] === "free")
              freeQuadrants.push(property);
      }

      //Can take values 1 and -1 and are used to place the hidden nodes in the random quadrant
      var horizontalMult;
      var verticalMult;
      if (freeQuadrants.length > 0)
      {
        if (freeQuadrants.length === 3)
        {
          if (freeQuadrants.includes('first') && freeQuadrants.includes('second') && freeQuadrants.includes('third'))
          {
            horizontalMult = -1;
            verticalMult = -1;
          }
          else if (freeQuadrants.includes('first') && freeQuadrants.includes('second') && freeQuadrants.includes('fourth'))
          {
            horizontalMult = 1;
            verticalMult = -1;
          }
          else if (freeQuadrants.includes('first') && freeQuadrants.includes('third') && freeQuadrants.includes('fourth'))
          {
            horizontalMult = 1;
            verticalMult = 1;
          }
          else if (freeQuadrants.includes('second') && freeQuadrants.includes('third') && freeQuadrants.includes('fourth'))
          {
            horizontalMult = -1;
            verticalMult = 1;
          }
        }
        else
        {
          //Randomly picks one quadrant from the free quadrants
          var randomQuadrant = freeQuadrants[Math.floor(Math.random()*freeQuadrants.length)];

          if (randomQuadrant === "first") {
              horizontalMult = 1;
              verticalMult = -1;
          }
          else if (randomQuadrant === "second") {
              horizontalMult = -1;
              verticalMult = -1;
          }
          else if (randomQuadrant === "third") {
              horizontalMult = -1;
              verticalMult = 1;
          }
          else if (randomQuadrant === "fourth") {
              horizontalMult = 1;
              verticalMult = 1;
          }
        }
      }
      else
      {
          horizontalMult = 0;
          verticalMult = 0;
      }
      // If the horizontalMult is 0 it means that no quadrant is free, so we randomly choose a quadrant
      var horizontalParam = mainUtilities.generateRandom(minHorizontalParam,maxHorizontalParam,horizontalMult);
      var verticalParam = mainUtilities.generateRandom(minVerticalParam,maxVerticalParam,verticalMult);

      //The coordinates of the center where the hidden nodes will be transfered
      var newCenterX = mainEle.position("x") + horizontalParam;
      var newCenterY = mainEle.position("y") + verticalParam;

      var xdiff = newCenterX - oldCenterX;
      var ydiff = newCenterY - oldCenterY;

      //Change the position of hidden elements
      hiddenEles.forEach(function( ele ){
          var newx = ele.position("x") + xdiff;
          var newy = ele.position("y") + ydiff;
          ele.position("x", newx);
          ele.position("y",newy);
      });
  };

  /*
   * Generates a number between 2 nr and multimplies it with 1 or -1
   * */
  mainUtilities.generateRandom = function(min, max, mult) {
      var val = [-1,1];
      if (mult === 0)
          mult = val[Math.floor(Math.random()*val.length)];
      return (Math.floor(Math.random() * (max - min + 1)) + min) * mult;
  };

  /*
   * This function makes sure that the random number lies in free quadrant
   * */
  mainUtilities.checkOccupiedQuadrants = function(mainEle, hiddenEles) {
      if (elementUtilities.getMapType() == 'PD')
      {
        var visibleNeighborEles = mainEle.neighborhood().difference(hiddenEles).nodes();
        var visibleNeighborsOfNeighbors = visibleNeighborEles.neighborhood().difference(hiddenEles).difference(mainEle).nodes();
        var visibleEles = visibleNeighborEles.union(visibleNeighborsOfNeighbors);
      }
      else
        var visibleEles = mainEle.neighborhood().difference(hiddenEles).nodes();
      var occupiedQuadrants = {first:"free", second:"free", third:"free", fourth:"free"};

      visibleEles.forEach(function( ele ){
          if (ele.data('class') != 'compartment' &&  ele.data('class') != 'complex')
          {
              if (ele.position("x") < mainEle.position("x") && ele.position("y") < mainEle.position("y"))
                  occupiedQuadrants.second = "occupied";
              else if (ele.position("x") > mainEle.position("x") && ele.position("y") < mainEle.position("y"))
                  occupiedQuadrants.first = "occupied";
              else if (ele.position("x") < mainEle.position("x") && ele.position("y") > mainEle.position("y"))
                  occupiedQuadrants.third = "occupied";
              else if (ele.position("x") > mainEle.position("x") && ele.position("y") > mainEle.position("y"))
                  occupiedQuadrants.fourth = "occupied";
          }
      });
      return occupiedQuadrants;
  };

  // Overrides highlightProcesses from SBGNVIZ - do not highlight any nodes when the map type is AF
  mainUtilities.highlightProcesses = function(_nodes) {
    if (elementUtilities.getMapType() == "AF")
      return;
    sbgnvizInstance.highlightProcesses(_nodes);
  };

  /**
   * Resets map type to undefined
   */
  mainUtilities.resetMapType = function(){
    elementUtilities.resetMapType();
  };

  /**
   * return : map type
   */
  mainUtilities.getMapType = function(){
    return elementUtilities.getMapType();
  };

  mainUtilities.addBackgroundImage = function(nodes, bgObj, updateInfo, promptInvalidImage, validateURL){
    if (nodes.length === 0 || !bgObj) {
      return;
    }

    bgObj['firstTime'] = true;
    if (options.undoable) {
      var param = {
        bgObj: bgObj,
        nodes: nodes,
        updateInfo: updateInfo,
        promptInvalidImage: promptInvalidImage,
        validateURL: validateURL,
      };

      cy.undoRedo().do("addBackgroundImage", param);
    }
    else {
      elementUtilities.addBackgroundImage(nodes, bgObj, updateInfo, promptInvalidImage, validateURL);
    }

    cy.style().update();
  }

  mainUtilities.removeBackgroundImage = function(nodes, bgObj){
    if (nodes.length === 0 || !bgObj) {
      return;
    }

    bgObj['firstTime'] = true;
    if (options.undoable) {
      var param = {
        bgObj: bgObj,
        nodes: nodes
      };

      cy.undoRedo().do("removeBackgroundImage", param);
    }
    else {
      elementUtilities.removeBackgroundImage(nodes, bgObj);
    }

    cy.style().update();
  }

  mainUtilities.updateBackgroundImage = function(nodes, bgObj){
    if (nodes.length === 0 || !bgObj) {
      return;
    }

    if (options.undoable) {
      var param = {
        bgObj: bgObj,
        nodes: nodes
      };

      cy.undoRedo().do("updateBackgroundImage", param);
    }
    else {
      elementUtilities.updateBackgroundImage(nodes, bgObj);
    }

    cy.style().update();
  }

  mainUtilities.changeBackgroundImage = function(nodes, oldImg, newImg, updateInfo, promptInvalidImage, validateURL){
    if (nodes.length === 0 || !oldImg || !newImg) {
      return;
    }

    if (options.undoable) {
      var param = {
        oldImg: oldImg,
        newImg: newImg,
        nodes: nodes,
        firstTime: true,
        updateInfo: updateInfo,
        promptInvalidImage: promptInvalidImage,
        validateURL: validateURL
      };

      cy.undoRedo().do("changeBackgroundImage", param);
    }
    else {
      elementUtilities.changeBackgroundImage(nodes, oldImg, newImg, true, updateInfo, promptInvalidImage, validateURL);
    }

    cy.style().update();
  }

  return mainUtilities;
};

},{"./lib-utilities":4}],6:[function(_dereq_,module,exports){
/*
 *  Extend default options and get current options by using this file
 */

module.exports = function () {

  // default options
  var defaults = {
    // The path of core library images when sbgnviz is required from npm and the index html
    // file and node_modules are under the same folder then using the default value is fine
    imgPath: 'node_modules/sbgnviz/src/img',
    // Whether to fit labels to nodes
    fitLabelsToNodes: function () {
      return false;
    },
    fitLabelsToInfoboxes: function () {
      return false;
    },
    // dynamic label size it may be 'small', 'regular', 'large'
    dynamicLabelSize: function () {
      return 'regular';
    },
    // Whether to infer nesting on load 
    inferNestingOnLoad: function () {
      return false;
    },
    // percentage used to calculate compound paddings
    compoundPadding: function () {
      return 10;
    },
    // The selector of the component containing the sbgn network
    networkContainerSelector: '#sbgn-network-container',
    // Whether the actions are undoable, requires cytoscape-undo-redo extension
    undoable: true,
    // Whether to have undoable drag feature in undo/redo extension. This options will be passed to undo/redo extension
    undoableDrag: true
  };

  var optionUtilities = function () {
  };

  // Extend the defaults options with the user options
  optionUtilities.extendOptions = function (options) {
    var result = {};

    for (var prop in defaults) {
      result[prop] = defaults[prop];
    }

    for (var prop in options) {
      result[prop] = options[prop];
    }

    optionUtilities.options = result;

    return options;
  };

  optionUtilities.getOptions = function () {
    return optionUtilities.options;
  };

  return optionUtilities;
};

},{}],7:[function(_dereq_,module,exports){
var libs = _dereq_('./lib-utilities').getLibs();
var $ = libs.jQuery;

module.exports = function () {

  var undoRedoActionFunctions, options, cy;

  var registerUndoRedoActions = function (param) {

    undoRedoActionFunctions = param.undoRedoActionFunctions;
    options = param.optionUtilities.getOptions();
    cy = param.sbgnvizInstanceUtilities.getCy();

    if (!options.undoable) {
      return;
    }

    // create undo-redo instance
    var ur = cy.undoRedo({
      undoableDrag: options.undoableDrag
    });

    // register add remove actions
    ur.action("addNode", undoRedoActionFunctions.addNode, undoRedoActionFunctions.deleteElesSimple);
    ur.action("deleteElesSimple", undoRedoActionFunctions.deleteElesSimple, undoRedoActionFunctions.restoreEles);
    ur.action("addEdge", undoRedoActionFunctions.addEdge, undoRedoActionFunctions.deleteElesSimple);
    ur.action("addProcessWithConvenientEdges", undoRedoActionFunctions.addProcessWithConvenientEdges, undoRedoActionFunctions.deleteElesSimple);
    ur.action("deleteElesSmart", undoRedoActionFunctions.deleteElesSmart, undoRedoActionFunctions.restoreEles);
    ur.action("createCompoundForGivenNodes", undoRedoActionFunctions.createCompoundForGivenNodes, undoRedoActionFunctions.createCompoundForGivenNodes);

    // register general actions
    ur.action("resizeNodes", undoRedoActionFunctions.resizeNodes, undoRedoActionFunctions.resizeNodes);
    ur.action("changeNodeLabel", undoRedoActionFunctions.changeNodeLabel, undoRedoActionFunctions.changeNodeLabel);
    ur.action("changeData", undoRedoActionFunctions.changeData, undoRedoActionFunctions.changeData);
    ur.action("updateSetField", undoRedoActionFunctions.updateSetField, undoRedoActionFunctions.updateSetField);
    ur.action("changeCss", undoRedoActionFunctions.changeCss, undoRedoActionFunctions.changeCss);
    ur.action("changeBendPoints", undoRedoActionFunctions.changeBendPoints, undoRedoActionFunctions.changeBendPoints);
    ur.action("changeFontProperties", undoRedoActionFunctions.changeFontProperties, undoRedoActionFunctions.changeFontProperties);
    ur.action("showAndPerformLayout", undoRedoActionFunctions.showAndPerformLayout, undoRedoActionFunctions.undoShowAndPerformLayout);
    ur.action("hideAndPerformLayout", undoRedoActionFunctions.hideAndPerformLayout, undoRedoActionFunctions.undoHideAndPerformLayout);
    ur.action("applySIFTopologyGrouping", undoRedoActionFunctions.applySIFTopologyGrouping, undoRedoActionFunctions.applySIFTopologyGrouping);

    // register SBGN actions
    ur.action("addStateOrInfoBox", undoRedoActionFunctions.addStateOrInfoBox, undoRedoActionFunctions.removeStateOrInfoBox);
    ur.action("changeStateOrInfoBox", undoRedoActionFunctions.changeStateOrInfoBox, undoRedoActionFunctions.changeStateOrInfoBox);
    ur.action("setMultimerStatus", undoRedoActionFunctions.setMultimerStatus, undoRedoActionFunctions.setMultimerStatus);
    ur.action("setCloneMarkerStatus", undoRedoActionFunctions.setCloneMarkerStatus, undoRedoActionFunctions.setCloneMarkerStatus);
    ur.action("removeStateOrInfoBox", undoRedoActionFunctions.removeStateOrInfoBox, undoRedoActionFunctions.addStateOrInfoBox);
    ur.action("fitUnits", undoRedoActionFunctions.fitUnits, undoRedoActionFunctions.restoreUnits);
    ur.action("addBackgroundImage", undoRedoActionFunctions.addBackgroundImage, undoRedoActionFunctions.removeBackgroundImage);
    ur.action("removeBackgroundImage", undoRedoActionFunctions.removeBackgroundImage, undoRedoActionFunctions.addBackgroundImage);
    ur.action("updateBackgroundImage", undoRedoActionFunctions.updateBackgroundImage, undoRedoActionFunctions.updateBackgroundImage);
    ur.action("changeBackgroundImage", undoRedoActionFunctions.changeBackgroundImage, undoRedoActionFunctions.changeBackgroundImage);
    ur.action("updateInfoboxStyle", undoRedoActionFunctions.updateInfoboxStyle, undoRedoActionFunctions.updateInfoboxStyle);
    ur.action("updateInfoboxObj", undoRedoActionFunctions.updateInfoboxObj, undoRedoActionFunctions.updateInfoboxObj);

    // register easy creation actions
    ur.action("createTemplateReaction", undoRedoActionFunctions.createTemplateReaction, undoRedoActionFunctions.deleteElesSimple);
    ur.action("setDefaultProperty", undoRedoActionFunctions.setDefaultProperty, undoRedoActionFunctions.setDefaultProperty);
    ur.action("convertIntoReversibleReaction", undoRedoActionFunctions.convertIntoReversibleReaction, undoRedoActionFunctions.convertIntoReversibleReaction);

    ur.action("moveEdge", undoRedoActionFunctions.moveEdge, undoRedoActionFunctions.moveEdge);
    ur.action("fixError", undoRedoActionFunctions.fixError,undoRedoActionFunctions.unfixError);
    ur.action("cloneHighDegreeNode", undoRedoActionFunctions.cloneHighDegreeNode,undoRedoActionFunctions.unCloneHighDegreeNode);

    ur.action("changeMapType", undoRedoActionFunctions.changeMapType,undoRedoActionFunctions.changeMapType);
    ur.action("setCompoundPadding", undoRedoActionFunctions.setCompoundPadding, undoRedoActionFunctions.setCompoundPadding);

  };

  return registerUndoRedoActions;
};

},{"./lib-utilities":4}],8:[function(_dereq_,module,exports){
var libs = _dereq_('./lib-utilities').getLibs();

module.exports = function () {

  var instance;

  function sbgnvizInstanceUtilities (options) {

    instance = libs.sbgnviz(options);

    return instance;
  }

  sbgnvizInstanceUtilities.getInstance = function () {
    return instance;
  }

  sbgnvizInstanceUtilities.getCy = function () {
    return this.getInstance().getCy();
  }

  return sbgnvizInstanceUtilities;
};

},{"./lib-utilities":4}],9:[function(_dereq_,module,exports){
var isEqual = _dereq_('lodash.isequal');

module.exports = function() {

  var cy, elementUtilities;
  var groupCompoundType, metaEdgeIdentifier, lockGraphTopology, shouldApply;

  var DEFAULT_GROUP_COMPOUND_TYPE = 'topology group';
  var EDGE_STYLE_NAMES = [ 'line-color', 'width' ];

  function topologyGrouping( param, props ) {
    cy = param.sbgnvizInstanceUtilities.getCy()
    elementUtilities = param.elementUtilities;

    groupCompoundType = props.groupCompoundType || DEFAULT_GROUP_COMPOUND_TYPE;
    metaEdgeIdentifier = props.metaEdgeIdentifier;
    lockGraphTopology = props.lockGraphTopology;
    shouldApply = props.shouldApply || true;

    topologyGrouping.applied = false;
    initMetaStyleMap();
  }

  topologyGrouping.apply = function() {
    if ( topologyGrouping.applied || !evalOpt( shouldApply ) ) {
      return;
    }

    var list = cy.nodes().map( function( node ) {
      return [ node ];
    } );

    // determine node groups by their topology
  	var groups = getNodeGroups( list );
  	// apply grouping in cy level
  	applyGrouping( groups );

    topologyGrouping.applied = true;

    if ( lockGraphTopology ) {
      elementUtilities.lockGraphTopology();
    }

  	return groups;
  };

  topologyGrouping.unapply = function() {
    if ( !topologyGrouping.applied ) {
      return;
    }

    var metaEdges = topologyGrouping.getMetaEdges();
    metaEdges.forEach( function( edge ) {
      var toRestore = edge.data('tg-to-restore');
      edge.remove();
      toRestore.restore();

      EDGE_STYLE_NAMES.forEach( function( name ) {
        var oldVal = topologyGrouping.metaStyleMap[ name ][ edge.id() ];
        var newVal = edge.data( name );

        if ( oldVal !== newVal ) {
          toRestore.data( name, newVal );
        }
      } );
    } );

    initMetaStyleMap();

    var parents = topologyGrouping.getGroupCompounds();
    elementUtilities.changeParent( parents.children(), null );
    parents.remove();

    topologyGrouping.applied = false;

    if ( lockGraphTopology ) {
      elementUtilities.unlockGraphTopology();
    }
  };

  topologyGrouping.getMetaEdges = function() {
    var metaEdges = cy.edges('[' + metaEdgeIdentifier + ']');
    return metaEdges;
  };

  topologyGrouping.getGroupCompounds = function() {
    var className = groupCompoundType;
    return cy.nodes('[class="' + className + '"]');
  };

  topologyGrouping.clearAppliedFlag = function() {
    topologyGrouping.applied = false;
  };

  topologyGrouping.setAppliedFlag = function(applied) {
    topologyGrouping.applied = applied;
  };

  topologyGrouping.toggleAppliedFlag = function() {
    topologyGrouping.applied = !topologyGrouping.applied;
  };

  function initMetaStyleMap() {
    topologyGrouping.metaStyleMap = {};
    EDGE_STYLE_NAMES.forEach( function( name ) {
      topologyGrouping.metaStyleMap[ name ] = {};
    } );
  }

  function evalOpt( opt ) {
    if ( typeof opt === 'function' ) {
      return opt();
    }

    return opt;
  }

  function getNodeGroups( list ) {
    if ( list.length <= 1 ) {
      return list;
    }

    var halves = getHalves( list );
    var firstPart = getNodeGroups( halves[ 0 ] );
    var secondPart = getNodeGroups( halves[ 1 ] );
    // merge the halves
	  var groups = mergeGroups( firstPart, secondPart );

    return groups;
  }

  function getParentOrSelf( node ) {
    var parent = node.parent();
    return parent.size() > 0 ? parent : node;
  }

  function calcGroupingKey( edge ) {
    var srcId = getParentOrSelf( edge.source() ).id();
    var tgtId = getParentOrSelf( edge.target() ).id();
    var edgeType = getEdgeType( edge );

    return [ edgeType, srcId, tgtId ].join( '-' );
  }

  function addToMapChain( map, key, val ) {
    if ( !map[ key ] ) {
      map[ key ] = cy.collection();
    }

    map[ key ] = map[ key ].add( val );
  }

  function applyGrouping( groups ) {
    groups.forEach( function( group ) {
      createGroupCompound( group );
    } );

    var compounds = topologyGrouping.getGroupCompounds();
    var childrenEdges = compounds.children().connectedEdges();
    var edgesMap = [];

    childrenEdges.forEach( function( edge ){
      var key = calcGroupingKey( edge );
      addToMapChain( edgesMap, key, edge );
      edge.remove();
    } );

    Object.keys( edgesMap ).forEach( function( key ) {
      // make a dummy edge for all of edges that are mapped by key
  		// dummy edge should have common properties of given edges
  		// and should carry their id list in its data
  		// for source and target it should have parent of common source and target
      createMetaEdgeFor( edgesMap[ key ] );
    } );
  }

  function createGroupCompound( group ) {
    if ( group.length < 2 ) {
      return;
    }

    var collection = cy.collection();

    group.forEach( function( node ) {
      collection = collection.add( node );
    } );

    elementUtilities.createCompoundForGivenNodes( collection, groupCompoundType );
  }

  function createMetaEdgeFor( edges ) {
    var srcId = getParentOrSelf( edges.source() ).id();
    var tgtId = getParentOrSelf( edges.target() ).id();
    var type = edges.data( 'class' );
    cy.remove( edges );

    var metaEdge = elementUtilities.addEdge( srcId, tgtId, type );
    metaEdge.data( 'tg-to-restore', edges );
    metaEdge.data( metaEdgeIdentifier, true );

    EDGE_STYLE_NAMES.forEach( function( styleName ) {
      edges.forEach( function( edge ) {
        topologyGrouping.metaStyleMap[ styleName ][ edge.id() ] = edge.data( styleName );
      } );

      var commonVal = elementUtilities.getCommonProperty(edges, styleName, 'data');
      if ( commonVal ) {
        metaEdge.data( styleName, commonVal );
      }
    } );

    return metaEdge;
  }

  function mergeGroups( groups1, groups2 ) {
    // notMergedGrs will include members of groups1 that are not merged
  	// mergedGrs will include the merged members from 2 groups
  	var notMergedGrs = [], mergedGrs = [];

    groups1.forEach( function( gr1 ) {
      var merged = false;

      mergedGrs.concat( groups2 ).forEach( function( gr2, index2 ) {
        // if groups should be merged merge them, remove gr2 from where it
        // comes from and push the merge result to mergedGrs
        if ( shouldMerge( gr1, gr2 ) ) {
          var mergedGr = gr1.concat( gr2 );

          if ( index2 >= mergedGrs.length ) {
            removeAt( groups2, index2 - mergedGrs.length );
          }
          else {
            removeAt( mergedGrs, index2 );
          }

          // mark as merged and break the loop
          mergedGrs.push( mergedGr );
          merged = true;
          return;
        }
      } );

      // if gr1 is not merged push it to notMergedGrs
      if ( !merged ) {
        notMergedGrs.push( gr1 );
      }
    } );

    // the groups that comes from groups2 but not merged are still included
	  // in groups2 add them to the result together with mergedGrs and notMergedGrs
    return notMergedGrs.concat( mergedGrs, groups2 );
  }

  function shouldMerge( group1, group2 ) {
    // using first elements is enough to decide whether to merge
  	var node1 = group1[ 0 ];
  	var node2 = group2[ 0 ];

    if ( node1.edges().length !== node2.edges().length ) {
      return false;
    }

    var getUndirectedEdges = function( node ) {
      var edges = node.connectedEdges().filter( isUndirectedEdge );
      return edges;
    };
    // undirected edges of node1 and node2 respectively
    var undir1 = getUndirectedEdges( node1 );
    var undir2 = getUndirectedEdges( node2 );

    var in1 = node1.incomers().edges().not( undir1 );
    var in2 = node2.incomers().edges().not( undir2 );

    var out1 = node1.outgoers().edges().not( undir1 );
	  var out2 = node2.outgoers().edges().not( undir2 );

    return compareEdgeGroup( in1, in2, node1, node2 )
            && compareEdgeGroup( out1, out2, node1, node2 )
            && compareEdgeGroup( undir1, undir2, node1, node2 );
  }

  // decide if 2 edge groups contains set of edges with similar content (type,
  // source,target) relative to their nodes where gr1 are edges of node1 and gr2 are edges of
  // node2
  function compareEdgeGroup( gr1, gr2, node1, node2 ) {
    var id1 = node1.id();
    var id2 = node2.id();

    var map1 = fillIdToTypeSetMap( gr1, node1 );
    var map2 = fillIdToTypeSetMap( gr2, node2 );

    if ( Object.keys( map1 ).length !== Object.keys( map2 ).length ) {
      return;
    }

    var failed = false;

    Object.keys( map1 ).forEach( function( key ) {
      // if already failed just return
      if ( failed ) {
        return;
      }

      // if key is id2 use id1 instead because comparison is relative to nodes
      var otherKey = ( key == id2 ) ? id1 : key;

      // check if the sets have the same content
  		// if check fails return false
      if ( !isEqual( map1[ key ], map2[ otherKey ] ) ) {
        failed = true;
      }
    } );

    // if check passes for each key return true
    return !failed;
  }

  function fillIdToTypeSetMap( edgeGroup, node ) {
    var map = {};
    var nodeId = node.id();

    edgeGroup.forEach( function( edge ) {
      var srcId = edge.data('source');
      var tgtId = edge.data('target');
      var edgeId = edge.id();

      var otherEnd = ( nodeId === tgtId ) ? srcId : tgtId;

      function addToRelatedSet( sideStr, value ) {
        if ( !map[ sideStr ] ) {
          map[ sideStr ] = new Set();
        }

        map[ sideStr ].add( value );
      }

      var edgeType = getEdgeType( edge );

      addToRelatedSet( otherEnd, edgeType );
    } );

    return map;
  }

  function getEdgeType( edge ) {
    return edge.data( 'class' );
  }

  function isUndirectedEdge( edge ) {
    return elementUtilities.isUndirectedEdge( edge );
  }

  // get halves of a list. It is assumed that list size is at least 2.
  function getHalves( list ) {
    var s = list.length;
    var halfIndex = Math.floor( s / 2 );
    var firstHalf = list.slice( 0, halfIndex );
    var secondHalf = list.slice( halfIndex, s );

    return [ firstHalf, secondHalf ];
  }

  function removeAt( arr, index ) {
    arr.splice( index, 1 );
  }

  return topologyGrouping;
};

},{"lodash.isequal":1}],10:[function(_dereq_,module,exports){
// Extends sbgnviz.undoRedoActionFunctions
var libs = _dereq_('./lib-utilities').getLibs();

module.exports = function () {

  var sbgnvizInstance, undoRedoActionFunctions, elementUtilities, cy, topologyGrouping;

  function undoRedoActionFunctionsExtender (param) {

    sbgnvizInstance = param.sbgnvizInstanceUtilities.getInstance();
    cy = param.sbgnvizInstanceUtilities.getCy();
    undoRedoActionFunctions = sbgnvizInstance.undoRedoActionFunctions;
    elementUtilities = param.elementUtilities;
    topologyGrouping = param.sifTopologyGrouping;

    extend();
  }

  // Extends undoRedoActionFunctions with chise specific features
  function extend () {

    undoRedoActionFunctions.applySIFTopologyGrouping = function(param) {
      var oldEles, newEles;
      if ( param.firstTime ) {
        oldEles = cy.elements();

        if (param.apply) {
          topologyGrouping.apply();
        }
        else {
          topologyGrouping.unapply();
        }

        newEles = cy.elements();
      }
      else {
        oldEles = param.oldEles;
        newEles = param.newEles;

        if ( elementUtilities.isGraphTopologyLocked() ) {
          elementUtilities.unlockGraphTopology();
        }
        else {
          elementUtilities.lockGraphTopology();
        }

        oldEles.remove();
        newEles.restore();

        topologyGrouping.toggleAppliedFlag();
      }

      var result = { oldEles: newEles, newEles: oldEles };
      return result;
    };

    // Section Start
    // add/remove action functions

    undoRedoActionFunctions.addNode = function (param) {
      var result;
      if (param.firstTime) {
        var newNode = param.newNode;
        result = elementUtilities.addNode(newNode.x, newNode.y, newNode.class, newNode.id, newNode.parent, newNode.visibility);
      }
      else {
        result = elementUtilities.restoreEles(param);
      }

      return {
        eles: result
      };
    };

    undoRedoActionFunctions.addEdge = function (param) {
      var result;
      if (param.firstTime) {
        var newEdge = param.newEdge;
        result = elementUtilities.addEdge(newEdge.source, newEdge.target, newEdge.class, newEdge.id, newEdge.visibility);
      }
      else {
        result = elementUtilities.restoreEles(param);
      }

      return {
        eles: result
      };
    };

    undoRedoActionFunctions.addProcessWithConvenientEdges = function(param) {
      var result;
      if (param.firstTime) {
        result = elementUtilities.addProcessWithConvenientEdges(param.source, param.target, param.processType);
      }
      else {
        result = elementUtilities.restoreEles(param);
      }

      return {
        eles: result
      };
    };

    undoRedoActionFunctions.createCompoundForGivenNodes = function (param) {
      var result = {};

      if (param.firstTime) {
        // Nodes to make compound, their descendants and edges connected to them will be removed during createCompoundForGivenNodes operation
        // (internally by eles.move() operation), so mark them as removed eles for undo operation.
        var nodesToMakeCompound = param.nodesToMakeCompound;
        var removedEles = nodesToMakeCompound.union(nodesToMakeCompound.descendants());
        removedEles = removedEles.union(removedEles.connectedEdges());
        result.removedEles = removedEles;
        // Assume that all nodes to make compound have the same parent
        var oldParentId = nodesToMakeCompound[0].data("parent");
        // The parent of new compound will be the old parent of the nodes to make compound
        // New eles includes new compound and the moved eles and will be used in undo operation.
        result.newEles = elementUtilities.createCompoundForGivenNodes(nodesToMakeCompound, param.compoundType);
      }
      else {
        result.removedEles = param.newEles.remove();
        result.newEles = param.removedEles.restore();
        elementUtilities.maintainPointer(result.newEles);
      }

      return result;
    };

    // Section End
    // add/remove action functions

    // Section Start
    // easy creation action functions

    undoRedoActionFunctions.createTemplateReaction = function (param) {
      var firstTime = param.firstTime;
      var eles;

      if (firstTime) {
        eles = elementUtilities.createTemplateReaction(param.templateType, param.macromoleculeList, param.complexName, param.processPosition, param.tilingPaddingVertical, param.tilingPaddingHorizontal, param.edgeLength, param.layoutParam)
      }
      else {
        eles = param;
        cy.add(eles);

        cy.elements().unselect();
        eles.select();
      }

      return {
        eles: eles
      };
    };

    // Section End
    // easy creation action functions

    // Section Start
    // general action functions

    undoRedoActionFunctions.getNodePositions = function () {
      var positions = {};
      var nodes = cy.nodes();

      nodes.each(function(ele, i) {
        if(typeof ele === "number") {
          ele = i;
        }

        positions[ele.id()] = {
          x: ele.position("x"),
          y: ele.position("y")
        };
      });

      return positions;
    };

    undoRedoActionFunctions.returnToPositions = function (positions) {
      var currentPositions = {};
      cy.nodes().positions(function (ele, i) {
        if(typeof ele === "number") {
          ele = i;
        }

        currentPositions[ele.id()] = {
          x: ele.position("x"),
          y: ele.position("y")
        };

        var pos = positions[ele.id()];
        return {
          x: pos.x,
          y: pos.y
        };
      });

      return currentPositions;
    };

    undoRedoActionFunctions.resizeNodes = function (param) {
      var result = {
        performOperation: true
      };

      var nodes = param.nodes;

      result.sizeMap = {};
      result.useAspectRatio = false;
      result.preserveRelativePos = param.preserveRelativePos;

      for (var i = 0; i < nodes.length; i++) {
        var node = nodes[i];
        if(node.isParent()){
          result.sizeMap[node.id()] = {
            w: node.data("minWidth"),
            h: node.data("minHeight"),
            biasL : node.data("minWidthBiasLeft"),
            bisaR : node.data("minWidthBiasRight"),
            biasT : node.data("minHeightBiasTop"),
            biasB : node.data("minHeightBiasBottom")
           // w: node.css("minWidth") != 0?  node.data("minWidth") : node.children().boundingBox().w,
            //h: node.css("min-height") != 0?  node.data("minHeight") : node.children().boundingBox().h
          };
        }else{
          result.sizeMap[node.id()] = {
            w: node.width(),
            h: node.height()
          };
        }
        
      }

      result.nodes = nodes;

      for (var i = 0; i < nodes.length; i++) {
        var node = nodes[i];

        if (param.performOperation) {
          if (param.sizeMap) {
            /* if (param.preserveRelativePos === true) {
              var oldWidth = node.data("bbox").w;
              var oldHeight = node.data("bbox").h;
            } */

            if(node.isParent()){
              
              node.data("minHeight" , param.sizeMap[node.id()].h);
              node.data("minWidth" , param.sizeMap[node.id()].w);
              node.data("minWidthBiasLeft", param.sizeMap[node.id()].biasL);
              node.data("minWidthBiasRight", param.sizeMap[node.id()].biasR);
              node.data("minHeightBiasTop", param.sizeMap[node.id()].biasT);
              node.data("minHeightBiasBottom", param.sizeMap[node.id()].biasB);

            }else{
              node.data("bbox").w = param.sizeMap[node.id()].w;
              node.data("bbox").h = param.sizeMap[node.id()].h;
            }
           

            /* if (param.preserveRelativePos === true) {
              var statesandinfos = node.data('statesandinfos');
              var topBottom = statesandinfos.filter(box => (box.anchorSide === "top" || box.anchorSide === "bottom"));
              var rightLeft = statesandinfos.filter(box => (box.anchorSide === "right" || box.anchorSide === "left"));

              topBottom.forEach(function(box){
                if (box.bbox.x < 0) {
                  box.bbox.x = 0;
                }
                else if (box.bbox.x > oldWidth) {
                  box.bbox.x = oldWidth;
                }
                box.bbox.x = node.data("bbox").w * box.bbox.x / oldWidth;
              });

              rightLeft.forEach(function(box){
                if (box.bbox.y < 0) {
                  box.bbox.y = 0;
                }
                else if (box.bbox.y > oldHeight) {
                  box.bbox.y = oldHeight;
                }
                box.bbox.y = node.data("bbox").h * box.bbox.y / oldHeight;
              });
            } */
          }
          else {
            elementUtilities.resizeNodes(param.nodes, param.width, param.height, param.useAspectRatio, param.preserveRelativePos);
          }
        }
      }
      cy.style().update();
      return result;
    };

    undoRedoActionFunctions.changeNodeLabel = function (param) {
      var result = {
      };
      var nodes = param.nodes;
      result.nodes = nodes;
      result.label = {};

      for (var i = 0; i < nodes.length; i++) {
        var node = nodes[i];
        result.label[node.id()] = node._private.data.label;
      }

      if (param.firstTime) {
        nodes.data('label', param.label);
      }
      else {
        for (var i = 0; i < nodes.length; i++) {
          var node = nodes[i];
          node._private.data.label = param.label[node.id()];
        }
      }

      return result;
    };

    undoRedoActionFunctions.updateInfoboxStyle = function (param) {
      var result = {
      };
      var style = param.node.data('statesandinfos')[param.index].style;
      result.newProps = $.extend( {}, style );
      result.node = param.node;
      result.index = param.index;

      elementUtilities.updateInfoboxStyle( param.node, param.index, param.newProps );

      return result;
    };

    undoRedoActionFunctions.updateInfoboxObj = function (param) {
      var result = {
      };
      var obj = param.node.data('statesandinfos')[param.index];
      result.newProps = $.extend( {}, obj );
      result.node = param.node;
      result.index = param.index;

      elementUtilities.updateInfoboxObj( param.node, param.index, param.newProps );

      return result;
    };

    undoRedoActionFunctions.changeData = function (param) {
      var result = {
      };
      var eles = param.eles;
      result.name = param.name;
      result.valueMap = {};
      result.eles = eles;

      for (var i = 0; i < eles.length; i++) {
        var ele = eles[i];
        result.valueMap[ele.id()] = ele.data(param.name);
      }

      elementUtilities.changeData(param.eles, param.name, param.valueMap);

      return result;
    };

    undoRedoActionFunctions.updateSetField = function( param ) {
      var updates = elementUtilities.updateSetField( param.ele, param.fieldName, param.toDelete, param.toAdd, param.callback );

      var result = {
        ele: param.ele,
        fieldName: param.fieldName,
        callback: param.callback,
        toDelete: updates.added,
        toAdd: updates.deleted
      };

      return result;
    };

    undoRedoActionFunctions.changeCss = function (param) {
      var result = {
      };
      var eles = param.eles;
      result.name = param.name;
      result.valueMap = {};
      result.eles = eles;

      for (var i = 0; i < eles.length; i++) {
        var ele = eles[i];
        result.valueMap[ele.id()] = ele.css(param.name);
      }

      elementUtilities.changeCss(param.eles, param.name, param.valueMap);

      return result;
    };

    undoRedoActionFunctions.changeFontProperties = function (param) {
      var result = {
      };

      var eles = param.eles;
      result.data = {};
      result.eles = eles;

      for (var i = 0; i < eles.length; i++) {
        var ele = eles[i];

        result.data[ele.id()] = {};

        var data = param.firstTime ? param.data : param.data[ele.id()];

        for (var prop in data) {
          result.data[ele.id()][prop] = ele.data(prop);
        }
      }

      if (param.firstTime) {
        elementUtilities.changeFontProperties(eles, data);
      }
      else {
        for (var i = 0; i < eles.length; i++) {
          var ele = eles[i];

          elementUtilities.changeFontProperties(ele, data);
        }
      }

      return result;
    };

    /*
     * Show eles and perform layout.
     */
    undoRedoActionFunctions.showAndPerformLayout = function (param) {
      var eles = param.eles;

      var result = {};
      result.positions = undoRedoActionFunctions.getNodePositions();

      if (param.firstTime) {
        result.eles = elementUtilities.showAndPerformLayout(param.eles, param.layoutparam);
      }
      else {
        result.eles = cy.viewUtilities().show(eles); // Show given eles
        undoRedoActionFunctions.returnToPositions(param.positions);
      }

      return result;
    };

    undoRedoActionFunctions.undoShowAndPerformLayout = function (param) {
      var eles = param.eles;

      var result = {};
      result.positions = undoRedoActionFunctions.getNodePositions();
      result.eles = cy.viewUtilities().hide(eles); // Hide previously unhidden eles;

      undoRedoActionFunctions.returnToPositions(param.positions);

      return result;
    };

    /*
     * Hide eles and perform layout.
     */
    undoRedoActionFunctions.hideAndPerformLayout = function (param) {
        var eles = param.eles;

        var result = {};
        result.positions = undoRedoActionFunctions.getNodePositions();

        if (param.firstTime) {
            result.eles = elementUtilities.hideAndPerformLayout(param.eles, param.layoutparam);
        }
        else {
            result.eles = cy.viewUtilities().hide(eles); // Hide given eles
            undoRedoActionFunctions.returnToPositions(param.positions);
        }

        return result;
    };

    undoRedoActionFunctions.undoHideAndPerformLayout = function (param) {
        var eles = param.eles;

        var result = {};
        result.positions = undoRedoActionFunctions.getNodePositions();
        result.eles = cy.viewUtilities().show(eles); // Show previously hidden eles

        undoRedoActionFunctions.returnToPositions(param.positions);

        return result;
    };

    // Section End
    // general action functions

    // Section Start
    // sbgn action functions

    undoRedoActionFunctions.changeStateOrInfoBox = function (param) {
      var result = {
      };
      result.type = param.type;
      result.nodes = param.nodes;
      result.index = param.index;
      var data = param.data;

      var tempData = elementUtilities.saveUnits(param.nodes);
      result.value = elementUtilities.changeStateOrInfoBox(param.nodes, param.index, param.value, param.type);
      /* var locations = elementUtilities.checkFit(param.nodes);
      if (locations !== undefined && locations.length > 0) {
        elementUtilities.fitUnits(param.nodes, locations);
      } */
      if (data !== undefined) {
        elementUtilities.restoreUnits(param.nodes, data);
      }

      cy.forceRender();
      result.data = tempData;
      return result;
    };

    undoRedoActionFunctions.addStateOrInfoBox = function (param) {
      var obj = param.obj;
      var nodes = param.nodes;
      var data = param.data;

      var tempData = elementUtilities.saveUnits(nodes);
      var locationObj = elementUtilities.addStateOrInfoBox(nodes, obj);
     /*  var locations = elementUtilities.checkFit(nodes);
      if (locations !== undefined && locations.length > 0) {
        elementUtilities.fitUnits(nodes, locations);
      } */
      if (data !== undefined) {
        elementUtilities.restoreUnits(nodes, data);
      }

      cy.forceRender();

      var result = {
        nodes: nodes,
        locationObj: locationObj,
        obj: obj,
        data: tempData
      };
      return result;
    };

    undoRedoActionFunctions.removeStateOrInfoBox = function (param) {
      var locationObj = param.locationObj;
      var nodes = param.nodes;
      var data = param.data;

      var tempData = elementUtilities.saveUnits(nodes);
      var obj = elementUtilities.removeStateOrInfoBox(nodes, locationObj);
      if (data !== undefined) {
        elementUtilities.restoreUnits(nodes, data);
      }

      cy.forceRender();

      var result = {
        nodes: nodes,
        obj: obj,
        data: tempData
      };
      return result;
    };

    undoRedoActionFunctions.fitUnits = function (param) {
      var node = param.node;
      var locations = param.locations;
      var obj = elementUtilities.fitUnits(node, locations);

      cy.forceRender();

      var result = {
        node: node,
        obj: obj,
        locations: locations
      };
      return result;
    };

    undoRedoActionFunctions.restoreUnits = function (param) {
      var node = param.node;
      var locations = param.locations;
      var obj = param.obj;
      var index = 0;
      node.data('statesandinfos').forEach( function (ele) {
        var box = obj[index++];
        ele.bbox.x = box.x;
        ele.bbox.y = box.y;
        var oldSide = ele.anchorSide;
        ele.anchorSide = box.anchorSide;
        elementUtilities.modifyUnits(node, ele, oldSide);
      });

      cy.forceRender();

      var result = {
        node: node,
        locations: locations
      };
      return result;
    };

    undoRedoActionFunctions.setMultimerStatus = function (param) {
      var firstTime = param.firstTime;
      var nodes = param.nodes;
      var status = param.status;
      var resultStatus = {};

      for (var i = 0; i < nodes.length; i++) {
        var node = nodes[i];
        var isMultimer = node.data('class').endsWith(' multimer');

        resultStatus[node.id()] = isMultimer;
      }

      // If this is the first time change the status of all nodes at once.
      // If not change status of each seperately to the values mapped to their id.
      if (firstTime) {
        elementUtilities.setMultimerStatus(nodes, status);
      }
      else {
        for (var i = 0; i < nodes.length; i++) {
          var node = nodes[i];
          elementUtilities.setMultimerStatus(node, status[node.id()]);
        }
      }

    //  if (!firstTime && _.isEqual(nodes, cy.nodes(':selected'))) {
    //    $('#inspector-is-multimer').attr("checked", !$('#inspector-is-multimer').attr("checked"));
    //  }

      var result = {
        status: resultStatus,
        nodes: nodes
      };

      return result;
    };

    undoRedoActionFunctions.setCloneMarkerStatus = function (param) {
      var nodes = param.nodes;
      var status = param.status;
      var firstTime = param.firstTime;
      var resultStatus = {};

      for (var i = 0; i < nodes.length; i++) {
        var node = nodes[i];
        resultStatus[node.id()] = node.data('clonemarker');
        var currentStatus = firstTime ? status : status[node.id()];
        elementUtilities.setCloneMarkerStatus(node, currentStatus);
      }

    //  if (!firstTime && _.isEqual(nodes, cy.nodes(':selected'))) {
    //    $('#inspector-is-clone-marker').attr("checked", !$('#inspector-is-clone-marker').attr("checked"));
    //  }

      var result = {
        status: resultStatus,
        nodes: nodes
      };

      return result;
    };

    // param: {class: sbgnclass, name: propertyName, value: value}
    undoRedoActionFunctions.setDefaultProperty = function (param) {
      var sbgnclass = param.class;
      var name = param.name;
      var value = param.value;
      var classDefaults = elementUtilities.getDefaultProperties(sbgnclass);
      var result = {
        class: sbgnclass,
        name: name,
        value: classDefaults.hasOwnProperty(name) ? classDefaults[name] : undefined
      };

      var propMap = {};
      propMap[ name ] = value;

      elementUtilities.setDefaultProperties( sbgnclass, propMap );

      return result;
    };

    undoRedoActionFunctions.addBackgroundImage = function (param) {
      var bgObj = param.bgObj;
      var nodes = param.nodes;
      var updateInfo = param.updateInfo;
      var promptInvalidImage = param.promptInvalidImage;
      var validateURL = param.validateURL;

      elementUtilities.addBackgroundImage(nodes, bgObj, updateInfo, promptInvalidImage, validateURL);

      cy.forceRender();

      var result = {
        nodes: nodes,
        bgObj: bgObj,
        updateInfo: updateInfo,
        promptInvalidImage: promptInvalidImage,
        validateURL: validateURL
      };
      return result;
    };

    undoRedoActionFunctions.removeBackgroundImage = function (param) {
      var bgObj = param.bgObj;
      var nodes = param.nodes;

      elementUtilities.removeBackgroundImage(nodes, bgObj);

      cy.forceRender();

      var result = {
        nodes: nodes,
        bgObj: bgObj
      };
      return result;
    };

    undoRedoActionFunctions.updateBackgroundImage = function (param) {
      var bgObj = param.bgObj;
      var nodes = param.nodes;

      var oldBgObj = elementUtilities.updateBackgroundImage(nodes, bgObj);

      cy.forceRender();

      var result = {
        nodes: nodes,
        bgObj: oldBgObj
      };
      return result;
    };

    undoRedoActionFunctions.changeBackgroundImage = function (param) {
      var oldImg = param.oldImg;
      var newImg = param.newImg;
      var nodes = param.nodes;
      var firstTime = param.firstTime;
      var updateInfo = param.updateInfo;
      var promptInvalidImage = param.promptInvalidImage;
      var validateURL= param.validateURL;

      var result = elementUtilities.changeBackgroundImage(nodes, oldImg, newImg, firstTime, updateInfo, promptInvalidImage, validateURL);

      cy.forceRender();

      return result;
    };

    // Section End
    // sbgn action functions
    undoRedoActionFunctions.convertIntoReversibleReaction = function (param) {
      let collection = cy.collection();
      let mapType = elementUtilities.getMapType();
      elementUtilities.setMapType(param.mapType);
      $('#map-type').val(param.mapType);

      param.collection.forEach(function(edge) {
        var sourceNode = edge._private.data.source;
        var targetNode = edge._private.data.target;

        edge.move({source: targetNode, target: sourceNode});

        let convertedEdge = cy.getElementById(edge.id());

        if(convertedEdge.data("cyedgebendeditingDistances")){
          let distance = convertedEdge.data("cyedgebendeditingDistances");
          distance = distance.map(function(element) {
            return -1*element;
          });
          convertedEdge.data("cyedgebendeditingDistances", distance.reverse());

          let weight = convertedEdge.data("cyedgebendeditingWeights");
          weight = weight.map(function(element) {
            return 1-element;
          });
          convertedEdge.data("cyedgebendeditingWeights", weight.reverse());
        }

        if (convertedEdge._private.data.class === "consumption") {
          convertedEdge._private.data.class = "production";
          convertedEdge._private.data.portsource = targetNode + ".1";
          convertedEdge._private.data.porttarget = sourceNode;
        }
        else if (convertedEdge._private.data.class === "production") {
          convertedEdge._private.data.class = "consumption";
          convertedEdge._private.data.portsource = targetNode;
          convertedEdge._private.data.porttarget = sourceNode + ".1";
        }

        collection = collection.add(convertedEdge);
        cy.style().update();
      });

      var result = {
        collection: collection,
        mapType: mapType,
        processId: param.processId
      };
      return result;
    }

    undoRedoActionFunctions.moveEdge = function (param) {
      var result = {
      };
      var edge = param.edge;
      result.name = param.name;      
     

      result.source = edge.source().id();
      result.target = edge.target().id();      
      result.portsource  =edge.data("portsource");
      result.porttarget = edge.data("porttarget");
      elementUtilities.changeData(edge, 'source', param.source);
      elementUtilities.changeData(edge, 'target', param.target);
      elementUtilities.changeData(edge, 'portsource', param.portsource);
      elementUtilities.changeData(edge, 'porttarget', param.porttarget); 
      edge = edge.move({
        target: param.target,
        source : param.source
    
     });

     result.edge = edge;
      return result;
    };

    undoRedoActionFunctions.fixError = function(param){
      
      var errorCode = param.errorCode;
      var result = {};
      result.errorCode = errorCode;
      if(errorCode == "pd10101" || errorCode == 'pd10102'){

        result.edge = elementUtilities.reverseEdge(param.edge);

         return result;
      }else if(errorCode == "pd10103" || errorCode == 'pd10107'){

       
        
        param.newNodes.forEach(function(newNode){
         elementUtilities.addNode(newNode.x, newNode.y, newNode.class, newNode.id, undefined);

          
        });

        param.newEdges.forEach(function(newEdge){          
          elementUtilities.addEdge(newEdge.source,newEdge.target,newEdge.class);
        });

        param.oldEdges.forEach(function(oldEdge){
          cy.elements().unselect();
          //return 
          oldEdge.remove();
        });

        param.node.remove();

        return param;

      }else if(errorCode == "pd10105" || errorCode == 'pd10106'){
   
        result.edge = elementUtilities.reverseEdge(param.edge);
        return result;
      }else if(errorCode == "pd10140"){
        param.node.remove();
        return param;
      }else if(errorCode == "pd10104") {
        
        param.edges.forEach(function(edge){
          edge.remove();
        });
        param.nodes.forEach(function(node){
          node.remove();
        });
        return param;
      }else if(errorCode == "pd10108"){
        param.edges.forEach(function(edge){
          edge.remove();
        });
        param.nodes.forEach(function(node){
          node.remove();
        });
        return param;
      }else if(errorCode == "pd10111"){
        param.edges.forEach(function(edge){
          edge.remove();
        });
        return param;
      }else if(errorCode == "pd10126"){
        param.edges.forEach(function(edge){
          edge.remove();
        });
        param.nodes.forEach(function(node){
          node.remove();
        });
        return param;
      }else if(errorCode == "pd10109" || errorCode == "pd10124") {
        
        result.newSource = param.edge.data().source;
        result.newTarget = param.edge.data().target;
        result.portsource = param.edge.data().portsource;
        var clonedEdge = param.edge.clone();
       
        var edgeParams = {class : clonedEdge.data().class, language :clonedEdge.data().language};
        clonedEdge.data().source = param.newSource;
        clonedEdge.data().target = param.newTarget;
        cy.remove(param.edge);
        result.edge = elementUtilities.addEdge(param.newSource,param.newTarget,edgeParams, clonedEdge.data().id);      
        return result;

      }else if(errorCode == "pd10112") {    
        
        param.callback = elementUtilities.maintainPointer;  
        // If this is first time we should move the node to its new parent and relocate it by given posDiff params
        // else we should remove the moved eles and restore the eles to restore
        if (param.firstTime) {
          var newParentId = param.parentData == undefined ? null : param.parentData;
          // These eles includes the nodes and their connected edges and will be removed in nodes.move().
          // They should be restored in undo
          var withDescendant = param.nodes.union(param.nodes.descendants());
          result.elesToRestore = withDescendant.union(withDescendant.connectedEdges());
          // These are the eles created by nodes.move(), they should be removed in undo.
          result.movedEles = param.nodes.move({"parent": newParentId});

          var posDiff = {
            x: param.posDiffX,
            y: param.posDiffY
          };

          elementUtilities.moveNodes(posDiff, result.movedEles);
        }
        else {
          result.elesToRestore = param.movedEles.remove();
          result.movedEles = param.elesToRestore.restore();
        }

        if (param.callback) {
          result.callback = param.callback; // keep the provided callback so it can be reused after undo/redo
          param.callback(result.movedEles); // apply the callback on newly created elements
        }

        return result;
      
      }else if(errorCode == "pd10125") {

       result.edge = param.edge.remove();       
       result.newEdge ={};
       var edgeclass = param.newEdge.edgeParams.class ? param.newEdge.edgeParams.class : param.newEdge.edgeParams;
       var validation = elementUtilities.validateArrowEnds(edgeclass, cy.getElementById(param.newEdge.source), cy.getElementById(param.newEdge.target));

       if (validation === 'reverse') {
        var temp = param.newEdge.source;
        param.newEdge.source = param.newEdge.target;
        param.newEdge.target = temp;
      }
       result.newEdge.id =elementUtilities.addEdge(param.newEdge.source,param.newEdge.target,param.newEdge.edgeParams).id();
       result.newEdge.source = param.newEdge.source;
       result.newEdge.target = param.newEdge.target;
       result.newEdge.edgeParams = param.newEdge.edgeParams;
       
       return result;

        
      }else if(errorCode == "pd10142") {
        result.edge = param.edge.remove();       
        result.newEdge ={};
        var edgeclass = param.newEdge.edgeParams.class ? param.newEdge.edgeParams.class : param.newEdge.edgeParams;
        var validation = elementUtilities.validateArrowEnds(edgeclass, cy.getElementById(param.newEdge.source), cy.getElementById(param.newEdge.target));

        if (validation === 'reverse') {
         var temp = param.newEdge.source;
         param.newEdge.source = param.newEdge.target;
         param.newEdge.target = temp;
       }
        result.newEdge.id =elementUtilities.addEdge(param.newEdge.source,param.newEdge.target,param.newEdge.edgeParams).id();
        result.newEdge.source = param.newEdge.source;
        result.newEdge.target = param.newEdge.target;
        result.newEdge.edgeParams = param.newEdge.edgeParams;
        
        return result;
      }else {

        result.newSource = param.edge.source().id();
        result.newTarget = param.edge.target().id();
        result.porttarget = param.edge.data("porttarget");
        result.edge = param.edge.move({
          target: param.newTarget,
          source : param.newSource      
        });

        elementUtilities.changeData(result.edge, 'porttarget', param.porttarget);
        return result;
        
      }
      
  }
  
  undoRedoActionFunctions.unfixError = function(param){
    var errorCode = param.errorCode;
    var result = {};
    result.errorCode = errorCode;
    if(errorCode == "pd10101" || errorCode == 'pd10102'){
     
        result.edge = elementUtilities.reverseEdge(param.edge);
      return result;
    }else if(errorCode == "pd10103" || errorCode == 'pd10107'){

      param.newNodes.forEach(function(newNode){    
        cy.remove(cy.$('#'+newNode.id))      
        
      });

      param.node.restore();

      param.oldEdges.forEach(function(oldEdge){  
        oldEdge.restore();
      });

      cy.animate({
        duration: 100,
        easing: 'ease',
        fit :{eles:{},padding:20}, 
        complete: function(){
              
        }
      });

      return param;

    }else if(errorCode == "pd10105" || errorCode == 'pd10106'){  

      result.edge = elementUtilities.reverseEdge(param.edge);
      return result;

    }else if(errorCode == "pd10140"){
      param.node.restore();
      cy.animate({
        duration: 100,
        easing: 'ease',
        fit :{eles:{},padding:20}, 
        complete: function(){
              
        }
      });
      return param;
    }else if(errorCode == "pd10104") {
      
      param.nodes.forEach(function(node){
        node.restore();
      });
      param.edges.forEach(function(edge){
        edge.restore();
      });
      return param;
    }else if(errorCode == "pd10108"){
      
      param.nodes.forEach(function(node){
        node.restore();
      });
      param.edges.forEach(function(edge){
        edge.restore();
      });
      return param;
    }else if(errorCode == "pd10111"){
      param.edges.forEach(function(edge){
        edge.restore();
      });
      return param;
    }else if(errorCode == "pd10126"){
      param.nodes.forEach(function(node){
        node.restore();
      });
      param.edges.forEach(function(edge){
        edge.restore();
      });       
      return param;
    }else if(errorCode == "pd10109" || errorCode == "pd10124") {

      result.newSource = param.edge.source().id();
      result.newTarget = param.edge.target().id();
      result.portsource = param.portsource;
      result.edge = param.edge.move({
        target: param.newTarget,
        source : param.newSource      
      });

      elementUtilities.changeData(result.edge, 'portsource', param.portsource); 
      return result;
    }else if(errorCode == "pd10112") {
     
      // If this is first time we should move the node to its new parent and relocate it by given posDiff params
      // else we should remove the moved eles and restore the eles to restore
      if (param.firstTime) {
        var newParentId = param.parentData == undefined ? null : param.parentData;
        // These eles includes the nodes and their connected edges and will be removed in nodes.move().
        // They should be restored in undo
        var withDescendant = param.nodes.union(param.nodes.descendants());
        result.elesToRestore = withDescendant.union(withDescendant.connectedEdges());
        // These are the eles created by nodes.move(), they should be removed in undo.
        result.movedEles = param.nodes.move({"parent": newParentId});

        var posDiff = {
          x: param.posDiffX,
          y: param.posDiffY
        };

        elementUtilities.moveNodes(posDiff, result.movedEles);
      }
      else {
        result.elesToRestore = param.movedEles.remove();
        result.movedEles = param.elesToRestore.restore();
      }

      if (param.callback) {
        result.callback = param.callback; // keep the provided callback so it can be reused after undo/redo
        param.callback(result.movedEles); // apply the callback on newly created elements
      }

     
      return result;
      
    }else if(errorCode == "pd10125") {

      cy.$('#'+param.newEdge.id).remove();
      param.edge = param.edge.restore();

    
      return param;
      
    }else if(errorCode == "pd10142") {
      cy.$('#'+param.newEdge.id).remove();
      param.edge = param.edge.restore();

    
      return param;
    }else {

      result.newSource = param.edge.source().id();
      result.newTarget = param.edge.target().id();
      result.porttarget = param.edge.data("porttarget");
      result.edge = param.edge.move({
        target: param.newTarget,
        source : param.newSource      
      });

      elementUtilities.changeData(result.edge, 'porttarget', param.porttarget);
      return result;

      
    }
    
  }

  undoRedoActionFunctions.cloneHighDegreeNode = function(node){

    var result = {};
    var oldX = node.position().x;
    var oldY = node.position().y;
    
    
    var claculateNewClonePosition = function(sourceEndPointX,sourceEndPointY,targetEndPointX,targetEndPointY,desiredDistance,direction){
      var distance = Math.sqrt(Math.pow(targetEndPointY-sourceEndPointY,2)+ Math.pow(targetEndPointX-sourceEndPointX,2));
      var ratio = desiredDistance/distance;
      var result = {};
      if(direction == "source"){ 
        result.cx = ((1-ratio) * sourceEndPointX)  + (ratio * targetEndPointX);
        result.cy = ((1-ratio) * sourceEndPointY)  + (ratio * targetEndPointY);
      }else{      
        result.cx = ((1-ratio) * targetEndPointX)  + (ratio * sourceEndPointX);
        result.cy = ((1-ratio) * targetEndPointY)  + (ratio * sourceEndPointY);
      }
      
      return result;
    };   
    var edges = node.connectedEdges();
    var desiredDistance = (node.height() > node.width()? node.height(): node.width())* 0.1;
    for(var i = 1 ; i < edges.length ; i++){
      var edge = edges[i];
      var index = i;
      var edgeClone = edge.clone();
      var startPosition = edge.source().id() == node.id() ? "source" : "target";    
      var newPosition = claculateNewClonePosition(edge.sourceEndpoint().x,edge.sourceEndpoint().y,edge.targetEndpoint().x,edge.targetEndpoint().y,desiredDistance,startPosition); 
      var newNodeId = node.id()+'clone-'+index;
      //edgeClone.data().id = edgeClone.data().id+ "-"+newNodeId;
      if(edge.source().id() == node.id()){        
        edgeClone.data().source = newNodeId;
        edgeClone.data().portsource = newNodeId;    
      }else{
          
        edgeClone.data().target = newNodeId;
        edgeClone.data().porttarget = newNodeId;    
      }
      var newNode = node.clone();
      newNode.data().id = newNodeId;
      cy.add(newNode);
     
      edge.remove();
      cy.add(edgeClone);
      newNode.position({
        x: newPosition.cx,
        y: newPosition.cy
      });
      elementUtilities.setCloneMarkerStatus(newNode, true);
      
    }  
    
    var newPosition = claculateNewClonePosition(
      edges[0].sourceEndpoint().x,
      edges[0].sourceEndpoint().y,
      edges[0].targetEndpoint().x,
      edges[0].targetEndpoint().y,
      desiredDistance,edges[0].source().id() == node.id() ? "source" : "target"
      );
  
    var cloneEdge = edges[0].clone();
    //cloneEdge.data().id = cloneEdge.data().id+ "-"+node.id()+'clone-0';
    
    edges[0].remove();
    cy.add(cloneEdge);
    elementUtilities.setCloneMarkerStatus(node,true);
    node.position({
      x: newPosition.cx,
      y: newPosition.cy
    });
  
    result.oldX = oldX;    
    result.oldY = oldY;
    result.node = node;
    result.numberOfEdges = edges.length;
    return result;

  }

  undoRedoActionFunctions.unCloneHighDegreeNode = function(param){

    var node = param.node;
    elementUtilities.setCloneMarkerStatus(node,false);
    node.position({
      x: param.oldX,
      y: param.oldY
    });
  
    for(var i = 1 ; i < param.numberOfEdges ; i++){
      var cloneId = node.id()+'clone-'+i;
      var clone = cy.$("#"+cloneId);
      var cloneEdge = clone.connectedEdges()[0];
      var edge = cloneEdge.clone();
      
    
      if(edge.data().source == cloneId){        
        edge.data().source = node.id();
        edge.data().portsource =  node.id();    
      }else{          
        edge.data().target =  node.id();
        edge.data().porttarget =  node.id();    
      }

      cloneEdge.remove();
      clone.remove();
      
      cy.add(edge);
    }

    return node;
  }

  undoRedoActionFunctions.changeMapType = function(param){
    var result ={};
    var currentMapType = elementUtilities.getMapType();
    elementUtilities.setMapType(param.mapType);
    result.mapType = currentMapType;
    result.callback = param.callback;
    param.callback();
    return result;
  }

  }

  return undoRedoActionFunctionsExtender;
};

},{"./lib-utilities":4}]},{},[2])(2)
});

//# sourceMappingURL=data:application/json;charset:utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","node_modules/lodash.isequal/index.js","src/index.js","src/utilities/element-utilities-extender-factory.js","src/utilities/lib-utilities.js","src/utilities/main-utilities-factory.js","src/utilities/option-utilities-factory.js","src/utilities/register-undo-redo-actions-factory.js","src/utilities/sbgnviz-instance-utilities-factory.js","src/utilities/topology-grouping-factory.js","src/utilities/ur-action-functions-extender-factory.js"],"names":[],"mappings":"AAAA;;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACxzDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9FA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxsDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACfA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjsCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChXA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;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":["(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})","/**\n * Lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright JS Foundation and other contributors <https://js.foundation/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n\n/** Used as the size to enable large array optimizations. */\nvar LARGE_ARRAY_SIZE = 200;\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1,\n    COMPARE_UNORDERED_FLAG = 2;\n\n/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n    arrayTag = '[object Array]',\n    asyncTag = '[object AsyncFunction]',\n    boolTag = '[object Boolean]',\n    dateTag = '[object Date]',\n    errorTag = '[object Error]',\n    funcTag = '[object Function]',\n    genTag = '[object GeneratorFunction]',\n    mapTag = '[object Map]',\n    numberTag = '[object Number]',\n    nullTag = '[object Null]',\n    objectTag = '[object Object]',\n    promiseTag = '[object Promise]',\n    proxyTag = '[object Proxy]',\n    regexpTag = '[object RegExp]',\n    setTag = '[object Set]',\n    stringTag = '[object String]',\n    symbolTag = '[object Symbol]',\n    undefinedTag = '[object Undefined]',\n    weakMapTag = '[object WeakMap]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n    dataViewTag = '[object DataView]',\n    float32Tag = '[object Float32Array]',\n    float64Tag = '[object Float64Array]',\n    int8Tag = '[object Int8Array]',\n    int16Tag = '[object Int16Array]',\n    int32Tag = '[object Int32Array]',\n    uint8Tag = '[object Uint8Array]',\n    uint8ClampedTag = '[object Uint8ClampedArray]',\n    uint16Tag = '[object Uint16Array]',\n    uint32Tag = '[object Uint32Array]';\n\n/**\n * Used to match `RegExp`\n * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n */\nvar reRegExpChar = /[\\\\^$.*+?()[\\]{}|]/g;\n\n/** Used to detect host constructors (Safari). */\nvar reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n/** Used to detect unsigned integer values. */\nvar reIsUint = /^(?:0|[1-9]\\d*)$/;\n\n/** Used to identify `toStringTag` values of typed arrays. */\nvar typedArrayTags = {};\ntypedArrayTags[float32Tag] = typedArrayTags[float64Tag] =\ntypedArrayTags[int8Tag] = typedArrayTags[int16Tag] =\ntypedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =\ntypedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =\ntypedArrayTags[uint32Tag] = true;\ntypedArrayTags[argsTag] = typedArrayTags[arrayTag] =\ntypedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =\ntypedArrayTags[dataViewTag] = typedArrayTags[dateTag] =\ntypedArrayTags[errorTag] = typedArrayTags[funcTag] =\ntypedArrayTags[mapTag] = typedArrayTags[numberTag] =\ntypedArrayTags[objectTag] = typedArrayTags[regexpTag] =\ntypedArrayTags[setTag] = typedArrayTags[stringTag] =\ntypedArrayTags[weakMapTag] = false;\n\n/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Detect free variable `process` from Node.js. */\nvar freeProcess = moduleExports && freeGlobal.process;\n\n/** Used to access faster Node.js helpers. */\nvar nodeUtil = (function() {\n  try {\n    return freeProcess && freeProcess.binding && freeProcess.binding('util');\n  } catch (e) {}\n}());\n\n/* Node.js helper references. */\nvar nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;\n\n/**\n * A specialized version of `_.filter` for arrays without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {Array} Returns the new filtered array.\n */\nfunction arrayFilter(array, predicate) {\n  var index = -1,\n      length = array == null ? 0 : array.length,\n      resIndex = 0,\n      result = [];\n\n  while (++index < length) {\n    var value = array[index];\n    if (predicate(value, index, array)) {\n      result[resIndex++] = value;\n    }\n  }\n  return result;\n}\n\n/**\n * Appends the elements of `values` to `array`.\n *\n * @private\n * @param {Array} array The array to modify.\n * @param {Array} values The values to append.\n * @returns {Array} Returns `array`.\n */\nfunction arrayPush(array, values) {\n  var index = -1,\n      length = values.length,\n      offset = array.length;\n\n  while (++index < length) {\n    array[offset + index] = values[index];\n  }\n  return array;\n}\n\n/**\n * A specialized version of `_.some` for arrays without support for iteratee\n * shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {boolean} Returns `true` if any element passes the predicate check,\n *  else `false`.\n */\nfunction arraySome(array, predicate) {\n  var index = -1,\n      length = array == null ? 0 : array.length;\n\n  while (++index < length) {\n    if (predicate(array[index], index, array)) {\n      return true;\n    }\n  }\n  return false;\n}\n\n/**\n * The base implementation of `_.times` without support for iteratee shorthands\n * or max array length checks.\n *\n * @private\n * @param {number} n The number of times to invoke `iteratee`.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the array of results.\n */\nfunction baseTimes(n, iteratee) {\n  var index = -1,\n      result = Array(n);\n\n  while (++index < n) {\n    result[index] = iteratee(index);\n  }\n  return result;\n}\n\n/**\n * The base implementation of `_.unary` without support for storing metadata.\n *\n * @private\n * @param {Function} func The function to cap arguments for.\n * @returns {Function} Returns the new capped function.\n */\nfunction baseUnary(func) {\n  return function(value) {\n    return func(value);\n  };\n}\n\n/**\n * Checks if a `cache` value for `key` exists.\n *\n * @private\n * @param {Object} cache The cache to query.\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction cacheHas(cache, key) {\n  return cache.has(key);\n}\n\n/**\n * Gets the value at `key` of `object`.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\nfunction getValue(object, key) {\n  return object == null ? undefined : object[key];\n}\n\n/**\n * Converts `map` to its key-value pairs.\n *\n * @private\n * @param {Object} map The map to convert.\n * @returns {Array} Returns the key-value pairs.\n */\nfunction mapToArray(map) {\n  var index = -1,\n      result = Array(map.size);\n\n  map.forEach(function(value, key) {\n    result[++index] = [key, value];\n  });\n  return result;\n}\n\n/**\n * Creates a unary function that invokes `func` with its argument transformed.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {Function} transform The argument transform.\n * @returns {Function} Returns the new function.\n */\nfunction overArg(func, transform) {\n  return function(arg) {\n    return func(transform(arg));\n  };\n}\n\n/**\n * Converts `set` to an array of its values.\n *\n * @private\n * @param {Object} set The set to convert.\n * @returns {Array} Returns the values.\n */\nfunction setToArray(set) {\n  var index = -1,\n      result = Array(set.size);\n\n  set.forEach(function(value) {\n    result[++index] = value;\n  });\n  return result;\n}\n\n/** Used for built-in method references. */\nvar arrayProto = Array.prototype,\n    funcProto = Function.prototype,\n    objectProto = Object.prototype;\n\n/** Used to detect overreaching core-js shims. */\nvar coreJsData = root['__core-js_shared__'];\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Used to detect methods masquerading as native. */\nvar maskSrcKey = (function() {\n  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');\n  return uid ? ('Symbol(src)_1.' + uid) : '';\n}());\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/** Used to detect if a method is native. */\nvar reIsNative = RegExp('^' +\n  funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\\\$&')\n  .replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$'\n);\n\n/** Built-in value references. */\nvar Buffer = moduleExports ? root.Buffer : undefined,\n    Symbol = root.Symbol,\n    Uint8Array = root.Uint8Array,\n    propertyIsEnumerable = objectProto.propertyIsEnumerable,\n    splice = arrayProto.splice,\n    symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeGetSymbols = Object.getOwnPropertySymbols,\n    nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined,\n    nativeKeys = overArg(Object.keys, Object);\n\n/* Built-in method references that are verified to be native. */\nvar DataView = getNative(root, 'DataView'),\n    Map = getNative(root, 'Map'),\n    Promise = getNative(root, 'Promise'),\n    Set = getNative(root, 'Set'),\n    WeakMap = getNative(root, 'WeakMap'),\n    nativeCreate = getNative(Object, 'create');\n\n/** Used to detect maps, sets, and weakmaps. */\nvar dataViewCtorString = toSource(DataView),\n    mapCtorString = toSource(Map),\n    promiseCtorString = toSource(Promise),\n    setCtorString = toSource(Set),\n    weakMapCtorString = toSource(WeakMap);\n\n/** Used to convert symbols to primitives and strings. */\nvar symbolProto = Symbol ? Symbol.prototype : undefined,\n    symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;\n\n/**\n * Creates a hash object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Hash(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n/**\n * Removes all key-value entries from the hash.\n *\n * @private\n * @name clear\n * @memberOf Hash\n */\nfunction hashClear() {\n  this.__data__ = nativeCreate ? nativeCreate(null) : {};\n  this.size = 0;\n}\n\n/**\n * Removes `key` and its value from the hash.\n *\n * @private\n * @name delete\n * @memberOf Hash\n * @param {Object} hash The hash to modify.\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction hashDelete(key) {\n  var result = this.has(key) && delete this.__data__[key];\n  this.size -= result ? 1 : 0;\n  return result;\n}\n\n/**\n * Gets the hash value for `key`.\n *\n * @private\n * @name get\n * @memberOf Hash\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction hashGet(key) {\n  var data = this.__data__;\n  if (nativeCreate) {\n    var result = data[key];\n    return result === HASH_UNDEFINED ? undefined : result;\n  }\n  return hasOwnProperty.call(data, key) ? data[key] : undefined;\n}\n\n/**\n * Checks if a hash value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Hash\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction hashHas(key) {\n  var data = this.__data__;\n  return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);\n}\n\n/**\n * Sets the hash `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Hash\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the hash instance.\n */\nfunction hashSet(key, value) {\n  var data = this.__data__;\n  this.size += this.has(key) ? 0 : 1;\n  data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;\n  return this;\n}\n\n// Add methods to `Hash`.\nHash.prototype.clear = hashClear;\nHash.prototype['delete'] = hashDelete;\nHash.prototype.get = hashGet;\nHash.prototype.has = hashHas;\nHash.prototype.set = hashSet;\n\n/**\n * Creates an list cache object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction ListCache(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n/**\n * Removes all key-value entries from the list cache.\n *\n * @private\n * @name clear\n * @memberOf ListCache\n */\nfunction listCacheClear() {\n  this.__data__ = [];\n  this.size = 0;\n}\n\n/**\n * Removes `key` and its value from the list cache.\n *\n * @private\n * @name delete\n * @memberOf ListCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction listCacheDelete(key) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  if (index < 0) {\n    return false;\n  }\n  var lastIndex = data.length - 1;\n  if (index == lastIndex) {\n    data.pop();\n  } else {\n    splice.call(data, index, 1);\n  }\n  --this.size;\n  return true;\n}\n\n/**\n * Gets the list cache value for `key`.\n *\n * @private\n * @name get\n * @memberOf ListCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction listCacheGet(key) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  return index < 0 ? undefined : data[index][1];\n}\n\n/**\n * Checks if a list cache value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf ListCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction listCacheHas(key) {\n  return assocIndexOf(this.__data__, key) > -1;\n}\n\n/**\n * Sets the list cache `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf ListCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the list cache instance.\n */\nfunction listCacheSet(key, value) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  if (index < 0) {\n    ++this.size;\n    data.push([key, value]);\n  } else {\n    data[index][1] = value;\n  }\n  return this;\n}\n\n// Add methods to `ListCache`.\nListCache.prototype.clear = listCacheClear;\nListCache.prototype['delete'] = listCacheDelete;\nListCache.prototype.get = listCacheGet;\nListCache.prototype.has = listCacheHas;\nListCache.prototype.set = listCacheSet;\n\n/**\n * Creates a map cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction MapCache(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n/**\n * Removes all key-value entries from the map.\n *\n * @private\n * @name clear\n * @memberOf MapCache\n */\nfunction mapCacheClear() {\n  this.size = 0;\n  this.__data__ = {\n    'hash': new Hash,\n    'map': new (Map || ListCache),\n    'string': new Hash\n  };\n}\n\n/**\n * Removes `key` and its value from the map.\n *\n * @private\n * @name delete\n * @memberOf MapCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction mapCacheDelete(key) {\n  var result = getMapData(this, key)['delete'](key);\n  this.size -= result ? 1 : 0;\n  return result;\n}\n\n/**\n * Gets the map value for `key`.\n *\n * @private\n * @name get\n * @memberOf MapCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction mapCacheGet(key) {\n  return getMapData(this, key).get(key);\n}\n\n/**\n * Checks if a map value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf MapCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction mapCacheHas(key) {\n  return getMapData(this, key).has(key);\n}\n\n/**\n * Sets the map `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf MapCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the map cache instance.\n */\nfunction mapCacheSet(key, value) {\n  var data = getMapData(this, key),\n      size = data.size;\n\n  data.set(key, value);\n  this.size += data.size == size ? 0 : 1;\n  return this;\n}\n\n// Add methods to `MapCache`.\nMapCache.prototype.clear = mapCacheClear;\nMapCache.prototype['delete'] = mapCacheDelete;\nMapCache.prototype.get = mapCacheGet;\nMapCache.prototype.has = mapCacheHas;\nMapCache.prototype.set = mapCacheSet;\n\n/**\n *\n * Creates an array cache object to store unique values.\n *\n * @private\n * @constructor\n * @param {Array} [values] The values to cache.\n */\nfunction SetCache(values) {\n  var index = -1,\n      length = values == null ? 0 : values.length;\n\n  this.__data__ = new MapCache;\n  while (++index < length) {\n    this.add(values[index]);\n  }\n}\n\n/**\n * Adds `value` to the array cache.\n *\n * @private\n * @name add\n * @memberOf SetCache\n * @alias push\n * @param {*} value The value to cache.\n * @returns {Object} Returns the cache instance.\n */\nfunction setCacheAdd(value) {\n  this.__data__.set(value, HASH_UNDEFINED);\n  return this;\n}\n\n/**\n * Checks if `value` is in the array cache.\n *\n * @private\n * @name has\n * @memberOf SetCache\n * @param {*} value The value to search for.\n * @returns {number} Returns `true` if `value` is found, else `false`.\n */\nfunction setCacheHas(value) {\n  return this.__data__.has(value);\n}\n\n// Add methods to `SetCache`.\nSetCache.prototype.add = SetCache.prototype.push = setCacheAdd;\nSetCache.prototype.has = setCacheHas;\n\n/**\n * Creates a stack cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Stack(entries) {\n  var data = this.__data__ = new ListCache(entries);\n  this.size = data.size;\n}\n\n/**\n * Removes all key-value entries from the stack.\n *\n * @private\n * @name clear\n * @memberOf Stack\n */\nfunction stackClear() {\n  this.__data__ = new ListCache;\n  this.size = 0;\n}\n\n/**\n * Removes `key` and its value from the stack.\n *\n * @private\n * @name delete\n * @memberOf Stack\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction stackDelete(key) {\n  var data = this.__data__,\n      result = data['delete'](key);\n\n  this.size = data.size;\n  return result;\n}\n\n/**\n * Gets the stack value for `key`.\n *\n * @private\n * @name get\n * @memberOf Stack\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction stackGet(key) {\n  return this.__data__.get(key);\n}\n\n/**\n * Checks if a stack value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Stack\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction stackHas(key) {\n  return this.__data__.has(key);\n}\n\n/**\n * Sets the stack `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Stack\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the stack cache instance.\n */\nfunction stackSet(key, value) {\n  var data = this.__data__;\n  if (data instanceof ListCache) {\n    var pairs = data.__data__;\n    if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {\n      pairs.push([key, value]);\n      this.size = ++data.size;\n      return this;\n    }\n    data = this.__data__ = new MapCache(pairs);\n  }\n  data.set(key, value);\n  this.size = data.size;\n  return this;\n}\n\n// Add methods to `Stack`.\nStack.prototype.clear = stackClear;\nStack.prototype['delete'] = stackDelete;\nStack.prototype.get = stackGet;\nStack.prototype.has = stackHas;\nStack.prototype.set = stackSet;\n\n/**\n * Creates an array of the enumerable property names of the array-like `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @param {boolean} inherited Specify returning inherited property names.\n * @returns {Array} Returns the array of property names.\n */\nfunction arrayLikeKeys(value, inherited) {\n  var isArr = isArray(value),\n      isArg = !isArr && isArguments(value),\n      isBuff = !isArr && !isArg && isBuffer(value),\n      isType = !isArr && !isArg && !isBuff && isTypedArray(value),\n      skipIndexes = isArr || isArg || isBuff || isType,\n      result = skipIndexes ? baseTimes(value.length, String) : [],\n      length = result.length;\n\n  for (var key in value) {\n    if ((inherited || hasOwnProperty.call(value, key)) &&\n        !(skipIndexes && (\n           // Safari 9 has enumerable `arguments.length` in strict mode.\n           key == 'length' ||\n           // Node.js 0.10 has enumerable non-index properties on buffers.\n           (isBuff && (key == 'offset' || key == 'parent')) ||\n           // PhantomJS 2 has enumerable non-index properties on typed arrays.\n           (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||\n           // Skip index properties.\n           isIndex(key, length)\n        ))) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\n/**\n * Gets the index at which the `key` is found in `array` of key-value pairs.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} key The key to search for.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\nfunction assocIndexOf(array, key) {\n  var length = array.length;\n  while (length--) {\n    if (eq(array[length][0], key)) {\n      return length;\n    }\n  }\n  return -1;\n}\n\n/**\n * The base implementation of `getAllKeys` and `getAllKeysIn` which uses\n * `keysFunc` and `symbolsFunc` to get the enumerable property names and\n * symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @param {Function} symbolsFunc The function to get the symbols of `object`.\n * @returns {Array} Returns the array of property names and symbols.\n */\nfunction baseGetAllKeys(object, keysFunc, symbolsFunc) {\n  var result = keysFunc(object);\n  return isArray(object) ? result : arrayPush(result, symbolsFunc(object));\n}\n\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n  if (value == null) {\n    return value === undefined ? undefinedTag : nullTag;\n  }\n  return (symToStringTag && symToStringTag in Object(value))\n    ? getRawTag(value)\n    : objectToString(value);\n}\n\n/**\n * The base implementation of `_.isArguments`.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n */\nfunction baseIsArguments(value) {\n  return isObjectLike(value) && baseGetTag(value) == argsTag;\n}\n\n/**\n * The base implementation of `_.isEqual` which supports partial comparisons\n * and tracks traversed objects.\n *\n * @private\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @param {boolean} bitmask The bitmask flags.\n *  1 - Unordered comparison\n *  2 - Partial comparison\n * @param {Function} [customizer] The function to customize comparisons.\n * @param {Object} [stack] Tracks traversed `value` and `other` objects.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n */\nfunction baseIsEqual(value, other, bitmask, customizer, stack) {\n  if (value === other) {\n    return true;\n  }\n  if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) {\n    return value !== value && other !== other;\n  }\n  return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);\n}\n\n/**\n * A specialized version of `baseIsEqual` for arrays and objects which performs\n * deep comparisons and tracks traversed objects enabling objects with circular\n * references to be compared.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} [stack] Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\nfunction baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {\n  var objIsArr = isArray(object),\n      othIsArr = isArray(other),\n      objTag = objIsArr ? arrayTag : getTag(object),\n      othTag = othIsArr ? arrayTag : getTag(other);\n\n  objTag = objTag == argsTag ? objectTag : objTag;\n  othTag = othTag == argsTag ? objectTag : othTag;\n\n  var objIsObj = objTag == objectTag,\n      othIsObj = othTag == objectTag,\n      isSameTag = objTag == othTag;\n\n  if (isSameTag && isBuffer(object)) {\n    if (!isBuffer(other)) {\n      return false;\n    }\n    objIsArr = true;\n    objIsObj = false;\n  }\n  if (isSameTag && !objIsObj) {\n    stack || (stack = new Stack);\n    return (objIsArr || isTypedArray(object))\n      ? equalArrays(object, other, bitmask, customizer, equalFunc, stack)\n      : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);\n  }\n  if (!(bitmask & COMPARE_PARTIAL_FLAG)) {\n    var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),\n        othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');\n\n    if (objIsWrapped || othIsWrapped) {\n      var objUnwrapped = objIsWrapped ? object.value() : object,\n          othUnwrapped = othIsWrapped ? other.value() : other;\n\n      stack || (stack = new Stack);\n      return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);\n    }\n  }\n  if (!isSameTag) {\n    return false;\n  }\n  stack || (stack = new Stack);\n  return equalObjects(object, other, bitmask, customizer, equalFunc, stack);\n}\n\n/**\n * The base implementation of `_.isNative` without bad shim checks.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a native function,\n *  else `false`.\n */\nfunction baseIsNative(value) {\n  if (!isObject(value) || isMasked(value)) {\n    return false;\n  }\n  var pattern = isFunction(value) ? reIsNative : reIsHostCtor;\n  return pattern.test(toSource(value));\n}\n\n/**\n * The base implementation of `_.isTypedArray` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n */\nfunction baseIsTypedArray(value) {\n  return isObjectLike(value) &&\n    isLength(value.length) && !!typedArrayTags[baseGetTag(value)];\n}\n\n/**\n * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction baseKeys(object) {\n  if (!isPrototype(object)) {\n    return nativeKeys(object);\n  }\n  var result = [];\n  for (var key in Object(object)) {\n    if (hasOwnProperty.call(object, key) && key != 'constructor') {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\n/**\n * A specialized version of `baseIsEqualDeep` for arrays with support for\n * partial deep comparisons.\n *\n * @private\n * @param {Array} array The array to compare.\n * @param {Array} other The other array to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `array` and `other` objects.\n * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.\n */\nfunction equalArrays(array, other, bitmask, customizer, equalFunc, stack) {\n  var isPartial = bitmask & COMPARE_PARTIAL_FLAG,\n      arrLength = array.length,\n      othLength = other.length;\n\n  if (arrLength != othLength && !(isPartial && othLength > arrLength)) {\n    return false;\n  }\n  // Assume cyclic values are equal.\n  var stacked = stack.get(array);\n  if (stacked && stack.get(other)) {\n    return stacked == other;\n  }\n  var index = -1,\n      result = true,\n      seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined;\n\n  stack.set(array, other);\n  stack.set(other, array);\n\n  // Ignore non-index properties.\n  while (++index < arrLength) {\n    var arrValue = array[index],\n        othValue = other[index];\n\n    if (customizer) {\n      var compared = isPartial\n        ? customizer(othValue, arrValue, index, other, array, stack)\n        : customizer(arrValue, othValue, index, array, other, stack);\n    }\n    if (compared !== undefined) {\n      if (compared) {\n        continue;\n      }\n      result = false;\n      break;\n    }\n    // Recursively compare arrays (susceptible to call stack limits).\n    if (seen) {\n      if (!arraySome(other, function(othValue, othIndex) {\n            if (!cacheHas(seen, othIndex) &&\n                (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {\n              return seen.push(othIndex);\n            }\n          })) {\n        result = false;\n        break;\n      }\n    } else if (!(\n          arrValue === othValue ||\n            equalFunc(arrValue, othValue, bitmask, customizer, stack)\n        )) {\n      result = false;\n      break;\n    }\n  }\n  stack['delete'](array);\n  stack['delete'](other);\n  return result;\n}\n\n/**\n * A specialized version of `baseIsEqualDeep` for comparing objects of\n * the same `toStringTag`.\n *\n * **Note:** This function only supports comparing values with tags of\n * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {string} tag The `toStringTag` of the objects to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\nfunction equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {\n  switch (tag) {\n    case dataViewTag:\n      if ((object.byteLength != other.byteLength) ||\n          (object.byteOffset != other.byteOffset)) {\n        return false;\n      }\n      object = object.buffer;\n      other = other.buffer;\n\n    case arrayBufferTag:\n      if ((object.byteLength != other.byteLength) ||\n          !equalFunc(new Uint8Array(object), new Uint8Array(other))) {\n        return false;\n      }\n      return true;\n\n    case boolTag:\n    case dateTag:\n    case numberTag:\n      // Coerce booleans to `1` or `0` and dates to milliseconds.\n      // Invalid dates are coerced to `NaN`.\n      return eq(+object, +other);\n\n    case errorTag:\n      return object.name == other.name && object.message == other.message;\n\n    case regexpTag:\n    case stringTag:\n      // Coerce regexes to strings and treat strings, primitives and objects,\n      // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring\n      // for more details.\n      return object == (other + '');\n\n    case mapTag:\n      var convert = mapToArray;\n\n    case setTag:\n      var isPartial = bitmask & COMPARE_PARTIAL_FLAG;\n      convert || (convert = setToArray);\n\n      if (object.size != other.size && !isPartial) {\n        return false;\n      }\n      // Assume cyclic values are equal.\n      var stacked = stack.get(object);\n      if (stacked) {\n        return stacked == other;\n      }\n      bitmask |= COMPARE_UNORDERED_FLAG;\n\n      // Recursively compare objects (susceptible to call stack limits).\n      stack.set(object, other);\n      var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);\n      stack['delete'](object);\n      return result;\n\n    case symbolTag:\n      if (symbolValueOf) {\n        return symbolValueOf.call(object) == symbolValueOf.call(other);\n      }\n  }\n  return false;\n}\n\n/**\n * A specialized version of `baseIsEqualDeep` for objects with support for\n * partial deep comparisons.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\nfunction equalObjects(object, other, bitmask, customizer, equalFunc, stack) {\n  var isPartial = bitmask & COMPARE_PARTIAL_FLAG,\n      objProps = getAllKeys(object),\n      objLength = objProps.length,\n      othProps = getAllKeys(other),\n      othLength = othProps.length;\n\n  if (objLength != othLength && !isPartial) {\n    return false;\n  }\n  var index = objLength;\n  while (index--) {\n    var key = objProps[index];\n    if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {\n      return false;\n    }\n  }\n  // Assume cyclic values are equal.\n  var stacked = stack.get(object);\n  if (stacked && stack.get(other)) {\n    return stacked == other;\n  }\n  var result = true;\n  stack.set(object, other);\n  stack.set(other, object);\n\n  var skipCtor = isPartial;\n  while (++index < objLength) {\n    key = objProps[index];\n    var objValue = object[key],\n        othValue = other[key];\n\n    if (customizer) {\n      var compared = isPartial\n        ? customizer(othValue, objValue, key, other, object, stack)\n        : customizer(objValue, othValue, key, object, other, stack);\n    }\n    // Recursively compare objects (susceptible to call stack limits).\n    if (!(compared === undefined\n          ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack))\n          : compared\n        )) {\n      result = false;\n      break;\n    }\n    skipCtor || (skipCtor = key == 'constructor');\n  }\n  if (result && !skipCtor) {\n    var objCtor = object.constructor,\n        othCtor = other.constructor;\n\n    // Non `Object` object instances with different constructors are not equal.\n    if (objCtor != othCtor &&\n        ('constructor' in object && 'constructor' in other) &&\n        !(typeof objCtor == 'function' && objCtor instanceof objCtor &&\n          typeof othCtor == 'function' && othCtor instanceof othCtor)) {\n      result = false;\n    }\n  }\n  stack['delete'](object);\n  stack['delete'](other);\n  return result;\n}\n\n/**\n * Creates an array of own enumerable property names and symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names and symbols.\n */\nfunction getAllKeys(object) {\n  return baseGetAllKeys(object, keys, getSymbols);\n}\n\n/**\n * Gets the data for `map`.\n *\n * @private\n * @param {Object} map The map to query.\n * @param {string} key The reference key.\n * @returns {*} Returns the map data.\n */\nfunction getMapData(map, key) {\n  var data = map.__data__;\n  return isKeyable(key)\n    ? data[typeof key == 'string' ? 'string' : 'hash']\n    : data.map;\n}\n\n/**\n * Gets the native function at `key` of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the method to get.\n * @returns {*} Returns the function if it's native, else `undefined`.\n */\nfunction getNative(object, key) {\n  var value = getValue(object, key);\n  return baseIsNative(value) ? value : undefined;\n}\n\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\nfunction getRawTag(value) {\n  var isOwn = hasOwnProperty.call(value, symToStringTag),\n      tag = value[symToStringTag];\n\n  try {\n    value[symToStringTag] = undefined;\n    var unmasked = true;\n  } catch (e) {}\n\n  var result = nativeObjectToString.call(value);\n  if (unmasked) {\n    if (isOwn) {\n      value[symToStringTag] = tag;\n    } else {\n      delete value[symToStringTag];\n    }\n  }\n  return result;\n}\n\n/**\n * Creates an array of the own enumerable symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of symbols.\n */\nvar getSymbols = !nativeGetSymbols ? stubArray : function(object) {\n  if (object == null) {\n    return [];\n  }\n  object = Object(object);\n  return arrayFilter(nativeGetSymbols(object), function(symbol) {\n    return propertyIsEnumerable.call(object, symbol);\n  });\n};\n\n/**\n * Gets the `toStringTag` of `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nvar getTag = baseGetTag;\n\n// Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.\nif ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||\n    (Map && getTag(new Map) != mapTag) ||\n    (Promise && getTag(Promise.resolve()) != promiseTag) ||\n    (Set && getTag(new Set) != setTag) ||\n    (WeakMap && getTag(new WeakMap) != weakMapTag)) {\n  getTag = function(value) {\n    var result = baseGetTag(value),\n        Ctor = result == objectTag ? value.constructor : undefined,\n        ctorString = Ctor ? toSource(Ctor) : '';\n\n    if (ctorString) {\n      switch (ctorString) {\n        case dataViewCtorString: return dataViewTag;\n        case mapCtorString: return mapTag;\n        case promiseCtorString: return promiseTag;\n        case setCtorString: return setTag;\n        case weakMapCtorString: return weakMapTag;\n      }\n    }\n    return result;\n  };\n}\n\n/**\n * Checks if `value` is a valid array-like index.\n *\n * @private\n * @param {*} value The value to check.\n * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n */\nfunction isIndex(value, length) {\n  length = length == null ? MAX_SAFE_INTEGER : length;\n  return !!length &&\n    (typeof value == 'number' || reIsUint.test(value)) &&\n    (value > -1 && value % 1 == 0 && value < length);\n}\n\n/**\n * Checks if `value` is suitable for use as unique object key.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is suitable, else `false`.\n */\nfunction isKeyable(value) {\n  var type = typeof value;\n  return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')\n    ? (value !== '__proto__')\n    : (value === null);\n}\n\n/**\n * Checks if `func` has its source masked.\n *\n * @private\n * @param {Function} func The function to check.\n * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n */\nfunction isMasked(func) {\n  return !!maskSrcKey && (maskSrcKey in func);\n}\n\n/**\n * Checks if `value` is likely a prototype object.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n */\nfunction isPrototype(value) {\n  var Ctor = value && value.constructor,\n      proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;\n\n  return value === proto;\n}\n\n/**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\nfunction objectToString(value) {\n  return nativeObjectToString.call(value);\n}\n\n/**\n * Converts `func` to its source code.\n *\n * @private\n * @param {Function} func The function to convert.\n * @returns {string} Returns the source code.\n */\nfunction toSource(func) {\n  if (func != null) {\n    try {\n      return funcToString.call(func);\n    } catch (e) {}\n    try {\n      return (func + '');\n    } catch (e) {}\n  }\n  return '';\n}\n\n/**\n * Performs a\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * comparison between two values to determine if they are equivalent.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.eq(object, object);\n * // => true\n *\n * _.eq(object, other);\n * // => false\n *\n * _.eq('a', 'a');\n * // => true\n *\n * _.eq('a', Object('a'));\n * // => false\n *\n * _.eq(NaN, NaN);\n * // => true\n */\nfunction eq(value, other) {\n  return value === other || (value !== value && other !== other);\n}\n\n/**\n * Checks if `value` is likely an `arguments` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n *  else `false`.\n * @example\n *\n * _.isArguments(function() { return arguments; }());\n * // => true\n *\n * _.isArguments([1, 2, 3]);\n * // => false\n */\nvar isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {\n  return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&\n    !propertyIsEnumerable.call(value, 'callee');\n};\n\n/**\n * Checks if `value` is classified as an `Array` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n * @example\n *\n * _.isArray([1, 2, 3]);\n * // => true\n *\n * _.isArray(document.body.children);\n * // => false\n *\n * _.isArray('abc');\n * // => false\n *\n * _.isArray(_.noop);\n * // => false\n */\nvar isArray = Array.isArray;\n\n/**\n * Checks if `value` is array-like. A value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n * @example\n *\n * _.isArrayLike([1, 2, 3]);\n * // => true\n *\n * _.isArrayLike(document.body.children);\n * // => true\n *\n * _.isArrayLike('abc');\n * // => true\n *\n * _.isArrayLike(_.noop);\n * // => false\n */\nfunction isArrayLike(value) {\n  return value != null && isLength(value.length) && !isFunction(value);\n}\n\n/**\n * Checks if `value` is a buffer.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.\n * @example\n *\n * _.isBuffer(new Buffer(2));\n * // => true\n *\n * _.isBuffer(new Uint8Array(2));\n * // => false\n */\nvar isBuffer = nativeIsBuffer || stubFalse;\n\n/**\n * Performs a deep comparison between two values to determine if they are\n * equivalent.\n *\n * **Note:** This method supports comparing arrays, array buffers, booleans,\n * date objects, error objects, maps, numbers, `Object` objects, regexes,\n * sets, strings, symbols, and typed arrays. `Object` objects are compared\n * by their own, not inherited, enumerable properties. Functions and DOM\n * nodes are compared by strict equality, i.e. `===`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.isEqual(object, other);\n * // => true\n *\n * object === other;\n * // => false\n */\nfunction isEqual(value, other) {\n  return baseIsEqual(value, other);\n}\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\nfunction isFunction(value) {\n  if (!isObject(value)) {\n    return false;\n  }\n  // The use of `Object#toString` avoids issues with the `typeof` operator\n  // in Safari 9 which returns 'object' for typed arrays and other constructors.\n  var tag = baseGetTag(value);\n  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;\n}\n\n/**\n * Checks if `value` is a valid array-like length.\n *\n * **Note:** This method is loosely based on\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n * @example\n *\n * _.isLength(3);\n * // => true\n *\n * _.isLength(Number.MIN_VALUE);\n * // => false\n *\n * _.isLength(Infinity);\n * // => false\n *\n * _.isLength('3');\n * // => false\n */\nfunction isLength(value) {\n  return typeof value == 'number' &&\n    value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n}\n\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return value != null && (type == 'object' || type == 'function');\n}\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return value != null && typeof value == 'object';\n}\n\n/**\n * Checks if `value` is classified as a typed array.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n * @example\n *\n * _.isTypedArray(new Uint8Array);\n * // => true\n *\n * _.isTypedArray([]);\n * // => false\n */\nvar isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;\n\n/**\n * Creates an array of the own enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects. See the\n * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * for more details.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keys(new Foo);\n * // => ['a', 'b'] (iteration order is not guaranteed)\n *\n * _.keys('hi');\n * // => ['0', '1']\n */\nfunction keys(object) {\n  return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);\n}\n\n/**\n * This method returns a new empty array.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {Array} Returns the new empty array.\n * @example\n *\n * var arrays = _.times(2, _.stubArray);\n *\n * console.log(arrays);\n * // => [[], []]\n *\n * console.log(arrays[0] === arrays[1]);\n * // => false\n */\nfunction stubArray() {\n  return [];\n}\n\n/**\n * This method returns `false`.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {boolean} Returns `false`.\n * @example\n *\n * _.times(2, _.stubFalse);\n * // => [false, false]\n */\nfunction stubFalse() {\n  return false;\n}\n\nmodule.exports = isEqual;\n","(function(){\r\n  var chise = function(_options) {\r\n\r\n    var param = {};\r\n\r\n    // Access the libs\r\n    var libs = require('./utilities/lib-utilities').getLibs();\r\n\r\n    var optionUtilities = require('./utilities/option-utilities-factory')();\r\n    var options = optionUtilities.extendOptions(_options); // Extends the default options with the given options\r\n\r\n    // Create an sbgnviz instance\r\n    var sbgnvizInstanceUtilities = require('./utilities/sbgnviz-instance-utilities-factory')();\r\n    var sbgnvizInstance = sbgnvizInstanceUtilities(options);\r\n\r\n    // Register undo/redo actions\r\n    var registerUndoRedoActions = require('./utilities/register-undo-redo-actions-factory')();\r\n\r\n    var mainUtilities = require('./utilities/main-utilities-factory')();\r\n    var elementUtilitiesExtender = require('./utilities/element-utilities-extender-factory')();\r\n    var undoRedoActionFunctionsExtender = require('./utilities/ur-action-functions-extender-factory')();\r\n    var sifTopologyGrouping = require('./utilities/topology-grouping-factory')();\r\n\r\n    var elementUtilities =  sbgnvizInstance.elementUtilities;\r\n    var undoRedoActionFunctions = sbgnvizInstance.undoRedoActionFunctions;\r\n\r\n    param.sbgnvizInstanceUtilities = sbgnvizInstanceUtilities;\r\n    param.optionUtilities = optionUtilities;\r\n    param.elementUtilities = elementUtilities;\r\n    param.undoRedoActionFunctions = undoRedoActionFunctions;\r\n    param.sifTopologyGrouping = sifTopologyGrouping;\r\n\r\n    var shouldApply = function() {\r\n      return param.elementUtilities.mapType === 'SIF';\r\n    };\r\n\r\n    undoRedoActionFunctionsExtender(param);\r\n    elementUtilitiesExtender(param);\r\n    registerUndoRedoActions(param);\r\n    mainUtilities(param);\r\n    sifTopologyGrouping(param, {metaEdgeIdentifier: 'sif-meta', lockGraphTopology: true, shouldApply});\r\n\r\n    // Expose the api\r\n    var api = {};\r\n\r\n    // Expose the properties inherited from sbgnviz\r\n    // then override some of these properties and expose some new properties\r\n    for (var prop in sbgnvizInstance) {\r\n      api[prop] = sbgnvizInstance[prop];\r\n    }\r\n\r\n    // Expose each main utility seperately\r\n    for (var prop in mainUtilities) {\r\n      api[prop] = mainUtilities[prop];\r\n    }\r\n\r\n    // Expose getSbgnvizInstance()\r\n    api.getSbgnvizInstance = sbgnvizInstanceUtilities.getInstance;\r\n\r\n    // Expose elementUtilities and undoRedoActionFunctions as is\r\n    api.elementUtilities = elementUtilities;\r\n    api.undoRedoActionFunctions = undoRedoActionFunctions;\r\n    api.sifTopologyGrouping = sifTopologyGrouping;\r\n\r\n    return api;\r\n  };\r\n\r\n  // Register chise with given libraries\r\n  chise.register = function (_libs) {\r\n\r\n    var libs = {};\r\n    libs.jQuery = _libs.jQuery || jQuery;\r\n    libs.cytoscape = _libs.cytoscape || cytoscape;\r\n    libs.sbgnviz = _libs.sbgnviz || sbgnviz;\r\n    libs.saveAs = _libs.filesaver ? _libs.filesaver.saveAs : saveAs;\r\n\r\n    libs.sbgnviz.register(_libs); // Register sbgnviz with the given libs\r\n\r\n    // inherit exposed static properties of sbgnviz other than register\r\n    for (var prop in libs.sbgnviz) {\r\n      if (prop !== 'register') {\r\n        chise[prop] = libs.sbgnviz[prop];\r\n      }\r\n    }\r\n\r\n    // Set the libraries to access them from any file\r\n    var libUtilities = require('./utilities/lib-utilities');\r\n    libUtilities.setLibs(libs);\r\n  };\r\n\r\n  if ( typeof module !== 'undefined' && module.exports ) {\r\n    module.exports = chise;\r\n  }\r\n})();\r\n","// Extends sbgnviz.elementUtilities\r\nvar libs = require('./lib-utilities').getLibs();\r\nvar jQuery = $ = libs.jQuery;\r\n\r\nmodule.exports = function () {\r\n  var options, sbgnvizInstance, elementUtilities, cy;\r\n\r\n  function elementUtilitiesExtender (param) {\r\n    sbgnvizInstance = param.sbgnvizInstanceUtilities.getInstance();\r\n    options = param.optionUtilities.getOptions();\r\n    elementUtilities = sbgnvizInstance.elementUtilities;\r\n    cy = param.sbgnvizInstanceUtilities.getCy();\r\n\r\n    extend();\r\n\r\n    // Return the extended elementUtilities\r\n    return elementUtilities;\r\n  }\r\n\r\n  // Extends elementUtilities with chise specific facilities\r\n  function extend () {\r\n    // Section Start\r\n    // Add remove utilities\r\n\r\n    elementUtilities.addNode = function (x, y, nodeParams, id, parent, visibility) {\r\n      if (typeof nodeParams != 'object'){\r\n        var sbgnclass = nodeParams;\r\n      } else {\r\n          var sbgnclass = nodeParams.class;\r\n          var language = nodeParams.language;\r\n      }\r\n\r\n      var css = {};\r\n      // if there is no specific default width or height for\r\n      // sbgnclass these sizes are used\r\n      var defaultWidth = 50;\r\n      var defaultHeight = 50;\r\n\r\n      if (visibility) {\r\n        css.visibility = visibility;\r\n      }\r\n\r\n      var data = {\r\n        class: sbgnclass,\r\n    \t  language: language,\r\n        bbox: {\r\n          w: defaultWidth,\r\n          h: defaultHeight,\r\n          x: x,\r\n          y: y\r\n        },\r\n        statesandinfos: [],\r\n        ports: []\r\n      };\r\n\r\n      if(id) {\r\n        data.id = id;\r\n      }\r\n      else {\r\n        data.id = elementUtilities.generateNodeId();\r\n      }\r\n\r\n      if (parent) {\r\n        data.parent = parent;\r\n      }\r\n\r\n      this.extendNodeDataWithClassDefaults( data, sbgnclass );\r\n\r\n      // some defaults are not set by extendNodeDataWithClassDefaults()\r\n      var defaults = this.getDefaultProperties( sbgnclass );\r\n\r\n      if ( defaults[ 'multimer' ] ) {\r\n        data.class += ' multimer';\r\n      }\r\n\r\n      if ( defaults[ 'clonemarker' ] ) {\r\n        data[ 'clonemarker' ] = true;\r\n      }\r\n\r\n      data.bbox[ 'w' ] = defaults[ 'width' ];\r\n      data.bbox[ 'h' ] = defaults[ 'height' ];\r\n\r\n      var eles = cy.add({\r\n        group: \"nodes\",\r\n        data: data,\r\n        css: css,\r\n        position: {\r\n          x: x,\r\n          y: y\r\n        }\r\n      });\r\n\r\n      var newNode = eles[eles.length - 1];\r\n      // Get the default ports ordering for the nodes with given sbgnclass\r\n      var ordering = defaults['ports-ordering'];\r\n\r\n      // If there is a default ports ordering for the nodes with given sbgnclass and it is different than 'none' set the ports ordering to that ordering\r\n      if (ordering && ordering !== 'none') {\r\n        this.setPortsOrdering(newNode, ordering);\r\n      }\r\n\r\n      if (language == \"AF\" && !elementUtilities.canHaveMultipleUnitOfInformation(newNode)){\r\n        if (sbgnclass != \"BA plain\") { // if AF node can have label i.e: not plain biological activity\r\n          var uoi_obj = {\r\n            clazz: \"unit of information\"\r\n          };\r\n          uoi_obj.label = {\r\n            text: \"\"\r\n          };\r\n\r\n          uoi_obj.bbox = {\r\n             w: 12,\r\n             h: 12\r\n          };\r\n          elementUtilities.addStateOrInfoBox(newNode, uoi_obj);\r\n        }\r\n      }\r\n\r\n      // node bg image was unexpectedly not rendered until it is clicked\r\n      // use this dirty hack until finding a solution to the problem\r\n      var bgImage = newNode.data('background-image');\r\n      if ( bgImage ) {\r\n        newNode.data( 'background-image', bgImage );\r\n      }\r\n\r\n      return newNode;\r\n    };\r\n\r\n    //Saves old aux units of given node\r\n    elementUtilities.saveUnits = function(node) {\r\n      var tempData = [];\r\n      var index = 0;\r\n      node.data('statesandinfos').forEach( function(ele) {\r\n        tempData.push({\r\n          x: ele.bbox.x,\r\n          y: ele.bbox.y,\r\n          anchorSide: ele.anchorSide,\r\n        });\r\n        index++;\r\n      });\r\n      return tempData;\r\n    };\r\n\r\n    //Restores from given data\r\n    elementUtilities.restoreUnits = function(node, data) {\r\n      var index = 0;\r\n      node.data('statesandinfos').forEach( function(ele) {\r\n        if (data !== undefined) {\r\n          ele.bbox.x = data[index].x;\r\n          ele.bbox.y = data[index].y\r\n          var anchorSide = ele.anchorSide;\r\n          ele.anchorSide = data[index].anchorSide;\r\n          elementUtilities.modifyUnits(node, ele, anchorSide);\r\n          index++;\r\n        }\r\n      });\r\n    };\r\n\r\n    //Modify aux unit layouts\r\n    elementUtilities.modifyUnits = function (node, ele, anchorSide) {\r\n      instance.classes.AuxUnitLayout.modifyUnits(node, ele, anchorSide, cy);\r\n    };\r\n\r\n\r\n    //For reversible reactions both side of the process can be input/output\r\n    //Group ID identifies to which group of nodes the edge is going to be connected for reversible reactions(0: group 1 ID and 1:group 2 ID)\r\n    elementUtilities.addEdge = function (source, target, edgeParams, id, visibility, groupID ) {\r\n      if (typeof edgeParams != 'object'){\r\n        var sbgnclass = edgeParams;\r\n      } else {\r\n          var sbgnclass = edgeParams.class;\r\n          var language = edgeParams.language;\r\n      }\r\n\r\n      var css = {};\r\n\r\n      if (visibility) {\r\n        css.visibility = visibility;\r\n      }\r\n\r\n      var data = {\r\n          source: source,\r\n          target: target,\r\n          class: sbgnclass,\r\n          language: language,\r\n      };\r\n\r\n      var defaults = elementUtilities.getDefaultProperties( sbgnclass );\r\n\r\n      // extend the data with default properties of edge style\r\n      Object.keys( defaults ).forEach( function( prop ) {\r\n        data[ prop ] = defaults[ prop ];\r\n      } );\r\n\r\n      if(id) {\r\n        data.id = id;\r\n      }\r\n      else {\r\n        data.id = elementUtilities.generateEdgeId();\r\n      }\r\n\r\n      if(elementUtilities.canHaveSBGNCardinality(sbgnclass)){\r\n        data.cardinality = 0;\r\n      }\r\n\r\n      var sourceNode = cy.getElementById(source); // The original source node\r\n      var targetNode = cy.getElementById(target); // The original target node\r\n      var sourceHasPorts = sourceNode.data('ports').length === 2;\r\n      var targetHasPorts = targetNode.data('ports').length === 2;\r\n      // The portsource and porttarget variables\r\n      var portsource;\r\n      var porttarget;\r\n\r\n      /*\r\n       * Get input/output port id's of a node with the assumption that the node has valid ports.\r\n       */\r\n      var getIOPortIds = function (node) {\r\n        var nodeInputPortId, nodeOutputPortId;\r\n        var nodePortsOrdering = sbgnvizInstance.elementUtilities.getPortsOrdering(node);\r\n        var nodePorts = node.data('ports');\r\n        if ( nodePortsOrdering === 'L-to-R' || nodePortsOrdering === 'R-to-L' ) {\r\n          var leftPortId = nodePorts[0].x < 0 ? nodePorts[0].id : nodePorts[1].id; // The x value of left port is supposed to be negative\r\n          var rightPortId = nodePorts[0].x > 0 ? nodePorts[0].id : nodePorts[1].id; // The x value of right port is supposed to be positive\r\n          /*\r\n           * If the port ordering is left to right then the input port is the left port and the output port is the right port.\r\n           * Else if it is right to left it is vice versa\r\n           */\r\n          nodeInputPortId = nodePortsOrdering === 'L-to-R' ? leftPortId : rightPortId;\r\n          nodeOutputPortId = nodePortsOrdering === 'R-to-L' ? leftPortId : rightPortId;\r\n        }\r\n        else if ( nodePortsOrdering === 'T-to-B' || nodePortsOrdering === 'B-to-T' ){\r\n          var topPortId = nodePorts[0].y < 0 ? nodePorts[0].id : nodePorts[1].id; // The y value of top port is supposed to be negative\r\n          var bottomPortId = nodePorts[0].y > 0 ? nodePorts[0].id : nodePorts[1].id; // The y value of bottom port is supposed to be positive\r\n          /*\r\n           * If the port ordering is top to bottom then the input port is the top port and the output port is the bottom port.\r\n           * Else if it is right to left it is vice versa\r\n           */\r\n          nodeInputPortId = nodePortsOrdering === 'T-to-B' ? topPortId : bottomPortId;\r\n          nodeOutputPortId = nodePortsOrdering === 'B-to-T' ? topPortId : bottomPortId;\r\n        }\r\n\r\n        // Return an object containing the IO ports of the node\r\n        return {\r\n          inputPortId: nodeInputPortId,\r\n          outputPortId: nodeOutputPortId\r\n        };\r\n      };\r\n\r\n      // If at least one end of the edge has ports then we should determine the ports where the edge should be connected.\r\n      if (sourceHasPorts || targetHasPorts) {\r\n        var sourceNodeInputPortId, sourceNodeOutputPortId, targetNodeInputPortId, targetNodeOutputPortId;\r\n\r\n        // If source node has ports set the variables dedicated for its IO ports\r\n        if ( sourceHasPorts ) {\r\n          var ioPorts = getIOPortIds(sourceNode);\r\n          sourceNodeInputPortId = ioPorts.inputPortId;\r\n          sourceNodeOutputPortId = ioPorts.outputPortId;\r\n        }\r\n\r\n        // If target node has ports set the variables dedicated for its IO ports\r\n        if ( targetHasPorts ) {\r\n          var ioPorts = getIOPortIds(targetNode);\r\n          targetNodeInputPortId = ioPorts.inputPortId;\r\n          targetNodeOutputPortId = ioPorts.outputPortId;\r\n        }\r\n\r\n        if (sbgnclass === 'consumption') {\r\n          // A consumption edge should be connected to the input port of the target node which is supposed to be a process (any kind of)\r\n          portsource = sourceNodeOutputPortId;\r\n          porttarget = targetNodeInputPortId;\r\n        }\r\n        else if (sbgnclass === 'production') {\r\n          // A production edge should be connected to the output port of the source node which is supposed to be a process (any kind of)\r\n          // A modulation edge may have a logical operator as source node in this case the edge should be connected to the output port of it\r\n          // The below assignment satisfy all of these condition\r\n          if(groupID == 0 || groupID == undefined) { // groupID 0 for reversible reactions group 0\r\n            portsource = sourceNodeOutputPortId;\r\n            porttarget = targetNodeInputPortId;\r\n          }\r\n          else { //if reaction is reversible and edge belongs to group 1\r\n            portsource = sourceNodeInputPortId;\r\n          }\r\n        }\r\n        else if(elementUtilities.isModulationArcClass(sbgnclass) || elementUtilities.isAFArcClass(sbgnclass)){\r\n          portsource = sourceNodeOutputPortId;\r\n        }\r\n        else if (sbgnclass === 'logic arc') {\r\n          var srcClass = sourceNode.data('class');\r\n          var tgtClass = targetNode.data('class');\r\n          var isSourceLogicalOp = srcClass === 'and' || srcClass === 'or' || srcClass === 'not';\r\n          var isTargetLogicalOp = tgtClass === 'and' || tgtClass === 'or' || tgtClass === 'not';\r\n\r\n          if (isSourceLogicalOp && isTargetLogicalOp) {\r\n            // If both end are logical operators then the edge should be connected to the input port of the target and the output port of the input\r\n            porttarget = targetNodeInputPortId;\r\n            portsource = sourceNodeOutputPortId;\r\n          }// If just one end of logical operator then the edge should be connected to the input port of the logical operator\r\n          else if (isSourceLogicalOp) {\r\n            portsource = sourceNodeInputPortId;\r\n            porttarget = targetNodeOutputPortId;\r\n          }\r\n          else if (isTargetLogicalOp) {\r\n            portsource = sourceNodeOutputPortId;\r\n            porttarget = targetNodeInputPortId;\r\n          }\r\n        }\r\n      }\r\n\r\n      // The default portsource/porttarget are the source/target themselves. If they are not set use these defaults.\r\n      // The portsource and porttarget are determined set them in data object.\r\n      data.portsource = portsource || source;\r\n      data.porttarget = porttarget || target;\r\n\r\n      var eles = cy.add({\r\n        group: \"edges\",\r\n        data: data,\r\n        css: css\r\n      });\r\n\r\n      var newEdge = eles[eles.length - 1];\r\n\r\n      return newEdge;\r\n    };\r\n\r\n    elementUtilities.addProcessWithConvenientEdges = function(_source, _target, nodeParams) {\r\n      // If source and target IDs are given get the elements by IDs\r\n      var source = typeof _source === 'string' ? cy.getElementById(_source) : _source;\r\n      var target = typeof _target === 'string' ? cy.getElementById(_target) : _target;\r\n\r\n      // Process parent should be the closest common ancestor of the source and target nodes\r\n      var processParent = cy.collection([source[0], target[0]]).commonAncestors().first();\r\n\r\n      // Process should be at the middle of the source and target nodes\r\n      var x = ( source.position('x') + target.position('x') ) / 2;\r\n      var y = ( source.position('y') + target.position('y') ) / 2;\r\n\r\n      // Create the process with given/calculated variables\r\n      var process = elementUtilities.addNode(x, y, nodeParams, undefined, processParent.id());\r\n        var xdiff = source.position('x') - target.position('x');\r\n        var ydiff = source.position('y') - target.position('y')\r\n        if (Math.abs(xdiff) >= Math.abs(ydiff))\r\n        {\r\n            if (xdiff < 0)\r\n                elementUtilities.setPortsOrdering(process, 'L-to-R');\r\n            else\r\n                elementUtilities.setPortsOrdering(process, 'R-to-L');\r\n        }\r\n        else\r\n        {\r\n            if (ydiff < 0)\r\n                elementUtilities.setPortsOrdering(process, 'T-to-B');\r\n            else\r\n                elementUtilities.setPortsOrdering(process, 'B-to-T');\r\n        }\r\n\r\n\r\n      // Create the edges one is between the process and the source node (which should be a consumption),\r\n      // the other one is between the process and the target node (which should be a production).\r\n      // For more information please refer to SBGN-PD reference card.\r\n      var edgeBtwSrc = elementUtilities.addEdge(source.id(), process.id(), {class : 'consumption', language : nodeParams.language});\r\n      var edgeBtwTgt = elementUtilities.addEdge(process.id(), target.id(), {class : 'production', language : nodeParams.language});\r\n\r\n      // Create a collection including the elements and to be returned\r\n      var collection = cy.collection([process[0], edgeBtwSrc[0], edgeBtwTgt[0]]);\r\n      return collection;\r\n    };\r\n\r\n    /*\r\n     * This method assumes that param.nodesToMakeCompound contains at least one node\r\n     * and all of the nodes including in it have the same parent. It creates a compound fot the given nodes an having the given type.\r\n     */\r\n    elementUtilities.createCompoundForGivenNodes = function (nodesToMakeCompound, compoundType) {\r\n      var oldParentId = nodesToMakeCompound[0].data(\"parent\");\r\n      var language = nodesToMakeCompound[0].data(\"language\");\r\n      // if nodesToMakeCompound contain both PD and AF nodes, then set language of compound as Unknown\r\n      for( var i=1; i<nodesToMakeCompound.length; i++){\r\n        if(nodesToMakeCompound[i] != language){\r\n          language = \"Unknown\";\r\n          break;\r\n        }\r\n      }\r\n      // The parent of new compound will be the old parent of the nodes to make compound. x, y and id parameters are not set.\r\n      var newCompound = elementUtilities.addNode(undefined, undefined, {class : compoundType, language : language}, undefined, oldParentId);\r\n      var newCompoundId = newCompound.id();\r\n      var newEles = elementUtilities.changeParent(nodesToMakeCompound, newCompoundId);\r\n      newEles = newEles.union(newCompound);\r\n      return newEles;\r\n    };\r\n\r\n    /*\r\n     * Creates a template reaction with given parameters. Requires cose-bilkent layout to tile the free macromolecules included\r\n     * in the complex. Parameters are explained below.\r\n     * templateType: The type of the template reaction. It may be 'association' or 'dissociation' for now.\r\n     * nodeList: The list of the names and types of molecules which will involve in the reaction.\r\n     * complexName: The name of the complex in the reaction.\r\n     * processPosition: The modal position of the process in the reaction. The default value is the center of the canvas.\r\n     * tilingPaddingVertical: This option will be passed to the cose-bilkent layout with the same name. The default value is 15.\r\n     * tilingPaddingHorizontal: This option will be passed to the cose-bilkent layout with the same name. The default value is 15.\r\n     * edgeLength: The distance between the process and the macromolecules at the both sides.\r\n     */\r\n    elementUtilities.createTemplateReaction = function (templateType, nodeList, complexName, processPosition, tilingPaddingVertical, tilingPaddingHorizontal, edgeLength, layoutParam) {\r\n\r\n      var defaultMacromoleculProperties = elementUtilities.getDefaultProperties( \"macromolecule\" );\r\n      var defaultSimpleChemicalProperties = elementUtilities.getDefaultProperties( \"simple chemical\" );\r\n      var defaultProcessProperties = elementUtilities.getDefaultProperties( templateType );\r\n      var processWidth = defaultProcessProperties.width || 50;\r\n      var macromoleculeWidth = defaultMacromoleculProperties.width || 50;\r\n      var macromoleculeHeight = defaultMacromoleculProperties.height || 50;\r\n      var simpleChemicalWidth = defaultSimpleChemicalProperties.width || 35;\r\n      var simpleChemicalHeight = defaultSimpleChemicalProperties.height || 35;\r\n      var processPosition = processPosition || elementUtilities.convertToModelPosition({x: cy.width() / 2, y: cy.height() / 2});\r\n      var nodeList = nodeList;\r\n      var complexName = complexName;\r\n      var numOfMolecules = nodeList.length;\r\n      var tilingPaddingVertical = tilingPaddingVertical || 15;\r\n      var tilingPaddingHorizontal = tilingPaddingHorizontal || 15;\r\n      var edgeLength = edgeLength || 60;\r\n\r\n      cy.startBatch();\r\n\r\n      var xPositionOfFreeMacromolecules;\r\n      var xPositionOfInputMacromolecules;\r\n      if (!elementUtilities.getMapType()) {\r\n        elementUtilities.setMapType(\"PD\");\r\n      }\r\n      if (templateType === 'association') {\r\n        xPositionOfFreeMacromolecules = processPosition.x - edgeLength - processWidth / 2 - macromoleculeWidth / 2;\r\n       \r\n      }\r\n      else if(templateType === 'dissociation'){\r\n        xPositionOfFreeMacromolecules = processPosition.x + edgeLength + processWidth / 2 + macromoleculeWidth / 2;\r\n       \r\n      }\r\n      else{\r\n        \r\n        xPositionOfFreeMacromolecules = processPosition.x - edgeLength - processWidth / 2 - macromoleculeWidth / 2;\r\n        xPositionOfInputMacromolecules = processPosition.x + edgeLength + processWidth / 2 + macromoleculeWidth / 2;\r\n      }\r\n\r\n      //Create the process in template type\r\n      var process;\r\n      if (templateType === 'reversible') {\r\n        process = elementUtilities.addNode(processPosition.x, processPosition.y, {class : 'process', language : 'PD'});\r\n        elementUtilities.setPortsOrdering(process, 'L-to-R');\r\n      }\r\n      else{\r\n        process = elementUtilities.addNode(processPosition.x, processPosition.y, {class : templateType, language : 'PD'});\r\n        elementUtilities.setPortsOrdering(process, 'L-to-R');\r\n      }\r\n      process.data('justAdded', true);\r\n\r\n      //Define the starting y position\r\n      var yPosition = processPosition.y - ((numOfMolecules - 1) / 2) * (macromoleculeHeight + tilingPaddingVertical);\r\n\r\n      //Create the free molecules\r\n      for (var i = 0; i < numOfMolecules; i++) {\r\n        // node addition operation is determined by molecule type\r\n        if(nodeList[i].type == \"Simple Chemical\"){\r\n          var newNode = elementUtilities.addNode(xPositionOfFreeMacromolecules, yPosition, {class : 'simple chemical', language : 'PD'});\r\n          //update the y position\r\n          yPosition += simpleChemicalHeight + tilingPaddingVertical;\r\n        }\r\n        else{\r\n          var newNode = elementUtilities.addNode(xPositionOfFreeMacromolecules, yPosition, {class : 'macromolecule', language : 'PD'});\r\n          //update the y position\r\n          yPosition += macromoleculeHeight + tilingPaddingVertical;\r\n        }\r\n        newNode.data('justAdded', true);\r\n        newNode.data('label', nodeList[i].name);\r\n\r\n        //create the edge connected to the new molecule\r\n        var newEdge;\r\n        if (templateType === 'association') {\r\n          newEdge = elementUtilities.addEdge(newNode.id(), process.id(), {class : 'consumption', language : 'PD'});\r\n        }\r\n        else if(templateType === 'dissociation'){\r\n          newEdge = elementUtilities.addEdge(process.id(), newNode.id(), {class : 'production', language : 'PD'});\r\n        }\r\n        else{\r\n          //Group right or top elements in group id 1\r\n          newEdge = elementUtilities.addEdge(process.id(), newNode.id(), {class : 'production', language : 'PD'}, undefined, undefined, 1);\r\n        }\r\n\r\n        newEdge.data('justAdded', true);\r\n      }\r\n\r\n      if(templateType === 'association' || templateType == 'dissociation'){\r\n        //Create the complex including macromolecules inside of it\r\n        //Temprorarily add it to the process position we will move it according to the last size of it\r\n        var complex = elementUtilities.addNode(processPosition.x, processPosition.y, {class : 'complex', language : 'PD'});\r\n        complex.data('justAdded', true);\r\n        complex.data('justAddedLayoutNode', true);\r\n\r\n        //If a name is specified for the complex set its label accordingly\r\n        if (complexName) {\r\n          complex.data('label', complexName);\r\n        }\r\n\r\n        //create the edge connnected to the complex\r\n        var edgeOfComplex;\r\n\r\n        if (templateType === 'association') {\r\n          edgeOfComplex = elementUtilities.addEdge(process.id(), complex.id(), {class : 'production', language : 'PD'});\r\n        }\r\n        else {\r\n          edgeOfComplex = elementUtilities.addEdge(complex.id(), process.id(), {class : 'consumption', language : 'PD'});\r\n        }\r\n\r\n        edgeOfComplex.data('justAdded', true);\r\n\r\n        for (var i = 0; i < numOfMolecules; i++) {\r\n\r\n          // Add a molecule(dependent on it's type) not having a previously defined id and having the complex created in this reaction as parent\r\n          if(nodeList[i].type == 'Simple Chemical'){\r\n            var newNode = elementUtilities.addNode(complex.position('x'), complex.position('y'), {class : 'simple chemical', language : 'PD'}, undefined, complex.id());\r\n          }\r\n          else{\r\n            var newNode = elementUtilities.addNode(complex.position('x'), complex.position('y'), {class : 'macromolecule', language : 'PD'}, undefined, complex.id());\r\n          }\r\n\r\n          newNode.data('justAdded', true);\r\n          newNode.data('label', nodeList[i].name);\r\n          newNode.data('justAddedLayoutNode', true);\r\n        }\r\n      }\r\n      else{\r\n\r\n        //Create the input macromolecules\r\n        var numOfInputMacromolecules = complexName.length;\r\n        yPosition = processPosition.y - ((numOfInputMacromolecules - 1) / 2) * (macromoleculeHeight + tilingPaddingVertical);\r\n\r\n        for (var i = 0; i < numOfInputMacromolecules; i++) {\r\n\r\n          if(complexName[i].type == 'Simple Chemical'){\r\n            var newNode = elementUtilities.addNode(xPositionOfInputMacromolecules, yPosition, {class : 'simple chemical', language : 'PD'});\r\n            yPosition += simpleChemicalHeight + tilingPaddingVertical;\r\n          }\r\n          else{\r\n            var newNode = elementUtilities.addNode(xPositionOfInputMacromolecules, yPosition, {class : 'macromolecule', language : 'PD'});\r\n            yPosition += macromoleculeHeight + tilingPaddingVertical;\r\n          }\r\n\r\n          newNode.data('justAdded', true);\r\n          newNode.data('label', complexName[i].name);\r\n\r\n          //create the edge connected to the new macromolecule\r\n          var newEdge;\r\n\r\n          //Group the left or bottom elements in group id 0\r\n          newEdge = elementUtilities.addEdge(process.id(), newNode.id(), {class : 'production', language : 'PD'}, undefined, undefined, 0);\r\n          newEdge.data('justAdded', true);\r\n\r\n        }\r\n      }\r\n\r\n      cy.endBatch();\r\n\r\n      var layoutNodes = cy.nodes('[justAddedLayoutNode]');\r\n      layoutNodes.removeData('justAddedLayoutNode');\r\n      var layout = layoutNodes.layout({\r\n        name: layoutParam.name,\r\n        randomize: false,\r\n        fit: false,\r\n        animate: false,\r\n        tilingPaddingVertical: tilingPaddingVertical,\r\n        tilingPaddingHorizontal: tilingPaddingHorizontal,\r\n        stop: function () {\r\n          //If it is a reversible reaction no need to re-position complexes\r\n          if(templateType === 'reversible')\r\n            return;\r\n          //re-position the nodes inside the complex\r\n          var supposedXPosition;\r\n          var supposedYPosition = processPosition.y;\r\n\r\n          if (templateType === 'association') {\r\n            supposedXPosition = processPosition.x + edgeLength + processWidth / 2 + complex.outerWidth() / 2;\r\n          }\r\n          else {\r\n            supposedXPosition = processPosition.x - edgeLength - processWidth / 2 - complex.outerWidth() / 2;\r\n          }\r\n\r\n          var positionDiffX = (supposedXPosition - complex.position('x')) / 2;\r\n          var positionDiffY = (supposedYPosition - complex.position('y')) / 2;\r\n          elementUtilities.moveNodes({x: positionDiffX, y: positionDiffY}, complex);\r\n        }\r\n      });\r\n\r\n      // Do this check for cytoscape.js backward compatibility\r\n      if (layout && layout.run && templateType !== 'reversible') {\r\n        layout.run();\r\n      }\r\n\r\n      //filter the just added elememts to return them and remove just added mark\r\n      var eles = cy.elements('[justAdded]');\r\n      eles.removeData('justAdded');\r\n\r\n      cy.elements().unselect();\r\n      eles.select();\r\n\r\n      return eles; // Return the just added elements\r\n    };\r\n\r\n    /*\r\n     * Move the nodes to a new parent and change their position if possDiff params are set.\r\n     */\r\n    elementUtilities.changeParent = function(nodes, newParent, posDiffX, posDiffY) {\r\n      var newParentId = newParent == undefined || typeof newParent === 'string' ? newParent : newParent.id();\r\n      var movedEles = nodes.move({\"parent\": newParentId});\r\n      if(typeof posDiffX != 'undefined' || typeof posDiffY != 'undefined') {\r\n        elementUtilities.moveNodes({x: posDiffX, y: posDiffY}, nodes);\r\n      }\r\n      elementUtilities.maintainPointer(movedEles);\r\n      return movedEles;\r\n    };\r\n\r\n    elementUtilities.updateInfoboxStyle = function( node, index, newProps ) {\r\n      var infoboxObj = node.data('statesandinfos')[index];\r\n      $.extend( infoboxObj.style, newProps );\r\n      cy.style().update();\r\n    };\r\n\r\n    elementUtilities.updateInfoboxObj = function( node, index, newProps ) {\r\n      var infoboxObj = node.data('statesandinfos')[index];\r\n      $.extend( infoboxObj, newProps );\r\n    };\r\n\r\n    // Resize given nodes if useAspectRatio is truthy one of width or height should not be set.\r\n    elementUtilities.resizeNodes = function (nodes, width, height, useAspectRatio, preserveRelativePos) {\r\n      for (var i = 0; i < nodes.length; i++) {\r\n\r\n        var node = nodes[i];\r\n        var ratio = undefined;\r\n        var eleMustBeSquare = elementUtilities.mustBeSquare(node.data('class'));\r\n\r\n        if (preserveRelativePos === true) {\r\n          var oldWidth = node.data(\"bbox\").w;\r\n          var oldHeight = node.data(\"bbox\").h;\r\n        }\r\n\r\n        // Note that both width and height should not be set if useAspectRatio is truthy\r\n        if(!node.isParent()){\r\n          if (width) {\r\n            if (useAspectRatio || eleMustBeSquare) {\r\n              ratio = width / node.width();\r\n            }\r\n  \r\n            node.data(\"bbox\").w = width;\r\n          }\r\n  \r\n          if (height) {\r\n            if (useAspectRatio || eleMustBeSquare) {\r\n              ratio = height / node.height();\r\n            }\r\n  \r\n            node.data(\"bbox\").h = height;\r\n          }\r\n  \r\n          if (ratio && !height) {\r\n            node.data(\"bbox\").h = node.height() * ratio;\r\n          }\r\n          else if (ratio && !width) {\r\n            node.data(\"bbox\").w = node.width() * ratio;\r\n          }\r\n        }else{\r\n          node.data(\"minHeight\" , \"\"+ height);\r\n          node.data(\"minWidth\" , \"\"+ width);\r\n          node.data(\"minWidthBiasLeft\", \"50%\");\r\n          node.data(\"minWidthBiasRight\", \"50%\");\r\n          node.data(\"minHeightBiasTop\", \"50%\" );\r\n          node.data(\"minHeightBiasBottom\", \"50%\");\r\n        }\r\n        \r\n\r\n     /*    if (preserveRelativePos === true) {\r\n          var statesandinfos = node.data('statesandinfos');\r\n          var topBottom = statesandinfos.filter(box => (box.anchorSide === \"top\" || box.anchorSide === \"bottom\"));\r\n          var rightLeft = statesandinfos.filter(box => (box.anchorSide === \"right\" || box.anchorSide === \"left\"));\r\n\r\n          topBottom.forEach(function(box){\r\n            if (box.bbox.x < 0) {\r\n              box.bbox.x = 0;\r\n            }\r\n            else if (box.bbox.x > oldWidth) {\r\n              box.bbox.x = oldWidth;\r\n            }\r\n            box.bbox.x = node.data(\"bbox\").w * box.bbox.x / oldWidth;\r\n          });\r\n\r\n          rightLeft.forEach(function(box){\r\n            if (box.bbox.y < 0) {\r\n              box.bbox.y = 0;\r\n            }\r\n            else if (box.bbox.y > oldHeight) {\r\n              box.bbox.y = oldHeight;\r\n            }\r\n            box.bbox.y = node.data(\"bbox\").h * box.bbox.y / oldHeight;\r\n          });\r\n        } */\r\n      }\r\n    };\r\n\r\n    elementUtilities.calculateMinWidth = function(node) {\r\n\r\n        var defaultWidth = this.getDefaultProperties(node.data('class')).width;\r\n\r\n        // Label width calculation\r\n        var style = node.style();\r\n\r\n        var fontFamiliy = style['font-family'];\r\n        var fontSize = style['font-size'];\r\n        var labelText = style['label'];\r\n\r\n        var labelWidth = elementUtilities.getWidthByContent( labelText, fontFamiliy, fontSize );\r\n\r\n        var statesandinfos = node.data('statesandinfos');\r\n        //Top and bottom infoBoxes\r\n        //var topInfoBoxes = statesandinfos.filter(box => (box.anchorSide === \"top\" || ((box.anchorSide === \"right\" || box.anchorSide === \"left\") && (box.bbox.y <= 12))));\r\n        //var bottomInfoBoxes = statesandinfos.filter(box => (box.anchorSide === \"bottom\" || ((box.anchorSide === \"right\" || box.anchorSide === \"left\") && (box.bbox.y >= node.data('bbox').h - 12))));\r\n        var unitGap = 5;\r\n        var topIdealWidth = unitGap;\r\n        var bottomIdealWidth = unitGap;        \r\n        var rightMaxWidth = 0;\r\n        var leftMaxWidth =0;\r\n        statesandinfos.forEach(function(box){\r\n          if(box.anchorSide === \"top\"){\r\n            topIdealWidth += box.bbox.w + unitGap;\r\n\r\n          }else if(box.anchorSide === \"bottom\"){\r\n            bottomIdealWidth += box.bbox.w + unitGap;\r\n\r\n          }else if(box.anchorSide === \"right\")\r\n          {           \r\n            rightMaxWidth = (box.bbox.w > rightMaxWidth) ? box.bbox.w : rightMaxWidth;\r\n          }else{\r\n            \r\n            leftMaxWidth = (box.bbox.w > leftMaxWidth) ? box.bbox.w : leftMaxWidth;\r\n          }\r\n        });      \r\n\r\n        var middleWidth = labelWidth + 2 * Math.max(rightMaxWidth/2, leftMaxWidth/2);\r\n\r\n        var compoundWidth = 0;\r\n        if(node.isParent()){\r\n          compoundWidth = node.children().boundingBox().w;\r\n        }\r\n        return Math.max(middleWidth, defaultWidth/2, topIdealWidth, bottomIdealWidth, compoundWidth);\r\n    }\r\n\r\n    elementUtilities.calculateMinHeight = function(node) {\r\n        var statesandinfos = node.data('statesandinfos');\r\n        var margin = 7;\r\n        var unitGap = 5;\r\n        var defaultHeight = this.getDefaultProperties(node.data('class')).height;\r\n        var leftInfoBoxes = statesandinfos.filter(box => box.anchorSide === \"left\");        \r\n        var leftHeight = unitGap; \r\n        leftInfoBoxes.forEach(function(box){\r\n            leftHeight += box.bbox.h + unitGap;\r\n           \r\n        });      \r\n        var rightInfoBoxes = statesandinfos.filter(box => box.anchorSide === \"right\");\r\n        var rightHeight = unitGap;        \r\n        rightInfoBoxes.forEach(function(box){\r\n            rightHeight += box.bbox.h + unitGap;           \r\n        });       \r\n        var style = node.style();\r\n        var labelText = ((style['label']).split(\"\\n\")).filter( text => text !== '');\r\n        var fontSize = parseFloat(style['font-size'].substring(0, style['font-size'].length - 2));\r\n        var totalHeight = labelText.length * fontSize + 2 * margin;\r\n\r\n        \r\n\r\n        var compoundHeight = 0;\r\n        if(node.isParent()){\r\n          compoundHeight = node.children().boundingBox().h;\r\n        }\r\n        return Math.max(totalHeight, defaultHeight/2, leftHeight, rightHeight, compoundHeight);\r\n    }\r\n\r\n    elementUtilities.isResizedToContent = function (node) {\r\n      if(!node || !node.isNode() || !node.data('bbox')){\r\n        return false;\r\n      }\r\n\r\n      //var w = node.data('bbox').w;\r\n      //var h = node.data('bbox').h;\r\n      var w = node.width();\r\n      var h = node.height();\r\n\r\n      var minW = elementUtilities.calculateMinWidth(node);\r\n      var minH = elementUtilities.calculateMinHeight(node);\r\n\r\n      if(w === minW && h === minH)\r\n        return true;\r\n      else\r\n        return false;\r\n    }\r\n\r\n    // Section End\r\n    // Add remove utilities\r\n\r\n    // Relocates state and info boxes. This function is expected to be called after add/remove state and info boxes\r\n    elementUtilities.relocateStateAndInfos = function (ele) {\r\n      var stateAndInfos = (ele.isNode && ele.isNode()) ? ele.data('statesandinfos') : ele;\r\n      var length = stateAndInfos.length;\r\n      if (length == 0) {\r\n        return;\r\n      }\r\n      else if (length == 1) {\r\n        stateAndInfos[0].bbox.x = 0;\r\n        stateAndInfos[0].bbox.y = -50;\r\n      }\r\n      else if (length == 2) {\r\n        stateAndInfos[0].bbox.x = 0;\r\n        stateAndInfos[0].bbox.y = -50;\r\n\r\n        stateAndInfos[1].bbox.x = 0;\r\n        stateAndInfos[1].bbox.y = 50;\r\n      }\r\n      else if (length == 3) {\r\n        stateAndInfos[0].bbox.x = -25;\r\n        stateAndInfos[0].bbox.y = -50;\r\n\r\n        stateAndInfos[1].bbox.x = 25;\r\n        stateAndInfos[1].bbox.y = -50;\r\n\r\n        stateAndInfos[2].bbox.x = 0;\r\n        stateAndInfos[2].bbox.y = 50;\r\n      }\r\n      else {\r\n        stateAndInfos[0].bbox.x = -25;\r\n        stateAndInfos[0].bbox.y = -50;\r\n\r\n        stateAndInfos[1].bbox.x = 25;\r\n        stateAndInfos[1].bbox.y = -50;\r\n\r\n        stateAndInfos[2].bbox.x = -25;\r\n        stateAndInfos[2].bbox.y = 50;\r\n\r\n        stateAndInfos[3].bbox.x = 25;\r\n        stateAndInfos[3].bbox.y = 50;\r\n      }\r\n    };\r\n\r\n    // Change state value or unit of information box of given nodes with given index.\r\n    // Type parameter indicates whether to change value or variable, it is valid if the box at the given index is a state variable.\r\n    // Value parameter is the new value to set.\r\n    // This method returns the old value of the changed data (We assume that the old value of the changed data was the same for all nodes).\r\n    // Each character assumed to occupy 8 unit\r\n    // Each infobox can have at most 32 units of width\r\n    elementUtilities.changeStateOrInfoBox = function (nodes, index, value, type) {\r\n      var result;\r\n      for (var i = 0; i < nodes.length; i++) {\r\n        var node = nodes[i];\r\n        var sbgnclass = node.data('class');\r\n        var stateAndInfos = node.data('statesandinfos');\r\n        var box = stateAndInfos[index];\r\n        var oldLength = box.bbox.w;\r\n        var newLength = 0;\r\n\r\n        var content = '';\r\n        if (box.clazz == \"state variable\") {\r\n          if (!result) {\r\n            result = box.state[type];\r\n          }\r\n\r\n          box.state[type] = value;\r\n          if (box.state[\"value\"] !== undefined) {\r\n            content += box.state[\"value\"];\r\n          }\r\n          if (box.state[\"variable\"] !== undefined && box.state[\"variable\"].length > 0) {\r\n            content += box.state[\"variable\"] + \"@\";\r\n          }\r\n\r\n        }\r\n        else if (box.clazz == \"unit of information\") {\r\n          if (!result) {\r\n            result = box.label.text;\r\n          }\r\n          content += value;\r\n          box.label.text = value;\r\n        }\r\n\r\n        var min = ( sbgnclass === 'SIF macromolecule' || sbgnclass === 'SIF simple chemical' ) ? 15 : 12;\r\n        var fontFamily = box.style[ 'font-family' ];\r\n        var fontSize = box.style[ 'font-size' ];\r\n        var borderWidth = box.style[ 'border-width' ];\r\n        var opts = {\r\n          min,\r\n          max: 48,\r\n          margin: borderWidth / 2 + 0.5\r\n        };\r\n        var previousWidth = box.bbox.w;\r\n        box.bbox.w = elementUtilities.getWidthByContent( content, fontFamily, fontSize, opts );\r\n\r\n        if(box.anchorSide == \"top\" || box.anchorSide == \"bottom\"){\r\n          var unitLayout = node.data()[\"auxunitlayouts\"][box.anchorSide];\r\n          if(unitLayout.units[unitLayout.units.length-1].id == box.id){\r\n             \r\n            var borderWidth = node.data()['border-width'];\r\n            var shiftAmount = (((box.bbox.w - previousWidth) / 2) * 100 )/ (node.outerWidth() - borderWidth);\r\n           \r\n            if(shiftAmount >= 0){\r\n            \r\n              if(box.bbox.x + shiftAmount <= 100){\r\n                box.bbox.x = box.bbox.x + shiftAmount;\r\n              }\r\n            }\r\n           /*  else{\r\n              var previousInfoBbox = {x : 0, w:0};\r\n              if(unitLayout.units.length > 1){\r\n                previousInfoBbox= unitLayout.units[unitLayout.units.length-2].bbox;      \r\n              }\r\n\r\n              \r\n              \r\n              sbgnvizInstance.classes.AuxUnitLayout.setIdealGap(node, box.anchorSide);\r\n              var idealGap = sbgnvizInstance.classes.AuxUnitLayout.getCurrentGap(box.anchorSide);\r\n              var newPosition = previousInfoBbox.x + (previousInfoBbox.w/2 + idealGap + box.bbox.w/2)*100 / (node.outerWidth() - borderWidth);\r\n              box.bbox.x = newPosition;\r\n              \r\n            } */\r\n           \r\n           \r\n          }\r\n        }\r\n        \r\n        \r\n        /* if (box.anchorSide === \"top\" || box.anchorSide === \"bottom\") {\r\n          box.bbox.x += (box.bbox.w - oldLength) / 2;\r\n          var units = (node.data('auxunitlayouts')[box.anchorSide]).units;\r\n          var shiftIndex = 0;\r\n          for (var i = 0; i < units.length; i++) {\r\n            if(units[i] === box){\r\n              shiftIndex = i;\r\n              break;\r\n            }\r\n          }\r\n          for (var j = shiftIndex+1; j < units.length; j++) {\r\n              units[j].bbox.x += (box.bbox.w - oldLength);\r\n          }\r\n        } */\r\n\r\n      }\r\n\r\n      //TODO find a way to elimate this redundancy to update info-box positions\r\n      node.data('border-width', node.data('border-width'));\r\n\r\n      return result;\r\n    };\r\n\r\n    // Add a new state or info box to given nodes.\r\n    // The box is represented by the parameter obj.\r\n    // This method returns the index of the just added box.\r\n    elementUtilities.addStateOrInfoBox = function (nodes, obj) {\r\n      for (var i = 0; i < nodes.length; i++) {\r\n        var node = nodes[i];\r\n        var locationObj;\r\n\r\n        var defaultProps = elementUtilities.getDefaultProperties( node.data('class') );\r\n        var infoboxProps = defaultProps[ obj.clazz ];\r\n        var bbox = obj.bbox || { w: infoboxProps.width, h: infoboxProps.height };        \r\n        var style = elementUtilities.getDefaultInfoboxStyle( node.data('class'), obj.clazz );\r\n        if(obj.style){\r\n          $.extend( style, obj.style );\r\n        }\r\n       \r\n        if(obj.clazz == \"unit of information\") {\r\n          locationObj = sbgnvizInstance.classes.UnitOfInformation.create(node, cy, obj.label.text, bbox, obj.location, obj.position, style, obj.index, obj.id);\r\n        }\r\n        else if (obj.clazz == \"state variable\") {\r\n          locationObj = sbgnvizInstance.classes.StateVariable.create(node, cy, obj.state.value, obj.state.variable, bbox, obj.location, obj.position, style, obj.index, obj.id);\r\n        }\r\n      }\r\n      return locationObj;\r\n    };\r\n\r\n    // Remove the state or info boxes of the given nodes at given index.\r\n    // Returns the removed box.\r\n    elementUtilities.removeStateOrInfoBox = function (nodes, locationObj) {\r\n      var obj;\r\n      for (var i = 0; i < nodes.length; i++) {\r\n        var node = nodes[i];\r\n        var stateAndInfos = node.data('statesandinfos');\r\n        var unit = stateAndInfos[locationObj.index];\r\n\r\n        var unitClass = sbgnvizInstance.classes.getAuxUnitClass(unit);\r\n\r\n        obj = unitClass.remove(unit, cy);\r\n      }\r\n\r\n      return obj;\r\n    };\r\n\r\n\r\n    //Tiles informations boxes for given anchorSides\r\n    elementUtilities.fitUnits = function (node, locations) {\r\n      var obj = [];\r\n      node.data('statesandinfos').forEach( function (ele) {\r\n        obj.push({\r\n          x: ele.bbox.x,\r\n          y: ele.bbox.y,\r\n          anchorSide: ele.anchorSide\r\n        });\r\n      });\r\n      sbgnvizInstance.classes.AuxUnitLayout.fitUnits(node, cy, locations);\r\n      return obj;\r\n    };\r\n\r\n    //Check which anchorsides fits\r\n    elementUtilities.checkFit = function (node, location) { //if no location given, it checks all possible locations\r\n      return sbgnvizInstance.classes.AuxUnitLayout.checkFit(node, cy, location);\r\n    };\r\n\r\n    //Modify array of aux layout units\r\n    elementUtilities.modifyUnits = function (node, unit, anchorSide) {\r\n      sbgnvizInstance.classes.AuxUnitLayout.modifyUnits(node, unit, anchorSide, cy);\r\n    };\r\n\r\n    // Set multimer status of the given nodes to the given status.\r\n    elementUtilities.setMultimerStatus = function (nodes, status) {\r\n      for (var i = 0; i < nodes.length; i++) {\r\n        var node = nodes[i];\r\n        var sbgnclass = node.data('class');\r\n        var isMultimer = node.data('class').endsWith(' multimer');\r\n\r\n        if (status) { // Make multimer status true\r\n          if (!isMultimer) {\r\n            node.data('class', sbgnclass + ' multimer');\r\n          }\r\n        }\r\n        else { // Make multimer status false\r\n          if (isMultimer) {\r\n            node.data('class', sbgnclass.replace(' multimer', ''));\r\n          }\r\n        }\r\n      }\r\n    };\r\n\r\n    // Change font properties of the given elements with given font data\r\n    elementUtilities.changeFontProperties = function (eles, data) {\r\n      for (var prop in data) {\r\n        eles.data(prop, data[prop]);\r\n      }\r\n    };\r\n\r\n    // This function gets an edge, and ends of that edge (Optionally it may take just the classes of the edge as well) as parameters.\r\n    // It may return 'valid' (that ends is valid for that edge), 'reverse' (that ends is not valid for that edge but they would be valid\r\n    // if you reverse the source and target), 'invalid' (that ends are totally invalid for that edge).\r\n    elementUtilities.validateArrowEnds = function (edge, source, target) {\r\n      // if map type is Unknown -- no rules applied\r\n      if (elementUtilities.getMapType() == \"HybridAny\" || elementUtilities.getMapType() == \"HybridSbgn\" || !elementUtilities.getMapType())\r\n        return \"valid\";\r\n\r\n      var edgeclass = typeof edge === 'string' ? edge : edge.data('class');\r\n      var sourceclass = source.data('class');\r\n      var targetclass = target.data('class');\r\n      var mapType = elementUtilities.getMapType();\r\n      var edgeConstraints = elementUtilities[mapType].connectivityConstraints[edgeclass];\r\n\r\n      if (mapType == \"AF\"){\r\n        if (sourceclass.startsWith(\"BA\")) // we have separate classes for each biological activity\r\n          sourceclass = \"biological activity\"; // but same rule applies to all of them\r\n\r\n        if (targetclass.startsWith(\"BA\")) // we have separate classes for each biological activity\r\n          targetclass = \"biological activity\"; // but same rule applies to all of them\r\n      }\r\n      else if (mapType == \"PD\"){\r\n        sourceclass = sourceclass.replace(/\\s*multimer$/, '');\r\n        targetclass = targetclass.replace(/\\s*multimer$/, '');\r\n      }\r\n\r\n      // given a node, acting as source or target, returns boolean wether or not it has too many edges already\r\n      function hasTooManyEdges(node, sourceOrTarget) {\r\n        var nodeclass = node.data('class');\r\n        nodeclass = nodeclass.replace(/\\s*multimer$/, '');\r\n        if (nodeclass.startsWith(\"BA\"))\r\n          nodeclass = \"biological activity\";\r\n\r\n        var totalTooMany = true;\r\n        var edgeTooMany = true;\r\n        if (sourceOrTarget == \"source\") {\r\n            var sameEdgeCountOut = node.outgoers('edge[class=\"'+edgeclass+'\"]').size();\r\n            var totalEdgeCountOut = node.outgoers('edge').size();\r\n            // check that the total edge count is within the limits\r\n            if (typeof edgeConstraints[nodeclass].asSource.maxTotal == 'undefined'\r\n                || totalEdgeCountOut < edgeConstraints[nodeclass].asSource.maxTotal ) {\r\n                totalTooMany = false;\r\n            }\r\n            // then check limits for this specific edge class\r\n            if (typeof edgeConstraints[nodeclass].asSource.maxEdge == 'undefined'\r\n                || sameEdgeCountOut < edgeConstraints[nodeclass].asSource.maxEdge ) {\r\n                edgeTooMany = false;\r\n            }\r\n            // if only one of the limits is reached then edge is invalid\r\n            return totalTooMany || edgeTooMany;\r\n        }\r\n        else { // node is used as target\r\n            var sameEdgeCountIn = node.incomers('edge[class=\"'+edgeclass+'\"]').size();\r\n            var totalEdgeCountIn = node.incomers('edge').size();\r\n            if (typeof edgeConstraints[nodeclass].asTarget.maxTotal == 'undefined'\r\n                || totalEdgeCountIn < edgeConstraints[nodeclass].asTarget.maxTotal ) {\r\n                totalTooMany = false;\r\n            }\r\n            if (typeof edgeConstraints[nodeclass].asTarget.maxEdge == 'undefined'\r\n                || sameEdgeCountIn < edgeConstraints[nodeclass].asTarget.maxEdge ) {\r\n                edgeTooMany = false;\r\n            }\r\n            return totalTooMany || edgeTooMany;\r\n        }\r\n        return false;\r\n      }\r\n\r\n      function isInComplex(node) {\r\n        var parentClass = node.parent().data('class');\r\n        return parentClass && parentClass.startsWith('complex');\r\n      }\r\n\r\n      if (isInComplex(source) || isInComplex(target)) { // subunits of a complex are no longer EPNs, no connection allowed\r\n        return 'invalid';\r\n      }\r\n\r\n      // check nature of connection\r\n      if (edgeConstraints[sourceclass].asSource.isAllowed && edgeConstraints[targetclass].asTarget.isAllowed) {\r\n        // check amount of connections\r\n        if (!hasTooManyEdges(source, \"source\") && !hasTooManyEdges(target, \"target\") ) {\r\n          return 'valid';\r\n        }\r\n      }\r\n      // try to reverse\r\n      if (edgeConstraints[targetclass].asSource.isAllowed && edgeConstraints[sourceclass].asTarget.isAllowed) {\r\n        if (!hasTooManyEdges(target, \"source\") && !hasTooManyEdges(source, \"target\") ) {\r\n          return 'reverse';\r\n        }\r\n      }\r\n      return 'invalid';\r\n    };\r\n\r\n    /*\r\n     * Hide given eles and perform given layout afterward. Layout parameter may be layout options\r\n     * or a function to call.\r\n     */\r\n    elementUtilities.hideAndPerformLayout = function(eles, layoutparam) {\r\n        var result = cy.viewUtilities().hide(eles); // Hide given eles\r\n        if (typeof layoutparam === 'function') {\r\n            layoutparam(); // If layoutparam is a function execute it\r\n        }\r\n        else {\r\n            var layout = cy.layout(layoutparam); // If layoutparam is layout options call layout with that options.\r\n\r\n            // Do this check for cytoscape.js backward compatibility\r\n            if (layout && layout.run) {\r\n                layout.run();\r\n            }\r\n        }\r\n\r\n        return result;\r\n    };\r\n\r\n    /*\r\n     * Unhide given eles and perform given layout afterward. Layout parameter may be layout options\r\n     * or a function to call.\r\n     */\r\n    elementUtilities.showAndPerformLayout = function(eles, layoutparam) {\r\n      var result = cy.viewUtilities().show(eles); // Show given eles\r\n      if (typeof layoutparam === 'function') {\r\n        layoutparam(); // If layoutparam is a function execute it\r\n      }\r\n      else {\r\n        var layout = cy.layout(layoutparam); // If layoutparam is layout options call layout with that options.\r\n\r\n        // Do this check for cytoscape.js backward compatibility\r\n        if (layout && layout.run) {\r\n          layout.run();\r\n        }\r\n      }\r\n\r\n      return result;\r\n    };\r\n\r\n    /*\r\n     * Change style/css of given eles by setting getting property name to the given value/values (Note that valueMap parameter may be\r\n     * a single string or an id to value map).\r\n     */\r\n    elementUtilities.changeCss = function(eles, name, valueMap) {\r\n      if ( typeof valueMap === 'object' ) {\r\n        cy.startBatch();\r\n        for (var i = 0; i < eles.length; i++) {\r\n          var ele = cy.getElementById(eles[i].id());\r\n          ele.css(name, valueMap[ele.id()]); // valueMap is an id to value map use it in this way\r\n        }\r\n        cy.endBatch();\r\n      }\r\n      else {\r\n        eles.css(name, valueMap); // valueMap is just a string set css('name') for all eles to this value\r\n      }\r\n    };\r\n\r\n    /*\r\n     * Change data of given eles by setting getting property name to the given value/values (Note that valueMap parameter may be\r\n     * a single string or an id to value map).\r\n     */\r\n    elementUtilities.changeData = function(eles, name, valueMap) {\r\n      if ( typeof valueMap === 'object' ) {\r\n        cy.startBatch();\r\n        for (var i = 0; i < eles.length; i++) {\r\n          var ele = cy.getElementById(eles[i].id());\r\n          ele.data(name, valueMap[ele.id()]); // valueMap is an id to value map use it in this way\r\n        }\r\n        cy.endBatch();\r\n      }\r\n      else {\r\n        eles.data(name, valueMap); // valueMap is just a string set css('name') for all eles to this value\r\n      }\r\n    };\r\n\r\n    elementUtilities.updateSetField = function(ele, fieldName, toDelete, toAdd, callback) {\r\n      var set = ele.data( fieldName );\r\n      if ( !set ) {\r\n        return;\r\n      }\r\n      var updates = {};\r\n\r\n      if ( toDelete != null && set[ toDelete ] ) {\r\n        delete set[ toDelete ];\r\n        updates.deleted = toDelete;\r\n      }\r\n\r\n      if ( toAdd != null ) {\r\n        set[ toAdd ] = true;\r\n        updates.added = toAdd;\r\n      }\r\n\r\n      if ( callback && ( updates[ 'deleted' ] != null || updates[ 'added' ] != null ) ) {\r\n        callback();\r\n      }\r\n\r\n      return updates;\r\n    };\r\n\r\n    /*\r\n     * Return the set of all nodes present under the given position\r\n     * renderedPos must be a point defined relatively to cytoscape container\r\n     * (like renderedPosition field of a node)\r\n     */\r\n    elementUtilities.getNodesAt = function(renderedPos) {\r\n      var nodes = cy.nodes();\r\n      var x = renderedPos.x;\r\n      var y = renderedPos.y;\r\n      var resultNodes = [];\r\n      for(var i = 0; i < nodes.length; i++) {\r\n        var node = nodes[i];\r\n        var renderedBbox = node.renderedBoundingBox({\r\n          includeNodes: true,\r\n          includeEdges: false,\r\n          includeLabels: false,\r\n          includeShadows: false\r\n        });\r\n        if (x >= renderedBbox.x1 && x <= renderedBbox.x2) {\r\n          if (y >= renderedBbox.y1 && y <= renderedBbox.y2) {\r\n            resultNodes.push(node);\r\n          }\r\n        }\r\n      }\r\n      return resultNodes;\r\n    };\r\n\r\n    elementUtilities.demultimerizeClass = function(sbgnclass) {\r\n      return sbgnclass.replace(\" multimer\", \"\");\r\n    };\r\n\r\n    /**\r\n     * @param mapType - type of the current map (PD, AF or Unknown)\r\n     */\r\n    elementUtilities.setMapType = function(mapType){\r\n      elementUtilities.mapType = mapType;\r\n      return mapType;\r\n    }\r\n\r\n    /**\r\n     * return - map type\r\n     */\r\n    elementUtilities.getMapType = function(){\r\n        return elementUtilities.mapType;\r\n    }\r\n    /**\r\n     * Resets map type\r\n     */\r\n    elementUtilities.resetMapType = function(){\r\n        elementUtilities.mapType = undefined;\r\n    }\r\n\r\n    /**\r\n     * Keep consistency of links to self inside the data() structure.\r\n     * This is needed whenever a node changes parents, for example,\r\n     * as it is destroyed and recreated. But the data() stays identical.\r\n     * This creates inconsistencies for the pointers stored in data(),\r\n     * as they now point to a deleted node.\r\n     */\r\n    elementUtilities.maintainPointer = function (eles) {\r\n      eles.nodes().forEach(function(ele){\r\n        // restore background images\r\n        ele.emit('data');\r\n\r\n        // skip nodes without any auxiliary units\r\n        if(!ele.data('statesandinfos') || ele.data('statesandinfos').length == 0) {\r\n          return;\r\n        }\r\n        for(var side in ele.data('auxunitlayouts')) {\r\n          ele.data('auxunitlayouts')[side].parentNode = ele.id();\r\n        }\r\n        for(var i=0; i < ele.data('statesandinfos').length; i++) {\r\n          ele.data('statesandinfos')[i].parent = ele.id();\r\n        }\r\n      });\r\n    }\r\n\r\n    elementUtilities.anyHasBackgroundImage = function (eles) {\r\n      var obj = elementUtilities.getBackgroundImageObjs(eles);\r\n      if(obj === undefined)\r\n        return false;\r\n      else{\r\n        for(var key in obj){\r\n          var value = obj[key];\r\n          if(value && !$.isEmptyObject(value))\r\n            return true;\r\n        }\r\n        return false;\r\n      }\r\n    }\r\n\r\n    elementUtilities.hasBackgroundImage = function (ele) {\r\n      if(ele.isNode()){\r\n        var bg = ele.data('background-image') ? ele.data('background-image') : \"\";\r\n        var cloneImg = 'data:image/svg+xml;utf8,%3Csvg%20width%3D%22100%22%20height%3D%22100%22%20viewBox%3D%220%200%20100%20100%22%20style%3D%22fill%3Anone%3Bstroke%3Ablack%3Bstroke-width%3A0%3B%22%20xmlns%3D%22http%3A//www.w3.org/2000/svg%22%20%3E%3Crect%20x%3D%220%22%20y%3D%220%22%20width%3D%22100%22%20height%3D%22100%22%20style%3D%22fill%3A%23a9a9a9%22/%3E%20%3C/svg%3E';\r\n        if(bg !== \"\" && !(bg.indexOf(cloneImg) > -1 && bg === cloneImg))\r\n          return true;\r\n\r\n      }\r\n      return false;\r\n    }\r\n\r\n    elementUtilities.getBackgroundImageURL = function (eles) {\r\n      if(!eles || eles.length < 1)\r\n        return;\r\n\r\n      var commonURL = \"\";\r\n      for(var i = 0; i < eles.length; i++){\r\n        var ele = eles[i];\r\n\r\n        if(!ele.isNode() || !elementUtilities.hasBackgroundImage(ele))\r\n          return;\r\n\r\n        var url = ele.data('background-image').split(\" \").pop();\r\n        if(!url || url.indexOf('http') !== 0 || (commonURL !== \"\" && commonURL !== url))\r\n          return;\r\n        else if(commonURL === \"\")\r\n          commonURL = url;\r\n      }\r\n\r\n      return commonURL;\r\n    }\r\n\r\n    elementUtilities.getBackgroundImageObjs = function (eles) {\r\n      if(!eles || eles.length < 1)\r\n        return;\r\n\r\n      var list = {};\r\n      for(var i = 0; i < eles.length; i++){\r\n        var ele = eles[i];\r\n        var obj = getBgObj(ele);\r\n        if(obj === undefined)\r\n          return;\r\n\r\n        list[ele.data('id')] = obj;\r\n      }\r\n      return list;\r\n\r\n      function getBgObj (ele) {\r\n        if(ele.isNode() && elementUtilities.hasBackgroundImage(ele)){\r\n          var keys = ['background-image', 'background-fit', 'background-image-opacity',\r\n          'background-position-x', 'background-position-y', 'background-height', 'background-width'];\r\n\r\n          var obj = {};\r\n          keys.forEach(function(key){\r\n            var arr = ele.data(key);\r\n            obj[key] = arr ? arr : \"\";\r\n          });\r\n\r\n          return obj;\r\n        }\r\n        else if(ele.isNode())\r\n          return {};\r\n      }\r\n    }\r\n\r\n    elementUtilities.getBackgroundFitOptions = function (eles) {\r\n      if(!eles || eles.length < 1)\r\n        return;\r\n\r\n      var commonFit = \"\";\r\n      for(var i = 0; i < eles.length; i++){\r\n        var node = eles[i];\r\n        if(!node.isNode())\r\n          return;\r\n\r\n        var fit = getFitOption(node);\r\n        if(!fit || (commonFit !== \"\" && fit !== commonFit))\r\n          return;\r\n        else if(commonFit === \"\")\r\n          commonFit = fit;\r\n      }\r\n\r\n      var options = '<option value=\"none\">None</option>'\r\n                  + '<option value=\"fit\">Fit</option>'\r\n                  + '<option value=\"cover\">Cover</option>'\r\n                  + '<option value=\"contain\">Contain</option>';\r\n      var searchKey = 'value=\"' + commonFit + '\"';\r\n      var index = options.indexOf(searchKey) + searchKey.length;\r\n      return options.substr(0, index) + ' selected' + options.substr(index);\r\n\r\n      function getFitOption(node) {\r\n        if(!elementUtilities.hasBackgroundImage(node))\r\n          return;\r\n\r\n        var f = node.data('background-fit');\r\n        var h = node.data('background-height');\r\n\r\n        if(!f || !h)\r\n          return;\r\n\r\n        f = f.split(\" \");\r\n        h = h.split(\" \");\r\n        if(f[f.length-1] === \"none\")\r\n          return (h[h.length-1] === \"auto\" ? \"none\" : \"fit\");\r\n        else\r\n          return f[f.length-1];\r\n      }\r\n    }\r\n\r\n    elementUtilities.updateBackgroundImage = function (nodes, bgObj) {\r\n      if(!nodes || nodes.length == 0 || !bgObj)\r\n        return;\r\n\r\n      for(var i = 0; i < nodes.length; i++){\r\n        var node = nodes[i];\r\n        var obj = bgObj[node.data('id')];\r\n        if(!obj || $.isEmptyObject(obj))\r\n          continue;\r\n\r\n        var imgs = node.data('background-image') ? node.data('background-image').split(\" \") : [];\r\n        var xPos = node.data('background-position-x') ? node.data('background-position-x').split(\" \") : [];\r\n        var yPos = node.data('background-position-y') ? node.data('background-position-y').split(\" \") : [];\r\n        var widths = node.data('background-width') ? node.data('background-width').split(\" \") : [];\r\n        var heights = node.data('background-height') ? node.data('background-height').split(\" \") : [];\r\n        var fits = node.data('background-fit') ? node.data('background-fit').split(\" \") : [];\r\n        var opacities = node.data('background-image-opacity') ? (\"\" + node.data('background-image-opacity')).split(\" \") : [];\r\n\r\n        var index = -1;\r\n        if(typeof obj['background-image'] === \"string\")\r\n          index = imgs.indexOf(obj['background-image']);\r\n        else if(Array.isArray(obj['background-image']))\r\n          index = imgs.indexOf(obj['background-image'][0]);\r\n\r\n        if(index < 0)\r\n          continue;\r\n\r\n        if(obj['background-image'] && imgs.length > index){\r\n          var tmp = imgs[index];\r\n          imgs[index] = obj['background-image'];\r\n          obj['background-image'] = tmp;\r\n        }\r\n        if(obj['background-fit'] && fits.length > index){\r\n          var tmp = fits[index];\r\n          fits[index] = obj['background-fit'];\r\n          obj['background-fit'] = tmp;\r\n        }\r\n        if(obj['background-width'] && widths.length > index){\r\n          var tmp = widths[index];\r\n          widths[index] = obj['background-width'];\r\n          obj['background-width'] = tmp;\r\n        }\r\n        if(obj['background-height'] && heights.length > index){\r\n          var tmp = heights[index];\r\n          heights[index] = obj['background-height'];\r\n          obj['background-height'] = tmp;\r\n        }\r\n        if(obj['background-position-x'] && xPos.length > index){\r\n          var tmp = xPos[index];\r\n          xPos[index] = obj['background-position-x'];\r\n          obj['background-position-x'] = tmp;\r\n        }\r\n        if(obj['background-position-y'] && yPos.length > index){\r\n          var tmp = yPos[index];\r\n          yPos[index] = obj['background-position-y'];\r\n          obj['background-position-y'] = tmp;\r\n        }\r\n        if(obj['background-image-opacity'] && opacities.length > index){\r\n          var tmp = opacities[index];\r\n          opacities[index] = obj['background-image-opacity'];\r\n          obj['background-image-opacity'] = tmp;\r\n        }\r\n\r\n        node.data('background-image', imgs.join(\" \"));\r\n        node.data('background-position-x', xPos.join(\" \"));\r\n        node.data('background-position-y', yPos.join(\" \"));\r\n        node.data('background-width', widths.join(\" \"));\r\n        node.data('background-height', heights.join(\" \"));\r\n        node.data('background-fit', fits.join(\" \"));\r\n        node.data('background-image-opacity', opacities.join(\" \"));\r\n      }\r\n\r\n      return bgObj;\r\n    }\r\n\r\n    elementUtilities.changeBackgroundImage = function (nodes, oldImg, newImg, firstTime, updateInfo, promptInvalidImage, validateURL) {\r\n      if(!nodes || nodes.length == 0 || !oldImg || !newImg)\r\n        return;\r\n\r\n      elementUtilities.removeBackgroundImage(nodes, oldImg);\r\n      for(var key in newImg){\r\n        newImg[key]['firstTime'] = firstTime;\r\n      }\r\n      elementUtilities.addBackgroundImage(nodes, newImg, updateInfo, promptInvalidImage, validateURL);\r\n\r\n      return {\r\n        nodes: nodes,\r\n        oldImg: newImg,\r\n        newImg: oldImg,\r\n        firstTime: false,\r\n        promptInvalidImage: promptInvalidImage,\r\n        validateURL: validateURL\r\n      };\r\n    }\r\n\r\n    // Add a background image to given nodes.\r\n    elementUtilities.addBackgroundImage = function (nodes, bgObj, updateInfo, promptInvalidImage, validateURL) {\r\n      if(!nodes || nodes.length == 0 || !bgObj)\r\n        return;\r\n\r\n      for(var i = 0; i < nodes.length; i++){\r\n        var node = nodes[i];\r\n        var obj = bgObj[node.data('id')];\r\n        if(!obj || $.isEmptyObject(obj))\r\n          continue;\r\n\r\n        // Load the image from local, else just put the URL\r\n        if(obj['fromFile'])\r\n        loadBackgroundThenApply(node, obj);\r\n        // Validity of given URL should be checked before applying it\r\n        else if(obj['firstTime']){\r\n          if(typeof validateURL === 'function')\r\n            validateURL(node, obj, applyBackground, promptInvalidImage);\r\n          else\r\n            checkGivenURL(node, obj);\r\n        }\r\n        else\r\n          applyBackground(node, obj);\r\n      }\r\n\r\n      function loadBackgroundThenApply(node, bgObj) {\r\n        var reader = new FileReader();\r\n        var imgFile = bgObj['background-image'];\r\n\r\n        // Check whether given file is an image file\r\n        if(imgFile.type.indexOf(\"image\") !== 0){\r\n          if(promptInvalidImage)\r\n            promptInvalidImage(\"Invalid image file is given!\");\r\n          return;\r\n        }\r\n\r\n        reader.readAsDataURL(imgFile);\r\n\r\n        reader.onload = function (e) {\r\n          var img = reader.result;\r\n          if(img){\r\n            bgObj['background-image'] = img;\r\n            bgObj['fromFile'] = false;\r\n            applyBackground(node, bgObj);\r\n          }\r\n          else{\r\n            if(promptInvalidImage)\r\n              promptInvalidImage(\"Given file could not be read!\");\r\n          }\r\n        };\r\n      }\r\n\r\n      function checkGivenURL(node, bgObj){\r\n        var url = bgObj['background-image'];\r\n        var extension = (url.split(/[?#]/)[0]).split(\".\").pop();\r\n        var validExtensions = [\"png\", \"svg\", \"jpg\", \"jpeg\"];\r\n\r\n        if(!validExtensions.includes(extension)){\r\n          if(typeof promptInvalidImage === 'function')\r\n            promptInvalidImage(\"Invalid URL is given!\");\r\n          return;\r\n        }\r\n\r\n        $.ajax({\r\n          url: url,\r\n          type: 'GET',\r\n          success: function(result, status, xhr){\r\n            applyBackground(node, bgObj);\r\n          },\r\n          error: function(xhr, status, error){\r\n            if(promptInvalidImage)\r\n              promptInvalidImage(\"Invalid URL is given!\");\r\n          },\r\n        });\r\n      }\r\n\r\n      function applyBackground(node, bgObj) {\r\n\r\n        if(elementUtilities.hasBackgroundImage(node))\r\n          return;\r\n\r\n        var imgs = node.data('background-image') ? node.data('background-image').split(\" \") : [];\r\n        var xPos = node.data('background-position-x') ? node.data('background-position-x').split(\" \") : [];\r\n        var yPos = node.data('background-position-y') ? node.data('background-position-y').split(\" \") : [];\r\n        var widths = node.data('background-width') ? node.data('background-width').split(\" \") : [];\r\n        var heights = node.data('background-height') ? node.data('background-height').split(\" \") : [];\r\n        var fits = node.data('background-fit') ? node.data('background-fit').split(\" \") : [];\r\n        var opacities = node.data('background-image-opacity') ? (\"\" + node.data('background-image-opacity')).split(\" \") : [];\r\n\r\n        var indexToInsert = imgs.length;\r\n\r\n        // insert to length-1\r\n        if(hasCloneMarker(node, imgs)){\r\n          indexToInsert--;\r\n        }\r\n\r\n        imgs.splice(indexToInsert, 0, bgObj['background-image']);\r\n        fits.splice(indexToInsert, 0, bgObj['background-fit']);\r\n        opacities.splice(indexToInsert, 0, bgObj['background-image-opacity']);\r\n        xPos.splice(indexToInsert, 0, bgObj['background-position-x']);\r\n        yPos.splice(indexToInsert, 0, bgObj['background-position-y']);\r\n        widths.splice(indexToInsert, 0, bgObj['background-width']);\r\n        heights.splice(indexToInsert, 0, bgObj['background-height']);\r\n\r\n        node.data('background-image', imgs.join(\" \"));\r\n        node.data('background-position-x', xPos.join(\" \"));\r\n        node.data('background-position-y', yPos.join(\" \"));\r\n        node.data('background-width', widths.join(\" \"));\r\n        node.data('background-height', heights.join(\" \"));\r\n        node.data('background-fit', fits.join(\" \"));\r\n        node.data('background-image-opacity', opacities.join(\" \"));\r\n        bgObj['firstTime'] = false;\r\n\r\n        if(updateInfo)\r\n          updateInfo();\r\n\r\n      }\r\n\r\n      function hasCloneMarker(node, imgs){\r\n        var cloneImg = 'data:image/svg+xml;utf8,%3Csvg%20width%3D%22100%22%20height%3D%22100%22%20viewBox%3D%220%200%20100%20100%22%20style%3D%22fill%3Anone%3Bstroke%3Ablack%3Bstroke-width%3A0%3B%22%20xmlns%3D%22http%3A//www.w3.org/2000/svg%22%20%3E%3Crect%20x%3D%220%22%20y%3D%220%22%20width%3D%22100%22%20height%3D%22100%22%20style%3D%22fill%3A%23a9a9a9%22/%3E%20%3C/svg%3E';\r\n        return (imgs.indexOf(cloneImg) > -1);\r\n      }\r\n    };\r\n\r\n    // Remove a background image from given nodes.\r\n    elementUtilities.removeBackgroundImage = function (nodes, bgObj) {\r\n      if(!nodes || nodes.length == 0 || !bgObj)\r\n        return;\r\n\r\n      for(var i = 0; i < nodes.length; i++){\r\n        var node = nodes[i];\r\n        var obj = bgObj[node.data('id')];\r\n        if(!obj)\r\n          continue;\r\n\r\n        var imgs = node.data('background-image') ? node.data('background-image').split(\" \") : [];\r\n        var xPos = node.data('background-position-x') ? node.data('background-position-x').split(\" \") : [];\r\n        var yPos = node.data('background-position-y') ? node.data('background-position-y').split(\" \") : [];\r\n        var widths = node.data('background-width') ? node.data('background-width').split(\" \") : [];\r\n        var heights = node.data('background-height') ? node.data('background-height').split(\" \") : [];\r\n        var fits = node.data('background-fit') ? node.data('background-fit').split(\" \") : [];\r\n        var opacities = node.data('background-image-opacity') ? (\"\" + node.data('background-image-opacity')).split(\" \") : [];\r\n\r\n        var index = -1;\r\n        if(typeof obj['background-image'] === \"string\")\r\n          index = imgs.indexOf(obj['background-image']);\r\n        else if(Array.isArray(obj['background-image']))\r\n          index = imgs.indexOf(obj['background-image'][0]);\r\n\r\n        if(index > -1){\r\n          imgs.splice(index, 1);\r\n          fits.splice(index, 1);\r\n          opacities.splice(index, 1);\r\n          xPos.splice(index, 1);\r\n          yPos.splice(index, 1);\r\n          widths.splice(index, 1);\r\n          heights.splice(index, 1);\r\n        }\r\n\r\n        node.data('background-image', imgs.join(\" \"));\r\n        node.data('background-position-x', xPos.join(\" \"));\r\n        node.data('background-position-y', yPos.join(\" \"));\r\n        node.data('background-width', widths.join(\" \"));\r\n        node.data('background-height', heights.join(\" \"));\r\n        node.data('background-fit', fits.join(\" \"));\r\n        node.data('background-image-opacity', opacities.join(\" \"));\r\n        bgObj['firstTime'] = false;\r\n      }\r\n    };\r\n\r\n    elementUtilities.reverseEdge = function(edge){\r\n      var oldSource = edge.source().id();\r\n      var oldTarget = edge.target().id();\r\n      var oldPortSource = edge.data(\"portsource\");\r\n      var oldPortTarget = edge.data(\"porttarget\");\r\n      var segmentPoints = edge.segmentPoints();\r\n\r\n\r\n      edge.data().source = oldTarget;\r\n      edge.data().target = oldSource;\r\n      edge.data().portsource = oldPortTarget;\r\n      edge.data().porttarget = oldPortSource;\r\n       edge = edge.move({\r\n         target: oldSource,\r\n         source : oldTarget        \r\n      });\r\n\r\n      if(Array.isArray(segmentPoints)){\r\n        segmentPoints.reverse();\r\n        edge.data().bendPointPositions = segmentPoints;\r\n        var edgeEditing = cy.edgeEditing('get');\r\n        edgeEditing.initBendPoints(edge);\r\n      }\r\n    \r\n\r\n      return edge;\r\n    }\r\n\r\n  }\r\n\r\n  return elementUtilitiesExtender;\r\n};\r\n","/* \r\n * Utility file to get and set the libraries to which sbgnviz is dependent from any file.\r\n */\r\n\r\nvar libUtilities = function(){\r\n};\r\n\r\nlibUtilities.setLibs = function(libs) {\r\n  this.libs = libs;\r\n};\r\n\r\nlibUtilities.getLibs = function() {\r\n  return this.libs;\r\n};\r\n\r\nmodule.exports = libUtilities;","var libs = require('./lib-utilities').getLibs();\r\n\r\n/*\r\n * The main utilities to be exposed directly.\r\n */\r\nmodule.exports = function () {\r\n\r\n  var elementUtilities, options, cy, sbgnvizInstance;\r\n\r\n  function mainUtilities (param) {\r\n    elementUtilities = param.elementUtilities;\r\n    options = param.optionUtilities.getOptions();\r\n    cy = param.sbgnvizInstanceUtilities.getCy();\r\n    sbgnvizInstance = param.sbgnvizInstanceUtilities.getInstance();\r\n  };\r\n\r\n  /*\r\n   * Adds a new node with the given class and at the given coordinates. Considers undoable option.\r\n   */\r\n  mainUtilities.addNode = function(x, y , nodeParams, id, parent, visibility) {\r\n    if ( elementUtilities.isGraphTopologyLocked() ) {\r\n      return;\r\n    }\r\n\r\n    // update map type\r\n    if (typeof nodeParams == 'object'){\r\n/* \r\n      if (!elementUtilities.getMapType())\r\n        elementUtilities.setMapType(nodeParams.language);\r\n      else if (elementUtilities.getMapType() != nodeParams.language)\r\n        elementUtilities.setMapType(\"Unknown\"); */\r\n    }\r\n\r\n    if (!options.undoable) {\r\n      return elementUtilities.addNode(x, y, nodeParams, id, parent, visibility);\r\n    }\r\n    else {\r\n      var param = {\r\n        newNode : {\r\n          x: x,\r\n          y: y,\r\n          class: nodeParams,\r\n          id: id,\r\n          parent: parent,\r\n          visibility: visibility\r\n        }\r\n      };\r\n\r\n      cy.undoRedo().do(\"addNode\", param);\r\n    }\r\n  };\r\n\r\n  /*\r\n   * Adds a new edge with the given class and having the given source and target ids. Considers undoable option.\r\n   */\r\n  mainUtilities.addEdge = function(source, target, edgeParams, invalidEdgeCallback, id, visibility) {\r\n    if ( elementUtilities.isGraphTopologyLocked() ) {\r\n      return;\r\n    }\r\n\r\n    // update map type\r\n    if (typeof edgeParams == 'object'){\r\n\r\n     /*  if (!elementUtilities.getMapType())\r\n        elementUtilities.setMapType(edgeParams.language);\r\n      else if (elementUtilities.getMapType() != edgeParams.language)\r\n        elementUtilities.setMapType(\"HybridAny\"); */\r\n    }\r\n    // Get the validation result\r\n    var edgeclass = edgeParams.class ? edgeParams.class : edgeParams;\r\n    var validation = elementUtilities.validateArrowEnds(edgeclass, cy.getElementById(source), cy.getElementById(target));\r\n\r\n    // If validation result is 'invalid' cancel the operation\r\n    if (validation === 'invalid') {\r\n      if(typeof invalidEdgeCallback === \"function\"){\r\n        invalidEdgeCallback();\r\n      }\r\n      return;\r\n    }\r\n\r\n    // If validation result is 'reverse' reverse the source-target pair before creating the edge\r\n    if (validation === 'reverse') {\r\n      var temp = source;\r\n      source = target;\r\n      target = temp;\r\n    }\r\n\r\n    if (!options.undoable) {\r\n      return elementUtilities.addEdge(source, target, edgeParams, id, visibility);\r\n    }\r\n    else {\r\n      var param = {\r\n        newEdge : {\r\n          source: source,\r\n          target: target,\r\n          class: edgeParams,\r\n          id: id,\r\n          visibility: visibility\r\n        }\r\n      };\r\n\r\n      var result = cy.undoRedo().do(\"addEdge\", param);\r\n      return result.eles;\r\n    }\r\n  };\r\n\r\n  /*\r\n   * Adds a process with convenient edges. For more information please see 'https://github.com/iVis-at-Bilkent/newt/issues/9'.\r\n   * Considers undoable option.\r\n   */\r\n  mainUtilities.addProcessWithConvenientEdges = function(_source, _target, processType) {\r\n    if ( elementUtilities.isGraphTopologyLocked() ) {\r\n      return;\r\n    }\r\n\r\n    // If source and target IDs are given get the elements by IDs\r\n    var source = typeof _source === 'string' ? cy.getElementById(_source) : _source;\r\n    var target = typeof _target === 'string' ? cy.getElementById(_target) : _target;\r\n\r\n    // If source or target does not have an EPN class the operation is not valid\r\n    if (!elementUtilities.isEPNClass(source) || !elementUtilities.isEPNClass(target)) {\r\n      return;\r\n    }\r\n\r\n    if (!options.undoable) {\r\n      return elementUtilities.addProcessWithConvenientEdges(_source, _target, processType);\r\n    }\r\n    else {\r\n      var param = {\r\n        source: _source,\r\n        target: _target,\r\n        processType: processType\r\n      };\r\n\r\n      cy.undoRedo().do(\"addProcessWithConvenientEdges\", param);\r\n    }\r\n  };\r\n\r\n  // convert collapsed compound nodes to simple nodes\r\n  // and update port values of pasted nodes and edges\r\n  var cloneCollapsedNodesAndPorts = function (elesBefore){\r\n    if ( elementUtilities.isGraphTopologyLocked() ) {\r\n      return;\r\n    }\r\n\r\n    cy.elements().unselect();\r\n    var elesAfter = cy.elements();\r\n    var elesDiff = elesAfter.diff(elesBefore).left;\r\n\r\n    // shallow copy collapsed nodes - collapsed compounds become simple nodes\r\n    // data related to collapsed nodes are removed from generated clones\r\n    // related issue: https://github.com/iVis-at-Bilkent/newt/issues/145\r\n    var collapsedNodes = elesDiff.filter('node.cy-expand-collapse-collapsed-node');\r\n\r\n    collapsedNodes.connectedEdges().remove();\r\n    collapsedNodes.removeClass('cy-expand-collapse-collapsed-node');\r\n    collapsedNodes.removeData('collapsedChildren');\r\n    collapsedNodes.removeData('position-before-collapse size-before-collapse');\r\n    collapsedNodes.removeData('expandcollapseRenderedCueSize expandcollapseRenderedStartX expandcollapseRenderedStartY');\r\n\r\n    // cloning ports\r\n    elesDiff.nodes().forEach(function(_node){\r\n      if(_node.data(\"ports\").length == 2){\r\n          var oldPortName0 = _node.data(\"ports\")[0].id;\r\n          var oldPortName1 = _node.data(\"ports\")[1].id;\r\n          _node.data(\"ports\")[0].id = _node.id() + \".1\";\r\n          _node.data(\"ports\")[1].id = _node.id() + \".2\";\r\n\r\n          _node.outgoers().edges().forEach(function(_edge){\r\n            if(_edge.data(\"portsource\") == oldPortName0){\r\n              _edge.data(\"portsource\", _node.data(\"ports\")[0].id);\r\n            }\r\n            else if(_edge.data(\"portsource\") == oldPortName1){\r\n              _edge.data(\"portsource\", _node.data(\"ports\")[1].id);\r\n            }\r\n            else{\r\n              _edge.data(\"portsource\", _node.id());\r\n            }\r\n          });\r\n          _node.incomers().edges().forEach(function(_edge){\r\n            if(_edge.data(\"porttarget\") == oldPortName0){\r\n              _edge.data(\"porttarget\", _node.data(\"ports\")[0].id);\r\n            }\r\n            else if(_edge.data(\"porttarget\") == oldPortName1){\r\n              _edge.data(\"porttarget\", _node.data(\"ports\")[1].id);\r\n            }\r\n            else{\r\n              _edge.data(\"porttarget\", _node.id());\r\n            }\r\n          });\r\n      }\r\n      else{\r\n        _node.outgoers().edges().forEach(function(_edge){\r\n          _edge.data(\"portsource\", _node.id());\r\n        });\r\n        _node.incomers().edges().forEach(function(_edge){\r\n          _edge.data(\"porttarget\", _node.id());\r\n        });\r\n      }\r\n    });\r\n    elesDiff.select();\r\n  }\r\n\r\n  /*\r\n   * Clone given elements. Considers undoable option. Requires cytoscape-clipboard extension.\r\n   */\r\n  mainUtilities.cloneElements = function (eles, pasteAtMouseLoc) {\r\n    if ( elementUtilities.isGraphTopologyLocked() ) {\r\n      return;\r\n    }\r\n\r\n    if (eles.length === 0) {\r\n      return;\r\n    }\r\n\r\n    this.copyElements(eles);\r\n\r\n    this.pasteElements(pasteAtMouseLoc);\r\n  };\r\n\r\n  /*\r\n   * Copy given elements to clipboard. Requires cytoscape-clipboard extension.\r\n   */\r\n  mainUtilities.copyElements = function (eles) {\r\n    cy.clipboard().copy(eles);\r\n  };\r\n\r\n  /*\r\n   * Paste the elements copied to clipboard. Considers undoable option. Requires cytoscape-clipboard extension.\r\n   */\r\n  mainUtilities.pasteElements = function(pasteAtMouseLoc) {\r\n    if ( elementUtilities.isGraphTopologyLocked() ) {\r\n      return;\r\n    }\r\n\r\n    var elesBefore = cy.elements();\r\n\r\n    if (options.undoable) {\r\n      cy.undoRedo().do(\"paste\",{pasteAtMouseLoc: pasteAtMouseLoc});\r\n    }\r\n    else {\r\n      cy.clipboard().paste();\r\n    }\r\n    cloneCollapsedNodesAndPorts(elesBefore);\r\n    cy.nodes(\":selected\").emit('data');\r\n  };\r\n\r\n  /*\r\n   * Aligns given nodes in given horizontal and vertical order.\r\n   * Horizontal and vertical parameters may be 'none' or undefined.\r\n   * alignTo parameter indicates the leading node.\r\n   * Requrires cytoscape-grid-guide extension and considers undoable option.\r\n   */\r\n  mainUtilities.align = function (nodes, horizontal, vertical, alignTo) {\r\n    if (nodes.length === 0) {\r\n      return;\r\n    }\r\n\r\n    if (options.undoable) {\r\n      cy.undoRedo().do(\"align\", {\r\n        nodes: nodes,\r\n        horizontal: horizontal,\r\n        vertical: vertical,\r\n        alignTo: alignTo\r\n      });\r\n    } else {\r\n      nodes.align(horizontal, vertical, alignTo);\r\n    }\r\n\r\n    if(cy.edges(\":selected\").length == 1 ) {\r\n      cy.edges().unselect();      \r\n    }\r\n    \r\n  };\r\n\r\n  /*\r\n   * Create compound for given nodes. compoundType may be 'complex' or 'compartment'.\r\n   * This method considers undoable option.\r\n   */\r\n  mainUtilities.createCompoundForGivenNodes = function (_nodes, compoundType) {\r\n    if ( elementUtilities.isGraphTopologyLocked() ) {\r\n      return;\r\n    }\r\n\r\n    var nodes = _nodes;\r\n    /*\r\n     * Eleminate the nodes which cannot have a parent with given compound type\r\n     */\r\n    nodes = _nodes.filter(function (element, i) {\r\n      if(typeof element === \"number\") {\r\n        element = i;\r\n      }\r\n\r\n      var sbgnclass = element.data(\"class\");\r\n      return elementUtilities.isValidParent(sbgnclass, compoundType, element);\r\n    });\r\n\r\n    nodes = elementUtilities.getTopMostNodes(nodes);\r\n\r\n    // All elements should have the same parent and the common parent should not be a 'complex'\r\n    // if compoundType is 'compartent'\r\n    // because the old common parent will be the parent of the new compartment after this operation and\r\n    // 'complexes' cannot include 'compartments'\r\n    if (nodes.length == 0 || !elementUtilities.allHaveTheSameParent(nodes)\r\n            || ( (compoundType === 'compartment' || compoundType == 'submap') && nodes.parent().data('class')\r\n            && nodes.parent().data('class').startsWith('complex') )) {\r\n      return;\r\n    }\r\n\r\n    if (cy.undoRedo()) {\r\n      var param = {\r\n        compoundType: compoundType,\r\n        nodesToMakeCompound: nodes\r\n      };\r\n\r\n      cy.undoRedo().do(\"createCompoundForGivenNodes\", param);\r\n    }\r\n    else {\r\n      elementUtilities.createCompoundForGivenNodes(nodes, compoundType);\r\n    }\r\n  };\r\n\r\n  /*\r\n   * Move the nodes to a new parent and change their position if possDiff params are set.\r\n   * Considers undoable option and checks if the operation is valid.\r\n   */\r\n  mainUtilities.changeParent = function(nodes, _newParent, posDiffX, posDiffY) {\r\n    if ( elementUtilities.isGraphTopologyLocked() ) {\r\n      return;\r\n    }\r\n\r\n    var newParent = typeof _newParent === 'string' ? cy.getElementById(_newParent) : _newParent;\r\n    // New parent is supposed to be one of the root, a complex or a compartment\r\n    if (newParent && !newParent.data(\"class\").startsWith(\"complex\") && newParent.data(\"class\") != \"compartment\"\r\n            && newParent.data(\"class\") != \"submap\") {\r\n      return;\r\n    }\r\n    /*\r\n     * Eleminate the nodes which cannot have the newParent as their parent\r\n     */\r\n    nodes = nodes.filter(function (element, i) {\r\n      if(typeof element === \"number\") {\r\n        element = i;\r\n      }\r\n\r\n      var sbgnclass = element.data(\"class\");\r\n      return elementUtilities.isValidParent(sbgnclass, newParent, element);\r\n    });\r\n\r\n    // Discard the nodes whose parent is already newParent.\r\n    // Discard the newParent itself if it is among the nodes\r\n    nodes = nodes.filter(function (ele, i) {\r\n      if(typeof ele === \"number\") {\r\n        ele = i;\r\n      }\r\n\r\n      // Discard the newParent if it is among the nodes\r\n      if (newParent && ele.id() === newParent.id()) {\r\n        return false;\r\n      }\r\n      // Discard the nodes whose parent is already newParent\r\n      if (!newParent) {\r\n        return ele.data('parent') != null;\r\n      }\r\n      return ele.data('parent') !== newParent.id();\r\n    });\r\n\r\n    // If some nodes are ancestor of new parent eleminate them\r\n    if (newParent) {\r\n      nodes = nodes.difference(newParent.ancestors());\r\n    }\r\n\r\n    // If all nodes are eleminated return directly\r\n    if (nodes.length === 0) {\r\n      return;\r\n    }\r\n\r\n    // Just move the top most nodes\r\n    nodes = elementUtilities.getTopMostNodes(nodes);\r\n\r\n    var parentId = newParent ? newParent.id() : null;\r\n\r\n    if (options.undoable) {\r\n      var param = {\r\n        firstTime: true,\r\n        parentData: parentId, // It keeps the newParentId (Just an id for each nodes for the first time)\r\n        nodes: nodes,\r\n        posDiffX: posDiffX,\r\n        posDiffY: posDiffY,\r\n        // This is needed because the changeParent function called is not from elementUtilities\r\n        // but from the undoRedo extension directly, so maintaining pointer is not automatically done.\r\n        callback: elementUtilities.maintainPointer\r\n      };\r\n\r\n      cy.undoRedo().do(\"changeParent\", param); // This action is registered by undoRedo extension\r\n    }\r\n    else {\r\n      elementUtilities.changeParent(nodes, parentId, posDiffX, posDiffY);\r\n    }\r\n  };\r\n\r\n  /*\r\n   * Creates a template reaction with given parameters. Requires cose-bilkent layout to tile the free macromolecules included\r\n   * in the complex. Considers undoable option. For more information see the same function in elementUtilities\r\n   */\r\n  mainUtilities.createTemplateReaction = function (templateType, macromoleculeList, complexName, processPosition, tilingPaddingVertical, tilingPaddingHorizontal, edgeLength, layoutParam) {\r\n    if ( elementUtilities.isGraphTopologyLocked() ) {\r\n      return;\r\n    }\r\n\r\n    if (!options.undoable) {\r\n      elementUtilities.createTemplateReaction(templateType, macromoleculeList, complexName, processPosition, tilingPaddingVertical, tilingPaddingHorizontal, edgeLength, layoutParam);\r\n    }\r\n    else {\r\n      var param = {\r\n        templateType: templateType,\r\n        macromoleculeList: macromoleculeList,\r\n        complexName: complexName,\r\n        processPosition: processPosition,\r\n        tilingPaddingVertical: tilingPaddingVertical,\r\n        tilingPaddingHorizontal: tilingPaddingHorizontal,\r\n        edgeLength: edgeLength,\r\n        layoutParam: layoutParam\r\n      };\r\n\r\n      cy.undoRedo().do(\"createTemplateReaction\", param);\r\n    }\r\n  };\r\n\r\n  /*\r\n   * Resize given nodes if useAspectRatio is truthy one of width or height should not be set.\r\n   * Considers undoable option.\r\n   */\r\n  mainUtilities.resizeNodes = function(nodes, width, height, useAspectRatio, preserveRelativePos) {\r\n    if (nodes.length === 0) {\r\n      return;\r\n    }\r\n\r\n    if (options.undoable) {\r\n      var param = {\r\n        nodes: nodes,\r\n        width: width,\r\n        height: height,\r\n        useAspectRatio: useAspectRatio,\r\n        performOperation: true,\r\n        preserveRelativePos: preserveRelativePos\r\n      };\r\n\r\n      cy.undoRedo().do(\"resizeNodes\", param);\r\n    }\r\n    else {\r\n      elementUtilities.resizeNodes(nodes, width, height, useAspectRatio);\r\n      cy.style().update();\r\n    }\r\n\r\n\r\n  };\r\n\r\n    /*\r\n     * Resize given nodes if useAspectRatio is truthy one of width or height should not be set.\r\n     * Considers undoable option.\r\n     */\r\n    mainUtilities.resizeNodesToContent = function(nodes, useAspectRatio) {\r\n        if (nodes.length === 0) {\r\n            return;\r\n        } \r\n        if (options.undoable) {\r\n          var actions = [];\r\n          nodes.forEach(function(node){\r\n            var width = elementUtilities.calculateMinWidth(node);\r\n            var height = elementUtilities.calculateMinHeight(node);\r\n            actions.push({name: \"resizeNodes\", param: {\r\n                nodes: node,\r\n                width: width,\r\n                height: height,\r\n                useAspectRatio: useAspectRatio,\r\n                performOperation: true,\r\n                preserveRelativePos: true\r\n            }});\r\n\r\n            var stateAndInfos = node.data('statesandinfos');\r\n            var length = stateAndInfos.length;\r\n            if (length != 0) {\r\n              var param = {\r\n                node: node,\r\n                locations: [\"top\",\"right\",\"bottom\",\"left\"]\r\n              };          \r\n              actions.push({name:\"fitUnits\",param : param})\r\n             }\r\n  \r\n\r\n          });\r\n\r\n        \r\n         \r\n          cy.undoRedo().do(\"batch\", actions);\r\n          cy.style().update();\r\n          return actions;\r\n        }\r\n        else {\r\n            nodes.forEach(function(node){\r\n              var width = elementUtilities.calculateMinWidth(node);\r\n              var height = elementUtilities.calculateMinHeight(node);\r\n              \r\n              elementUtilities.resizeNodes(node, width, height, useAspectRatio, true);\r\n            });\r\n        }\r\n\r\n        cy.style().update();\r\n    };\r\n\r\n  /*\r\n   * Changes the label of the given nodes to the given label. Considers undoable option.\r\n   */\r\n  mainUtilities.changeNodeLabel = function(nodes, label) {\r\n    if (nodes.length === 0) {\r\n      return;\r\n    }\r\n\r\n    if (!options.undoable) {\r\n      nodes.data('label', label);\r\n    }\r\n    else {\r\n      var param = {\r\n        nodes: nodes,\r\n        label: label,\r\n        firstTime: true\r\n      };\r\n\r\n      cy.undoRedo().do(\"changeNodeLabel\", param);\r\n    }\r\n\r\n    cy.style().update();\r\n  };\r\n\r\n  /*\r\n   * Change font properties for given nodes use the given font data.\r\n   * Considers undoable option.\r\n   */\r\n  mainUtilities.changeFontProperties = function(eles, data) {\r\n    if (eles.length === 0) {\r\n      return;\r\n    }\r\n\r\n    if (options.undoable) {\r\n      var param = {\r\n        eles: eles,\r\n        data: data,\r\n        firstTime: true\r\n      };\r\n\r\n      cy.undoRedo().do(\"changeFontProperties\", param);\r\n    }\r\n    else {\r\n      elementUtilities.changeFontProperties(eles, data);\r\n    }\r\n\r\n    cy.style().update();\r\n  };\r\n\r\n  /*\r\n   * Change state value or unit of information box of given nodes with given index.\r\n   * Considers undoable option.\r\n   * For more information about the parameters see elementUtilities.changeStateOrInfoBox\r\n   */\r\n  mainUtilities.changeStateOrInfoBox = function(nodes, index, value, type) {\r\n    if (nodes.length === 0) {\r\n      return;\r\n    }\r\n    if (options.undoable) {\r\n      var param = {\r\n        index: index,\r\n        value: value,\r\n        type: type,\r\n        nodes: nodes\r\n      };\r\n\r\n      cy.undoRedo().do(\"changeStateOrInfoBox\", param);\r\n    }\r\n    else {\r\n      return elementUtilities.changeStateOrInfoBox(nodes, index, value, type);\r\n    }\r\n\r\n    cy.style().update();\r\n  };\r\n\r\n  // Add a new state or info box to given nodes.\r\n  // The box is represented by the parameter obj.\r\n  // Considers undoable option.\r\n  mainUtilities.addStateOrInfoBox = function(nodes, obj) {\r\n    if (nodes.length === 0) {\r\n      return;\r\n    }\r\n\r\n    if (!options.undoable) {\r\n      elementUtilities.addStateOrInfoBox(nodes, obj);\r\n    }\r\n    else {\r\n      var param = {\r\n        obj: obj,\r\n        nodes: nodes\r\n      };\r\n\r\n      cy.undoRedo().do(\"addStateOrInfoBox\", param);\r\n    }\r\n\r\n    cy.style().update();\r\n  };\r\n\r\n  // Remove the state or info boxes of the given nodes at given index.\r\n  // Considers undoable option.\r\n  mainUtilities.removeStateOrInfoBox = function(nodes, index) {\r\n    if (nodes.length === 0) {\r\n      return;\r\n    }\r\n\r\n    if (!options.undoable) {\r\n      elementUtilities.removeStateOrInfoBox(nodes, {index: index});\r\n    }\r\n    else {\r\n      var param = {\r\n        locationObj: {index: index},\r\n        nodes: nodes\r\n      };\r\n\r\n      cy.undoRedo().do(\"removeStateOrInfoBox\", param);\r\n    }\r\n\r\n    cy.style().update();\r\n  };\r\n\r\n\r\n  //Arrange information boxes\r\n  //If force check is true, it rearranges all information boxes\r\n  mainUtilities.fitUnits = function (node, locations) {\r\n    if (node.data('auxunitlayouts') === undefined || node.data('statesandinfos').length <= 0) {\r\n      return;\r\n    }\r\n    if (locations === undefined || locations.length <= 0) {\r\n      return;\r\n    }\r\n\r\n    if (!options.undoable) {\r\n      elementUtilities.fitUnits(node, locations);\r\n    }\r\n    else {\r\n      var param = {\r\n        node: node,\r\n        locations: locations\r\n      };\r\n\r\n      cy.undoRedo().do(\"fitUnits\", param);\r\n    }\r\n\r\n    cy.style().update();\r\n  };\r\n\r\n  /*\r\n   * Set multimer status of the given nodes to the given status.\r\n   * Considers undoable option.\r\n   */\r\n  mainUtilities.setMultimerStatus = function(nodes, status) {\r\n    if (nodes.length === 0) {\r\n      return;\r\n    }\r\n\r\n    if (options.undoable) {\r\n      var param = {\r\n        status: status,\r\n        nodes: nodes,\r\n        firstTime: true\r\n      };\r\n\r\n      cy.undoRedo().do(\"setMultimerStatus\", param);\r\n    }\r\n    else {\r\n      elementUtilities.setMultimerStatus(nodes, status);\r\n    }\r\n\r\n    cy.style().update();\r\n  };\r\n\r\n  /*\r\n   * Set clone marker status of given nodes to the given status.\r\n   * Considers undoable option.\r\n   */\r\n  mainUtilities.setCloneMarkerStatus = function(nodes, status) {\r\n    if (nodes.length === 0) {\r\n      return;\r\n    }\r\n\r\n    if (options.undoable) {\r\n      var param = {\r\n        status: status,\r\n        nodes: nodes,\r\n        firstTime: true\r\n      };\r\n\r\n      cy.undoRedo().do(\"setCloneMarkerStatus\", param);\r\n    }\r\n    else {\r\n      elementUtilities.setCloneMarkerStatus(nodes, status);\r\n    }\r\n\r\n    cy.style().update();\r\n  };\r\n\r\n  /*\r\n   * Change style/css of given eles by setting getting property name to the given given value/values (Note that valueMap parameter may be\r\n   * a single string or an id to value map). Considers undoable option.\r\n   */\r\n  mainUtilities.changeCss = function(eles, name, valueMap) {\r\n    if (eles.length === 0) {\r\n      return;\r\n    }\r\n\r\n    if (!options.undoable) {\r\n      elementUtilities.changeCss(eles, name, valueMap);\r\n    }\r\n    else {\r\n      var param = {\r\n        eles: eles,\r\n        valueMap: valueMap,\r\n        name: name\r\n      };\r\n\r\n      cy.undoRedo().do(\"changeCss\", param);\r\n    }\r\n\r\n    cy.style().update();\r\n  };\r\n\r\n  /*\r\n   * Change data of given eles by setting getting property name to the given given value/values (Note that valueMap parameter may be\r\n   * a single string or an id to value map). Considers undoable option.\r\n   */\r\n  mainUtilities.changeData = function(eles, name, valueMap) {\r\n    if (eles.length === 0) {\r\n      return;\r\n    }\r\n\r\n    if (!options.undoable) {\r\n      elementUtilities.changeData(eles, name, valueMap);\r\n    }\r\n    else {\r\n      var param = {\r\n        eles: eles,\r\n        valueMap: valueMap,\r\n        name: name\r\n      };\r\n\r\n      cy.undoRedo().do(\"changeData\", param);\r\n    }\r\n\r\n    cy.style().update();\r\n  };\r\n\r\n  mainUtilities.updateSetField = function(ele, fieldName, toDelete, toAdd, callback) {\r\n    if (!options.undoable) {\r\n      elementUtilities.changeData(ele, fieldName, toDelete, toAdd, callback);\r\n    }\r\n    else {\r\n      var param = {\r\n        ele,\r\n        fieldName,\r\n        toDelete,\r\n        toAdd,\r\n        callback\r\n      };\r\n\r\n      cy.undoRedo().do(\"updateSetField\", param);\r\n    }\r\n  };\r\n\r\n  mainUtilities.setDefaultProperty = function( _class, name, value ) {\r\n    if (!options.undoable) {\r\n      var propMap = {};\r\n      propMap[ name ] = value;\r\n\r\n      elementUtilities.setDefaultProperties(_class, propMap);\r\n    }\r\n    else {\r\n      var param = {\r\n        class: _class,\r\n        name,\r\n        value\r\n      };\r\n\r\n      cy.undoRedo().do(\"setDefaultProperty\", param);\r\n    }\r\n  };\r\n\r\n  mainUtilities.updateInfoboxStyle = function( node, index, newProps ) {\r\n    if (!options.undoable) {\r\n      elementUtilities.updateInfoboxStyle( node, index, newProps );\r\n    }\r\n    else {\r\n      var param = {\r\n        node: node,\r\n        index: index,\r\n        newProps: newProps\r\n      };\r\n\r\n      cy.undoRedo().do(\"updateInfoboxStyle\", param);\r\n    }\r\n\r\n    cy.style().update();\r\n  };\r\n\r\n  mainUtilities.updateInfoboxObj = function( node, index, newProps ) {\r\n    if (!options.undoable) {\r\n      elementUtilities.updateInfoboxObj( node, index, newProps );\r\n    }\r\n    else {\r\n      var param = {\r\n        node: node,\r\n        index: index,\r\n        newProps: newProps\r\n      };\r\n\r\n      cy.undoRedo().do(\"updateInfoboxObj\", param);\r\n    }\r\n\r\n    cy.style().update();\r\n  };\r\n\r\n\r\n  /*\r\n   * Hides given eles (the ones which are selected) and perform given layout afterward. Layout parameter may be layout options\r\n   * or a function to call. Requires viewUtilities extension and considers undoable option.\r\n   */\r\n  mainUtilities.hideAndPerformLayout = function(eles, layoutparam) {\r\n      var nodes = eles.nodes(); // Ensure that nodes list just include nodes\r\n\r\n      var allNodes = cy.nodes(\":visible\");\r\n      var nodesToShow = elementUtilities.extendRemainingNodes(nodes, allNodes);\r\n      var nodesToHide = allNodes.not(nodesToShow);\r\n\r\n      if (nodesToHide.length === 0) {\r\n          return;\r\n      }\r\n\r\n      if (!options.undoable) {\r\n\r\n          var nodesWithHiddenNeighbor = cy.edges(\":hidden\").connectedNodes(':visible');\r\n          sbgnvizInstance.thinBorder(nodesWithHiddenNeighbor);\r\n          elementUtilities.hideAndPerformLayout(nodesToHide, layoutparam);\r\n          var nodesWithHiddenNeighbor = cy.edges(\":hidden\").connectedNodes(':visible');\r\n          sbgnvizInstance.thickenBorder(nodesWithHiddenNeighbor);\r\n      }\r\n      else {\r\n          var param = {\r\n              eles: nodesToHide,\r\n              layoutparam: layoutparam,\r\n              firstTime: true\r\n          };\r\n\r\n          var ur = cy.undoRedo();\r\n          ur.action(\"thickenBorder\", sbgnvizInstance.thickenBorder, sbgnvizInstance.thinBorder);\r\n          ur.action(\"thinBorder\", sbgnvizInstance.thinBorder, sbgnvizInstance.thickenBorder);\r\n\r\n          var actions = [];\r\n          var nodesWithHiddenNeighbor = cy.edges(\":hidden\").connectedNodes().intersection(nodesToHide);\r\n          actions.push({name: \"thinBorder\", param: nodesWithHiddenNeighbor});\r\n          actions.push({name: \"hideAndPerformLayout\", param: param});\r\n          nodesWithHiddenNeighbor = nodesToHide.neighborhood(\":visible\").nodes().difference(nodesToHide).difference(cy.nodes(\"[thickBorder]\"));\r\n          actions.push({name: \"thickenBorder\", param: nodesWithHiddenNeighbor});\r\n          cy.undoRedo().do(\"batch\", actions);\r\n      }\r\n  };\r\n\r\n  /*\r\n   * Shows all elements (the ones which are hidden if any) and perform given layout afterward. Layout parameter may be layout options\r\n   * or a function to call. Requires viewUtilities extension and considers undoable option.\r\n   */\r\n  mainUtilities.showAllAndPerformLayout = function(layoutparam) {\r\n    var hiddenEles = cy.elements(':hidden');\r\n    if (hiddenEles.length === 0) {\r\n      return;\r\n    }\r\n    if (!options.undoable) {\r\n      var nodesWithHiddenNeighbor = cy.edges(\":hidden\").connectedNodes(':visible');\r\n      sbgnvizInstance.thinBorder(nodesWithHiddenNeighbor);\r\n      elementUtilities.showAndPerformLayout(hiddenEles, layoutparam);\r\n    }\r\n    else {\r\n      var param = {\r\n        eles: hiddenEles,\r\n        layoutparam: layoutparam,\r\n        firstTime: true\r\n      };\r\n\r\n      var ur = cy.undoRedo();\r\n      ur.action(\"thickenBorder\", sbgnvizInstance.thickenBorder, sbgnvizInstance.thinBorder);\r\n      ur.action(\"thinBorder\", sbgnvizInstance.thinBorder, sbgnvizInstance.thickenBorder);\r\n\r\n      var actions = [];\r\n      var nodesWithHiddenNeighbor = cy.nodes(\"[thickBorder]\");\r\n      actions.push({name: \"thinBorder\", param: nodesWithHiddenNeighbor});\r\n      actions.push({name: \"showAndPerformLayout\", param: param});\r\n      cy.undoRedo().do(\"batch\", actions);\r\n    }\r\n  };\r\n\r\n  /*\r\n   * Unhide given eles (the ones which are hidden if any) and perform given layout afterward. Layout parameter may be layout options\r\n   * or a function to call. Requires viewUtilities extension and considers undoable option.\r\n   */\r\n  mainUtilities.showAndPerformLayout = function(mainEle, eles, layoutparam) {\r\n      var hiddenEles = eles.filter(':hidden');\r\n      if (hiddenEles.length === 0) {\r\n          return;\r\n      }\r\n      mainUtilities.closeUpElements(mainEle, hiddenEles.nodes());\r\n      if (!options.undoable) {\r\n          var nodesWithHiddenNeighbor = cy.edges(\":hidden\").connectedNodes(':visible');\r\n          sbgnvizInstance.thinBorder(nodesWithHiddenNeighbor);\r\n          elementUtilities.showAndPerformLayout(hiddenEles, layoutparam);\r\n          var nodesWithHiddenNeighbor = cy.edges(\":hidden\").connectedNodes(':visible');\r\n          sbgnvizInstance.thickenBorder(nodesWithHiddenNeighbor);\r\n      }\r\n      else {\r\n          var param = {\r\n              eles: hiddenEles,\r\n              layoutparam: layoutparam,\r\n              firstTime: true\r\n          };\r\n\r\n          var ur = cy.undoRedo();\r\n          ur.action(\"thickenBorder\", sbgnvizInstance.thickenBorder, sbgnvizInstance.thinBorder);\r\n          ur.action(\"thinBorder\", sbgnvizInstance.thinBorder, sbgnvizInstance.thickenBorder);\r\n\r\n          var actions = [];\r\n          var nodesToThinBorder = (hiddenEles.neighborhood(\":visible\").nodes(\"[thickBorder]\"))\r\n                  .difference(cy.edges(\":hidden\").difference(hiddenEles.edges().union(hiddenEles.nodes().connectedEdges())).connectedNodes());\r\n          actions.push({name: \"thinBorder\", param: nodesToThinBorder});\r\n          actions.push({name: \"showAndPerformLayout\", param: param});\r\n          var nodesToThickenBorder = hiddenEles.nodes().edgesWith(cy.nodes(\":hidden\").difference(hiddenEles.nodes()))\r\n  \t            .connectedNodes().intersection(hiddenEles.nodes());\r\n          actions.push({name: \"thickenBorder\", param: nodesToThickenBorder});\r\n          cy.undoRedo().do(\"batch\", actions);\r\n      }\r\n  };\r\n\r\n  /*\r\n  * Takes the hidden elements close to the nodes whose neighbors will be shown\r\n  * */\r\n  mainUtilities.closeUpElements = function(mainEle, hiddenEles) {\r\n      var leftX = Number.MAX_VALUE;\r\n      var rightX = Number.MIN_VALUE;\r\n      var topY = Number.MAX_VALUE;\r\n      var bottomY = Number.MIN_VALUE;\r\n      // Check the x and y limits of all hidden elements and store them in the variables above\r\n      hiddenEles.forEach(function( ele ){\r\n          if (ele.data('class') != 'compartment' &&  ele.data('class') != 'complex')\r\n          {\r\n              var halfWidth = ele.outerWidth()/2;\r\n              var halfHeight = ele.outerHeight()/2;\r\n              if (ele.position(\"x\") - halfWidth < leftX)\r\n                  leftX = ele.position(\"x\") - halfWidth;\r\n              if (ele.position(\"x\") + halfWidth > rightX)\r\n                  rightX = ele.position(\"x\") + halfWidth;\r\n              if (ele.position(\"y\") - halfHeight < topY)\r\n                  topY = ele.position(\"y\") - halfHeight;\r\n              if (ele.position(\"y\") + halfHeight > topY)\r\n                  bottomY = ele.position(\"y\") + halfHeight;\r\n          }\r\n      });\r\n\r\n      //The coordinates of the old center containing the hidden nodes\r\n      var oldCenterX = (leftX + rightX)/2;\r\n      var oldCenterY = (topY + bottomY)/2;\r\n\r\n      //Here we calculate two parameters which define the area in which the hidden elements are placed initially\r\n      var minHorizontalParam = mainEle.outerWidth()/2 + (rightX - leftX)/2;\r\n      var maxHorizontalParam = mainEle.outerWidth() + (rightX - leftX)/2;\r\n      var minVerticalParam = mainEle.outerHeight()/2 + (bottomY - topY)/2;\r\n      var maxVerticalParam = mainEle.outerHeight() + (bottomY - topY)/2;\r\n\r\n      //Quadrants is an object of the form {first:\"obtained\", second:\"free\", third:\"free\", fourth:\"obtained\"}\r\n      // which holds which quadrant are free (that's where hidden nodes will be brought)\r\n      var quadrants = mainUtilities.checkOccupiedQuadrants(mainEle, hiddenEles);\r\n      var freeQuadrants = [];\r\n      for (var property in quadrants) {\r\n          if (quadrants[property] === \"free\")\r\n              freeQuadrants.push(property);\r\n      }\r\n\r\n      //Can take values 1 and -1 and are used to place the hidden nodes in the random quadrant\r\n      var horizontalMult;\r\n      var verticalMult;\r\n      if (freeQuadrants.length > 0)\r\n      {\r\n        if (freeQuadrants.length === 3)\r\n        {\r\n          if (freeQuadrants.includes('first') && freeQuadrants.includes('second') && freeQuadrants.includes('third'))\r\n          {\r\n            horizontalMult = -1;\r\n            verticalMult = -1;\r\n          }\r\n          else if (freeQuadrants.includes('first') && freeQuadrants.includes('second') && freeQuadrants.includes('fourth'))\r\n          {\r\n            horizontalMult = 1;\r\n            verticalMult = -1;\r\n          }\r\n          else if (freeQuadrants.includes('first') && freeQuadrants.includes('third') && freeQuadrants.includes('fourth'))\r\n          {\r\n            horizontalMult = 1;\r\n            verticalMult = 1;\r\n          }\r\n          else if (freeQuadrants.includes('second') && freeQuadrants.includes('third') && freeQuadrants.includes('fourth'))\r\n          {\r\n            horizontalMult = -1;\r\n            verticalMult = 1;\r\n          }\r\n        }\r\n        else\r\n        {\r\n          //Randomly picks one quadrant from the free quadrants\r\n          var randomQuadrant = freeQuadrants[Math.floor(Math.random()*freeQuadrants.length)];\r\n\r\n          if (randomQuadrant === \"first\") {\r\n              horizontalMult = 1;\r\n              verticalMult = -1;\r\n          }\r\n          else if (randomQuadrant === \"second\") {\r\n              horizontalMult = -1;\r\n              verticalMult = -1;\r\n          }\r\n          else if (randomQuadrant === \"third\") {\r\n              horizontalMult = -1;\r\n              verticalMult = 1;\r\n          }\r\n          else if (randomQuadrant === \"fourth\") {\r\n              horizontalMult = 1;\r\n              verticalMult = 1;\r\n          }\r\n        }\r\n      }\r\n      else\r\n      {\r\n          horizontalMult = 0;\r\n          verticalMult = 0;\r\n      }\r\n      // If the horizontalMult is 0 it means that no quadrant is free, so we randomly choose a quadrant\r\n      var horizontalParam = mainUtilities.generateRandom(minHorizontalParam,maxHorizontalParam,horizontalMult);\r\n      var verticalParam = mainUtilities.generateRandom(minVerticalParam,maxVerticalParam,verticalMult);\r\n\r\n      //The coordinates of the center where the hidden nodes will be transfered\r\n      var newCenterX = mainEle.position(\"x\") + horizontalParam;\r\n      var newCenterY = mainEle.position(\"y\") + verticalParam;\r\n\r\n      var xdiff = newCenterX - oldCenterX;\r\n      var ydiff = newCenterY - oldCenterY;\r\n\r\n      //Change the position of hidden elements\r\n      hiddenEles.forEach(function( ele ){\r\n          var newx = ele.position(\"x\") + xdiff;\r\n          var newy = ele.position(\"y\") + ydiff;\r\n          ele.position(\"x\", newx);\r\n          ele.position(\"y\",newy);\r\n      });\r\n  };\r\n\r\n  /*\r\n   * Generates a number between 2 nr and multimplies it with 1 or -1\r\n   * */\r\n  mainUtilities.generateRandom = function(min, max, mult) {\r\n      var val = [-1,1];\r\n      if (mult === 0)\r\n          mult = val[Math.floor(Math.random()*val.length)];\r\n      return (Math.floor(Math.random() * (max - min + 1)) + min) * mult;\r\n  };\r\n\r\n  /*\r\n   * This function makes sure that the random number lies in free quadrant\r\n   * */\r\n  mainUtilities.checkOccupiedQuadrants = function(mainEle, hiddenEles) {\r\n      if (elementUtilities.getMapType() == 'PD')\r\n      {\r\n        var visibleNeighborEles = mainEle.neighborhood().difference(hiddenEles).nodes();\r\n        var visibleNeighborsOfNeighbors = visibleNeighborEles.neighborhood().difference(hiddenEles).difference(mainEle).nodes();\r\n        var visibleEles = visibleNeighborEles.union(visibleNeighborsOfNeighbors);\r\n      }\r\n      else\r\n        var visibleEles = mainEle.neighborhood().difference(hiddenEles).nodes();\r\n      var occupiedQuadrants = {first:\"free\", second:\"free\", third:\"free\", fourth:\"free\"};\r\n\r\n      visibleEles.forEach(function( ele ){\r\n          if (ele.data('class') != 'compartment' &&  ele.data('class') != 'complex')\r\n          {\r\n              if (ele.position(\"x\") < mainEle.position(\"x\") && ele.position(\"y\") < mainEle.position(\"y\"))\r\n                  occupiedQuadrants.second = \"occupied\";\r\n              else if (ele.position(\"x\") > mainEle.position(\"x\") && ele.position(\"y\") < mainEle.position(\"y\"))\r\n                  occupiedQuadrants.first = \"occupied\";\r\n              else if (ele.position(\"x\") < mainEle.position(\"x\") && ele.position(\"y\") > mainEle.position(\"y\"))\r\n                  occupiedQuadrants.third = \"occupied\";\r\n              else if (ele.position(\"x\") > mainEle.position(\"x\") && ele.position(\"y\") > mainEle.position(\"y\"))\r\n                  occupiedQuadrants.fourth = \"occupied\";\r\n          }\r\n      });\r\n      return occupiedQuadrants;\r\n  };\r\n\r\n  // Overrides highlightProcesses from SBGNVIZ - do not highlight any nodes when the map type is AF\r\n  mainUtilities.highlightProcesses = function(_nodes) {\r\n    if (elementUtilities.getMapType() == \"AF\")\r\n      return;\r\n    sbgnvizInstance.highlightProcesses(_nodes);\r\n  };\r\n\r\n  /**\r\n   * Resets map type to undefined\r\n   */\r\n  mainUtilities.resetMapType = function(){\r\n    elementUtilities.resetMapType();\r\n  };\r\n\r\n  /**\r\n   * return : map type\r\n   */\r\n  mainUtilities.getMapType = function(){\r\n    return elementUtilities.getMapType();\r\n  };\r\n\r\n  mainUtilities.addBackgroundImage = function(nodes, bgObj, updateInfo, promptInvalidImage, validateURL){\r\n    if (nodes.length === 0 || !bgObj) {\r\n      return;\r\n    }\r\n\r\n    bgObj['firstTime'] = true;\r\n    if (options.undoable) {\r\n      var param = {\r\n        bgObj: bgObj,\r\n        nodes: nodes,\r\n        updateInfo: updateInfo,\r\n        promptInvalidImage: promptInvalidImage,\r\n        validateURL: validateURL,\r\n      };\r\n\r\n      cy.undoRedo().do(\"addBackgroundImage\", param);\r\n    }\r\n    else {\r\n      elementUtilities.addBackgroundImage(nodes, bgObj, updateInfo, promptInvalidImage, validateURL);\r\n    }\r\n\r\n    cy.style().update();\r\n  }\r\n\r\n  mainUtilities.removeBackgroundImage = function(nodes, bgObj){\r\n    if (nodes.length === 0 || !bgObj) {\r\n      return;\r\n    }\r\n\r\n    bgObj['firstTime'] = true;\r\n    if (options.undoable) {\r\n      var param = {\r\n        bgObj: bgObj,\r\n        nodes: nodes\r\n      };\r\n\r\n      cy.undoRedo().do(\"removeBackgroundImage\", param);\r\n    }\r\n    else {\r\n      elementUtilities.removeBackgroundImage(nodes, bgObj);\r\n    }\r\n\r\n    cy.style().update();\r\n  }\r\n\r\n  mainUtilities.updateBackgroundImage = function(nodes, bgObj){\r\n    if (nodes.length === 0 || !bgObj) {\r\n      return;\r\n    }\r\n\r\n    if (options.undoable) {\r\n      var param = {\r\n        bgObj: bgObj,\r\n        nodes: nodes\r\n      };\r\n\r\n      cy.undoRedo().do(\"updateBackgroundImage\", param);\r\n    }\r\n    else {\r\n      elementUtilities.updateBackgroundImage(nodes, bgObj);\r\n    }\r\n\r\n    cy.style().update();\r\n  }\r\n\r\n  mainUtilities.changeBackgroundImage = function(nodes, oldImg, newImg, updateInfo, promptInvalidImage, validateURL){\r\n    if (nodes.length === 0 || !oldImg || !newImg) {\r\n      return;\r\n    }\r\n\r\n    if (options.undoable) {\r\n      var param = {\r\n        oldImg: oldImg,\r\n        newImg: newImg,\r\n        nodes: nodes,\r\n        firstTime: true,\r\n        updateInfo: updateInfo,\r\n        promptInvalidImage: promptInvalidImage,\r\n        validateURL: validateURL\r\n      };\r\n\r\n      cy.undoRedo().do(\"changeBackgroundImage\", param);\r\n    }\r\n    else {\r\n      elementUtilities.changeBackgroundImage(nodes, oldImg, newImg, true, updateInfo, promptInvalidImage, validateURL);\r\n    }\r\n\r\n    cy.style().update();\r\n  }\r\n\r\n  return mainUtilities;\r\n};\r\n","/*\r\n *  Extend default options and get current options by using this file\r\n */\r\n\r\nmodule.exports = function () {\r\n\r\n  // default options\r\n  var defaults = {\r\n    // The path of core library images when sbgnviz is required from npm and the index html\r\n    // file and node_modules are under the same folder then using the default value is fine\r\n    imgPath: 'node_modules/sbgnviz/src/img',\r\n    // Whether to fit labels to nodes\r\n    fitLabelsToNodes: function () {\r\n      return false;\r\n    },\r\n    fitLabelsToInfoboxes: function () {\r\n      return false;\r\n    },\r\n    // dynamic label size it may be 'small', 'regular', 'large'\r\n    dynamicLabelSize: function () {\r\n      return 'regular';\r\n    },\r\n    // Whether to infer nesting on load \r\n    inferNestingOnLoad: function () {\r\n      return false;\r\n    },\r\n    // percentage used to calculate compound paddings\r\n    compoundPadding: function () {\r\n      return 10;\r\n    },\r\n    // The selector of the component containing the sbgn network\r\n    networkContainerSelector: '#sbgn-network-container',\r\n    // Whether the actions are undoable, requires cytoscape-undo-redo extension\r\n    undoable: true,\r\n    // Whether to have undoable drag feature in undo/redo extension. This options will be passed to undo/redo extension\r\n    undoableDrag: true\r\n  };\r\n\r\n  var optionUtilities = function () {\r\n  };\r\n\r\n  // Extend the defaults options with the user options\r\n  optionUtilities.extendOptions = function (options) {\r\n    var result = {};\r\n\r\n    for (var prop in defaults) {\r\n      result[prop] = defaults[prop];\r\n    }\r\n\r\n    for (var prop in options) {\r\n      result[prop] = options[prop];\r\n    }\r\n\r\n    optionUtilities.options = result;\r\n\r\n    return options;\r\n  };\r\n\r\n  optionUtilities.getOptions = function () {\r\n    return optionUtilities.options;\r\n  };\r\n\r\n  return optionUtilities;\r\n};\r\n","var libs = require('./lib-utilities').getLibs();\r\nvar $ = libs.jQuery;\r\n\r\nmodule.exports = function () {\r\n\r\n  var undoRedoActionFunctions, options, cy;\r\n\r\n  var registerUndoRedoActions = function (param) {\r\n\r\n    undoRedoActionFunctions = param.undoRedoActionFunctions;\r\n    options = param.optionUtilities.getOptions();\r\n    cy = param.sbgnvizInstanceUtilities.getCy();\r\n\r\n    if (!options.undoable) {\r\n      return;\r\n    }\r\n\r\n    // create undo-redo instance\r\n    var ur = cy.undoRedo({\r\n      undoableDrag: options.undoableDrag\r\n    });\r\n\r\n    // register add remove actions\r\n    ur.action(\"addNode\", undoRedoActionFunctions.addNode, undoRedoActionFunctions.deleteElesSimple);\r\n    ur.action(\"deleteElesSimple\", undoRedoActionFunctions.deleteElesSimple, undoRedoActionFunctions.restoreEles);\r\n    ur.action(\"addEdge\", undoRedoActionFunctions.addEdge, undoRedoActionFunctions.deleteElesSimple);\r\n    ur.action(\"addProcessWithConvenientEdges\", undoRedoActionFunctions.addProcessWithConvenientEdges, undoRedoActionFunctions.deleteElesSimple);\r\n    ur.action(\"deleteElesSmart\", undoRedoActionFunctions.deleteElesSmart, undoRedoActionFunctions.restoreEles);\r\n    ur.action(\"createCompoundForGivenNodes\", undoRedoActionFunctions.createCompoundForGivenNodes, undoRedoActionFunctions.createCompoundForGivenNodes);\r\n\r\n    // register general actions\r\n    ur.action(\"resizeNodes\", undoRedoActionFunctions.resizeNodes, undoRedoActionFunctions.resizeNodes);\r\n    ur.action(\"changeNodeLabel\", undoRedoActionFunctions.changeNodeLabel, undoRedoActionFunctions.changeNodeLabel);\r\n    ur.action(\"changeData\", undoRedoActionFunctions.changeData, undoRedoActionFunctions.changeData);\r\n    ur.action(\"updateSetField\", undoRedoActionFunctions.updateSetField, undoRedoActionFunctions.updateSetField);\r\n    ur.action(\"changeCss\", undoRedoActionFunctions.changeCss, undoRedoActionFunctions.changeCss);\r\n    ur.action(\"changeBendPoints\", undoRedoActionFunctions.changeBendPoints, undoRedoActionFunctions.changeBendPoints);\r\n    ur.action(\"changeFontProperties\", undoRedoActionFunctions.changeFontProperties, undoRedoActionFunctions.changeFontProperties);\r\n    ur.action(\"showAndPerformLayout\", undoRedoActionFunctions.showAndPerformLayout, undoRedoActionFunctions.undoShowAndPerformLayout);\r\n    ur.action(\"hideAndPerformLayout\", undoRedoActionFunctions.hideAndPerformLayout, undoRedoActionFunctions.undoHideAndPerformLayout);\r\n    ur.action(\"applySIFTopologyGrouping\", undoRedoActionFunctions.applySIFTopologyGrouping, undoRedoActionFunctions.applySIFTopologyGrouping);\r\n\r\n    // register SBGN actions\r\n    ur.action(\"addStateOrInfoBox\", undoRedoActionFunctions.addStateOrInfoBox, undoRedoActionFunctions.removeStateOrInfoBox);\r\n    ur.action(\"changeStateOrInfoBox\", undoRedoActionFunctions.changeStateOrInfoBox, undoRedoActionFunctions.changeStateOrInfoBox);\r\n    ur.action(\"setMultimerStatus\", undoRedoActionFunctions.setMultimerStatus, undoRedoActionFunctions.setMultimerStatus);\r\n    ur.action(\"setCloneMarkerStatus\", undoRedoActionFunctions.setCloneMarkerStatus, undoRedoActionFunctions.setCloneMarkerStatus);\r\n    ur.action(\"removeStateOrInfoBox\", undoRedoActionFunctions.removeStateOrInfoBox, undoRedoActionFunctions.addStateOrInfoBox);\r\n    ur.action(\"fitUnits\", undoRedoActionFunctions.fitUnits, undoRedoActionFunctions.restoreUnits);\r\n    ur.action(\"addBackgroundImage\", undoRedoActionFunctions.addBackgroundImage, undoRedoActionFunctions.removeBackgroundImage);\r\n    ur.action(\"removeBackgroundImage\", undoRedoActionFunctions.removeBackgroundImage, undoRedoActionFunctions.addBackgroundImage);\r\n    ur.action(\"updateBackgroundImage\", undoRedoActionFunctions.updateBackgroundImage, undoRedoActionFunctions.updateBackgroundImage);\r\n    ur.action(\"changeBackgroundImage\", undoRedoActionFunctions.changeBackgroundImage, undoRedoActionFunctions.changeBackgroundImage);\r\n    ur.action(\"updateInfoboxStyle\", undoRedoActionFunctions.updateInfoboxStyle, undoRedoActionFunctions.updateInfoboxStyle);\r\n    ur.action(\"updateInfoboxObj\", undoRedoActionFunctions.updateInfoboxObj, undoRedoActionFunctions.updateInfoboxObj);\r\n\r\n    // register easy creation actions\r\n    ur.action(\"createTemplateReaction\", undoRedoActionFunctions.createTemplateReaction, undoRedoActionFunctions.deleteElesSimple);\r\n    ur.action(\"setDefaultProperty\", undoRedoActionFunctions.setDefaultProperty, undoRedoActionFunctions.setDefaultProperty);\r\n    ur.action(\"convertIntoReversibleReaction\", undoRedoActionFunctions.convertIntoReversibleReaction, undoRedoActionFunctions.convertIntoReversibleReaction);\r\n\r\n    ur.action(\"moveEdge\", undoRedoActionFunctions.moveEdge, undoRedoActionFunctions.moveEdge);\r\n    ur.action(\"fixError\", undoRedoActionFunctions.fixError,undoRedoActionFunctions.unfixError);\r\n    ur.action(\"cloneHighDegreeNode\", undoRedoActionFunctions.cloneHighDegreeNode,undoRedoActionFunctions.unCloneHighDegreeNode);\r\n\r\n    ur.action(\"changeMapType\", undoRedoActionFunctions.changeMapType,undoRedoActionFunctions.changeMapType);\r\n    ur.action(\"setCompoundPadding\", undoRedoActionFunctions.setCompoundPadding, undoRedoActionFunctions.setCompoundPadding);\r\n\r\n  };\r\n\r\n  return registerUndoRedoActions;\r\n};\r\n","var libs = require('./lib-utilities').getLibs();\r\n\r\nmodule.exports = function () {\r\n\r\n  var instance;\r\n\r\n  function sbgnvizInstanceUtilities (options) {\r\n\r\n    instance = libs.sbgnviz(options);\r\n\r\n    return instance;\r\n  }\r\n\r\n  sbgnvizInstanceUtilities.getInstance = function () {\r\n    return instance;\r\n  }\r\n\r\n  sbgnvizInstanceUtilities.getCy = function () {\r\n    return this.getInstance().getCy();\r\n  }\r\n\r\n  return sbgnvizInstanceUtilities;\r\n};\r\n","var isEqual = require('lodash.isequal');\r\n\r\nmodule.exports = function() {\r\n\r\n  var cy, elementUtilities;\r\n  var groupCompoundType, metaEdgeIdentifier, lockGraphTopology, shouldApply;\r\n\r\n  var DEFAULT_GROUP_COMPOUND_TYPE = 'topology group';\r\n  var EDGE_STYLE_NAMES = [ 'line-color', 'width' ];\r\n\r\n  function topologyGrouping( param, props ) {\r\n    cy = param.sbgnvizInstanceUtilities.getCy()\r\n    elementUtilities = param.elementUtilities;\r\n\r\n    groupCompoundType = props.groupCompoundType || DEFAULT_GROUP_COMPOUND_TYPE;\r\n    metaEdgeIdentifier = props.metaEdgeIdentifier;\r\n    lockGraphTopology = props.lockGraphTopology;\r\n    shouldApply = props.shouldApply || true;\r\n\r\n    topologyGrouping.applied = false;\r\n    initMetaStyleMap();\r\n  }\r\n\r\n  topologyGrouping.apply = function() {\r\n    if ( topologyGrouping.applied || !evalOpt( shouldApply ) ) {\r\n      return;\r\n    }\r\n\r\n    var list = cy.nodes().map( function( node ) {\r\n      return [ node ];\r\n    } );\r\n\r\n    // determine node groups by their topology\r\n  \tvar groups = getNodeGroups( list );\r\n  \t// apply grouping in cy level\r\n  \tapplyGrouping( groups );\r\n\r\n    topologyGrouping.applied = true;\r\n\r\n    if ( lockGraphTopology ) {\r\n      elementUtilities.lockGraphTopology();\r\n    }\r\n\r\n  \treturn groups;\r\n  };\r\n\r\n  topologyGrouping.unapply = function() {\r\n    if ( !topologyGrouping.applied ) {\r\n      return;\r\n    }\r\n\r\n    var metaEdges = topologyGrouping.getMetaEdges();\r\n    metaEdges.forEach( function( edge ) {\r\n      var toRestore = edge.data('tg-to-restore');\r\n      edge.remove();\r\n      toRestore.restore();\r\n\r\n      EDGE_STYLE_NAMES.forEach( function( name ) {\r\n        var oldVal = topologyGrouping.metaStyleMap[ name ][ edge.id() ];\r\n        var newVal = edge.data( name );\r\n\r\n        if ( oldVal !== newVal ) {\r\n          toRestore.data( name, newVal );\r\n        }\r\n      } );\r\n    } );\r\n\r\n    initMetaStyleMap();\r\n\r\n    var parents = topologyGrouping.getGroupCompounds();\r\n    elementUtilities.changeParent( parents.children(), null );\r\n    parents.remove();\r\n\r\n    topologyGrouping.applied = false;\r\n\r\n    if ( lockGraphTopology ) {\r\n      elementUtilities.unlockGraphTopology();\r\n    }\r\n  };\r\n\r\n  topologyGrouping.getMetaEdges = function() {\r\n    var metaEdges = cy.edges('[' + metaEdgeIdentifier + ']');\r\n    return metaEdges;\r\n  };\r\n\r\n  topologyGrouping.getGroupCompounds = function() {\r\n    var className = groupCompoundType;\r\n    return cy.nodes('[class=\"' + className + '\"]');\r\n  };\r\n\r\n  topologyGrouping.clearAppliedFlag = function() {\r\n    topologyGrouping.applied = false;\r\n  };\r\n\r\n  topologyGrouping.setAppliedFlag = function(applied) {\r\n    topologyGrouping.applied = applied;\r\n  };\r\n\r\n  topologyGrouping.toggleAppliedFlag = function() {\r\n    topologyGrouping.applied = !topologyGrouping.applied;\r\n  };\r\n\r\n  function initMetaStyleMap() {\r\n    topologyGrouping.metaStyleMap = {};\r\n    EDGE_STYLE_NAMES.forEach( function( name ) {\r\n      topologyGrouping.metaStyleMap[ name ] = {};\r\n    } );\r\n  }\r\n\r\n  function evalOpt( opt ) {\r\n    if ( typeof opt === 'function' ) {\r\n      return opt();\r\n    }\r\n\r\n    return opt;\r\n  }\r\n\r\n  function getNodeGroups( list ) {\r\n    if ( list.length <= 1 ) {\r\n      return list;\r\n    }\r\n\r\n    var halves = getHalves( list );\r\n    var firstPart = getNodeGroups( halves[ 0 ] );\r\n    var secondPart = getNodeGroups( halves[ 1 ] );\r\n    // merge the halves\r\n\t  var groups = mergeGroups( firstPart, secondPart );\r\n\r\n    return groups;\r\n  }\r\n\r\n  function getParentOrSelf( node ) {\r\n    var parent = node.parent();\r\n    return parent.size() > 0 ? parent : node;\r\n  }\r\n\r\n  function calcGroupingKey( edge ) {\r\n    var srcId = getParentOrSelf( edge.source() ).id();\r\n    var tgtId = getParentOrSelf( edge.target() ).id();\r\n    var edgeType = getEdgeType( edge );\r\n\r\n    return [ edgeType, srcId, tgtId ].join( '-' );\r\n  }\r\n\r\n  function addToMapChain( map, key, val ) {\r\n    if ( !map[ key ] ) {\r\n      map[ key ] = cy.collection();\r\n    }\r\n\r\n    map[ key ] = map[ key ].add( val );\r\n  }\r\n\r\n  function applyGrouping( groups ) {\r\n    groups.forEach( function( group ) {\r\n      createGroupCompound( group );\r\n    } );\r\n\r\n    var compounds = topologyGrouping.getGroupCompounds();\r\n    var childrenEdges = compounds.children().connectedEdges();\r\n    var edgesMap = [];\r\n\r\n    childrenEdges.forEach( function( edge ){\r\n      var key = calcGroupingKey( edge );\r\n      addToMapChain( edgesMap, key, edge );\r\n      edge.remove();\r\n    } );\r\n\r\n    Object.keys( edgesMap ).forEach( function( key ) {\r\n      // make a dummy edge for all of edges that are mapped by key\r\n  \t\t// dummy edge should have common properties of given edges\r\n  \t\t// and should carry their id list in its data\r\n  \t\t// for source and target it should have parent of common source and target\r\n      createMetaEdgeFor( edgesMap[ key ] );\r\n    } );\r\n  }\r\n\r\n  function createGroupCompound( group ) {\r\n    if ( group.length < 2 ) {\r\n      return;\r\n    }\r\n\r\n    var collection = cy.collection();\r\n\r\n    group.forEach( function( node ) {\r\n      collection = collection.add( node );\r\n    } );\r\n\r\n    elementUtilities.createCompoundForGivenNodes( collection, groupCompoundType );\r\n  }\r\n\r\n  function createMetaEdgeFor( edges ) {\r\n    var srcId = getParentOrSelf( edges.source() ).id();\r\n    var tgtId = getParentOrSelf( edges.target() ).id();\r\n    var type = edges.data( 'class' );\r\n    cy.remove( edges );\r\n\r\n    var metaEdge = elementUtilities.addEdge( srcId, tgtId, type );\r\n    metaEdge.data( 'tg-to-restore', edges );\r\n    metaEdge.data( metaEdgeIdentifier, true );\r\n\r\n    EDGE_STYLE_NAMES.forEach( function( styleName ) {\r\n      edges.forEach( function( edge ) {\r\n        topologyGrouping.metaStyleMap[ styleName ][ edge.id() ] = edge.data( styleName );\r\n      } );\r\n\r\n      var commonVal = elementUtilities.getCommonProperty(edges, styleName, 'data');\r\n      if ( commonVal ) {\r\n        metaEdge.data( styleName, commonVal );\r\n      }\r\n    } );\r\n\r\n    return metaEdge;\r\n  }\r\n\r\n  function mergeGroups( groups1, groups2 ) {\r\n    // notMergedGrs will include members of groups1 that are not merged\r\n  \t// mergedGrs will include the merged members from 2 groups\r\n  \tvar notMergedGrs = [], mergedGrs = [];\r\n\r\n    groups1.forEach( function( gr1 ) {\r\n      var merged = false;\r\n\r\n      mergedGrs.concat( groups2 ).forEach( function( gr2, index2 ) {\r\n        // if groups should be merged merge them, remove gr2 from where it\r\n        // comes from and push the merge result to mergedGrs\r\n        if ( shouldMerge( gr1, gr2 ) ) {\r\n          var mergedGr = gr1.concat( gr2 );\r\n\r\n          if ( index2 >= mergedGrs.length ) {\r\n            removeAt( groups2, index2 - mergedGrs.length );\r\n          }\r\n          else {\r\n            removeAt( mergedGrs, index2 );\r\n          }\r\n\r\n          // mark as merged and break the loop\r\n          mergedGrs.push( mergedGr );\r\n          merged = true;\r\n          return;\r\n        }\r\n      } );\r\n\r\n      // if gr1 is not merged push it to notMergedGrs\r\n      if ( !merged ) {\r\n        notMergedGrs.push( gr1 );\r\n      }\r\n    } );\r\n\r\n    // the groups that comes from groups2 but not merged are still included\r\n\t  // in groups2 add them to the result together with mergedGrs and notMergedGrs\r\n    return notMergedGrs.concat( mergedGrs, groups2 );\r\n  }\r\n\r\n  function shouldMerge( group1, group2 ) {\r\n    // using first elements is enough to decide whether to merge\r\n  \tvar node1 = group1[ 0 ];\r\n  \tvar node2 = group2[ 0 ];\r\n\r\n    if ( node1.edges().length !== node2.edges().length ) {\r\n      return false;\r\n    }\r\n\r\n    var getUndirectedEdges = function( node ) {\r\n      var edges = node.connectedEdges().filter( isUndirectedEdge );\r\n      return edges;\r\n    };\r\n    // undirected edges of node1 and node2 respectively\r\n    var undir1 = getUndirectedEdges( node1 );\r\n    var undir2 = getUndirectedEdges( node2 );\r\n\r\n    var in1 = node1.incomers().edges().not( undir1 );\r\n    var in2 = node2.incomers().edges().not( undir2 );\r\n\r\n    var out1 = node1.outgoers().edges().not( undir1 );\r\n\t  var out2 = node2.outgoers().edges().not( undir2 );\r\n\r\n    return compareEdgeGroup( in1, in2, node1, node2 )\r\n            && compareEdgeGroup( out1, out2, node1, node2 )\r\n            && compareEdgeGroup( undir1, undir2, node1, node2 );\r\n  }\r\n\r\n  // decide if 2 edge groups contains set of edges with similar content (type,\r\n  // source,target) relative to their nodes where gr1 are edges of node1 and gr2 are edges of\r\n  // node2\r\n  function compareEdgeGroup( gr1, gr2, node1, node2 ) {\r\n    var id1 = node1.id();\r\n    var id2 = node2.id();\r\n\r\n    var map1 = fillIdToTypeSetMap( gr1, node1 );\r\n    var map2 = fillIdToTypeSetMap( gr2, node2 );\r\n\r\n    if ( Object.keys( map1 ).length !== Object.keys( map2 ).length ) {\r\n      return;\r\n    }\r\n\r\n    var failed = false;\r\n\r\n    Object.keys( map1 ).forEach( function( key ) {\r\n      // if already failed just return\r\n      if ( failed ) {\r\n        return;\r\n      }\r\n\r\n      // if key is id2 use id1 instead because comparison is relative to nodes\r\n      var otherKey = ( key == id2 ) ? id1 : key;\r\n\r\n      // check if the sets have the same content\r\n  \t\t// if check fails return false\r\n      if ( !isEqual( map1[ key ], map2[ otherKey ] ) ) {\r\n        failed = true;\r\n      }\r\n    } );\r\n\r\n    // if check passes for each key return true\r\n    return !failed;\r\n  }\r\n\r\n  function fillIdToTypeSetMap( edgeGroup, node ) {\r\n    var map = {};\r\n    var nodeId = node.id();\r\n\r\n    edgeGroup.forEach( function( edge ) {\r\n      var srcId = edge.data('source');\r\n      var tgtId = edge.data('target');\r\n      var edgeId = edge.id();\r\n\r\n      var otherEnd = ( nodeId === tgtId ) ? srcId : tgtId;\r\n\r\n      function addToRelatedSet( sideStr, value ) {\r\n        if ( !map[ sideStr ] ) {\r\n          map[ sideStr ] = new Set();\r\n        }\r\n\r\n        map[ sideStr ].add( value );\r\n      }\r\n\r\n      var edgeType = getEdgeType( edge );\r\n\r\n      addToRelatedSet( otherEnd, edgeType );\r\n    } );\r\n\r\n    return map;\r\n  }\r\n\r\n  function getEdgeType( edge ) {\r\n    return edge.data( 'class' );\r\n  }\r\n\r\n  function isUndirectedEdge( edge ) {\r\n    return elementUtilities.isUndirectedEdge( edge );\r\n  }\r\n\r\n  // get halves of a list. It is assumed that list size is at least 2.\r\n  function getHalves( list ) {\r\n    var s = list.length;\r\n    var halfIndex = Math.floor( s / 2 );\r\n    var firstHalf = list.slice( 0, halfIndex );\r\n    var secondHalf = list.slice( halfIndex, s );\r\n\r\n    return [ firstHalf, secondHalf ];\r\n  }\r\n\r\n  function removeAt( arr, index ) {\r\n    arr.splice( index, 1 );\r\n  }\r\n\r\n  return topologyGrouping;\r\n};\r\n","// Extends sbgnviz.undoRedoActionFunctions\r\nvar libs = require('./lib-utilities').getLibs();\r\n\r\nmodule.exports = function () {\r\n\r\n  var sbgnvizInstance, undoRedoActionFunctions, elementUtilities, cy, topologyGrouping;\r\n\r\n  function undoRedoActionFunctionsExtender (param) {\r\n\r\n    sbgnvizInstance = param.sbgnvizInstanceUtilities.getInstance();\r\n    cy = param.sbgnvizInstanceUtilities.getCy();\r\n    undoRedoActionFunctions = sbgnvizInstance.undoRedoActionFunctions;\r\n    elementUtilities = param.elementUtilities;\r\n    topologyGrouping = param.sifTopologyGrouping;\r\n\r\n    extend();\r\n  }\r\n\r\n  // Extends undoRedoActionFunctions with chise specific features\r\n  function extend () {\r\n\r\n    undoRedoActionFunctions.applySIFTopologyGrouping = function(param) {\r\n      var oldEles, newEles;\r\n      if ( param.firstTime ) {\r\n        oldEles = cy.elements();\r\n\r\n        if (param.apply) {\r\n          topologyGrouping.apply();\r\n        }\r\n        else {\r\n          topologyGrouping.unapply();\r\n        }\r\n\r\n        newEles = cy.elements();\r\n      }\r\n      else {\r\n        oldEles = param.oldEles;\r\n        newEles = param.newEles;\r\n\r\n        if ( elementUtilities.isGraphTopologyLocked() ) {\r\n          elementUtilities.unlockGraphTopology();\r\n        }\r\n        else {\r\n          elementUtilities.lockGraphTopology();\r\n        }\r\n\r\n        oldEles.remove();\r\n        newEles.restore();\r\n\r\n        topologyGrouping.toggleAppliedFlag();\r\n      }\r\n\r\n      var result = { oldEles: newEles, newEles: oldEles };\r\n      return result;\r\n    };\r\n\r\n    // Section Start\r\n    // add/remove action functions\r\n\r\n    undoRedoActionFunctions.addNode = function (param) {\r\n      var result;\r\n      if (param.firstTime) {\r\n        var newNode = param.newNode;\r\n        result = elementUtilities.addNode(newNode.x, newNode.y, newNode.class, newNode.id, newNode.parent, newNode.visibility);\r\n      }\r\n      else {\r\n        result = elementUtilities.restoreEles(param);\r\n      }\r\n\r\n      return {\r\n        eles: result\r\n      };\r\n    };\r\n\r\n    undoRedoActionFunctions.addEdge = function (param) {\r\n      var result;\r\n      if (param.firstTime) {\r\n        var newEdge = param.newEdge;\r\n        result = elementUtilities.addEdge(newEdge.source, newEdge.target, newEdge.class, newEdge.id, newEdge.visibility);\r\n      }\r\n      else {\r\n        result = elementUtilities.restoreEles(param);\r\n      }\r\n\r\n      return {\r\n        eles: result\r\n      };\r\n    };\r\n\r\n    undoRedoActionFunctions.addProcessWithConvenientEdges = function(param) {\r\n      var result;\r\n      if (param.firstTime) {\r\n        result = elementUtilities.addProcessWithConvenientEdges(param.source, param.target, param.processType);\r\n      }\r\n      else {\r\n        result = elementUtilities.restoreEles(param);\r\n      }\r\n\r\n      return {\r\n        eles: result\r\n      };\r\n    };\r\n\r\n    undoRedoActionFunctions.createCompoundForGivenNodes = function (param) {\r\n      var result = {};\r\n\r\n      if (param.firstTime) {\r\n        // Nodes to make compound, their descendants and edges connected to them will be removed during createCompoundForGivenNodes operation\r\n        // (internally by eles.move() operation), so mark them as removed eles for undo operation.\r\n        var nodesToMakeCompound = param.nodesToMakeCompound;\r\n        var removedEles = nodesToMakeCompound.union(nodesToMakeCompound.descendants());\r\n        removedEles = removedEles.union(removedEles.connectedEdges());\r\n        result.removedEles = removedEles;\r\n        // Assume that all nodes to make compound have the same parent\r\n        var oldParentId = nodesToMakeCompound[0].data(\"parent\");\r\n        // The parent of new compound will be the old parent of the nodes to make compound\r\n        // New eles includes new compound and the moved eles and will be used in undo operation.\r\n        result.newEles = elementUtilities.createCompoundForGivenNodes(nodesToMakeCompound, param.compoundType);\r\n      }\r\n      else {\r\n        result.removedEles = param.newEles.remove();\r\n        result.newEles = param.removedEles.restore();\r\n        elementUtilities.maintainPointer(result.newEles);\r\n      }\r\n\r\n      return result;\r\n    };\r\n\r\n    // Section End\r\n    // add/remove action functions\r\n\r\n    // Section Start\r\n    // easy creation action functions\r\n\r\n    undoRedoActionFunctions.createTemplateReaction = function (param) {\r\n      var firstTime = param.firstTime;\r\n      var eles;\r\n\r\n      if (firstTime) {\r\n        eles = elementUtilities.createTemplateReaction(param.templateType, param.macromoleculeList, param.complexName, param.processPosition, param.tilingPaddingVertical, param.tilingPaddingHorizontal, param.edgeLength, param.layoutParam)\r\n      }\r\n      else {\r\n        eles = param;\r\n        cy.add(eles);\r\n\r\n        cy.elements().unselect();\r\n        eles.select();\r\n      }\r\n\r\n      return {\r\n        eles: eles\r\n      };\r\n    };\r\n\r\n    // Section End\r\n    // easy creation action functions\r\n\r\n    // Section Start\r\n    // general action functions\r\n\r\n    undoRedoActionFunctions.getNodePositions = function () {\r\n      var positions = {};\r\n      var nodes = cy.nodes();\r\n\r\n      nodes.each(function(ele, i) {\r\n        if(typeof ele === \"number\") {\r\n          ele = i;\r\n        }\r\n\r\n        positions[ele.id()] = {\r\n          x: ele.position(\"x\"),\r\n          y: ele.position(\"y\")\r\n        };\r\n      });\r\n\r\n      return positions;\r\n    };\r\n\r\n    undoRedoActionFunctions.returnToPositions = function (positions) {\r\n      var currentPositions = {};\r\n      cy.nodes().positions(function (ele, i) {\r\n        if(typeof ele === \"number\") {\r\n          ele = i;\r\n        }\r\n\r\n        currentPositions[ele.id()] = {\r\n          x: ele.position(\"x\"),\r\n          y: ele.position(\"y\")\r\n        };\r\n\r\n        var pos = positions[ele.id()];\r\n        return {\r\n          x: pos.x,\r\n          y: pos.y\r\n        };\r\n      });\r\n\r\n      return currentPositions;\r\n    };\r\n\r\n    undoRedoActionFunctions.resizeNodes = function (param) {\r\n      var result = {\r\n        performOperation: true\r\n      };\r\n\r\n      var nodes = param.nodes;\r\n\r\n      result.sizeMap = {};\r\n      result.useAspectRatio = false;\r\n      result.preserveRelativePos = param.preserveRelativePos;\r\n\r\n      for (var i = 0; i < nodes.length; i++) {\r\n        var node = nodes[i];\r\n        if(node.isParent()){\r\n          result.sizeMap[node.id()] = {\r\n            w: node.data(\"minWidth\"),\r\n            h: node.data(\"minHeight\"),\r\n            biasL : node.data(\"minWidthBiasLeft\"),\r\n            bisaR : node.data(\"minWidthBiasRight\"),\r\n            biasT : node.data(\"minHeightBiasTop\"),\r\n            biasB : node.data(\"minHeightBiasBottom\")\r\n           // w: node.css(\"minWidth\") != 0?  node.data(\"minWidth\") : node.children().boundingBox().w,\r\n            //h: node.css(\"min-height\") != 0?  node.data(\"minHeight\") : node.children().boundingBox().h\r\n          };\r\n        }else{\r\n          result.sizeMap[node.id()] = {\r\n            w: node.width(),\r\n            h: node.height()\r\n          };\r\n        }\r\n        \r\n      }\r\n\r\n      result.nodes = nodes;\r\n\r\n      for (var i = 0; i < nodes.length; i++) {\r\n        var node = nodes[i];\r\n\r\n        if (param.performOperation) {\r\n          if (param.sizeMap) {\r\n            /* if (param.preserveRelativePos === true) {\r\n              var oldWidth = node.data(\"bbox\").w;\r\n              var oldHeight = node.data(\"bbox\").h;\r\n            } */\r\n\r\n            if(node.isParent()){\r\n              \r\n              node.data(\"minHeight\" , param.sizeMap[node.id()].h);\r\n              node.data(\"minWidth\" , param.sizeMap[node.id()].w);\r\n              node.data(\"minWidthBiasLeft\", param.sizeMap[node.id()].biasL);\r\n              node.data(\"minWidthBiasRight\", param.sizeMap[node.id()].biasR);\r\n              node.data(\"minHeightBiasTop\", param.sizeMap[node.id()].biasT);\r\n              node.data(\"minHeightBiasBottom\", param.sizeMap[node.id()].biasB);\r\n\r\n            }else{\r\n              node.data(\"bbox\").w = param.sizeMap[node.id()].w;\r\n              node.data(\"bbox\").h = param.sizeMap[node.id()].h;\r\n            }\r\n           \r\n\r\n            /* if (param.preserveRelativePos === true) {\r\n              var statesandinfos = node.data('statesandinfos');\r\n              var topBottom = statesandinfos.filter(box => (box.anchorSide === \"top\" || box.anchorSide === \"bottom\"));\r\n              var rightLeft = statesandinfos.filter(box => (box.anchorSide === \"right\" || box.anchorSide === \"left\"));\r\n\r\n              topBottom.forEach(function(box){\r\n                if (box.bbox.x < 0) {\r\n                  box.bbox.x = 0;\r\n                }\r\n                else if (box.bbox.x > oldWidth) {\r\n                  box.bbox.x = oldWidth;\r\n                }\r\n                box.bbox.x = node.data(\"bbox\").w * box.bbox.x / oldWidth;\r\n              });\r\n\r\n              rightLeft.forEach(function(box){\r\n                if (box.bbox.y < 0) {\r\n                  box.bbox.y = 0;\r\n                }\r\n                else if (box.bbox.y > oldHeight) {\r\n                  box.bbox.y = oldHeight;\r\n                }\r\n                box.bbox.y = node.data(\"bbox\").h * box.bbox.y / oldHeight;\r\n              });\r\n            } */\r\n          }\r\n          else {\r\n            elementUtilities.resizeNodes(param.nodes, param.width, param.height, param.useAspectRatio, param.preserveRelativePos);\r\n          }\r\n        }\r\n      }\r\n      cy.style().update();\r\n      return result;\r\n    };\r\n\r\n    undoRedoActionFunctions.changeNodeLabel = function (param) {\r\n      var result = {\r\n      };\r\n      var nodes = param.nodes;\r\n      result.nodes = nodes;\r\n      result.label = {};\r\n\r\n      for (var i = 0; i < nodes.length; i++) {\r\n        var node = nodes[i];\r\n        result.label[node.id()] = node._private.data.label;\r\n      }\r\n\r\n      if (param.firstTime) {\r\n        nodes.data('label', param.label);\r\n      }\r\n      else {\r\n        for (var i = 0; i < nodes.length; i++) {\r\n          var node = nodes[i];\r\n          node._private.data.label = param.label[node.id()];\r\n        }\r\n      }\r\n\r\n      return result;\r\n    };\r\n\r\n    undoRedoActionFunctions.updateInfoboxStyle = function (param) {\r\n      var result = {\r\n      };\r\n      var style = param.node.data('statesandinfos')[param.index].style;\r\n      result.newProps = $.extend( {}, style );\r\n      result.node = param.node;\r\n      result.index = param.index;\r\n\r\n      elementUtilities.updateInfoboxStyle( param.node, param.index, param.newProps );\r\n\r\n      return result;\r\n    };\r\n\r\n    undoRedoActionFunctions.updateInfoboxObj = function (param) {\r\n      var result = {\r\n      };\r\n      var obj = param.node.data('statesandinfos')[param.index];\r\n      result.newProps = $.extend( {}, obj );\r\n      result.node = param.node;\r\n      result.index = param.index;\r\n\r\n      elementUtilities.updateInfoboxObj( param.node, param.index, param.newProps );\r\n\r\n      return result;\r\n    };\r\n\r\n    undoRedoActionFunctions.changeData = function (param) {\r\n      var result = {\r\n      };\r\n      var eles = param.eles;\r\n      result.name = param.name;\r\n      result.valueMap = {};\r\n      result.eles = eles;\r\n\r\n      for (var i = 0; i < eles.length; i++) {\r\n        var ele = eles[i];\r\n        result.valueMap[ele.id()] = ele.data(param.name);\r\n      }\r\n\r\n      elementUtilities.changeData(param.eles, param.name, param.valueMap);\r\n\r\n      return result;\r\n    };\r\n\r\n    undoRedoActionFunctions.updateSetField = function( param ) {\r\n      var updates = elementUtilities.updateSetField( param.ele, param.fieldName, param.toDelete, param.toAdd, param.callback );\r\n\r\n      var result = {\r\n        ele: param.ele,\r\n        fieldName: param.fieldName,\r\n        callback: param.callback,\r\n        toDelete: updates.added,\r\n        toAdd: updates.deleted\r\n      };\r\n\r\n      return result;\r\n    };\r\n\r\n    undoRedoActionFunctions.changeCss = function (param) {\r\n      var result = {\r\n      };\r\n      var eles = param.eles;\r\n      result.name = param.name;\r\n      result.valueMap = {};\r\n      result.eles = eles;\r\n\r\n      for (var i = 0; i < eles.length; i++) {\r\n        var ele = eles[i];\r\n        result.valueMap[ele.id()] = ele.css(param.name);\r\n      }\r\n\r\n      elementUtilities.changeCss(param.eles, param.name, param.valueMap);\r\n\r\n      return result;\r\n    };\r\n\r\n    undoRedoActionFunctions.changeFontProperties = function (param) {\r\n      var result = {\r\n      };\r\n\r\n      var eles = param.eles;\r\n      result.data = {};\r\n      result.eles = eles;\r\n\r\n      for (var i = 0; i < eles.length; i++) {\r\n        var ele = eles[i];\r\n\r\n        result.data[ele.id()] = {};\r\n\r\n        var data = param.firstTime ? param.data : param.data[ele.id()];\r\n\r\n        for (var prop in data) {\r\n          result.data[ele.id()][prop] = ele.data(prop);\r\n        }\r\n      }\r\n\r\n      if (param.firstTime) {\r\n        elementUtilities.changeFontProperties(eles, data);\r\n      }\r\n      else {\r\n        for (var i = 0; i < eles.length; i++) {\r\n          var ele = eles[i];\r\n\r\n          elementUtilities.changeFontProperties(ele, data);\r\n        }\r\n      }\r\n\r\n      return result;\r\n    };\r\n\r\n    /*\r\n     * Show eles and perform layout.\r\n     */\r\n    undoRedoActionFunctions.showAndPerformLayout = function (param) {\r\n      var eles = param.eles;\r\n\r\n      var result = {};\r\n      result.positions = undoRedoActionFunctions.getNodePositions();\r\n\r\n      if (param.firstTime) {\r\n        result.eles = elementUtilities.showAndPerformLayout(param.eles, param.layoutparam);\r\n      }\r\n      else {\r\n        result.eles = cy.viewUtilities().show(eles); // Show given eles\r\n        undoRedoActionFunctions.returnToPositions(param.positions);\r\n      }\r\n\r\n      return result;\r\n    };\r\n\r\n    undoRedoActionFunctions.undoShowAndPerformLayout = function (param) {\r\n      var eles = param.eles;\r\n\r\n      var result = {};\r\n      result.positions = undoRedoActionFunctions.getNodePositions();\r\n      result.eles = cy.viewUtilities().hide(eles); // Hide previously unhidden eles;\r\n\r\n      undoRedoActionFunctions.returnToPositions(param.positions);\r\n\r\n      return result;\r\n    };\r\n\r\n    /*\r\n     * Hide eles and perform layout.\r\n     */\r\n    undoRedoActionFunctions.hideAndPerformLayout = function (param) {\r\n        var eles = param.eles;\r\n\r\n        var result = {};\r\n        result.positions = undoRedoActionFunctions.getNodePositions();\r\n\r\n        if (param.firstTime) {\r\n            result.eles = elementUtilities.hideAndPerformLayout(param.eles, param.layoutparam);\r\n        }\r\n        else {\r\n            result.eles = cy.viewUtilities().hide(eles); // Hide given eles\r\n            undoRedoActionFunctions.returnToPositions(param.positions);\r\n        }\r\n\r\n        return result;\r\n    };\r\n\r\n    undoRedoActionFunctions.undoHideAndPerformLayout = function (param) {\r\n        var eles = param.eles;\r\n\r\n        var result = {};\r\n        result.positions = undoRedoActionFunctions.getNodePositions();\r\n        result.eles = cy.viewUtilities().show(eles); // Show previously hidden eles\r\n\r\n        undoRedoActionFunctions.returnToPositions(param.positions);\r\n\r\n        return result;\r\n    };\r\n\r\n    // Section End\r\n    // general action functions\r\n\r\n    // Section Start\r\n    // sbgn action functions\r\n\r\n    undoRedoActionFunctions.changeStateOrInfoBox = function (param) {\r\n      var result = {\r\n      };\r\n      result.type = param.type;\r\n      result.nodes = param.nodes;\r\n      result.index = param.index;\r\n      var data = param.data;\r\n\r\n      var tempData = elementUtilities.saveUnits(param.nodes);\r\n      result.value = elementUtilities.changeStateOrInfoBox(param.nodes, param.index, param.value, param.type);\r\n      /* var locations = elementUtilities.checkFit(param.nodes);\r\n      if (locations !== undefined && locations.length > 0) {\r\n        elementUtilities.fitUnits(param.nodes, locations);\r\n      } */\r\n      if (data !== undefined) {\r\n        elementUtilities.restoreUnits(param.nodes, data);\r\n      }\r\n\r\n      cy.forceRender();\r\n      result.data = tempData;\r\n      return result;\r\n    };\r\n\r\n    undoRedoActionFunctions.addStateOrInfoBox = function (param) {\r\n      var obj = param.obj;\r\n      var nodes = param.nodes;\r\n      var data = param.data;\r\n\r\n      var tempData = elementUtilities.saveUnits(nodes);\r\n      var locationObj = elementUtilities.addStateOrInfoBox(nodes, obj);\r\n     /*  var locations = elementUtilities.checkFit(nodes);\r\n      if (locations !== undefined && locations.length > 0) {\r\n        elementUtilities.fitUnits(nodes, locations);\r\n      } */\r\n      if (data !== undefined) {\r\n        elementUtilities.restoreUnits(nodes, data);\r\n      }\r\n\r\n      cy.forceRender();\r\n\r\n      var result = {\r\n        nodes: nodes,\r\n        locationObj: locationObj,\r\n        obj: obj,\r\n        data: tempData\r\n      };\r\n      return result;\r\n    };\r\n\r\n    undoRedoActionFunctions.removeStateOrInfoBox = function (param) {\r\n      var locationObj = param.locationObj;\r\n      var nodes = param.nodes;\r\n      var data = param.data;\r\n\r\n      var tempData = elementUtilities.saveUnits(nodes);\r\n      var obj = elementUtilities.removeStateOrInfoBox(nodes, locationObj);\r\n      if (data !== undefined) {\r\n        elementUtilities.restoreUnits(nodes, data);\r\n      }\r\n\r\n      cy.forceRender();\r\n\r\n      var result = {\r\n        nodes: nodes,\r\n        obj: obj,\r\n        data: tempData\r\n      };\r\n      return result;\r\n    };\r\n\r\n    undoRedoActionFunctions.fitUnits = function (param) {\r\n      var node = param.node;\r\n      var locations = param.locations;\r\n      var obj = elementUtilities.fitUnits(node, locations);\r\n\r\n      cy.forceRender();\r\n\r\n      var result = {\r\n        node: node,\r\n        obj: obj,\r\n        locations: locations\r\n      };\r\n      return result;\r\n    };\r\n\r\n    undoRedoActionFunctions.restoreUnits = function (param) {\r\n      var node = param.node;\r\n      var locations = param.locations;\r\n      var obj = param.obj;\r\n      var index = 0;\r\n      node.data('statesandinfos').forEach( function (ele) {\r\n        var box = obj[index++];\r\n        ele.bbox.x = box.x;\r\n        ele.bbox.y = box.y;\r\n        var oldSide = ele.anchorSide;\r\n        ele.anchorSide = box.anchorSide;\r\n        elementUtilities.modifyUnits(node, ele, oldSide);\r\n      });\r\n\r\n      cy.forceRender();\r\n\r\n      var result = {\r\n        node: node,\r\n        locations: locations\r\n      };\r\n      return result;\r\n    };\r\n\r\n    undoRedoActionFunctions.setMultimerStatus = function (param) {\r\n      var firstTime = param.firstTime;\r\n      var nodes = param.nodes;\r\n      var status = param.status;\r\n      var resultStatus = {};\r\n\r\n      for (var i = 0; i < nodes.length; i++) {\r\n        var node = nodes[i];\r\n        var isMultimer = node.data('class').endsWith(' multimer');\r\n\r\n        resultStatus[node.id()] = isMultimer;\r\n      }\r\n\r\n      // If this is the first time change the status of all nodes at once.\r\n      // If not change status of each seperately to the values mapped to their id.\r\n      if (firstTime) {\r\n        elementUtilities.setMultimerStatus(nodes, status);\r\n      }\r\n      else {\r\n        for (var i = 0; i < nodes.length; i++) {\r\n          var node = nodes[i];\r\n          elementUtilities.setMultimerStatus(node, status[node.id()]);\r\n        }\r\n      }\r\n\r\n    //  if (!firstTime && _.isEqual(nodes, cy.nodes(':selected'))) {\r\n    //    $('#inspector-is-multimer').attr(\"checked\", !$('#inspector-is-multimer').attr(\"checked\"));\r\n    //  }\r\n\r\n      var result = {\r\n        status: resultStatus,\r\n        nodes: nodes\r\n      };\r\n\r\n      return result;\r\n    };\r\n\r\n    undoRedoActionFunctions.setCloneMarkerStatus = function (param) {\r\n      var nodes = param.nodes;\r\n      var status = param.status;\r\n      var firstTime = param.firstTime;\r\n      var resultStatus = {};\r\n\r\n      for (var i = 0; i < nodes.length; i++) {\r\n        var node = nodes[i];\r\n        resultStatus[node.id()] = node.data('clonemarker');\r\n        var currentStatus = firstTime ? status : status[node.id()];\r\n        elementUtilities.setCloneMarkerStatus(node, currentStatus);\r\n      }\r\n\r\n    //  if (!firstTime && _.isEqual(nodes, cy.nodes(':selected'))) {\r\n    //    $('#inspector-is-clone-marker').attr(\"checked\", !$('#inspector-is-clone-marker').attr(\"checked\"));\r\n    //  }\r\n\r\n      var result = {\r\n        status: resultStatus,\r\n        nodes: nodes\r\n      };\r\n\r\n      return result;\r\n    };\r\n\r\n    // param: {class: sbgnclass, name: propertyName, value: value}\r\n    undoRedoActionFunctions.setDefaultProperty = function (param) {\r\n      var sbgnclass = param.class;\r\n      var name = param.name;\r\n      var value = param.value;\r\n      var classDefaults = elementUtilities.getDefaultProperties(sbgnclass);\r\n      var result = {\r\n        class: sbgnclass,\r\n        name: name,\r\n        value: classDefaults.hasOwnProperty(name) ? classDefaults[name] : undefined\r\n      };\r\n\r\n      var propMap = {};\r\n      propMap[ name ] = value;\r\n\r\n      elementUtilities.setDefaultProperties( sbgnclass, propMap );\r\n\r\n      return result;\r\n    };\r\n\r\n    undoRedoActionFunctions.addBackgroundImage = function (param) {\r\n      var bgObj = param.bgObj;\r\n      var nodes = param.nodes;\r\n      var updateInfo = param.updateInfo;\r\n      var promptInvalidImage = param.promptInvalidImage;\r\n      var validateURL = param.validateURL;\r\n\r\n      elementUtilities.addBackgroundImage(nodes, bgObj, updateInfo, promptInvalidImage, validateURL);\r\n\r\n      cy.forceRender();\r\n\r\n      var result = {\r\n        nodes: nodes,\r\n        bgObj: bgObj,\r\n        updateInfo: updateInfo,\r\n        promptInvalidImage: promptInvalidImage,\r\n        validateURL: validateURL\r\n      };\r\n      return result;\r\n    };\r\n\r\n    undoRedoActionFunctions.removeBackgroundImage = function (param) {\r\n      var bgObj = param.bgObj;\r\n      var nodes = param.nodes;\r\n\r\n      elementUtilities.removeBackgroundImage(nodes, bgObj);\r\n\r\n      cy.forceRender();\r\n\r\n      var result = {\r\n        nodes: nodes,\r\n        bgObj: bgObj\r\n      };\r\n      return result;\r\n    };\r\n\r\n    undoRedoActionFunctions.updateBackgroundImage = function (param) {\r\n      var bgObj = param.bgObj;\r\n      var nodes = param.nodes;\r\n\r\n      var oldBgObj = elementUtilities.updateBackgroundImage(nodes, bgObj);\r\n\r\n      cy.forceRender();\r\n\r\n      var result = {\r\n        nodes: nodes,\r\n        bgObj: oldBgObj\r\n      };\r\n      return result;\r\n    };\r\n\r\n    undoRedoActionFunctions.changeBackgroundImage = function (param) {\r\n      var oldImg = param.oldImg;\r\n      var newImg = param.newImg;\r\n      var nodes = param.nodes;\r\n      var firstTime = param.firstTime;\r\n      var updateInfo = param.updateInfo;\r\n      var promptInvalidImage = param.promptInvalidImage;\r\n      var validateURL= param.validateURL;\r\n\r\n      var result = elementUtilities.changeBackgroundImage(nodes, oldImg, newImg, firstTime, updateInfo, promptInvalidImage, validateURL);\r\n\r\n      cy.forceRender();\r\n\r\n      return result;\r\n    };\r\n\r\n    // Section End\r\n    // sbgn action functions\r\n    undoRedoActionFunctions.convertIntoReversibleReaction = function (param) {\r\n      let collection = cy.collection();\r\n      let mapType = elementUtilities.getMapType();\r\n      elementUtilities.setMapType(param.mapType);\r\n      $('#map-type').val(param.mapType);\r\n\r\n      param.collection.forEach(function(edge) {\r\n        var sourceNode = edge._private.data.source;\r\n        var targetNode = edge._private.data.target;\r\n\r\n        edge.move({source: targetNode, target: sourceNode});\r\n\r\n        let convertedEdge = cy.getElementById(edge.id());\r\n\r\n        if(convertedEdge.data(\"cyedgebendeditingDistances\")){\r\n          let distance = convertedEdge.data(\"cyedgebendeditingDistances\");\r\n          distance = distance.map(function(element) {\r\n            return -1*element;\r\n          });\r\n          convertedEdge.data(\"cyedgebendeditingDistances\", distance.reverse());\r\n\r\n          let weight = convertedEdge.data(\"cyedgebendeditingWeights\");\r\n          weight = weight.map(function(element) {\r\n            return 1-element;\r\n          });\r\n          convertedEdge.data(\"cyedgebendeditingWeights\", weight.reverse());\r\n        }\r\n\r\n        if (convertedEdge._private.data.class === \"consumption\") {\r\n          convertedEdge._private.data.class = \"production\";\r\n          convertedEdge._private.data.portsource = targetNode + \".1\";\r\n          convertedEdge._private.data.porttarget = sourceNode;\r\n        }\r\n        else if (convertedEdge._private.data.class === \"production\") {\r\n          convertedEdge._private.data.class = \"consumption\";\r\n          convertedEdge._private.data.portsource = targetNode;\r\n          convertedEdge._private.data.porttarget = sourceNode + \".1\";\r\n        }\r\n\r\n        collection = collection.add(convertedEdge);\r\n        cy.style().update();\r\n      });\r\n\r\n      var result = {\r\n        collection: collection,\r\n        mapType: mapType,\r\n        processId: param.processId\r\n      };\r\n      return result;\r\n    }\r\n\r\n    undoRedoActionFunctions.moveEdge = function (param) {\r\n      var result = {\r\n      };\r\n      var edge = param.edge;\r\n      result.name = param.name;      \r\n     \r\n\r\n      result.source = edge.source().id();\r\n      result.target = edge.target().id();      \r\n      result.portsource  =edge.data(\"portsource\");\r\n      result.porttarget = edge.data(\"porttarget\");\r\n      elementUtilities.changeData(edge, 'source', param.source);\r\n      elementUtilities.changeData(edge, 'target', param.target);\r\n      elementUtilities.changeData(edge, 'portsource', param.portsource);\r\n      elementUtilities.changeData(edge, 'porttarget', param.porttarget); \r\n      edge = edge.move({\r\n        target: param.target,\r\n        source : param.source\r\n    \r\n     });\r\n\r\n     result.edge = edge;\r\n      return result;\r\n    };\r\n\r\n    undoRedoActionFunctions.fixError = function(param){\r\n      \r\n      var errorCode = param.errorCode;\r\n      var result = {};\r\n      result.errorCode = errorCode;\r\n      if(errorCode == \"pd10101\" || errorCode == 'pd10102'){\r\n\r\n        result.edge = elementUtilities.reverseEdge(param.edge);\r\n\r\n         return result;\r\n      }else if(errorCode == \"pd10103\" || errorCode == 'pd10107'){\r\n\r\n       \r\n        \r\n        param.newNodes.forEach(function(newNode){\r\n         elementUtilities.addNode(newNode.x, newNode.y, newNode.class, newNode.id, undefined);\r\n\r\n          \r\n        });\r\n\r\n        param.newEdges.forEach(function(newEdge){          \r\n          elementUtilities.addEdge(newEdge.source,newEdge.target,newEdge.class);\r\n        });\r\n\r\n        param.oldEdges.forEach(function(oldEdge){\r\n          cy.elements().unselect();\r\n          //return \r\n          oldEdge.remove();\r\n        });\r\n\r\n        param.node.remove();\r\n\r\n        return param;\r\n\r\n      }else if(errorCode == \"pd10105\" || errorCode == 'pd10106'){\r\n   \r\n        result.edge = elementUtilities.reverseEdge(param.edge);\r\n        return result;\r\n      }else if(errorCode == \"pd10140\"){\r\n        param.node.remove();\r\n        return param;\r\n      }else if(errorCode == \"pd10104\") {\r\n        \r\n        param.edges.forEach(function(edge){\r\n          edge.remove();\r\n        });\r\n        param.nodes.forEach(function(node){\r\n          node.remove();\r\n        });\r\n        return param;\r\n      }else if(errorCode == \"pd10108\"){\r\n        param.edges.forEach(function(edge){\r\n          edge.remove();\r\n        });\r\n        param.nodes.forEach(function(node){\r\n          node.remove();\r\n        });\r\n        return param;\r\n      }else if(errorCode == \"pd10111\"){\r\n        param.edges.forEach(function(edge){\r\n          edge.remove();\r\n        });\r\n        return param;\r\n      }else if(errorCode == \"pd10126\"){\r\n        param.edges.forEach(function(edge){\r\n          edge.remove();\r\n        });\r\n        param.nodes.forEach(function(node){\r\n          node.remove();\r\n        });\r\n        return param;\r\n      }else if(errorCode == \"pd10109\" || errorCode == \"pd10124\") {\r\n        \r\n        result.newSource = param.edge.data().source;\r\n        result.newTarget = param.edge.data().target;\r\n        result.portsource = param.edge.data().portsource;\r\n        var clonedEdge = param.edge.clone();\r\n       \r\n        var edgeParams = {class : clonedEdge.data().class, language :clonedEdge.data().language};\r\n        clonedEdge.data().source = param.newSource;\r\n        clonedEdge.data().target = param.newTarget;\r\n        cy.remove(param.edge);\r\n        result.edge = elementUtilities.addEdge(param.newSource,param.newTarget,edgeParams, clonedEdge.data().id);      \r\n        return result;\r\n\r\n      }else if(errorCode == \"pd10112\") {    \r\n        \r\n        param.callback = elementUtilities.maintainPointer;  \r\n        // If this is first time we should move the node to its new parent and relocate it by given posDiff params\r\n        // else we should remove the moved eles and restore the eles to restore\r\n        if (param.firstTime) {\r\n          var newParentId = param.parentData == undefined ? null : param.parentData;\r\n          // These eles includes the nodes and their connected edges and will be removed in nodes.move().\r\n          // They should be restored in undo\r\n          var withDescendant = param.nodes.union(param.nodes.descendants());\r\n          result.elesToRestore = withDescendant.union(withDescendant.connectedEdges());\r\n          // These are the eles created by nodes.move(), they should be removed in undo.\r\n          result.movedEles = param.nodes.move({\"parent\": newParentId});\r\n\r\n          var posDiff = {\r\n            x: param.posDiffX,\r\n            y: param.posDiffY\r\n          };\r\n\r\n          elementUtilities.moveNodes(posDiff, result.movedEles);\r\n        }\r\n        else {\r\n          result.elesToRestore = param.movedEles.remove();\r\n          result.movedEles = param.elesToRestore.restore();\r\n        }\r\n\r\n        if (param.callback) {\r\n          result.callback = param.callback; // keep the provided callback so it can be reused after undo/redo\r\n          param.callback(result.movedEles); // apply the callback on newly created elements\r\n        }\r\n\r\n        return result;\r\n      \r\n      }else if(errorCode == \"pd10125\") {\r\n\r\n       result.edge = param.edge.remove();       \r\n       result.newEdge ={};\r\n       var edgeclass = param.newEdge.edgeParams.class ? param.newEdge.edgeParams.class : param.newEdge.edgeParams;\r\n       var validation = elementUtilities.validateArrowEnds(edgeclass, cy.getElementById(param.newEdge.source), cy.getElementById(param.newEdge.target));\r\n\r\n       if (validation === 'reverse') {\r\n        var temp = param.newEdge.source;\r\n        param.newEdge.source = param.newEdge.target;\r\n        param.newEdge.target = temp;\r\n      }\r\n       result.newEdge.id =elementUtilities.addEdge(param.newEdge.source,param.newEdge.target,param.newEdge.edgeParams).id();\r\n       result.newEdge.source = param.newEdge.source;\r\n       result.newEdge.target = param.newEdge.target;\r\n       result.newEdge.edgeParams = param.newEdge.edgeParams;\r\n       \r\n       return result;\r\n\r\n        \r\n      }else if(errorCode == \"pd10142\") {\r\n        result.edge = param.edge.remove();       \r\n        result.newEdge ={};\r\n        var edgeclass = param.newEdge.edgeParams.class ? param.newEdge.edgeParams.class : param.newEdge.edgeParams;\r\n        var validation = elementUtilities.validateArrowEnds(edgeclass, cy.getElementById(param.newEdge.source), cy.getElementById(param.newEdge.target));\r\n\r\n        if (validation === 'reverse') {\r\n         var temp = param.newEdge.source;\r\n         param.newEdge.source = param.newEdge.target;\r\n         param.newEdge.target = temp;\r\n       }\r\n        result.newEdge.id =elementUtilities.addEdge(param.newEdge.source,param.newEdge.target,param.newEdge.edgeParams).id();\r\n        result.newEdge.source = param.newEdge.source;\r\n        result.newEdge.target = param.newEdge.target;\r\n        result.newEdge.edgeParams = param.newEdge.edgeParams;\r\n        \r\n        return result;\r\n      }else {\r\n\r\n        result.newSource = param.edge.source().id();\r\n        result.newTarget = param.edge.target().id();\r\n        result.porttarget = param.edge.data(\"porttarget\");\r\n        result.edge = param.edge.move({\r\n          target: param.newTarget,\r\n          source : param.newSource      \r\n        });\r\n\r\n        elementUtilities.changeData(result.edge, 'porttarget', param.porttarget);\r\n        return result;\r\n        \r\n      }\r\n      \r\n  }\r\n  \r\n  undoRedoActionFunctions.unfixError = function(param){\r\n    var errorCode = param.errorCode;\r\n    var result = {};\r\n    result.errorCode = errorCode;\r\n    if(errorCode == \"pd10101\" || errorCode == 'pd10102'){\r\n     \r\n        result.edge = elementUtilities.reverseEdge(param.edge);\r\n      return result;\r\n    }else if(errorCode == \"pd10103\" || errorCode == 'pd10107'){\r\n\r\n      param.newNodes.forEach(function(newNode){    \r\n        cy.remove(cy.$('#'+newNode.id))      \r\n        \r\n      });\r\n\r\n      param.node.restore();\r\n\r\n      param.oldEdges.forEach(function(oldEdge){  \r\n        oldEdge.restore();\r\n      });\r\n\r\n      cy.animate({\r\n        duration: 100,\r\n        easing: 'ease',\r\n        fit :{eles:{},padding:20}, \r\n        complete: function(){\r\n              \r\n        }\r\n      });\r\n\r\n      return param;\r\n\r\n    }else if(errorCode == \"pd10105\" || errorCode == 'pd10106'){  \r\n\r\n      result.edge = elementUtilities.reverseEdge(param.edge);\r\n      return result;\r\n\r\n    }else if(errorCode == \"pd10140\"){\r\n      param.node.restore();\r\n      cy.animate({\r\n        duration: 100,\r\n        easing: 'ease',\r\n        fit :{eles:{},padding:20}, \r\n        complete: function(){\r\n              \r\n        }\r\n      });\r\n      return param;\r\n    }else if(errorCode == \"pd10104\") {\r\n      \r\n      param.nodes.forEach(function(node){\r\n        node.restore();\r\n      });\r\n      param.edges.forEach(function(edge){\r\n        edge.restore();\r\n      });\r\n      return param;\r\n    }else if(errorCode == \"pd10108\"){\r\n      \r\n      param.nodes.forEach(function(node){\r\n        node.restore();\r\n      });\r\n      param.edges.forEach(function(edge){\r\n        edge.restore();\r\n      });\r\n      return param;\r\n    }else if(errorCode == \"pd10111\"){\r\n      param.edges.forEach(function(edge){\r\n        edge.restore();\r\n      });\r\n      return param;\r\n    }else if(errorCode == \"pd10126\"){\r\n      param.nodes.forEach(function(node){\r\n        node.restore();\r\n      });\r\n      param.edges.forEach(function(edge){\r\n        edge.restore();\r\n      });       \r\n      return param;\r\n    }else if(errorCode == \"pd10109\" || errorCode == \"pd10124\") {\r\n\r\n      result.newSource = param.edge.source().id();\r\n      result.newTarget = param.edge.target().id();\r\n      result.portsource = param.portsource;\r\n      result.edge = param.edge.move({\r\n        target: param.newTarget,\r\n        source : param.newSource      \r\n      });\r\n\r\n      elementUtilities.changeData(result.edge, 'portsource', param.portsource); \r\n      return result;\r\n    }else if(errorCode == \"pd10112\") {\r\n     \r\n      // If this is first time we should move the node to its new parent and relocate it by given posDiff params\r\n      // else we should remove the moved eles and restore the eles to restore\r\n      if (param.firstTime) {\r\n        var newParentId = param.parentData == undefined ? null : param.parentData;\r\n        // These eles includes the nodes and their connected edges and will be removed in nodes.move().\r\n        // They should be restored in undo\r\n        var withDescendant = param.nodes.union(param.nodes.descendants());\r\n        result.elesToRestore = withDescendant.union(withDescendant.connectedEdges());\r\n        // These are the eles created by nodes.move(), they should be removed in undo.\r\n        result.movedEles = param.nodes.move({\"parent\": newParentId});\r\n\r\n        var posDiff = {\r\n          x: param.posDiffX,\r\n          y: param.posDiffY\r\n        };\r\n\r\n        elementUtilities.moveNodes(posDiff, result.movedEles);\r\n      }\r\n      else {\r\n        result.elesToRestore = param.movedEles.remove();\r\n        result.movedEles = param.elesToRestore.restore();\r\n      }\r\n\r\n      if (param.callback) {\r\n        result.callback = param.callback; // keep the provided callback so it can be reused after undo/redo\r\n        param.callback(result.movedEles); // apply the callback on newly created elements\r\n      }\r\n\r\n     \r\n      return result;\r\n      \r\n    }else if(errorCode == \"pd10125\") {\r\n\r\n      cy.$('#'+param.newEdge.id).remove();\r\n      param.edge = param.edge.restore();\r\n\r\n    \r\n      return param;\r\n      \r\n    }else if(errorCode == \"pd10142\") {\r\n      cy.$('#'+param.newEdge.id).remove();\r\n      param.edge = param.edge.restore();\r\n\r\n    \r\n      return param;\r\n    }else {\r\n\r\n      result.newSource = param.edge.source().id();\r\n      result.newTarget = param.edge.target().id();\r\n      result.porttarget = param.edge.data(\"porttarget\");\r\n      result.edge = param.edge.move({\r\n        target: param.newTarget,\r\n        source : param.newSource      \r\n      });\r\n\r\n      elementUtilities.changeData(result.edge, 'porttarget', param.porttarget);\r\n      return result;\r\n\r\n      \r\n    }\r\n    \r\n  }\r\n\r\n  undoRedoActionFunctions.cloneHighDegreeNode = function(node){\r\n\r\n    var result = {};\r\n    var oldX = node.position().x;\r\n    var oldY = node.position().y;\r\n    \r\n    \r\n    var claculateNewClonePosition = function(sourceEndPointX,sourceEndPointY,targetEndPointX,targetEndPointY,desiredDistance,direction){\r\n      var distance = Math.sqrt(Math.pow(targetEndPointY-sourceEndPointY,2)+ Math.pow(targetEndPointX-sourceEndPointX,2));\r\n      var ratio = desiredDistance/distance;\r\n      var result = {};\r\n      if(direction == \"source\"){ \r\n        result.cx = ((1-ratio) * sourceEndPointX)  + (ratio * targetEndPointX);\r\n        result.cy = ((1-ratio) * sourceEndPointY)  + (ratio * targetEndPointY);\r\n      }else{      \r\n        result.cx = ((1-ratio) * targetEndPointX)  + (ratio * sourceEndPointX);\r\n        result.cy = ((1-ratio) * targetEndPointY)  + (ratio * sourceEndPointY);\r\n      }\r\n      \r\n      return result;\r\n    };   \r\n    var edges = node.connectedEdges();\r\n    var desiredDistance = (node.height() > node.width()? node.height(): node.width())* 0.1;\r\n    for(var i = 1 ; i < edges.length ; i++){\r\n      var edge = edges[i];\r\n      var index = i;\r\n      var edgeClone = edge.clone();\r\n      var startPosition = edge.source().id() == node.id() ? \"source\" : \"target\";    \r\n      var newPosition = claculateNewClonePosition(edge.sourceEndpoint().x,edge.sourceEndpoint().y,edge.targetEndpoint().x,edge.targetEndpoint().y,desiredDistance,startPosition); \r\n      var newNodeId = node.id()+'clone-'+index;\r\n      //edgeClone.data().id = edgeClone.data().id+ \"-\"+newNodeId;\r\n      if(edge.source().id() == node.id()){        \r\n        edgeClone.data().source = newNodeId;\r\n        edgeClone.data().portsource = newNodeId;    \r\n      }else{\r\n          \r\n        edgeClone.data().target = newNodeId;\r\n        edgeClone.data().porttarget = newNodeId;    \r\n      }\r\n      var newNode = node.clone();\r\n      newNode.data().id = newNodeId;\r\n      cy.add(newNode);\r\n     \r\n      edge.remove();\r\n      cy.add(edgeClone);\r\n      newNode.position({\r\n        x: newPosition.cx,\r\n        y: newPosition.cy\r\n      });\r\n      elementUtilities.setCloneMarkerStatus(newNode, true);\r\n      \r\n    }  \r\n    \r\n    var newPosition = claculateNewClonePosition(\r\n      edges[0].sourceEndpoint().x,\r\n      edges[0].sourceEndpoint().y,\r\n      edges[0].targetEndpoint().x,\r\n      edges[0].targetEndpoint().y,\r\n      desiredDistance,edges[0].source().id() == node.id() ? \"source\" : \"target\"\r\n      );\r\n  \r\n    var cloneEdge = edges[0].clone();\r\n    //cloneEdge.data().id = cloneEdge.data().id+ \"-\"+node.id()+'clone-0';\r\n    \r\n    edges[0].remove();\r\n    cy.add(cloneEdge);\r\n    elementUtilities.setCloneMarkerStatus(node,true);\r\n    node.position({\r\n      x: newPosition.cx,\r\n      y: newPosition.cy\r\n    });\r\n  \r\n    result.oldX = oldX;    \r\n    result.oldY = oldY;\r\n    result.node = node;\r\n    result.numberOfEdges = edges.length;\r\n    return result;\r\n\r\n  }\r\n\r\n  undoRedoActionFunctions.unCloneHighDegreeNode = function(param){\r\n\r\n    var node = param.node;\r\n    elementUtilities.setCloneMarkerStatus(node,false);\r\n    node.position({\r\n      x: param.oldX,\r\n      y: param.oldY\r\n    });\r\n  \r\n    for(var i = 1 ; i < param.numberOfEdges ; i++){\r\n      var cloneId = node.id()+'clone-'+i;\r\n      var clone = cy.$(\"#\"+cloneId);\r\n      var cloneEdge = clone.connectedEdges()[0];\r\n      var edge = cloneEdge.clone();\r\n      \r\n    \r\n      if(edge.data().source == cloneId){        \r\n        edge.data().source = node.id();\r\n        edge.data().portsource =  node.id();    \r\n      }else{          \r\n        edge.data().target =  node.id();\r\n        edge.data().porttarget =  node.id();    \r\n      }\r\n\r\n      cloneEdge.remove();\r\n      clone.remove();\r\n      \r\n      cy.add(edge);\r\n    }\r\n\r\n    return node;\r\n  }\r\n\r\n  undoRedoActionFunctions.changeMapType = function(param){\r\n    var result ={};\r\n    var currentMapType = elementUtilities.getMapType();\r\n    elementUtilities.setMapType(param.mapType);\r\n    result.mapType = currentMapType;\r\n    result.callback = param.callback;\r\n    param.callback();\r\n    return result;\r\n  }\r\n\r\n  }\r\n\r\n  return undoRedoActionFunctionsExtender;\r\n};\r\n"]}