{"version":3,"file":"4.47dfc246.js","mappings":"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","sources":["webpack://@finviz/website/../node_modules/@finviz/spine/index.js","webpack://@finviz/website/../node_modules/@finviz/spine/lib/spine.js","webpack://@finviz/website/../node_modules/date-fns/esm/addBusinessDays/index.js","webpack://@finviz/website/../node_modules/date-fns/esm/isSaturday/index.js","webpack://@finviz/website/../node_modules/date-fns/esm/isSunday/index.js","webpack://@finviz/website/../node_modules/date-fns/esm/addYears/index.js","webpack://@finviz/website/../node_modules/date-fns/esm/eachDayOfInterval/index.js","webpack://@finviz/website/../node_modules/date-fns/esm/isSameDay/index.js","webpack://@finviz/website/../node_modules/date-fns/esm/isSameMonth/index.js","webpack://@finviz/website/../node_modules/date-fns/esm/isSameWeek/index.js","webpack://@finviz/website/../node_modules/date-fns/esm/isWeekend/index.js","webpack://@finviz/website/../node_modules/date-fns/esm/isWithinInterval/index.js","webpack://@finviz/website/../node_modules/date-fns/esm/lastDayOfMonth/index.js","webpack://@finviz/website/../node_modules/date-fns/esm/lastDayOfWeek/index.js","webpack://@finviz/website/../node_modules/date-fns/esm/setMonth/index.js","webpack://@finviz/website/../node_modules/date-fns/esm/getDaysInMonth/index.js","webpack://@finviz/website/../node_modules/date-fns/esm/set/index.js","webpack://@finviz/website/../node_modules/date-fns/esm/startOfMonth/index.js","webpack://@finviz/website/../node_modules/date-fns/esm/startOfWeek/index.js","webpack://@finviz/website/../node_modules/date-fns/esm/startOfYear/index.js","webpack://@finviz/website/../node_modules/date-fns/esm/subYears/index.js","webpack://@finviz/website/../node_modules/decode-uri-component/index.js","webpack://@finviz/website/../node_modules/filter-obj/index.js","webpack://@finviz/website/../node_modules/hammerjs/hammer.js","webpack://@finviz/website/../node_modules/lodash.flowright/index.js","webpack://@finviz/website/../node_modules/lodash.merge/index.js","webpack://@finviz/website/../node_modules/lodash.mergewith/index.js","webpack://@finviz/website/../node_modules/lodash.omit/index.js","webpack://@finviz/website/../node_modules/query-string/index.js","webpack://@finviz/website/../node_modules/re-resizable/lib/resizer.js","webpack://@finviz/website/../node_modules/re-resizable/lib/index.js","webpack://@finviz/website/../node_modules/split-on-first/index.js","webpack://@finviz/website/../node_modules/strict-uri-encode/index.js","webpack://@finviz/website/../node_modules/core-js/internals/delete-property-or-throw.js","webpack://@finviz/website/../node_modules/core-js/modules/es.array.find-last-index.js","webpack://@finviz/website/../node_modules/core-js/modules/es.array.unshift.js","webpack://@finviz/website/../node_modules/bezier-js/src/utils.js","webpack://@finviz/website/../node_modules/bezier-js/src/poly-bezier.js","webpack://@finviz/website/../node_modules/bezier-js/src/bezier.js"],"sourcesContent":["module.exports = require('./lib/spine');","// Generated by CoffeeScript 1.11.1\n\n/*\nSpine.js MVC library\nReleased under the MIT License\n */\n\n(function() {\n  var Collection, Events, Instance, Log, Model, Module, Singleton, Spine, association, createObject, makeArray, moduleKeywords, singularize, underscore,\n    slice = [].slice,\n    indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; },\n    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },\n    hasProp = {}.hasOwnProperty;\n\n  Events = {\n    on: function(ev, callback) {\n      var base, evs, j, len, name;\n      evs = ev.split(' ');\n      if (!this.hasOwnProperty('_callbacks')) {\n        this._callbacks || (this._callbacks = {});\n      }\n      for (j = 0, len = evs.length; j < len; j++) {\n        name = evs[j];\n        (base = this._callbacks)[name] || (base[name] = []);\n        this._callbacks[name].push(callback);\n      }\n      return this;\n    },\n    one: function(ev, callback) {\n      var handler;\n      return this.on(ev, handler = function() {\n        this.off(ev, handler);\n        return callback.apply(this, arguments);\n      });\n    },\n    trigger: function() {\n      var args, callback, ev, j, len, list, ref;\n      args = 1 <= arguments.length ? slice.call(arguments, 0) : [];\n      ev = args.shift();\n      list = (ref = this._callbacks) != null ? ref[ev] : void 0;\n      if (!list) {\n        return;\n      }\n      for (j = 0, len = list.length; j < len; j++) {\n        callback = list[j];\n        if (callback.apply(this, args) === false) {\n          break;\n        }\n      }\n      return true;\n    },\n    listenTo: function(obj, ev, callback) {\n      obj.on(ev, callback);\n      this.listeningTo || (this.listeningTo = []);\n      this.listeningTo.push({\n        obj: obj,\n        ev: ev,\n        callback: callback\n      });\n      return this;\n    },\n    listenToOnce: function(obj, ev, callback) {\n      var handler, listeningToOnce;\n      listeningToOnce = this.listeningToOnce || (this.listeningToOnce = []);\n      obj.on(ev, handler = function() {\n        var i, idx, j, len, lt;\n        idx = -1;\n        for (i = j = 0, len = listeningToOnce.length; j < len; i = ++j) {\n          lt = listeningToOnce[i];\n          if (lt.obj === obj) {\n            if (lt.ev === ev && lt.callback === handler) {\n              idx = i;\n            }\n          }\n        }\n        obj.off(ev, handler);\n        if (idx !== -1) {\n          listeningToOnce.splice(idx, 1);\n        }\n        return callback.apply(this, arguments);\n      });\n      listeningToOnce.push({\n        obj: obj,\n        ev: ev,\n        callback: handler\n      });\n      return this;\n    },\n    stopListening: function(obj, events, callback) {\n      var e, ev, evts, idx, j, k, l, len, len1, len2, len3, listeningTo, lt, m, n, ref, ref1, ref2;\n      if (arguments.length === 0) {\n        ref = [this.listeningTo, this.listeningToOnce];\n        for (j = 0, len = ref.length; j < len; j++) {\n          listeningTo = ref[j];\n          if (!(listeningTo != null ? listeningTo.length : void 0)) {\n            continue;\n          }\n          for (k = 0, len1 = listeningTo.length; k < len1; k++) {\n            lt = listeningTo[k];\n            lt.obj.off(lt.ev, lt.callback);\n          }\n        }\n        this.listeningTo = void 0;\n        this.listeningToOnce = void 0;\n      } else if (obj) {\n        events = events ? events.split(' ') : [void 0];\n        ref1 = [this.listeningTo, this.listeningToOnce];\n        for (l = 0, len2 = ref1.length; l < len2; l++) {\n          listeningTo = ref1[l];\n          if (!listeningTo) {\n            continue;\n          }\n          for (m = 0, len3 = events.length; m < len3; m++) {\n            ev = events[m];\n            for (idx = n = ref2 = listeningTo.length - 1; ref2 <= 0 ? n <= 0 : n >= 0; idx = ref2 <= 0 ? ++n : --n) {\n              lt = listeningTo[idx];\n              if (lt.obj !== obj) {\n                continue;\n              }\n              if (callback && lt.callback !== callback) {\n                continue;\n              }\n              if ((!ev) || (ev === lt.ev)) {\n                lt.obj.off(lt.ev, lt.callback);\n                if (idx !== -1) {\n                  listeningTo.splice(idx, 1);\n                }\n              } else if (ev) {\n                evts = lt.ev.split(' ');\n                if (indexOf.call(evts, ev) >= 0) {\n                  evts = (function() {\n                    var len4, p, results;\n                    results = [];\n                    for (p = 0, len4 = evts.length; p < len4; p++) {\n                      e = evts[p];\n                      if (e !== ev) {\n                        results.push(e);\n                      }\n                    }\n                    return results;\n                  })();\n                  lt.ev = evts.join(' ').trim();\n                  lt.obj.off(ev, lt.callback);\n                }\n              }\n            }\n          }\n        }\n      }\n      return this;\n    },\n    off: function(ev, callback) {\n      var cb, evs, i, j, k, len, len1, list, name, ref;\n      if (arguments.length === 0) {\n        this._callbacks = {};\n        return this;\n      }\n      if (!ev) {\n        return this;\n      }\n      evs = ev.split(' ');\n      for (j = 0, len = evs.length; j < len; j++) {\n        name = evs[j];\n        list = (ref = this._callbacks) != null ? ref[name] : void 0;\n        if (!list) {\n          continue;\n        }\n        if (!callback) {\n          delete this._callbacks[name];\n          continue;\n        }\n        for (i = k = 0, len1 = list.length; k < len1; i = ++k) {\n          cb = list[i];\n          if (!(cb === callback)) {\n            continue;\n          }\n          list = list.slice();\n          list.splice(i, 1);\n          this._callbacks[name] = list;\n          break;\n        }\n      }\n      return this;\n    }\n  };\n\n  Events.bind = Events.on;\n\n  Events.unbind = Events.off;\n\n  Log = {\n    trace: true,\n    logPrefix: '(App)',\n    log: function() {\n      var args;\n      args = 1 <= arguments.length ? slice.call(arguments, 0) : [];\n      if (!this.trace) {\n        return;\n      }\n      if (this.logPrefix) {\n        args.unshift(this.logPrefix);\n      }\n      if (typeof console !== \"undefined\" && console !== null) {\n        if (typeof console.log === \"function\") {\n          console.log.apply(console, args);\n        }\n      }\n      return this;\n    }\n  };\n\n  moduleKeywords = ['included', 'extended'];\n\n  Module = (function() {\n    Module.include = function(obj) {\n      var key, ref, value;\n      if (!obj) {\n        throw new Error('include(obj) requires obj');\n      }\n      for (key in obj) {\n        value = obj[key];\n        if (indexOf.call(moduleKeywords, key) < 0) {\n          this.prototype[key] = value;\n        }\n      }\n      if ((ref = obj.included) != null) {\n        ref.apply(this);\n      }\n      return this;\n    };\n\n    Module.extend = function(obj) {\n      var key, ref, value;\n      if (!obj) {\n        throw new Error('extend(obj) requires obj');\n      }\n      for (key in obj) {\n        value = obj[key];\n        if (indexOf.call(moduleKeywords, key) < 0) {\n          this[key] = value;\n        }\n      }\n      if ((ref = obj.extended) != null) {\n        ref.apply(this);\n      }\n      return this;\n    };\n\n    Module.extend(Events);\n\n    Module.include(Events);\n\n    Module.proxy = function(func) {\n      return (function(_this) {\n        return function() {\n          return func.apply(_this, arguments);\n        };\n      })(this);\n    };\n\n    Module.prototype.proxy = function(func) {\n      return (function(_this) {\n        return function() {\n          return func.apply(_this, arguments);\n        };\n      })(this);\n    };\n\n    function Module() {\n      if (typeof this.init === \"function\") {\n        this.init.apply(this, arguments);\n      }\n    }\n\n    return Module;\n\n  })();\n\n  Model = (function(superClass) {\n    extend(Model, superClass);\n\n    Model.records = [];\n\n    Model.irecords = {};\n\n    Model.attributes = [];\n\n    Model.configure = function() {\n      var attributes, name;\n      name = arguments[0], attributes = 2 <= arguments.length ? slice.call(arguments, 1) : [];\n      this.className = name;\n      this.deleteAll();\n      if (attributes.length) {\n        this.attributes = attributes;\n      }\n      this.attributes && (this.attributes = makeArray(this.attributes));\n      this.attributes || (this.attributes = []);\n      this.off();\n      return this;\n    };\n\n    Model.toString = function() {\n      return this.className + \"(\" + (this.attributes.join(\", \")) + \")\";\n    };\n\n    Model.find = function(id, notFound) {\n      var ref;\n      if (notFound == null) {\n        notFound = this.notFound;\n      }\n      return ((ref = this.irecords[id]) != null ? ref.clone() : void 0) || (notFound != null ? notFound.call(this, id) : void 0);\n    };\n\n    Model.findAll = function(ids, notFound) {\n      var id, j, len, results;\n      results = [];\n      for (j = 0, len = ids.length; j < len; j++) {\n        id = ids[j];\n        if (this.find(id, notFound)) {\n          results.push(this.find(id));\n        }\n      }\n      return results;\n    };\n\n    Model.notFound = function(id) {\n      return null;\n    };\n\n    Model.exists = function(id) {\n      return Boolean(this.irecords[id]);\n    };\n\n    Model.addRecord = function(record, idx) {\n      var root;\n      if (root = this.irecords[record.id || record.cid]) {\n        root.refresh(record);\n      } else {\n        record.id || (record.id = record.cid);\n        this.irecords[record.id] = this.irecords[record.cid] = record;\n        if (idx !== void 0) {\n          this.records.splice(idx, 0, record);\n        } else {\n          this.records.push(record);\n        }\n      }\n      return record;\n    };\n\n    Model.refresh = function(values, options) {\n      var j, len, record, records, result;\n      if (options == null) {\n        options = {};\n      }\n      if (options.clear) {\n        this.deleteAll();\n      }\n      records = this.fromJSON(values);\n      if (!Array.isArray(records)) {\n        records = [records];\n      }\n      for (j = 0, len = records.length; j < len; j++) {\n        record = records[j];\n        this.addRecord(record);\n      }\n      this.sort();\n      result = this.cloneArray(records);\n      this.trigger('refresh', result, options);\n      return result;\n    };\n\n    Model.select = function(callback) {\n      var j, len, record, ref, results;\n      ref = this.records;\n      results = [];\n      for (j = 0, len = ref.length; j < len; j++) {\n        record = ref[j];\n        if (callback(record)) {\n          results.push(record.clone());\n        }\n      }\n      return results;\n    };\n\n    Model.findByAttribute = function(name, value) {\n      var j, len, record, ref;\n      ref = this.records;\n      for (j = 0, len = ref.length; j < len; j++) {\n        record = ref[j];\n        if (record[name] === value) {\n          return record.clone();\n        }\n      }\n      return null;\n    };\n\n    Model.findAllByAttribute = function(name, value) {\n      return this.select(function(item) {\n        return item[name] === value;\n      });\n    };\n\n    Model.each = function(callback) {\n      var j, len, record, ref, results;\n      ref = this.records;\n      results = [];\n      for (j = 0, len = ref.length; j < len; j++) {\n        record = ref[j];\n        results.push(callback(record.clone()));\n      }\n      return results;\n    };\n\n    Model.all = function() {\n      return this.cloneArray(this.records);\n    };\n\n    Model.slice = function(begin, end) {\n      if (begin == null) {\n        begin = 0;\n      }\n      return this.cloneArray(this.records.slice(begin, end));\n    };\n\n    Model.first = function(end) {\n      var ref;\n      if (end == null) {\n        end = 1;\n      }\n      if (end > 1) {\n        return this.cloneArray(this.records.slice(0, end));\n      } else {\n        return (ref = this.records[0]) != null ? ref.clone() : void 0;\n      }\n    };\n\n    Model.last = function(begin) {\n      var ref;\n      if (typeof begin === 'number') {\n        return this.cloneArray(this.records.slice(-begin));\n      } else {\n        return (ref = this.records[this.records.length - 1]) != null ? ref.clone() : void 0;\n      }\n    };\n\n    Model.count = function() {\n      return this.records.length;\n    };\n\n    Model.deleteAll = function() {\n      this.records = [];\n      return this.irecords = {};\n    };\n\n    Model.destroyAll = function(options) {\n      var j, len, record, ref, results;\n      ref = this.records;\n      results = [];\n      for (j = 0, len = ref.length; j < len; j++) {\n        record = ref[j];\n        results.push(record.destroy(options));\n      }\n      return results;\n    };\n\n    Model.update = function(id, atts, options) {\n      return this.find(id).updateAttributes(atts, options);\n    };\n\n    Model.create = function(atts, options) {\n      var record;\n      record = new this(atts);\n      return record.save(options);\n    };\n\n    Model.destroy = function(id, options) {\n      var ref;\n      return (ref = this.find(id)) != null ? ref.destroy(options) : void 0;\n    };\n\n    Model.change = function(callbackOrParams) {\n      if (typeof callbackOrParams === 'function') {\n        return this.on('change', callbackOrParams);\n      } else {\n        return this.trigger.apply(this, ['change'].concat(slice.call(arguments)));\n      }\n    };\n\n    Model.fetch = function(callbackOrParams) {\n      if (typeof callbackOrParams === 'function') {\n        return this.on('fetch', callbackOrParams);\n      } else {\n        return this.trigger.apply(this, ['fetch'].concat(slice.call(arguments)));\n      }\n    };\n\n    Model.toJSON = function() {\n      return this.records;\n    };\n\n    Model.beforeFromJSON = function(objects) {\n      return objects;\n    };\n\n    Model.fromJSON = function(objects) {\n      var j, len, results, value;\n      if (!objects) {\n        return;\n      }\n      if (typeof objects === 'string') {\n        objects = JSON.parse(objects);\n      }\n      objects = this.beforeFromJSON(objects);\n      if (Array.isArray(objects)) {\n        results = [];\n        for (j = 0, len = objects.length; j < len; j++) {\n          value = objects[j];\n          if (value instanceof this) {\n            results.push(value);\n          } else {\n            results.push(new this(value));\n          }\n        }\n        return results;\n      } else {\n        if (objects instanceof this) {\n          return objects;\n        }\n        return new this(objects);\n      }\n    };\n\n    Model.sort = function() {\n      if (this.comparator) {\n        this.records.sort(this.comparator);\n      }\n      return this;\n    };\n\n    Model.cloneArray = function(array) {\n      var j, len, results, value;\n      results = [];\n      for (j = 0, len = array.length; j < len; j++) {\n        value = array[j];\n        results.push(value.clone());\n      }\n      return results;\n    };\n\n    Model.idCounter = 0;\n\n    Model.uid = function(prefix) {\n      var uid;\n      if (prefix == null) {\n        prefix = '';\n      }\n      uid = prefix + this.idCounter++;\n      if (this.exists(uid)) {\n        uid = this.uid(prefix);\n      }\n      return uid;\n    };\n\n    function Model(atts) {\n      Model.__super__.constructor.apply(this, arguments);\n      if ((this.constructor.uuid != null) && typeof this.constructor.uuid === 'function') {\n        this.cid = this.constructor.uuid();\n        if (!this.id) {\n          this.id = this.cid;\n        }\n      } else {\n        this.cid = (atts != null ? atts.cid : void 0) || this.constructor.uid('c-');\n      }\n      if (atts) {\n        this.load(atts);\n      }\n    }\n\n    Model.prototype.isNew = function() {\n      return !this.exists();\n    };\n\n    Model.prototype.isValid = function() {\n      return !this.validate();\n    };\n\n    Model.prototype.validate = function() {};\n\n    Model.prototype.load = function(atts) {\n      var key, value;\n      if (atts.id) {\n        this.id = atts.id;\n      }\n      for (key in atts) {\n        value = atts[key];\n        if (key === '_callbacks') {\n          continue;\n        }\n        if (typeof this[key] === 'function') {\n          if (typeof value === 'function') {\n            continue;\n          }\n          this[key](value);\n        } else {\n          this[key] = value;\n        }\n      }\n      return this;\n    };\n\n    Model.prototype.attributes = function() {\n      var j, key, len, ref, result;\n      result = {};\n      ref = this.constructor.attributes;\n      for (j = 0, len = ref.length; j < len; j++) {\n        key = ref[j];\n        if (key in this) {\n          if (typeof this[key] === 'function') {\n            result[key] = this[key]();\n          } else {\n            result[key] = this[key];\n          }\n        }\n      }\n      if (this.id) {\n        result.id = this.id;\n      }\n      return result;\n    };\n\n    Model.prototype.eql = function(rec) {\n      return rec && rec.constructor === this.constructor && ((rec.cid === this.cid) || (rec.id && rec.id === this.id));\n    };\n\n    Model.prototype.save = function(options) {\n      var error, record;\n      if (options == null) {\n        options = {};\n      }\n      if (options.validate !== false) {\n        error = this.validate();\n        if (error) {\n          this.trigger('error', this, error);\n          return false;\n        }\n      }\n      this.trigger('beforeSave', this, options);\n      record = this.isNew() ? this.create(options) : this.update(options);\n      this.stripCloneAttrs();\n      this.trigger('save', record, options);\n      return record;\n    };\n\n    Model.prototype.stripCloneAttrs = function() {\n      var key, ref, value;\n      if (this.hasOwnProperty('cid')) {\n        return;\n      }\n      ref = this;\n      for (key in ref) {\n        if (!hasProp.call(ref, key)) continue;\n        value = ref[key];\n        if (indexOf.call(this.constructor.attributes, key) >= 0) {\n          delete this[key];\n        }\n      }\n      return this;\n    };\n\n    Model.prototype.updateAttribute = function(name, value, options) {\n      var atts;\n      atts = {};\n      atts[name] = value;\n      return this.updateAttributes(atts, options);\n    };\n\n    Model.prototype.updateAttributes = function(atts, options) {\n      this.load(atts);\n      return this.save(options);\n    };\n\n    Model.prototype.changeID = function(id) {\n      var records;\n      if (id === this.id) {\n        return;\n      }\n      records = this.constructor.irecords;\n      records[id] = records[this.id];\n      if (this.cid !== this.id) {\n        delete records[this.id];\n      }\n      return this.id = id;\n    };\n\n    Model.prototype.remove = function(options) {\n      var i, j, len, record, records;\n      if (options == null) {\n        options = {};\n      }\n      records = this.constructor.records.slice(0);\n      for (i = j = 0, len = records.length; j < len; i = ++j) {\n        record = records[i];\n        if (!(this.eql(record))) {\n          continue;\n        }\n        records.splice(i, 1);\n        break;\n      }\n      this.constructor.records = records;\n      if (options.clear) {\n        delete this.constructor.irecords[this.id];\n        return delete this.constructor.irecords[this.cid];\n      }\n    };\n\n    Model.prototype.destroy = function(options) {\n      if (options == null) {\n        options = {};\n      }\n      if (options.clear == null) {\n        options.clear = true;\n      }\n      this.trigger('beforeDestroy', this, options);\n      this.remove(options);\n      this.destroyed = true;\n      this.trigger('destroy', this, options);\n      this.trigger('change', this, 'destroy', options);\n      if (this.listeningTo) {\n        this.stopListening();\n      }\n      this.off();\n      return this;\n    };\n\n    Model.prototype.dup = function(newRecord) {\n      var atts, record;\n      if (newRecord == null) {\n        newRecord = true;\n      }\n      atts = this.attributes();\n      if (newRecord) {\n        delete atts.id;\n      } else {\n        atts.cid = this.cid;\n      }\n      record = new this.constructor(atts);\n      if (!newRecord) {\n        this._callbacks && (record._callbacks = this._callbacks);\n      }\n      return record;\n    };\n\n    Model.prototype.clone = function() {\n      return createObject(this);\n    };\n\n    Model.prototype.reload = function() {\n      var original;\n      if (this.isNew()) {\n        return this;\n      }\n      original = this.constructor.find(this.id);\n      this.load(original.attributes());\n      return original;\n    };\n\n    Model.prototype.refresh = function(atts) {\n      atts = this.constructor.fromJSON(atts);\n      if (atts.id && this.id !== atts.id) {\n        this.changeID(atts.id);\n      }\n      this.constructor.irecords[this.id].load(atts);\n      this.trigger('refresh', this);\n      this.trigger('change', this, 'refresh');\n      return this;\n    };\n\n    Model.prototype.toJSON = function() {\n      return this.attributes();\n    };\n\n    Model.prototype.toString = function() {\n      return \"<\" + this.constructor.className + \" (\" + (JSON.stringify(this)) + \")>\";\n    };\n\n    Model.prototype.exists = function() {\n      return this.constructor.exists(this.id);\n    };\n\n    Model.prototype.update = function(options) {\n      var clone, records;\n      this.trigger('beforeUpdate', this, options);\n      records = this.constructor.irecords;\n      records[this.id].load(this.attributes());\n      this.constructor.sort();\n      clone = records[this.id].clone();\n      clone.trigger('update', clone, options);\n      clone.trigger('change', clone, 'update', options);\n      return clone;\n    };\n\n    Model.prototype.create = function(options) {\n      var clone, record;\n      this.trigger('beforeCreate', this, options);\n      this.id || (this.id = this.cid);\n      record = this.dup(false);\n      this.constructor.addRecord(record, options.idx);\n      this.constructor.sort();\n      clone = record.clone();\n      clone.trigger('create', clone, options);\n      clone.trigger('change', clone, 'create', options);\n      return clone;\n    };\n\n    Model.prototype.on = function() {\n      var record;\n      record = this.constructor.irecords[this.id] || this;\n      return Events.on.apply(record, arguments);\n    };\n\n    Model.prototype.one = function() {\n      var record;\n      record = this.constructor.irecords[this.id] || this;\n      return Events.one.apply(record, arguments);\n    };\n\n    Model.prototype.off = function() {\n      var record;\n      record = this.constructor.irecords[this.id] || this;\n      return Events.off.apply(record, arguments);\n    };\n\n    Model.prototype.trigger = function() {\n      var ref;\n      Events.trigger.apply(this, arguments);\n      if (arguments[0] === 'refresh') {\n        return true;\n      }\n      return (ref = this.constructor).trigger.apply(ref, arguments);\n    };\n\n    return Model;\n\n  })(Module);\n\n  Model.prototype.bind = Model.prototype.on;\n\n  Model.prototype.unbind = Model.prototype.off;\n\n  createObject = Object.create || function(o) {\n    var Func;\n    Func = function() {};\n    Func.prototype = o;\n    return new Func();\n  };\n\n  makeArray = function(args) {\n    return Array.prototype.slice.call(args, 0);\n  };\n\n  Spine = this.Spine = {};\n\n  if (typeof module !== \"undefined\" && module !== null) {\n    module.exports = Spine;\n  }\n\n  Spine.version = '2.1.0';\n\n  Spine.Events = Events;\n\n  Spine.Log = Log;\n\n  Spine.Module = Module;\n\n  Spine.Model = Model;\n\n  Module.extend.call(Spine, Events);\n\n  Module.create = Module.sub = Model.sub = function(instances, statics) {\n    var Result;\n    Result = (function(superClass) {\n      extend(Result, superClass);\n\n      function Result() {\n        return Result.__super__.constructor.apply(this, arguments);\n      }\n\n      return Result;\n\n    })(this);\n    if (instances) {\n      Result.include(instances);\n    }\n    if (statics) {\n      Result.extend(statics);\n    }\n    if (typeof Result.off === \"function\") {\n      Result.off();\n    }\n    return Result;\n  };\n\n  Model.setup = function(name, attributes) {\n    var Instance;\n    if (attributes == null) {\n      attributes = [];\n    }\n    Instance = (function(superClass) {\n      extend(Instance, superClass);\n\n      function Instance() {\n        return Instance.__super__.constructor.apply(this, arguments);\n      }\n\n      return Instance;\n\n    })(this);\n    Instance.configure.apply(Instance, [name].concat(slice.call(attributes)));\n    return Instance;\n  };\n\n  Spine.Class = Module;\n\n  Collection = (function(superClass) {\n    extend(Collection, superClass);\n\n    function Collection(options) {\n      var key, value;\n      if (options == null) {\n        options = {};\n      }\n      for (key in options) {\n        value = options[key];\n        this[key] = value;\n      }\n    }\n\n    Collection.prototype.all = function() {\n      return this.model.select((function(_this) {\n        return function(rec) {\n          return _this.associated(rec);\n        };\n      })(this));\n    };\n\n    Collection.prototype.first = function() {\n      return this.all()[0];\n    };\n\n    Collection.prototype.last = function() {\n      var values;\n      values = this.all();\n      return values[values.length - 1];\n    };\n\n    Collection.prototype.count = function() {\n      return this.all().length;\n    };\n\n    Collection.prototype.find = function(id, notFound) {\n      var records;\n      if (notFound == null) {\n        notFound = this.model.notFound;\n      }\n      records = this.select((function(_this) {\n        return function(rec) {\n          return (\"\" + rec.id) === (\"\" + id);\n        };\n      })(this));\n      return records[0] || (typeof notFound === \"function\" ? notFound(id) : void 0);\n    };\n\n    Collection.prototype.findAllByAttribute = function(name, value) {\n      return this.model.select((function(_this) {\n        return function(rec) {\n          return _this.associated(rec) && rec[name] === value;\n        };\n      })(this));\n    };\n\n    Collection.prototype.findByAttribute = function(name, value) {\n      return this.findAllByAttribute(name, value)[0];\n    };\n\n    Collection.prototype.select = function(cb) {\n      return this.model.select((function(_this) {\n        return function(rec) {\n          return _this.associated(rec) && cb(rec);\n        };\n      })(this));\n    };\n\n    Collection.prototype.refresh = function(values) {\n      var i, j, k, l, len, len1, len2, match, record, ref, ref1;\n      if (values == null) {\n        return this;\n      }\n      ref = this.all();\n      for (j = 0, len = ref.length; j < len; j++) {\n        record = ref[j];\n        delete this.model.irecords[record.id];\n        ref1 = this.model.records;\n        for (i = k = 0, len1 = ref1.length; k < len1; i = ++k) {\n          match = ref1[i];\n          if (!(match.id === record.id)) {\n            continue;\n          }\n          this.model.records.splice(i, 1);\n          break;\n        }\n      }\n      if (!Array.isArray(values)) {\n        values = [values];\n      }\n      for (l = 0, len2 = values.length; l < len2; l++) {\n        record = values[l];\n        record.newRecord = false;\n        record[this.fkey] = this.record.id;\n      }\n      this.model.refresh(values);\n      return this;\n    };\n\n    Collection.prototype.create = function(record, options) {\n      record[this.fkey] = this.record.id;\n      return this.model.create(record, options);\n    };\n\n    Collection.prototype.add = function(record, options) {\n      return record.updateAttribute(this.fkey, this.record.id, options);\n    };\n\n    Collection.prototype.remove = function(record, options) {\n      return record.updateAttribute(this.fkey, null, options);\n    };\n\n    Collection.prototype.associated = function(record) {\n      return record[this.fkey] === this.record.id;\n    };\n\n    return Collection;\n\n  })(Spine.Module);\n\n  Instance = (function(superClass) {\n    extend(Instance, superClass);\n\n    function Instance(options) {\n      var key, value;\n      if (options == null) {\n        options = {};\n      }\n      for (key in options) {\n        value = options[key];\n        this[key] = value;\n      }\n    }\n\n    Instance.prototype.find = function() {\n      return this.model.find(this.record[this.fkey]);\n    };\n\n    Instance.prototype.update = function(value) {\n      if (value == null) {\n        return this;\n      }\n      value = this.model.refresh(value)[0];\n      this.record[this.fkey] = value && value.id;\n      return this;\n    };\n\n    return Instance;\n\n  })(Spine.Module);\n\n  Singleton = (function(superClass) {\n    extend(Singleton, superClass);\n\n    function Singleton(options) {\n      var key, value;\n      if (options == null) {\n        options = {};\n      }\n      for (key in options) {\n        value = options[key];\n        this[key] = value;\n      }\n    }\n\n    Singleton.prototype.find = function() {\n      return this.record.id && this.model.findByAttribute(this.fkey, this.record.id);\n    };\n\n    Singleton.prototype.update = function(value) {\n      if (value == null) {\n        return this;\n      }\n      value[this.fkey] = this.record.id;\n      this.model.refresh(value);\n      return this;\n    };\n\n    return Singleton;\n\n  })(Spine.Module);\n\n  singularize = function(str) {\n    return str.replace(/s$/, '');\n  };\n\n  underscore = function(str) {\n    return str.replace(/::/g, '/').replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2').replace(/([a-z\\d])([A-Z])/g, '$1_$2').replace(/(-|\\.)/g, '_').toLowerCase();\n  };\n\n  association = function(name, model, record, fkey, Ctor) {\n    return new Ctor({\n      name: name,\n      model: model,\n      record: record,\n      fkey: fkey\n    });\n  };\n\n  Spine.Model.extend({\n    hasMany: function(name, model, fkey) {\n      if (fkey == null) {\n        fkey = (underscore(this.className)) + \"_id\";\n      }\n      return this.prototype[name] = function(value) {\n        return association(name, model, this, fkey, Collection).refresh(value);\n      };\n    },\n    belongsTo: function(name, model, fkey) {\n      if (fkey == null) {\n        fkey = (underscore(singularize(name))) + \"_id\";\n      }\n      this.prototype[name] = function(value) {\n        return association(name, model, this, fkey, Instance).update(value).find();\n      };\n      return this.attributes.push(fkey);\n    },\n    hasOne: function(name, model, fkey) {\n      if (fkey == null) {\n        fkey = (underscore(this.className)) + \"_id\";\n      }\n      return this.prototype[name] = function(value) {\n        return association(name, model, this, fkey, Singleton).update(value).find();\n      };\n    }\n  });\n\n  Spine.Collection = Collection;\n\n  Spine.Singleton = Singleton;\n\n  Spine.Instance = Instance;\n\n}).call(this);\n\n//# sourceMappingURL=spine.js.map\n","import isWeekend from \"../isWeekend/index.js\";\nimport toDate from \"../toDate/index.js\";\nimport toInteger from \"../_lib/toInteger/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\nimport isSunday from \"../isSunday/index.js\";\nimport isSaturday from \"../isSaturday/index.js\";\n/**\n * @name addBusinessDays\n * @category Day Helpers\n * @summary Add the specified number of business days (mon - fri) to the given date.\n *\n * @description\n * Add the specified number of business days (mon - fri) to the given date, ignoring weekends.\n *\n * @param {Date|Number} date - the date to be changed\n * @param {Number} amount - the amount of business days to be added. Positive decimals will be rounded using `Math.floor`, decimals less than zero will be rounded using `Math.ceil`.\n * @returns {Date} the new date with the business days added\n * @throws {TypeError} 2 arguments required\n *\n * @example\n * // Add 10 business days to 1 September 2014:\n * const result = addBusinessDays(new Date(2014, 8, 1), 10)\n * //=> Mon Sep 15 2014 00:00:00 (skipped weekend days)\n */\nexport default function addBusinessDays(dirtyDate, dirtyAmount) {\n  requiredArgs(2, arguments);\n  var date = toDate(dirtyDate);\n  var startedOnWeekend = isWeekend(date);\n  var amount = toInteger(dirtyAmount);\n  if (isNaN(amount)) return new Date(NaN);\n  var hours = date.getHours();\n  var sign = amount < 0 ? -1 : 1;\n  var fullWeeks = toInteger(amount / 5);\n  date.setDate(date.getDate() + fullWeeks * 7);\n\n  // Get remaining days not part of a full week\n  var restDays = Math.abs(amount % 5);\n\n  // Loops over remaining days\n  while (restDays > 0) {\n    date.setDate(date.getDate() + sign);\n    if (!isWeekend(date)) restDays -= 1;\n  }\n\n  // If the date is a weekend day and we reduce a dividable of\n  // 5 from it, we land on a weekend date.\n  // To counter this, we add days accordingly to land on the next business day\n  if (startedOnWeekend && isWeekend(date) && amount !== 0) {\n    // If we're reducing days, we want to add days until we land on a weekday\n    // If we're adding days we want to reduce days until we land on a weekday\n    if (isSaturday(date)) date.setDate(date.getDate() + (sign < 0 ? 2 : -1));\n    if (isSunday(date)) date.setDate(date.getDate() + (sign < 0 ? 1 : -2));\n  }\n\n  // Restore hours to avoid DST lag\n  date.setHours(hours);\n  return date;\n}","import toDate from \"../toDate/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n/**\n * @name isSaturday\n * @category Weekday Helpers\n * @summary Is the given date Saturday?\n *\n * @description\n * Is the given date Saturday?\n *\n * @param {Date|Number} date - the date to check\n * @returns {Boolean} the date is Saturday\n * @throws {TypeError} 1 argument required\n *\n * @example\n * // Is 27 September 2014 Saturday?\n * const result = isSaturday(new Date(2014, 8, 27))\n * //=> true\n */\nexport default function isSaturday(dirtyDate) {\n  requiredArgs(1, arguments);\n  return toDate(dirtyDate).getDay() === 6;\n}","import toDate from \"../toDate/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n/**\n * @name isSunday\n * @category Weekday Helpers\n * @summary Is the given date Sunday?\n *\n * @description\n * Is the given date Sunday?\n *\n * @param {Date|Number} date - the date to check\n * @returns {Boolean} the date is Sunday\n * @throws {TypeError} 1 argument required\n *\n * @example\n * // Is 21 September 2014 Sunday?\n * const result = isSunday(new Date(2014, 8, 21))\n * //=> true\n */\nexport default function isSunday(dirtyDate) {\n  requiredArgs(1, arguments);\n  return toDate(dirtyDate).getDay() === 0;\n}","import toInteger from \"../_lib/toInteger/index.js\";\nimport addMonths from \"../addMonths/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n/**\n * @name addYears\n * @category Year Helpers\n * @summary Add the specified number of years to the given date.\n *\n * @description\n * Add the specified number of years to the given date.\n *\n * @param {Date|Number} date - the date to be changed\n * @param {Number} amount - the amount of years to be added. Positive decimals will be rounded using `Math.floor`, decimals less than zero will be rounded using `Math.ceil`.\n * @returns {Date} the new date with the years added\n * @throws {TypeError} 2 arguments required\n *\n * @example\n * // Add 5 years to 1 September 2014:\n * const result = addYears(new Date(2014, 8, 1), 5)\n * //=> Sun Sep 01 2019 00:00:00\n */\nexport default function addYears(dirtyDate, dirtyAmount) {\n  requiredArgs(2, arguments);\n  var amount = toInteger(dirtyAmount);\n  return addMonths(dirtyDate, amount * 12);\n}","import toDate from \"../toDate/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n/**\n * @name eachDayOfInterval\n * @category Interval Helpers\n * @summary Return the array of dates within the specified time interval.\n *\n * @description\n * Return the array of dates within the specified time interval.\n *\n * @param {Interval} interval - the interval. See [Interval]{@link https://date-fns.org/docs/Interval}\n * @param {Object} [options] - an object with options.\n * @param {Number} [options.step=1] - the step to increment by. The value should be more than 1.\n * @returns {Date[]} the array with starts of days from the day of the interval start to the day of the interval end\n * @throws {TypeError} 1 argument required\n * @throws {RangeError} `options.step` must be a number greater than 1\n * @throws {RangeError} The start of an interval cannot be after its end\n * @throws {RangeError} Date in interval cannot be `Invalid Date`\n *\n * @example\n * // Each day between 6 October 2014 and 10 October 2014:\n * const result = eachDayOfInterval({\n *   start: new Date(2014, 9, 6),\n *   end: new Date(2014, 9, 10)\n * })\n * //=> [\n * //   Mon Oct 06 2014 00:00:00,\n * //   Tue Oct 07 2014 00:00:00,\n * //   Wed Oct 08 2014 00:00:00,\n * //   Thu Oct 09 2014 00:00:00,\n * //   Fri Oct 10 2014 00:00:00\n * // ]\n */\nexport default function eachDayOfInterval(dirtyInterval, options) {\n  var _options$step;\n  requiredArgs(1, arguments);\n  var interval = dirtyInterval || {};\n  var startDate = toDate(interval.start);\n  var endDate = toDate(interval.end);\n  var endTime = endDate.getTime();\n\n  // Throw an exception if start date is after end date or if any date is `Invalid Date`\n  if (!(startDate.getTime() <= endTime)) {\n    throw new RangeError('Invalid interval');\n  }\n  var dates = [];\n  var currentDate = startDate;\n  currentDate.setHours(0, 0, 0, 0);\n  var step = Number((_options$step = options === null || options === void 0 ? void 0 : options.step) !== null && _options$step !== void 0 ? _options$step : 1);\n  if (step < 1 || isNaN(step)) throw new RangeError('`options.step` must be a number greater than 1');\n  while (currentDate.getTime() <= endTime) {\n    dates.push(toDate(currentDate));\n    currentDate.setDate(currentDate.getDate() + step);\n    currentDate.setHours(0, 0, 0, 0);\n  }\n  return dates;\n}","import startOfDay from \"../startOfDay/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n/**\n * @name isSameDay\n * @category Day Helpers\n * @summary Are the given dates in the same day (and year and month)?\n *\n * @description\n * Are the given dates in the same day (and year and month)?\n *\n * @param {Date|Number} dateLeft - the first date to check\n * @param {Date|Number} dateRight - the second date to check\n * @returns {Boolean} the dates are in the same day (and year and month)\n * @throws {TypeError} 2 arguments required\n *\n * @example\n * // Are 4 September 06:00:00 and 4 September 18:00:00 in the same day?\n * const result = isSameDay(new Date(2014, 8, 4, 6, 0), new Date(2014, 8, 4, 18, 0))\n * //=> true\n *\n * @example\n * // Are 4 September and 4 October in the same day?\n * const result = isSameDay(new Date(2014, 8, 4), new Date(2014, 9, 4))\n * //=> false\n *\n * @example\n * // Are 4 September, 2014 and 4 September, 2015 in the same day?\n * const result = isSameDay(new Date(2014, 8, 4), new Date(2015, 8, 4))\n * //=> false\n */\nexport default function isSameDay(dirtyDateLeft, dirtyDateRight) {\n  requiredArgs(2, arguments);\n  var dateLeftStartOfDay = startOfDay(dirtyDateLeft);\n  var dateRightStartOfDay = startOfDay(dirtyDateRight);\n  return dateLeftStartOfDay.getTime() === dateRightStartOfDay.getTime();\n}","import toDate from \"../toDate/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n/**\n * @name isSameMonth\n * @category Month Helpers\n * @summary Are the given dates in the same month (and year)?\n *\n * @description\n * Are the given dates in the same month (and year)?\n *\n * @param {Date|Number} dateLeft - the first date to check\n * @param {Date|Number} dateRight - the second date to check\n * @returns {Boolean} the dates are in the same month (and year)\n * @throws {TypeError} 2 arguments required\n *\n * @example\n * // Are 2 September 2014 and 25 September 2014 in the same month?\n * const result = isSameMonth(new Date(2014, 8, 2), new Date(2014, 8, 25))\n * //=> true\n *\n * @example\n * // Are 2 September 2014 and 25 September 2015 in the same month?\n * const result = isSameMonth(new Date(2014, 8, 2), new Date(2015, 8, 25))\n * //=> false\n */\nexport default function isSameMonth(dirtyDateLeft, dirtyDateRight) {\n  requiredArgs(2, arguments);\n  var dateLeft = toDate(dirtyDateLeft);\n  var dateRight = toDate(dirtyDateRight);\n  return dateLeft.getFullYear() === dateRight.getFullYear() && dateLeft.getMonth() === dateRight.getMonth();\n}","import startOfWeek from \"../startOfWeek/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n/**\n * @name isSameWeek\n * @category Week Helpers\n * @summary Are the given dates in the same week (and month and year)?\n *\n * @description\n * Are the given dates in the same week (and month and year)?\n *\n * @param {Date|Number} dateLeft - the first date to check\n * @param {Date|Number} dateRight - the second date to check\n * @param {Object} [options] - an object with options.\n * @param {Locale} [options.locale=defaultLocale] - the locale object. See [Locale]{@link https://date-fns.org/docs/Locale}\n * @param {0|1|2|3|4|5|6} [options.weekStartsOn=0] - the index of the first day of the week (0 - Sunday)\n * @returns {Boolean} the dates are in the same week (and month and year)\n * @throws {TypeError} 2 arguments required\n * @throws {RangeError} `options.weekStartsOn` must be between 0 and 6\n *\n * @example\n * // Are 31 August 2014 and 4 September 2014 in the same week?\n * const result = isSameWeek(new Date(2014, 7, 31), new Date(2014, 8, 4))\n * //=> true\n *\n * @example\n * // If week starts with Monday,\n * // are 31 August 2014 and 4 September 2014 in the same week?\n * const result = isSameWeek(new Date(2014, 7, 31), new Date(2014, 8, 4), {\n *   weekStartsOn: 1\n * })\n * //=> false\n *\n * @example\n * // Are 1 January 2014 and 1 January 2015 in the same week?\n * const result = isSameWeek(new Date(2014, 0, 1), new Date(2015, 0, 1))\n * //=> false\n */\nexport default function isSameWeek(dirtyDateLeft, dirtyDateRight, options) {\n  requiredArgs(2, arguments);\n  var dateLeftStartOfWeek = startOfWeek(dirtyDateLeft, options);\n  var dateRightStartOfWeek = startOfWeek(dirtyDateRight, options);\n  return dateLeftStartOfWeek.getTime() === dateRightStartOfWeek.getTime();\n}","import toDate from \"../toDate/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n/**\n * @name isWeekend\n * @category Weekday Helpers\n * @summary Does the given date fall on a weekend?\n *\n * @description\n * Does the given date fall on a weekend?\n *\n * @param {Date|Number} date - the date to check\n * @returns {Boolean} the date falls on a weekend\n * @throws {TypeError} 1 argument required\n *\n * @example\n * // Does 5 October 2014 fall on a weekend?\n * const result = isWeekend(new Date(2014, 9, 5))\n * //=> true\n */\nexport default function isWeekend(dirtyDate) {\n  requiredArgs(1, arguments);\n  var date = toDate(dirtyDate);\n  var day = date.getDay();\n  return day === 0 || day === 6;\n}","import toDate from \"../toDate/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n/**\n * @name isWithinInterval\n * @category Interval Helpers\n * @summary Is the given date within the interval?\n *\n * @description\n * Is the given date within the interval? (Including start and end.)\n *\n * @param {Date|Number} date - the date to check\n * @param {Interval} interval - the interval to check\n * @returns {Boolean} the date is within the interval\n * @throws {TypeError} 2 arguments required\n * @throws {RangeError} The start of an interval cannot be after its end\n * @throws {RangeError} Date in interval cannot be `Invalid Date`\n *\n * @example\n * // For the date within the interval:\n * isWithinInterval(new Date(2014, 0, 3), {\n *   start: new Date(2014, 0, 1),\n *   end: new Date(2014, 0, 7)\n * })\n * //=> true\n *\n * @example\n * // For the date outside of the interval:\n * isWithinInterval(new Date(2014, 0, 10), {\n *   start: new Date(2014, 0, 1),\n *   end: new Date(2014, 0, 7)\n * })\n * //=> false\n *\n * @example\n * // For date equal to interval start:\n * isWithinInterval(date, { start, end: date }) // => true\n *\n * @example\n * // For date equal to interval end:\n * isWithinInterval(date, { start: date, end }) // => true\n */\nexport default function isWithinInterval(dirtyDate, interval) {\n  requiredArgs(2, arguments);\n  var time = toDate(dirtyDate).getTime();\n  var startTime = toDate(interval.start).getTime();\n  var endTime = toDate(interval.end).getTime();\n\n  // Throw an exception if start date is after end date or if any date is `Invalid Date`\n  if (!(startTime <= endTime)) {\n    throw new RangeError('Invalid interval');\n  }\n  return time >= startTime && time <= endTime;\n}","import toDate from \"../toDate/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n/**\n * @name lastDayOfMonth\n * @category Month Helpers\n * @summary Return the last day of a month for the given date.\n *\n * @description\n * Return the last day of a month for the given date.\n * The result will be in the local timezone.\n *\n * @param {Date|Number} date - the original date\n * @returns {Date} the last day of a month\n * @throws {TypeError} 1 argument required\n *\n * @example\n * // The last day of a month for 2 September 2014 11:55:00:\n * const result = lastDayOfMonth(new Date(2014, 8, 2, 11, 55, 0))\n * //=> Tue Sep 30 2014 00:00:00\n */\nexport default function lastDayOfMonth(dirtyDate) {\n  requiredArgs(1, arguments);\n  var date = toDate(dirtyDate);\n  var month = date.getMonth();\n  date.setFullYear(date.getFullYear(), month + 1, 0);\n  date.setHours(0, 0, 0, 0);\n  return date;\n}","import toDate from \"../toDate/index.js\";\nimport toInteger from \"../_lib/toInteger/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\nimport { getDefaultOptions } from \"../_lib/defaultOptions/index.js\";\n/**\n * @name lastDayOfWeek\n * @category Week Helpers\n * @summary Return the last day of a week for the given date.\n *\n * @description\n * Return the last day of a week for the given date.\n * The result will be in the local timezone.\n *\n * @param {Date|Number} date - the original date\n * @param {Object} [options] - an object with options.\n * @param {Locale} [options.locale=defaultLocale] - the locale object. See [Locale]{@link https://date-fns.org/docs/Locale}\n * @param {0|1|2|3|4|5|6} [options.weekStartsOn=0] - the index of the first day of the week (0 - Sunday)\n * @returns {Date} the last day of a week\n * @throws {TypeError} 1 argument required\n * @throws {RangeError} `options.weekStartsOn` must be between 0 and 6\n *\n * @example\n * // The last day of a week for 2 September 2014 11:55:00:\n * const result = lastDayOfWeek(new Date(2014, 8, 2, 11, 55, 0))\n * //=> Sat Sep 06 2014 00:00:00\n *\n * @example\n * // If the week starts on Monday, the last day of the week for 2 September 2014 11:55:00:\n * const result = lastDayOfWeek(new Date(2014, 8, 2, 11, 55, 0), { weekStartsOn: 1 })\n * //=> Sun Sep 07 2014 00:00:00\n */\nexport default function lastDayOfWeek(dirtyDate, options) {\n  var _ref, _ref2, _ref3, _options$weekStartsOn, _options$locale, _options$locale$optio, _defaultOptions$local, _defaultOptions$local2;\n  requiredArgs(1, arguments);\n  var defaultOptions = getDefaultOptions();\n  var weekStartsOn = toInteger((_ref = (_ref2 = (_ref3 = (_options$weekStartsOn = options === null || options === void 0 ? void 0 : options.weekStartsOn) !== null && _options$weekStartsOn !== void 0 ? _options$weekStartsOn : options === null || options === void 0 ? void 0 : (_options$locale = options.locale) === null || _options$locale === void 0 ? void 0 : (_options$locale$optio = _options$locale.options) === null || _options$locale$optio === void 0 ? void 0 : _options$locale$optio.weekStartsOn) !== null && _ref3 !== void 0 ? _ref3 : defaultOptions.weekStartsOn) !== null && _ref2 !== void 0 ? _ref2 : (_defaultOptions$local = defaultOptions.locale) === null || _defaultOptions$local === void 0 ? void 0 : (_defaultOptions$local2 = _defaultOptions$local.options) === null || _defaultOptions$local2 === void 0 ? void 0 : _defaultOptions$local2.weekStartsOn) !== null && _ref !== void 0 ? _ref : 0);\n\n  // Test if weekStartsOn is between 0 and 6 _and_ is not NaN\n  if (!(weekStartsOn >= 0 && weekStartsOn <= 6)) {\n    throw new RangeError('weekStartsOn must be between 0 and 6');\n  }\n  var date = toDate(dirtyDate);\n  var day = date.getDay();\n  var diff = (day < weekStartsOn ? -7 : 0) + 6 - (day - weekStartsOn);\n  date.setHours(0, 0, 0, 0);\n  date.setDate(date.getDate() + diff);\n  return date;\n}","import toInteger from \"../_lib/toInteger/index.js\";\nimport toDate from \"../toDate/index.js\";\nimport getDaysInMonth from \"../getDaysInMonth/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n/**\n * @name setMonth\n * @category Month Helpers\n * @summary Set the month to the given date.\n *\n * @description\n * Set the month to the given date.\n *\n * @param {Date|Number} date - the date to be changed\n * @param {Number} month - the month of the new date\n * @returns {Date} the new date with the month set\n * @throws {TypeError} 2 arguments required\n *\n * @example\n * // Set February to 1 September 2014:\n * const result = setMonth(new Date(2014, 8, 1), 1)\n * //=> Sat Feb 01 2014 00:00:00\n */\nexport default function setMonth(dirtyDate, dirtyMonth) {\n  requiredArgs(2, arguments);\n  var date = toDate(dirtyDate);\n  var month = toInteger(dirtyMonth);\n  var year = date.getFullYear();\n  var day = date.getDate();\n  var dateWithDesiredMonth = new Date(0);\n  dateWithDesiredMonth.setFullYear(year, month, 15);\n  dateWithDesiredMonth.setHours(0, 0, 0, 0);\n  var daysInMonth = getDaysInMonth(dateWithDesiredMonth);\n  // Set the last day of the new month\n  // if the original date was the last day of the longer month\n  date.setMonth(month, Math.min(day, daysInMonth));\n  return date;\n}","import toDate from \"../toDate/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n/**\n * @name getDaysInMonth\n * @category Month Helpers\n * @summary Get the number of days in a month of the given date.\n *\n * @description\n * Get the number of days in a month of the given date.\n *\n * @param {Date|Number} date - the given date\n * @returns {Number} the number of days in a month\n * @throws {TypeError} 1 argument required\n *\n * @example\n * // How many days are in February 2000?\n * const result = getDaysInMonth(new Date(2000, 1))\n * //=> 29\n */\nexport default function getDaysInMonth(dirtyDate) {\n  requiredArgs(1, arguments);\n  var date = toDate(dirtyDate);\n  var year = date.getFullYear();\n  var monthIndex = date.getMonth();\n  var lastDayOfMonth = new Date(0);\n  lastDayOfMonth.setFullYear(year, monthIndex + 1, 0);\n  lastDayOfMonth.setHours(0, 0, 0, 0);\n  return lastDayOfMonth.getDate();\n}","import _typeof from \"@babel/runtime/helpers/esm/typeof\";\nimport toDate from \"../toDate/index.js\";\nimport setMonth from \"../setMonth/index.js\";\nimport toInteger from \"../_lib/toInteger/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n/**\n * @name set\n * @category Common Helpers\n * @summary Set date values to a given date.\n *\n * @description\n * Set date values to a given date.\n *\n * Sets time values to date from object `values`.\n * A value is not set if it is undefined or null or doesn't exist in `values`.\n *\n * Note about bundle size: `set` does not internally use `setX` functions from date-fns but instead opts\n * to use native `Date#setX` methods. If you use this function, you may not want to include the\n * other `setX` functions that date-fns provides if you are concerned about the bundle size.\n *\n * @param {Date|Number} date - the date to be changed\n * @param {Object} values - an object with options\n * @param {Number} [values.year] - the number of years to be set\n * @param {Number} [values.month] - the number of months to be set\n * @param {Number} [values.date] - the number of days to be set\n * @param {Number} [values.hours] - the number of hours to be set\n * @param {Number} [values.minutes] - the number of minutes to be set\n * @param {Number} [values.seconds] - the number of seconds to be set\n * @param {Number} [values.milliseconds] - the number of milliseconds to be set\n * @returns {Date} the new date with options set\n * @throws {TypeError} 2 arguments required\n * @throws {RangeError} `values` must be an object\n *\n * @example\n * // Transform 1 September 2014 into 20 October 2015 in a single line:\n * const result = set(new Date(2014, 8, 20), { year: 2015, month: 9, date: 20 })\n * //=> Tue Oct 20 2015 00:00:00\n *\n * @example\n * // Set 12 PM to 1 September 2014 01:23:45 to 1 September 2014 12:00:00:\n * const result = set(new Date(2014, 8, 1, 1, 23, 45), { hours: 12 })\n * //=> Mon Sep 01 2014 12:23:45\n */\nexport default function set(dirtyDate, values) {\n  requiredArgs(2, arguments);\n  if (_typeof(values) !== 'object' || values === null) {\n    throw new RangeError('values parameter must be an object');\n  }\n  var date = toDate(dirtyDate);\n\n  // Check if date is Invalid Date because Date.prototype.setFullYear ignores the value of Invalid Date\n  if (isNaN(date.getTime())) {\n    return new Date(NaN);\n  }\n  if (values.year != null) {\n    date.setFullYear(values.year);\n  }\n  if (values.month != null) {\n    date = setMonth(date, values.month);\n  }\n  if (values.date != null) {\n    date.setDate(toInteger(values.date));\n  }\n  if (values.hours != null) {\n    date.setHours(toInteger(values.hours));\n  }\n  if (values.minutes != null) {\n    date.setMinutes(toInteger(values.minutes));\n  }\n  if (values.seconds != null) {\n    date.setSeconds(toInteger(values.seconds));\n  }\n  if (values.milliseconds != null) {\n    date.setMilliseconds(toInteger(values.milliseconds));\n  }\n  return date;\n}","import toDate from \"../toDate/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n/**\n * @name startOfMonth\n * @category Month Helpers\n * @summary Return the start of a month for the given date.\n *\n * @description\n * Return the start of a month for the given date.\n * The result will be in the local timezone.\n *\n * @param {Date|Number} date - the original date\n * @returns {Date} the start of a month\n * @throws {TypeError} 1 argument required\n *\n * @example\n * // The start of a month for 2 September 2014 11:55:00:\n * const result = startOfMonth(new Date(2014, 8, 2, 11, 55, 0))\n * //=> Mon Sep 01 2014 00:00:00\n */\nexport default function startOfMonth(dirtyDate) {\n  requiredArgs(1, arguments);\n  var date = toDate(dirtyDate);\n  date.setDate(1);\n  date.setHours(0, 0, 0, 0);\n  return date;\n}","import toDate from \"../toDate/index.js\";\nimport toInteger from \"../_lib/toInteger/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\nimport { getDefaultOptions } from \"../_lib/defaultOptions/index.js\";\n/**\n * @name startOfWeek\n * @category Week Helpers\n * @summary Return the start of a week for the given date.\n *\n * @description\n * Return the start of a week for the given date.\n * The result will be in the local timezone.\n *\n * @param {Date|Number} date - the original date\n * @param {Object} [options] - an object with options.\n * @param {Locale} [options.locale=defaultLocale] - the locale object. See [Locale]{@link https://date-fns.org/docs/Locale}\n * @param {0|1|2|3|4|5|6} [options.weekStartsOn=0] - the index of the first day of the week (0 - Sunday)\n * @returns {Date} the start of a week\n * @throws {TypeError} 1 argument required\n * @throws {RangeError} `options.weekStartsOn` must be between 0 and 6\n *\n * @example\n * // The start of a week for 2 September 2014 11:55:00:\n * const result = startOfWeek(new Date(2014, 8, 2, 11, 55, 0))\n * //=> Sun Aug 31 2014 00:00:00\n *\n * @example\n * // If the week starts on Monday, the start of the week for 2 September 2014 11:55:00:\n * const result = startOfWeek(new Date(2014, 8, 2, 11, 55, 0), { weekStartsOn: 1 })\n * //=> Mon Sep 01 2014 00:00:00\n */\nexport default function startOfWeek(dirtyDate, options) {\n  var _ref, _ref2, _ref3, _options$weekStartsOn, _options$locale, _options$locale$optio, _defaultOptions$local, _defaultOptions$local2;\n  requiredArgs(1, arguments);\n  var defaultOptions = getDefaultOptions();\n  var weekStartsOn = toInteger((_ref = (_ref2 = (_ref3 = (_options$weekStartsOn = options === null || options === void 0 ? void 0 : options.weekStartsOn) !== null && _options$weekStartsOn !== void 0 ? _options$weekStartsOn : options === null || options === void 0 ? void 0 : (_options$locale = options.locale) === null || _options$locale === void 0 ? void 0 : (_options$locale$optio = _options$locale.options) === null || _options$locale$optio === void 0 ? void 0 : _options$locale$optio.weekStartsOn) !== null && _ref3 !== void 0 ? _ref3 : defaultOptions.weekStartsOn) !== null && _ref2 !== void 0 ? _ref2 : (_defaultOptions$local = defaultOptions.locale) === null || _defaultOptions$local === void 0 ? void 0 : (_defaultOptions$local2 = _defaultOptions$local.options) === null || _defaultOptions$local2 === void 0 ? void 0 : _defaultOptions$local2.weekStartsOn) !== null && _ref !== void 0 ? _ref : 0);\n\n  // Test if weekStartsOn is between 0 and 6 _and_ is not NaN\n  if (!(weekStartsOn >= 0 && weekStartsOn <= 6)) {\n    throw new RangeError('weekStartsOn must be between 0 and 6 inclusively');\n  }\n  var date = toDate(dirtyDate);\n  var day = date.getDay();\n  var diff = (day < weekStartsOn ? 7 : 0) + day - weekStartsOn;\n  date.setDate(date.getDate() - diff);\n  date.setHours(0, 0, 0, 0);\n  return date;\n}","import toDate from \"../toDate/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n/**\n * @name startOfYear\n * @category Year Helpers\n * @summary Return the start of a year for the given date.\n *\n * @description\n * Return the start of a year for the given date.\n * The result will be in the local timezone.\n *\n * @param {Date|Number} date - the original date\n * @returns {Date} the start of a year\n * @throws {TypeError} 1 argument required\n *\n * @example\n * // The start of a year for 2 September 2014 11:55:00:\n * const result = startOfYear(new Date(2014, 8, 2, 11, 55, 00))\n * //=> Wed Jan 01 2014 00:00:00\n */\nexport default function startOfYear(dirtyDate) {\n  requiredArgs(1, arguments);\n  var cleanDate = toDate(dirtyDate);\n  var date = new Date(0);\n  date.setFullYear(cleanDate.getFullYear(), 0, 1);\n  date.setHours(0, 0, 0, 0);\n  return date;\n}","import toInteger from \"../_lib/toInteger/index.js\";\nimport addYears from \"../addYears/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n/**\n * @name subYears\n * @category Year Helpers\n * @summary Subtract the specified number of years from the given date.\n *\n * @description\n * Subtract the specified number of years from the given date.\n *\n * @param {Date|Number} date - the date to be changed\n * @param {Number} amount - the amount of years to be subtracted. Positive decimals will be rounded using `Math.floor`, decimals less than zero will be rounded using `Math.ceil`.\n * @returns {Date} the new date with the years subtracted\n * @throws {TypeError} 2 arguments required\n *\n * @example\n * // Subtract 5 years from 1 September 2014:\n * const result = subYears(new Date(2014, 8, 1), 5)\n * //=> Tue Sep 01 2009 00:00:00\n */\nexport default function subYears(dirtyDate, dirtyAmount) {\n  requiredArgs(2, arguments);\n  var amount = toInteger(dirtyAmount);\n  return addYears(dirtyDate, -amount);\n}","'use strict';\nvar token = '%[a-f0-9]{2}';\nvar singleMatcher = new RegExp('(' + token + ')|([^%]+?)', 'gi');\nvar multiMatcher = new RegExp('(' + token + ')+', 'gi');\n\nfunction decodeComponents(components, split) {\n\ttry {\n\t\t// Try to decode the entire string first\n\t\treturn [decodeURIComponent(components.join(''))];\n\t} catch (err) {\n\t\t// Do nothing\n\t}\n\n\tif (components.length === 1) {\n\t\treturn components;\n\t}\n\n\tsplit = split || 1;\n\n\t// Split the array in 2 parts\n\tvar left = components.slice(0, split);\n\tvar right = components.slice(split);\n\n\treturn Array.prototype.concat.call([], decodeComponents(left), decodeComponents(right));\n}\n\nfunction decode(input) {\n\ttry {\n\t\treturn decodeURIComponent(input);\n\t} catch (err) {\n\t\tvar tokens = input.match(singleMatcher) || [];\n\n\t\tfor (var i = 1; i < tokens.length; i++) {\n\t\t\tinput = decodeComponents(tokens, i).join('');\n\n\t\t\ttokens = input.match(singleMatcher) || [];\n\t\t}\n\n\t\treturn input;\n\t}\n}\n\nfunction customDecodeURIComponent(input) {\n\t// Keep track of all the replacements and prefill the map with the `BOM`\n\tvar replaceMap = {\n\t\t'%FE%FF': '\\uFFFD\\uFFFD',\n\t\t'%FF%FE': '\\uFFFD\\uFFFD'\n\t};\n\n\tvar match = multiMatcher.exec(input);\n\twhile (match) {\n\t\ttry {\n\t\t\t// Decode as big chunks as possible\n\t\t\treplaceMap[match[0]] = decodeURIComponent(match[0]);\n\t\t} catch (err) {\n\t\t\tvar result = decode(match[0]);\n\n\t\t\tif (result !== match[0]) {\n\t\t\t\treplaceMap[match[0]] = result;\n\t\t\t}\n\t\t}\n\n\t\tmatch = multiMatcher.exec(input);\n\t}\n\n\t// Add `%C2` at the end of the map to make sure it does not replace the combinator before everything else\n\treplaceMap['%C2'] = '\\uFFFD';\n\n\tvar entries = Object.keys(replaceMap);\n\n\tfor (var i = 0; i < entries.length; i++) {\n\t\t// Replace all decoded components\n\t\tvar key = entries[i];\n\t\tinput = input.replace(new RegExp(key, 'g'), replaceMap[key]);\n\t}\n\n\treturn input;\n}\n\nmodule.exports = function (encodedURI) {\n\tif (typeof encodedURI !== 'string') {\n\t\tthrow new TypeError('Expected `encodedURI` to be of type `string`, got `' + typeof encodedURI + '`');\n\t}\n\n\ttry {\n\t\tencodedURI = encodedURI.replace(/\\+/g, ' ');\n\n\t\t// Try the built in decoder first\n\t\treturn decodeURIComponent(encodedURI);\n\t} catch (err) {\n\t\t// Fallback to a more advanced decoder\n\t\treturn customDecodeURIComponent(encodedURI);\n\t}\n};\n","'use strict';\nmodule.exports = function (obj, predicate) {\n\tvar ret = {};\n\tvar keys = Object.keys(obj);\n\tvar isArr = Array.isArray(predicate);\n\n\tfor (var i = 0; i < keys.length; i++) {\n\t\tvar key = keys[i];\n\t\tvar val = obj[key];\n\n\t\tif (isArr ? predicate.indexOf(key) !== -1 : predicate(key, val, obj)) {\n\t\t\tret[key] = val;\n\t\t}\n\t}\n\n\treturn ret;\n};\n","/*! Hammer.JS - v2.0.7 - 2016-04-22\n * http://hammerjs.github.io/\n *\n * Copyright (c) 2016 Jorik Tangelder;\n * Licensed under the MIT license */\n(function(window, document, exportName, undefined) {\n  'use strict';\n\nvar VENDOR_PREFIXES = ['', 'webkit', 'Moz', 'MS', 'ms', 'o'];\nvar TEST_ELEMENT = document.createElement('div');\n\nvar TYPE_FUNCTION = 'function';\n\nvar round = Math.round;\nvar abs = Math.abs;\nvar now = Date.now;\n\n/**\n * set a timeout with a given scope\n * @param {Function} fn\n * @param {Number} timeout\n * @param {Object} context\n * @returns {number}\n */\nfunction setTimeoutContext(fn, timeout, context) {\n    return setTimeout(bindFn(fn, context), timeout);\n}\n\n/**\n * if the argument is an array, we want to execute the fn on each entry\n * if it aint an array we don't want to do a thing.\n * this is used by all the methods that accept a single and array argument.\n * @param {*|Array} arg\n * @param {String} fn\n * @param {Object} [context]\n * @returns {Boolean}\n */\nfunction invokeArrayArg(arg, fn, context) {\n    if (Array.isArray(arg)) {\n        each(arg, context[fn], context);\n        return true;\n    }\n    return false;\n}\n\n/**\n * walk objects and arrays\n * @param {Object} obj\n * @param {Function} iterator\n * @param {Object} context\n */\nfunction each(obj, iterator, context) {\n    var i;\n\n    if (!obj) {\n        return;\n    }\n\n    if (obj.forEach) {\n        obj.forEach(iterator, context);\n    } else if (obj.length !== undefined) {\n        i = 0;\n        while (i < obj.length) {\n            iterator.call(context, obj[i], i, obj);\n            i++;\n        }\n    } else {\n        for (i in obj) {\n            obj.hasOwnProperty(i) && iterator.call(context, obj[i], i, obj);\n        }\n    }\n}\n\n/**\n * wrap a method with a deprecation warning and stack trace\n * @param {Function} method\n * @param {String} name\n * @param {String} message\n * @returns {Function} A new function wrapping the supplied method.\n */\nfunction deprecate(method, name, message) {\n    var deprecationMessage = 'DEPRECATED METHOD: ' + name + '\\n' + message + ' AT \\n';\n    return function() {\n        var e = new Error('get-stack-trace');\n        var stack = e && e.stack ? e.stack.replace(/^[^\\(]+?[\\n$]/gm, '')\n            .replace(/^\\s+at\\s+/gm, '')\n            .replace(/^Object.<anonymous>\\s*\\(/gm, '{anonymous}()@') : 'Unknown Stack Trace';\n\n        var log = window.console && (window.console.warn || window.console.log);\n        if (log) {\n            log.call(window.console, deprecationMessage, stack);\n        }\n        return method.apply(this, arguments);\n    };\n}\n\n/**\n * extend object.\n * means that properties in dest will be overwritten by the ones in src.\n * @param {Object} target\n * @param {...Object} objects_to_assign\n * @returns {Object} target\n */\nvar assign;\nif (typeof Object.assign !== 'function') {\n    assign = function assign(target) {\n        if (target === undefined || target === null) {\n            throw new TypeError('Cannot convert undefined or null to object');\n        }\n\n        var output = Object(target);\n        for (var index = 1; index < arguments.length; index++) {\n            var source = arguments[index];\n            if (source !== undefined && source !== null) {\n                for (var nextKey in source) {\n                    if (source.hasOwnProperty(nextKey)) {\n                        output[nextKey] = source[nextKey];\n                    }\n                }\n            }\n        }\n        return output;\n    };\n} else {\n    assign = Object.assign;\n}\n\n/**\n * extend object.\n * means that properties in dest will be overwritten by the ones in src.\n * @param {Object} dest\n * @param {Object} src\n * @param {Boolean} [merge=false]\n * @returns {Object} dest\n */\nvar extend = deprecate(function extend(dest, src, merge) {\n    var keys = Object.keys(src);\n    var i = 0;\n    while (i < keys.length) {\n        if (!merge || (merge && dest[keys[i]] === undefined)) {\n            dest[keys[i]] = src[keys[i]];\n        }\n        i++;\n    }\n    return dest;\n}, 'extend', 'Use `assign`.');\n\n/**\n * merge the values from src in the dest.\n * means that properties that exist in dest will not be overwritten by src\n * @param {Object} dest\n * @param {Object} src\n * @returns {Object} dest\n */\nvar merge = deprecate(function merge(dest, src) {\n    return extend(dest, src, true);\n}, 'merge', 'Use `assign`.');\n\n/**\n * simple class inheritance\n * @param {Function} child\n * @param {Function} base\n * @param {Object} [properties]\n */\nfunction inherit(child, base, properties) {\n    var baseP = base.prototype,\n        childP;\n\n    childP = child.prototype = Object.create(baseP);\n    childP.constructor = child;\n    childP._super = baseP;\n\n    if (properties) {\n        assign(childP, properties);\n    }\n}\n\n/**\n * simple function bind\n * @param {Function} fn\n * @param {Object} context\n * @returns {Function}\n */\nfunction bindFn(fn, context) {\n    return function boundFn() {\n        return fn.apply(context, arguments);\n    };\n}\n\n/**\n * let a boolean value also be a function that must return a boolean\n * this first item in args will be used as the context\n * @param {Boolean|Function} val\n * @param {Array} [args]\n * @returns {Boolean}\n */\nfunction boolOrFn(val, args) {\n    if (typeof val == TYPE_FUNCTION) {\n        return val.apply(args ? args[0] || undefined : undefined, args);\n    }\n    return val;\n}\n\n/**\n * use the val2 when val1 is undefined\n * @param {*} val1\n * @param {*} val2\n * @returns {*}\n */\nfunction ifUndefined(val1, val2) {\n    return (val1 === undefined) ? val2 : val1;\n}\n\n/**\n * addEventListener with multiple events at once\n * @param {EventTarget} target\n * @param {String} types\n * @param {Function} handler\n */\nfunction addEventListeners(target, types, handler) {\n    each(splitStr(types), function(type) {\n        target.addEventListener(type, handler, false);\n    });\n}\n\n/**\n * removeEventListener with multiple events at once\n * @param {EventTarget} target\n * @param {String} types\n * @param {Function} handler\n */\nfunction removeEventListeners(target, types, handler) {\n    each(splitStr(types), function(type) {\n        target.removeEventListener(type, handler, false);\n    });\n}\n\n/**\n * find if a node is in the given parent\n * @method hasParent\n * @param {HTMLElement} node\n * @param {HTMLElement} parent\n * @return {Boolean} found\n */\nfunction hasParent(node, parent) {\n    while (node) {\n        if (node == parent) {\n            return true;\n        }\n        node = node.parentNode;\n    }\n    return false;\n}\n\n/**\n * small indexOf wrapper\n * @param {String} str\n * @param {String} find\n * @returns {Boolean} found\n */\nfunction inStr(str, find) {\n    return str.indexOf(find) > -1;\n}\n\n/**\n * split string on whitespace\n * @param {String} str\n * @returns {Array} words\n */\nfunction splitStr(str) {\n    return str.trim().split(/\\s+/g);\n}\n\n/**\n * find if a array contains the object using indexOf or a simple polyFill\n * @param {Array} src\n * @param {String} find\n * @param {String} [findByKey]\n * @return {Boolean|Number} false when not found, or the index\n */\nfunction inArray(src, find, findByKey) {\n    if (src.indexOf && !findByKey) {\n        return src.indexOf(find);\n    } else {\n        var i = 0;\n        while (i < src.length) {\n            if ((findByKey && src[i][findByKey] == find) || (!findByKey && src[i] === find)) {\n                return i;\n            }\n            i++;\n        }\n        return -1;\n    }\n}\n\n/**\n * convert array-like objects to real arrays\n * @param {Object} obj\n * @returns {Array}\n */\nfunction toArray(obj) {\n    return Array.prototype.slice.call(obj, 0);\n}\n\n/**\n * unique array with objects based on a key (like 'id') or just by the array's value\n * @param {Array} src [{id:1},{id:2},{id:1}]\n * @param {String} [key]\n * @param {Boolean} [sort=False]\n * @returns {Array} [{id:1},{id:2}]\n */\nfunction uniqueArray(src, key, sort) {\n    var results = [];\n    var values = [];\n    var i = 0;\n\n    while (i < src.length) {\n        var val = key ? src[i][key] : src[i];\n        if (inArray(values, val) < 0) {\n            results.push(src[i]);\n        }\n        values[i] = val;\n        i++;\n    }\n\n    if (sort) {\n        if (!key) {\n            results = results.sort();\n        } else {\n            results = results.sort(function sortUniqueArray(a, b) {\n                return a[key] > b[key];\n            });\n        }\n    }\n\n    return results;\n}\n\n/**\n * get the prefixed property\n * @param {Object} obj\n * @param {String} property\n * @returns {String|Undefined} prefixed\n */\nfunction prefixed(obj, property) {\n    var prefix, prop;\n    var camelProp = property[0].toUpperCase() + property.slice(1);\n\n    var i = 0;\n    while (i < VENDOR_PREFIXES.length) {\n        prefix = VENDOR_PREFIXES[i];\n        prop = (prefix) ? prefix + camelProp : property;\n\n        if (prop in obj) {\n            return prop;\n        }\n        i++;\n    }\n    return undefined;\n}\n\n/**\n * get a unique id\n * @returns {number} uniqueId\n */\nvar _uniqueId = 1;\nfunction uniqueId() {\n    return _uniqueId++;\n}\n\n/**\n * get the window object of an element\n * @param {HTMLElement} element\n * @returns {DocumentView|Window}\n */\nfunction getWindowForElement(element) {\n    var doc = element.ownerDocument || element;\n    return (doc.defaultView || doc.parentWindow || window);\n}\n\nvar MOBILE_REGEX = /mobile|tablet|ip(ad|hone|od)|android/i;\n\nvar SUPPORT_TOUCH = ('ontouchstart' in window);\nvar SUPPORT_POINTER_EVENTS = prefixed(window, 'PointerEvent') !== undefined;\nvar SUPPORT_ONLY_TOUCH = SUPPORT_TOUCH && MOBILE_REGEX.test(navigator.userAgent);\n\nvar INPUT_TYPE_TOUCH = 'touch';\nvar INPUT_TYPE_PEN = 'pen';\nvar INPUT_TYPE_MOUSE = 'mouse';\nvar INPUT_TYPE_KINECT = 'kinect';\n\nvar COMPUTE_INTERVAL = 25;\n\nvar INPUT_START = 1;\nvar INPUT_MOVE = 2;\nvar INPUT_END = 4;\nvar INPUT_CANCEL = 8;\n\nvar DIRECTION_NONE = 1;\nvar DIRECTION_LEFT = 2;\nvar DIRECTION_RIGHT = 4;\nvar DIRECTION_UP = 8;\nvar DIRECTION_DOWN = 16;\n\nvar DIRECTION_HORIZONTAL = DIRECTION_LEFT | DIRECTION_RIGHT;\nvar DIRECTION_VERTICAL = DIRECTION_UP | DIRECTION_DOWN;\nvar DIRECTION_ALL = DIRECTION_HORIZONTAL | DIRECTION_VERTICAL;\n\nvar PROPS_XY = ['x', 'y'];\nvar PROPS_CLIENT_XY = ['clientX', 'clientY'];\n\n/**\n * create new input type manager\n * @param {Manager} manager\n * @param {Function} callback\n * @returns {Input}\n * @constructor\n */\nfunction Input(manager, callback) {\n    var self = this;\n    this.manager = manager;\n    this.callback = callback;\n    this.element = manager.element;\n    this.target = manager.options.inputTarget;\n\n    // smaller wrapper around the handler, for the scope and the enabled state of the manager,\n    // so when disabled the input events are completely bypassed.\n    this.domHandler = function(ev) {\n        if (boolOrFn(manager.options.enable, [manager])) {\n            self.handler(ev);\n        }\n    };\n\n    this.init();\n\n}\n\nInput.prototype = {\n    /**\n     * should handle the inputEvent data and trigger the callback\n     * @virtual\n     */\n    handler: function() { },\n\n    /**\n     * bind the events\n     */\n    init: function() {\n        this.evEl && addEventListeners(this.element, this.evEl, this.domHandler);\n        this.evTarget && addEventListeners(this.target, this.evTarget, this.domHandler);\n        this.evWin && addEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);\n    },\n\n    /**\n     * unbind the events\n     */\n    destroy: function() {\n        this.evEl && removeEventListeners(this.element, this.evEl, this.domHandler);\n        this.evTarget && removeEventListeners(this.target, this.evTarget, this.domHandler);\n        this.evWin && removeEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);\n    }\n};\n\n/**\n * create new input type manager\n * called by the Manager constructor\n * @param {Hammer} manager\n * @returns {Input}\n */\nfunction createInputInstance(manager) {\n    var Type;\n    var inputClass = manager.options.inputClass;\n\n    if (inputClass) {\n        Type = inputClass;\n    } else if (SUPPORT_POINTER_EVENTS) {\n        Type = PointerEventInput;\n    } else if (SUPPORT_ONLY_TOUCH) {\n        Type = TouchInput;\n    } else if (!SUPPORT_TOUCH) {\n        Type = MouseInput;\n    } else {\n        Type = TouchMouseInput;\n    }\n    return new (Type)(manager, inputHandler);\n}\n\n/**\n * handle input events\n * @param {Manager} manager\n * @param {String} eventType\n * @param {Object} input\n */\nfunction inputHandler(manager, eventType, input) {\n    var pointersLen = input.pointers.length;\n    var changedPointersLen = input.changedPointers.length;\n    var isFirst = (eventType & INPUT_START && (pointersLen - changedPointersLen === 0));\n    var isFinal = (eventType & (INPUT_END | INPUT_CANCEL) && (pointersLen - changedPointersLen === 0));\n\n    input.isFirst = !!isFirst;\n    input.isFinal = !!isFinal;\n\n    if (isFirst) {\n        manager.session = {};\n    }\n\n    // source event is the normalized value of the domEvents\n    // like 'touchstart, mouseup, pointerdown'\n    input.eventType = eventType;\n\n    // compute scale, rotation etc\n    computeInputData(manager, input);\n\n    // emit secret event\n    manager.emit('hammer.input', input);\n\n    manager.recognize(input);\n    manager.session.prevInput = input;\n}\n\n/**\n * extend the data with some usable properties like scale, rotate, velocity etc\n * @param {Object} manager\n * @param {Object} input\n */\nfunction computeInputData(manager, input) {\n    var session = manager.session;\n    var pointers = input.pointers;\n    var pointersLength = pointers.length;\n\n    // store the first input to calculate the distance and direction\n    if (!session.firstInput) {\n        session.firstInput = simpleCloneInputData(input);\n    }\n\n    // to compute scale and rotation we need to store the multiple touches\n    if (pointersLength > 1 && !session.firstMultiple) {\n        session.firstMultiple = simpleCloneInputData(input);\n    } else if (pointersLength === 1) {\n        session.firstMultiple = false;\n    }\n\n    var firstInput = session.firstInput;\n    var firstMultiple = session.firstMultiple;\n    var offsetCenter = firstMultiple ? firstMultiple.center : firstInput.center;\n\n    var center = input.center = getCenter(pointers);\n    input.timeStamp = now();\n    input.deltaTime = input.timeStamp - firstInput.timeStamp;\n\n    input.angle = getAngle(offsetCenter, center);\n    input.distance = getDistance(offsetCenter, center);\n\n    computeDeltaXY(session, input);\n    input.offsetDirection = getDirection(input.deltaX, input.deltaY);\n\n    var overallVelocity = getVelocity(input.deltaTime, input.deltaX, input.deltaY);\n    input.overallVelocityX = overallVelocity.x;\n    input.overallVelocityY = overallVelocity.y;\n    input.overallVelocity = (abs(overallVelocity.x) > abs(overallVelocity.y)) ? overallVelocity.x : overallVelocity.y;\n\n    input.scale = firstMultiple ? getScale(firstMultiple.pointers, pointers) : 1;\n    input.rotation = firstMultiple ? getRotation(firstMultiple.pointers, pointers) : 0;\n\n    input.maxPointers = !session.prevInput ? input.pointers.length : ((input.pointers.length >\n        session.prevInput.maxPointers) ? input.pointers.length : session.prevInput.maxPointers);\n\n    computeIntervalInputData(session, input);\n\n    // find the correct target\n    var target = manager.element;\n    if (hasParent(input.srcEvent.target, target)) {\n        target = input.srcEvent.target;\n    }\n    input.target = target;\n}\n\nfunction computeDeltaXY(session, input) {\n    var center = input.center;\n    var offset = session.offsetDelta || {};\n    var prevDelta = session.prevDelta || {};\n    var prevInput = session.prevInput || {};\n\n    if (input.eventType === INPUT_START || prevInput.eventType === INPUT_END) {\n        prevDelta = session.prevDelta = {\n            x: prevInput.deltaX || 0,\n            y: prevInput.deltaY || 0\n        };\n\n        offset = session.offsetDelta = {\n            x: center.x,\n            y: center.y\n        };\n    }\n\n    input.deltaX = prevDelta.x + (center.x - offset.x);\n    input.deltaY = prevDelta.y + (center.y - offset.y);\n}\n\n/**\n * velocity is calculated every x ms\n * @param {Object} session\n * @param {Object} input\n */\nfunction computeIntervalInputData(session, input) {\n    var last = session.lastInterval || input,\n        deltaTime = input.timeStamp - last.timeStamp,\n        velocity, velocityX, velocityY, direction;\n\n    if (input.eventType != INPUT_CANCEL && (deltaTime > COMPUTE_INTERVAL || last.velocity === undefined)) {\n        var deltaX = input.deltaX - last.deltaX;\n        var deltaY = input.deltaY - last.deltaY;\n\n        var v = getVelocity(deltaTime, deltaX, deltaY);\n        velocityX = v.x;\n        velocityY = v.y;\n        velocity = (abs(v.x) > abs(v.y)) ? v.x : v.y;\n        direction = getDirection(deltaX, deltaY);\n\n        session.lastInterval = input;\n    } else {\n        // use latest velocity info if it doesn't overtake a minimum period\n        velocity = last.velocity;\n        velocityX = last.velocityX;\n        velocityY = last.velocityY;\n        direction = last.direction;\n    }\n\n    input.velocity = velocity;\n    input.velocityX = velocityX;\n    input.velocityY = velocityY;\n    input.direction = direction;\n}\n\n/**\n * create a simple clone from the input used for storage of firstInput and firstMultiple\n * @param {Object} input\n * @returns {Object} clonedInputData\n */\nfunction simpleCloneInputData(input) {\n    // make a simple copy of the pointers because we will get a reference if we don't\n    // we only need clientXY for the calculations\n    var pointers = [];\n    var i = 0;\n    while (i < input.pointers.length) {\n        pointers[i] = {\n            clientX: round(input.pointers[i].clientX),\n            clientY: round(input.pointers[i].clientY)\n        };\n        i++;\n    }\n\n    return {\n        timeStamp: now(),\n        pointers: pointers,\n        center: getCenter(pointers),\n        deltaX: input.deltaX,\n        deltaY: input.deltaY\n    };\n}\n\n/**\n * get the center of all the pointers\n * @param {Array} pointers\n * @return {Object} center contains `x` and `y` properties\n */\nfunction getCenter(pointers) {\n    var pointersLength = pointers.length;\n\n    // no need to loop when only one touch\n    if (pointersLength === 1) {\n        return {\n            x: round(pointers[0].clientX),\n            y: round(pointers[0].clientY)\n        };\n    }\n\n    var x = 0, y = 0, i = 0;\n    while (i < pointersLength) {\n        x += pointers[i].clientX;\n        y += pointers[i].clientY;\n        i++;\n    }\n\n    return {\n        x: round(x / pointersLength),\n        y: round(y / pointersLength)\n    };\n}\n\n/**\n * calculate the velocity between two points. unit is in px per ms.\n * @param {Number} deltaTime\n * @param {Number} x\n * @param {Number} y\n * @return {Object} velocity `x` and `y`\n */\nfunction getVelocity(deltaTime, x, y) {\n    return {\n        x: x / deltaTime || 0,\n        y: y / deltaTime || 0\n    };\n}\n\n/**\n * get the direction between two points\n * @param {Number} x\n * @param {Number} y\n * @return {Number} direction\n */\nfunction getDirection(x, y) {\n    if (x === y) {\n        return DIRECTION_NONE;\n    }\n\n    if (abs(x) >= abs(y)) {\n        return x < 0 ? DIRECTION_LEFT : DIRECTION_RIGHT;\n    }\n    return y < 0 ? DIRECTION_UP : DIRECTION_DOWN;\n}\n\n/**\n * calculate the absolute distance between two points\n * @param {Object} p1 {x, y}\n * @param {Object} p2 {x, y}\n * @param {Array} [props] containing x and y keys\n * @return {Number} distance\n */\nfunction getDistance(p1, p2, props) {\n    if (!props) {\n        props = PROPS_XY;\n    }\n    var x = p2[props[0]] - p1[props[0]],\n        y = p2[props[1]] - p1[props[1]];\n\n    return Math.sqrt((x * x) + (y * y));\n}\n\n/**\n * calculate the angle between two coordinates\n * @param {Object} p1\n * @param {Object} p2\n * @param {Array} [props] containing x and y keys\n * @return {Number} angle\n */\nfunction getAngle(p1, p2, props) {\n    if (!props) {\n        props = PROPS_XY;\n    }\n    var x = p2[props[0]] - p1[props[0]],\n        y = p2[props[1]] - p1[props[1]];\n    return Math.atan2(y, x) * 180 / Math.PI;\n}\n\n/**\n * calculate the rotation degrees between two pointersets\n * @param {Array} start array of pointers\n * @param {Array} end array of pointers\n * @return {Number} rotation\n */\nfunction getRotation(start, end) {\n    return getAngle(end[1], end[0], PROPS_CLIENT_XY) + getAngle(start[1], start[0], PROPS_CLIENT_XY);\n}\n\n/**\n * calculate the scale factor between two pointersets\n * no scale is 1, and goes down to 0 when pinched together, and bigger when pinched out\n * @param {Array} start array of pointers\n * @param {Array} end array of pointers\n * @return {Number} scale\n */\nfunction getScale(start, end) {\n    return getDistance(end[0], end[1], PROPS_CLIENT_XY) / getDistance(start[0], start[1], PROPS_CLIENT_XY);\n}\n\nvar MOUSE_INPUT_MAP = {\n    mousedown: INPUT_START,\n    mousemove: INPUT_MOVE,\n    mouseup: INPUT_END\n};\n\nvar MOUSE_ELEMENT_EVENTS = 'mousedown';\nvar MOUSE_WINDOW_EVENTS = 'mousemove mouseup';\n\n/**\n * Mouse events input\n * @constructor\n * @extends Input\n */\nfunction MouseInput() {\n    this.evEl = MOUSE_ELEMENT_EVENTS;\n    this.evWin = MOUSE_WINDOW_EVENTS;\n\n    this.pressed = false; // mousedown state\n\n    Input.apply(this, arguments);\n}\n\ninherit(MouseInput, Input, {\n    /**\n     * handle mouse events\n     * @param {Object} ev\n     */\n    handler: function MEhandler(ev) {\n        var eventType = MOUSE_INPUT_MAP[ev.type];\n\n        // on start we want to have the left mouse button down\n        if (eventType & INPUT_START && ev.button === 0) {\n            this.pressed = true;\n        }\n\n        if (eventType & INPUT_MOVE && ev.which !== 1) {\n            eventType = INPUT_END;\n        }\n\n        // mouse must be down\n        if (!this.pressed) {\n            return;\n        }\n\n        if (eventType & INPUT_END) {\n            this.pressed = false;\n        }\n\n        this.callback(this.manager, eventType, {\n            pointers: [ev],\n            changedPointers: [ev],\n            pointerType: INPUT_TYPE_MOUSE,\n            srcEvent: ev\n        });\n    }\n});\n\nvar POINTER_INPUT_MAP = {\n    pointerdown: INPUT_START,\n    pointermove: INPUT_MOVE,\n    pointerup: INPUT_END,\n    pointercancel: INPUT_CANCEL,\n    pointerout: INPUT_CANCEL\n};\n\n// in IE10 the pointer types is defined as an enum\nvar IE10_POINTER_TYPE_ENUM = {\n    2: INPUT_TYPE_TOUCH,\n    3: INPUT_TYPE_PEN,\n    4: INPUT_TYPE_MOUSE,\n    5: INPUT_TYPE_KINECT // see https://twitter.com/jacobrossi/status/480596438489890816\n};\n\nvar POINTER_ELEMENT_EVENTS = 'pointerdown';\nvar POINTER_WINDOW_EVENTS = 'pointermove pointerup pointercancel';\n\n// IE10 has prefixed support, and case-sensitive\nif (window.MSPointerEvent && !window.PointerEvent) {\n    POINTER_ELEMENT_EVENTS = 'MSPointerDown';\n    POINTER_WINDOW_EVENTS = 'MSPointerMove MSPointerUp MSPointerCancel';\n}\n\n/**\n * Pointer events input\n * @constructor\n * @extends Input\n */\nfunction PointerEventInput() {\n    this.evEl = POINTER_ELEMENT_EVENTS;\n    this.evWin = POINTER_WINDOW_EVENTS;\n\n    Input.apply(this, arguments);\n\n    this.store = (this.manager.session.pointerEvents = []);\n}\n\ninherit(PointerEventInput, Input, {\n    /**\n     * handle mouse events\n     * @param {Object} ev\n     */\n    handler: function PEhandler(ev) {\n        var store = this.store;\n        var removePointer = false;\n\n        var eventTypeNormalized = ev.type.toLowerCase().replace('ms', '');\n        var eventType = POINTER_INPUT_MAP[eventTypeNormalized];\n        var pointerType = IE10_POINTER_TYPE_ENUM[ev.pointerType] || ev.pointerType;\n\n        var isTouch = (pointerType == INPUT_TYPE_TOUCH);\n\n        // get index of the event in the store\n        var storeIndex = inArray(store, ev.pointerId, 'pointerId');\n\n        // start and mouse must be down\n        if (eventType & INPUT_START && (ev.button === 0 || isTouch)) {\n            if (storeIndex < 0) {\n                store.push(ev);\n                storeIndex = store.length - 1;\n            }\n        } else if (eventType & (INPUT_END | INPUT_CANCEL)) {\n            removePointer = true;\n        }\n\n        // it not found, so the pointer hasn't been down (so it's probably a hover)\n        if (storeIndex < 0) {\n            return;\n        }\n\n        // update the event in the store\n        store[storeIndex] = ev;\n\n        this.callback(this.manager, eventType, {\n            pointers: store,\n            changedPointers: [ev],\n            pointerType: pointerType,\n            srcEvent: ev\n        });\n\n        if (removePointer) {\n            // remove from the store\n            store.splice(storeIndex, 1);\n        }\n    }\n});\n\nvar SINGLE_TOUCH_INPUT_MAP = {\n    touchstart: INPUT_START,\n    touchmove: INPUT_MOVE,\n    touchend: INPUT_END,\n    touchcancel: INPUT_CANCEL\n};\n\nvar SINGLE_TOUCH_TARGET_EVENTS = 'touchstart';\nvar SINGLE_TOUCH_WINDOW_EVENTS = 'touchstart touchmove touchend touchcancel';\n\n/**\n * Touch events input\n * @constructor\n * @extends Input\n */\nfunction SingleTouchInput() {\n    this.evTarget = SINGLE_TOUCH_TARGET_EVENTS;\n    this.evWin = SINGLE_TOUCH_WINDOW_EVENTS;\n    this.started = false;\n\n    Input.apply(this, arguments);\n}\n\ninherit(SingleTouchInput, Input, {\n    handler: function TEhandler(ev) {\n        var type = SINGLE_TOUCH_INPUT_MAP[ev.type];\n\n        // should we handle the touch events?\n        if (type === INPUT_START) {\n            this.started = true;\n        }\n\n        if (!this.started) {\n            return;\n        }\n\n        var touches = normalizeSingleTouches.call(this, ev, type);\n\n        // when done, reset the started state\n        if (type & (INPUT_END | INPUT_CANCEL) && touches[0].length - touches[1].length === 0) {\n            this.started = false;\n        }\n\n        this.callback(this.manager, type, {\n            pointers: touches[0],\n            changedPointers: touches[1],\n            pointerType: INPUT_TYPE_TOUCH,\n            srcEvent: ev\n        });\n    }\n});\n\n/**\n * @this {TouchInput}\n * @param {Object} ev\n * @param {Number} type flag\n * @returns {undefined|Array} [all, changed]\n */\nfunction normalizeSingleTouches(ev, type) {\n    var all = toArray(ev.touches);\n    var changed = toArray(ev.changedTouches);\n\n    if (type & (INPUT_END | INPUT_CANCEL)) {\n        all = uniqueArray(all.concat(changed), 'identifier', true);\n    }\n\n    return [all, changed];\n}\n\nvar TOUCH_INPUT_MAP = {\n    touchstart: INPUT_START,\n    touchmove: INPUT_MOVE,\n    touchend: INPUT_END,\n    touchcancel: INPUT_CANCEL\n};\n\nvar TOUCH_TARGET_EVENTS = 'touchstart touchmove touchend touchcancel';\n\n/**\n * Multi-user touch events input\n * @constructor\n * @extends Input\n */\nfunction TouchInput() {\n    this.evTarget = TOUCH_TARGET_EVENTS;\n    this.targetIds = {};\n\n    Input.apply(this, arguments);\n}\n\ninherit(TouchInput, Input, {\n    handler: function MTEhandler(ev) {\n        var type = TOUCH_INPUT_MAP[ev.type];\n        var touches = getTouches.call(this, ev, type);\n        if (!touches) {\n            return;\n        }\n\n        this.callback(this.manager, type, {\n            pointers: touches[0],\n            changedPointers: touches[1],\n            pointerType: INPUT_TYPE_TOUCH,\n            srcEvent: ev\n        });\n    }\n});\n\n/**\n * @this {TouchInput}\n * @param {Object} ev\n * @param {Number} type flag\n * @returns {undefined|Array} [all, changed]\n */\nfunction getTouches(ev, type) {\n    var allTouches = toArray(ev.touches);\n    var targetIds = this.targetIds;\n\n    // when there is only one touch, the process can be simplified\n    if (type & (INPUT_START | INPUT_MOVE) && allTouches.length === 1) {\n        targetIds[allTouches[0].identifier] = true;\n        return [allTouches, allTouches];\n    }\n\n    var i,\n        targetTouches,\n        changedTouches = toArray(ev.changedTouches),\n        changedTargetTouches = [],\n        target = this.target;\n\n    // get target touches from touches\n    targetTouches = allTouches.filter(function(touch) {\n        return hasParent(touch.target, target);\n    });\n\n    // collect touches\n    if (type === INPUT_START) {\n        i = 0;\n        while (i < targetTouches.length) {\n            targetIds[targetTouches[i].identifier] = true;\n            i++;\n        }\n    }\n\n    // filter changed touches to only contain touches that exist in the collected target ids\n    i = 0;\n    while (i < changedTouches.length) {\n        if (targetIds[changedTouches[i].identifier]) {\n            changedTargetTouches.push(changedTouches[i]);\n        }\n\n        // cleanup removed touches\n        if (type & (INPUT_END | INPUT_CANCEL)) {\n            delete targetIds[changedTouches[i].identifier];\n        }\n        i++;\n    }\n\n    if (!changedTargetTouches.length) {\n        return;\n    }\n\n    return [\n        // merge targetTouches with changedTargetTouches so it contains ALL touches, including 'end' and 'cancel'\n        uniqueArray(targetTouches.concat(changedTargetTouches), 'identifier', true),\n        changedTargetTouches\n    ];\n}\n\n/**\n * Combined touch and mouse input\n *\n * Touch has a higher priority then mouse, and while touching no mouse events are allowed.\n * This because touch devices also emit mouse events while doing a touch.\n *\n * @constructor\n * @extends Input\n */\n\nvar DEDUP_TIMEOUT = 2500;\nvar DEDUP_DISTANCE = 25;\n\nfunction TouchMouseInput() {\n    Input.apply(this, arguments);\n\n    var handler = bindFn(this.handler, this);\n    this.touch = new TouchInput(this.manager, handler);\n    this.mouse = new MouseInput(this.manager, handler);\n\n    this.primaryTouch = null;\n    this.lastTouches = [];\n}\n\ninherit(TouchMouseInput, Input, {\n    /**\n     * handle mouse and touch events\n     * @param {Hammer} manager\n     * @param {String} inputEvent\n     * @param {Object} inputData\n     */\n    handler: function TMEhandler(manager, inputEvent, inputData) {\n        var isTouch = (inputData.pointerType == INPUT_TYPE_TOUCH),\n            isMouse = (inputData.pointerType == INPUT_TYPE_MOUSE);\n\n        if (isMouse && inputData.sourceCapabilities && inputData.sourceCapabilities.firesTouchEvents) {\n            return;\n        }\n\n        // when we're in a touch event, record touches to  de-dupe synthetic mouse event\n        if (isTouch) {\n            recordTouches.call(this, inputEvent, inputData);\n        } else if (isMouse && isSyntheticEvent.call(this, inputData)) {\n            return;\n        }\n\n        this.callback(manager, inputEvent, inputData);\n    },\n\n    /**\n     * remove the event listeners\n     */\n    destroy: function destroy() {\n        this.touch.destroy();\n        this.mouse.destroy();\n    }\n});\n\nfunction recordTouches(eventType, eventData) {\n    if (eventType & INPUT_START) {\n        this.primaryTouch = eventData.changedPointers[0].identifier;\n        setLastTouch.call(this, eventData);\n    } else if (eventType & (INPUT_END | INPUT_CANCEL)) {\n        setLastTouch.call(this, eventData);\n    }\n}\n\nfunction setLastTouch(eventData) {\n    var touch = eventData.changedPointers[0];\n\n    if (touch.identifier === this.primaryTouch) {\n        var lastTouch = {x: touch.clientX, y: touch.clientY};\n        this.lastTouches.push(lastTouch);\n        var lts = this.lastTouches;\n        var removeLastTouch = function() {\n            var i = lts.indexOf(lastTouch);\n            if (i > -1) {\n                lts.splice(i, 1);\n            }\n        };\n        setTimeout(removeLastTouch, DEDUP_TIMEOUT);\n    }\n}\n\nfunction isSyntheticEvent(eventData) {\n    var x = eventData.srcEvent.clientX, y = eventData.srcEvent.clientY;\n    for (var i = 0; i < this.lastTouches.length; i++) {\n        var t = this.lastTouches[i];\n        var dx = Math.abs(x - t.x), dy = Math.abs(y - t.y);\n        if (dx <= DEDUP_DISTANCE && dy <= DEDUP_DISTANCE) {\n            return true;\n        }\n    }\n    return false;\n}\n\nvar PREFIXED_TOUCH_ACTION = prefixed(TEST_ELEMENT.style, 'touchAction');\nvar NATIVE_TOUCH_ACTION = PREFIXED_TOUCH_ACTION !== undefined;\n\n// magical touchAction value\nvar TOUCH_ACTION_COMPUTE = 'compute';\nvar TOUCH_ACTION_AUTO = 'auto';\nvar TOUCH_ACTION_MANIPULATION = 'manipulation'; // not implemented\nvar TOUCH_ACTION_NONE = 'none';\nvar TOUCH_ACTION_PAN_X = 'pan-x';\nvar TOUCH_ACTION_PAN_Y = 'pan-y';\nvar TOUCH_ACTION_MAP = getTouchActionProps();\n\n/**\n * Touch Action\n * sets the touchAction property or uses the js alternative\n * @param {Manager} manager\n * @param {String} value\n * @constructor\n */\nfunction TouchAction(manager, value) {\n    this.manager = manager;\n    this.set(value);\n}\n\nTouchAction.prototype = {\n    /**\n     * set the touchAction value on the element or enable the polyfill\n     * @param {String} value\n     */\n    set: function(value) {\n        // find out the touch-action by the event handlers\n        if (value == TOUCH_ACTION_COMPUTE) {\n            value = this.compute();\n        }\n\n        if (NATIVE_TOUCH_ACTION && this.manager.element.style && TOUCH_ACTION_MAP[value]) {\n            this.manager.element.style[PREFIXED_TOUCH_ACTION] = value;\n        }\n        this.actions = value.toLowerCase().trim();\n    },\n\n    /**\n     * just re-set the touchAction value\n     */\n    update: function() {\n        this.set(this.manager.options.touchAction);\n    },\n\n    /**\n     * compute the value for the touchAction property based on the recognizer's settings\n     * @returns {String} value\n     */\n    compute: function() {\n        var actions = [];\n        each(this.manager.recognizers, function(recognizer) {\n            if (boolOrFn(recognizer.options.enable, [recognizer])) {\n                actions = actions.concat(recognizer.getTouchAction());\n            }\n        });\n        return cleanTouchActions(actions.join(' '));\n    },\n\n    /**\n     * this method is called on each input cycle and provides the preventing of the browser behavior\n     * @param {Object} input\n     */\n    preventDefaults: function(input) {\n        var srcEvent = input.srcEvent;\n        var direction = input.offsetDirection;\n\n        // if the touch action did prevented once this session\n        if (this.manager.session.prevented) {\n            srcEvent.preventDefault();\n            return;\n        }\n\n        var actions = this.actions;\n        var hasNone = inStr(actions, TOUCH_ACTION_NONE) && !TOUCH_ACTION_MAP[TOUCH_ACTION_NONE];\n        var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y) && !TOUCH_ACTION_MAP[TOUCH_ACTION_PAN_Y];\n        var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X) && !TOUCH_ACTION_MAP[TOUCH_ACTION_PAN_X];\n\n        if (hasNone) {\n            //do not prevent defaults if this is a tap gesture\n\n            var isTapPointer = input.pointers.length === 1;\n            var isTapMovement = input.distance < 2;\n            var isTapTouchTime = input.deltaTime < 250;\n\n            if (isTapPointer && isTapMovement && isTapTouchTime) {\n                return;\n            }\n        }\n\n        if (hasPanX && hasPanY) {\n            // `pan-x pan-y` means browser handles all scrolling/panning, do not prevent\n            return;\n        }\n\n        if (hasNone ||\n            (hasPanY && direction & DIRECTION_HORIZONTAL) ||\n            (hasPanX && direction & DIRECTION_VERTICAL)) {\n            return this.preventSrc(srcEvent);\n        }\n    },\n\n    /**\n     * call preventDefault to prevent the browser's default behavior (scrolling in most cases)\n     * @param {Object} srcEvent\n     */\n    preventSrc: function(srcEvent) {\n        this.manager.session.prevented = true;\n        srcEvent.preventDefault();\n    }\n};\n\n/**\n * when the touchActions are collected they are not a valid value, so we need to clean things up. *\n * @param {String} actions\n * @returns {*}\n */\nfunction cleanTouchActions(actions) {\n    // none\n    if (inStr(actions, TOUCH_ACTION_NONE)) {\n        return TOUCH_ACTION_NONE;\n    }\n\n    var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X);\n    var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y);\n\n    // if both pan-x and pan-y are set (different recognizers\n    // for different directions, e.g. horizontal pan but vertical swipe?)\n    // we need none (as otherwise with pan-x pan-y combined none of these\n    // recognizers will work, since the browser would handle all panning\n    if (hasPanX && hasPanY) {\n        return TOUCH_ACTION_NONE;\n    }\n\n    // pan-x OR pan-y\n    if (hasPanX || hasPanY) {\n        return hasPanX ? TOUCH_ACTION_PAN_X : TOUCH_ACTION_PAN_Y;\n    }\n\n    // manipulation\n    if (inStr(actions, TOUCH_ACTION_MANIPULATION)) {\n        return TOUCH_ACTION_MANIPULATION;\n    }\n\n    return TOUCH_ACTION_AUTO;\n}\n\nfunction getTouchActionProps() {\n    if (!NATIVE_TOUCH_ACTION) {\n        return false;\n    }\n    var touchMap = {};\n    var cssSupports = window.CSS && window.CSS.supports;\n    ['auto', 'manipulation', 'pan-y', 'pan-x', 'pan-x pan-y', 'none'].forEach(function(val) {\n\n        // If css.supports is not supported but there is native touch-action assume it supports\n        // all values. This is the case for IE 10 and 11.\n        touchMap[val] = cssSupports ? window.CSS.supports('touch-action', val) : true;\n    });\n    return touchMap;\n}\n\n/**\n * Recognizer flow explained; *\n * All recognizers have the initial state of POSSIBLE when a input session starts.\n * The definition of a input session is from the first input until the last input, with all it's movement in it. *\n * Example session for mouse-input: mousedown -> mousemove -> mouseup\n *\n * On each recognizing cycle (see Manager.recognize) the .recognize() method is executed\n * which determines with state it should be.\n *\n * If the recognizer has the state FAILED, CANCELLED or RECOGNIZED (equals ENDED), it is reset to\n * POSSIBLE to give it another change on the next cycle.\n *\n *               Possible\n *                  |\n *            +-----+---------------+\n *            |                     |\n *      +-----+-----+               |\n *      |           |               |\n *   Failed      Cancelled          |\n *                          +-------+------+\n *                          |              |\n *                      Recognized       Began\n *                                         |\n *                                      Changed\n *                                         |\n *                                  Ended/Recognized\n */\nvar STATE_POSSIBLE = 1;\nvar STATE_BEGAN = 2;\nvar STATE_CHANGED = 4;\nvar STATE_ENDED = 8;\nvar STATE_RECOGNIZED = STATE_ENDED;\nvar STATE_CANCELLED = 16;\nvar STATE_FAILED = 32;\n\n/**\n * Recognizer\n * Every recognizer needs to extend from this class.\n * @constructor\n * @param {Object} options\n */\nfunction Recognizer(options) {\n    this.options = assign({}, this.defaults, options || {});\n\n    this.id = uniqueId();\n\n    this.manager = null;\n\n    // default is enable true\n    this.options.enable = ifUndefined(this.options.enable, true);\n\n    this.state = STATE_POSSIBLE;\n\n    this.simultaneous = {};\n    this.requireFail = [];\n}\n\nRecognizer.prototype = {\n    /**\n     * @virtual\n     * @type {Object}\n     */\n    defaults: {},\n\n    /**\n     * set options\n     * @param {Object} options\n     * @return {Recognizer}\n     */\n    set: function(options) {\n        assign(this.options, options);\n\n        // also update the touchAction, in case something changed about the directions/enabled state\n        this.manager && this.manager.touchAction.update();\n        return this;\n    },\n\n    /**\n     * recognize simultaneous with an other recognizer.\n     * @param {Recognizer} otherRecognizer\n     * @returns {Recognizer} this\n     */\n    recognizeWith: function(otherRecognizer) {\n        if (invokeArrayArg(otherRecognizer, 'recognizeWith', this)) {\n            return this;\n        }\n\n        var simultaneous = this.simultaneous;\n        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);\n        if (!simultaneous[otherRecognizer.id]) {\n            simultaneous[otherRecognizer.id] = otherRecognizer;\n            otherRecognizer.recognizeWith(this);\n        }\n        return this;\n    },\n\n    /**\n     * drop the simultaneous link. it doesnt remove the link on the other recognizer.\n     * @param {Recognizer} otherRecognizer\n     * @returns {Recognizer} this\n     */\n    dropRecognizeWith: function(otherRecognizer) {\n        if (invokeArrayArg(otherRecognizer, 'dropRecognizeWith', this)) {\n            return this;\n        }\n\n        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);\n        delete this.simultaneous[otherRecognizer.id];\n        return this;\n    },\n\n    /**\n     * recognizer can only run when an other is failing\n     * @param {Recognizer} otherRecognizer\n     * @returns {Recognizer} this\n     */\n    requireFailure: function(otherRecognizer) {\n        if (invokeArrayArg(otherRecognizer, 'requireFailure', this)) {\n            return this;\n        }\n\n        var requireFail = this.requireFail;\n        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);\n        if (inArray(requireFail, otherRecognizer) === -1) {\n            requireFail.push(otherRecognizer);\n            otherRecognizer.requireFailure(this);\n        }\n        return this;\n    },\n\n    /**\n     * drop the requireFailure link. it does not remove the link on the other recognizer.\n     * @param {Recognizer} otherRecognizer\n     * @returns {Recognizer} this\n     */\n    dropRequireFailure: function(otherRecognizer) {\n        if (invokeArrayArg(otherRecognizer, 'dropRequireFailure', this)) {\n            return this;\n        }\n\n        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);\n        var index = inArray(this.requireFail, otherRecognizer);\n        if (index > -1) {\n            this.requireFail.splice(index, 1);\n        }\n        return this;\n    },\n\n    /**\n     * has require failures boolean\n     * @returns {boolean}\n     */\n    hasRequireFailures: function() {\n        return this.requireFail.length > 0;\n    },\n\n    /**\n     * if the recognizer can recognize simultaneous with an other recognizer\n     * @param {Recognizer} otherRecognizer\n     * @returns {Boolean}\n     */\n    canRecognizeWith: function(otherRecognizer) {\n        return !!this.simultaneous[otherRecognizer.id];\n    },\n\n    /**\n     * You should use `tryEmit` instead of `emit` directly to check\n     * that all the needed recognizers has failed before emitting.\n     * @param {Object} input\n     */\n    emit: function(input) {\n        var self = this;\n        var state = this.state;\n\n        function emit(event) {\n            self.manager.emit(event, input);\n        }\n\n        // 'panstart' and 'panmove'\n        if (state < STATE_ENDED) {\n            emit(self.options.event + stateStr(state));\n        }\n\n        emit(self.options.event); // simple 'eventName' events\n\n        if (input.additionalEvent) { // additional event(panleft, panright, pinchin, pinchout...)\n            emit(input.additionalEvent);\n        }\n\n        // panend and pancancel\n        if (state >= STATE_ENDED) {\n            emit(self.options.event + stateStr(state));\n        }\n    },\n\n    /**\n     * Check that all the require failure recognizers has failed,\n     * if true, it emits a gesture event,\n     * otherwise, setup the state to FAILED.\n     * @param {Object} input\n     */\n    tryEmit: function(input) {\n        if (this.canEmit()) {\n            return this.emit(input);\n        }\n        // it's failing anyway\n        this.state = STATE_FAILED;\n    },\n\n    /**\n     * can we emit?\n     * @returns {boolean}\n     */\n    canEmit: function() {\n        var i = 0;\n        while (i < this.requireFail.length) {\n            if (!(this.requireFail[i].state & (STATE_FAILED | STATE_POSSIBLE))) {\n                return false;\n            }\n            i++;\n        }\n        return true;\n    },\n\n    /**\n     * update the recognizer\n     * @param {Object} inputData\n     */\n    recognize: function(inputData) {\n        // make a new copy of the inputData\n        // so we can change the inputData without messing up the other recognizers\n        var inputDataClone = assign({}, inputData);\n\n        // is is enabled and allow recognizing?\n        if (!boolOrFn(this.options.enable, [this, inputDataClone])) {\n            this.reset();\n            this.state = STATE_FAILED;\n            return;\n        }\n\n        // reset when we've reached the end\n        if (this.state & (STATE_RECOGNIZED | STATE_CANCELLED | STATE_FAILED)) {\n            this.state = STATE_POSSIBLE;\n        }\n\n        this.state = this.process(inputDataClone);\n\n        // the recognizer has recognized a gesture\n        // so trigger an event\n        if (this.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED | STATE_CANCELLED)) {\n            this.tryEmit(inputDataClone);\n        }\n    },\n\n    /**\n     * return the state of the recognizer\n     * the actual recognizing happens in this method\n     * @virtual\n     * @param {Object} inputData\n     * @returns {Const} STATE\n     */\n    process: function(inputData) { }, // jshint ignore:line\n\n    /**\n     * return the preferred touch-action\n     * @virtual\n     * @returns {Array}\n     */\n    getTouchAction: function() { },\n\n    /**\n     * called when the gesture isn't allowed to recognize\n     * like when another is being recognized or it is disabled\n     * @virtual\n     */\n    reset: function() { }\n};\n\n/**\n * get a usable string, used as event postfix\n * @param {Const} state\n * @returns {String} state\n */\nfunction stateStr(state) {\n    if (state & STATE_CANCELLED) {\n        return 'cancel';\n    } else if (state & STATE_ENDED) {\n        return 'end';\n    } else if (state & STATE_CHANGED) {\n        return 'move';\n    } else if (state & STATE_BEGAN) {\n        return 'start';\n    }\n    return '';\n}\n\n/**\n * direction cons to string\n * @param {Const} direction\n * @returns {String}\n */\nfunction directionStr(direction) {\n    if (direction == DIRECTION_DOWN) {\n        return 'down';\n    } else if (direction == DIRECTION_UP) {\n        return 'up';\n    } else if (direction == DIRECTION_LEFT) {\n        return 'left';\n    } else if (direction == DIRECTION_RIGHT) {\n        return 'right';\n    }\n    return '';\n}\n\n/**\n * get a recognizer by name if it is bound to a manager\n * @param {Recognizer|String} otherRecognizer\n * @param {Recognizer} recognizer\n * @returns {Recognizer}\n */\nfunction getRecognizerByNameIfManager(otherRecognizer, recognizer) {\n    var manager = recognizer.manager;\n    if (manager) {\n        return manager.get(otherRecognizer);\n    }\n    return otherRecognizer;\n}\n\n/**\n * This recognizer is just used as a base for the simple attribute recognizers.\n * @constructor\n * @extends Recognizer\n */\nfunction AttrRecognizer() {\n    Recognizer.apply(this, arguments);\n}\n\ninherit(AttrRecognizer, Recognizer, {\n    /**\n     * @namespace\n     * @memberof AttrRecognizer\n     */\n    defaults: {\n        /**\n         * @type {Number}\n         * @default 1\n         */\n        pointers: 1\n    },\n\n    /**\n     * Used to check if it the recognizer receives valid input, like input.distance > 10.\n     * @memberof AttrRecognizer\n     * @param {Object} input\n     * @returns {Boolean} recognized\n     */\n    attrTest: function(input) {\n        var optionPointers = this.options.pointers;\n        return optionPointers === 0 || input.pointers.length === optionPointers;\n    },\n\n    /**\n     * Process the input and return the state for the recognizer\n     * @memberof AttrRecognizer\n     * @param {Object} input\n     * @returns {*} State\n     */\n    process: function(input) {\n        var state = this.state;\n        var eventType = input.eventType;\n\n        var isRecognized = state & (STATE_BEGAN | STATE_CHANGED);\n        var isValid = this.attrTest(input);\n\n        // on cancel input and we've recognized before, return STATE_CANCELLED\n        if (isRecognized && (eventType & INPUT_CANCEL || !isValid)) {\n            return state | STATE_CANCELLED;\n        } else if (isRecognized || isValid) {\n            if (eventType & INPUT_END) {\n                return state | STATE_ENDED;\n            } else if (!(state & STATE_BEGAN)) {\n                return STATE_BEGAN;\n            }\n            return state | STATE_CHANGED;\n        }\n        return STATE_FAILED;\n    }\n});\n\n/**\n * Pan\n * Recognized when the pointer is down and moved in the allowed direction.\n * @constructor\n * @extends AttrRecognizer\n */\nfunction PanRecognizer() {\n    AttrRecognizer.apply(this, arguments);\n\n    this.pX = null;\n    this.pY = null;\n}\n\ninherit(PanRecognizer, AttrRecognizer, {\n    /**\n     * @namespace\n     * @memberof PanRecognizer\n     */\n    defaults: {\n        event: 'pan',\n        threshold: 10,\n        pointers: 1,\n        direction: DIRECTION_ALL\n    },\n\n    getTouchAction: function() {\n        var direction = this.options.direction;\n        var actions = [];\n        if (direction & DIRECTION_HORIZONTAL) {\n            actions.push(TOUCH_ACTION_PAN_Y);\n        }\n        if (direction & DIRECTION_VERTICAL) {\n            actions.push(TOUCH_ACTION_PAN_X);\n        }\n        return actions;\n    },\n\n    directionTest: function(input) {\n        var options = this.options;\n        var hasMoved = true;\n        var distance = input.distance;\n        var direction = input.direction;\n        var x = input.deltaX;\n        var y = input.deltaY;\n\n        // lock to axis?\n        if (!(direction & options.direction)) {\n            if (options.direction & DIRECTION_HORIZONTAL) {\n                direction = (x === 0) ? DIRECTION_NONE : (x < 0) ? DIRECTION_LEFT : DIRECTION_RIGHT;\n                hasMoved = x != this.pX;\n                distance = Math.abs(input.deltaX);\n            } else {\n                direction = (y === 0) ? DIRECTION_NONE : (y < 0) ? DIRECTION_UP : DIRECTION_DOWN;\n                hasMoved = y != this.pY;\n                distance = Math.abs(input.deltaY);\n            }\n        }\n        input.direction = direction;\n        return hasMoved && distance > options.threshold && direction & options.direction;\n    },\n\n    attrTest: function(input) {\n        return AttrRecognizer.prototype.attrTest.call(this, input) &&\n            (this.state & STATE_BEGAN || (!(this.state & STATE_BEGAN) && this.directionTest(input)));\n    },\n\n    emit: function(input) {\n\n        this.pX = input.deltaX;\n        this.pY = input.deltaY;\n\n        var direction = directionStr(input.direction);\n\n        if (direction) {\n            input.additionalEvent = this.options.event + direction;\n        }\n        this._super.emit.call(this, input);\n    }\n});\n\n/**\n * Pinch\n * Recognized when two or more pointers are moving toward (zoom-in) or away from each other (zoom-out).\n * @constructor\n * @extends AttrRecognizer\n */\nfunction PinchRecognizer() {\n    AttrRecognizer.apply(this, arguments);\n}\n\ninherit(PinchRecognizer, AttrRecognizer, {\n    /**\n     * @namespace\n     * @memberof PinchRecognizer\n     */\n    defaults: {\n        event: 'pinch',\n        threshold: 0,\n        pointers: 2\n    },\n\n    getTouchAction: function() {\n        return [TOUCH_ACTION_NONE];\n    },\n\n    attrTest: function(input) {\n        return this._super.attrTest.call(this, input) &&\n            (Math.abs(input.scale - 1) > this.options.threshold || this.state & STATE_BEGAN);\n    },\n\n    emit: function(input) {\n        if (input.scale !== 1) {\n            var inOut = input.scale < 1 ? 'in' : 'out';\n            input.additionalEvent = this.options.event + inOut;\n        }\n        this._super.emit.call(this, input);\n    }\n});\n\n/**\n * Press\n * Recognized when the pointer is down for x ms without any movement.\n * @constructor\n * @extends Recognizer\n */\nfunction PressRecognizer() {\n    Recognizer.apply(this, arguments);\n\n    this._timer = null;\n    this._input = null;\n}\n\ninherit(PressRecognizer, Recognizer, {\n    /**\n     * @namespace\n     * @memberof PressRecognizer\n     */\n    defaults: {\n        event: 'press',\n        pointers: 1,\n        time: 251, // minimal time of the pointer to be pressed\n        threshold: 9 // a minimal movement is ok, but keep it low\n    },\n\n    getTouchAction: function() {\n        return [TOUCH_ACTION_AUTO];\n    },\n\n    process: function(input) {\n        var options = this.options;\n        var validPointers = input.pointers.length === options.pointers;\n        var validMovement = input.distance < options.threshold;\n        var validTime = input.deltaTime > options.time;\n\n        this._input = input;\n\n        // we only allow little movement\n        // and we've reached an end event, so a tap is possible\n        if (!validMovement || !validPointers || (input.eventType & (INPUT_END | INPUT_CANCEL) && !validTime)) {\n            this.reset();\n        } else if (input.eventType & INPUT_START) {\n            this.reset();\n            this._timer = setTimeoutContext(function() {\n                this.state = STATE_RECOGNIZED;\n                this.tryEmit();\n            }, options.time, this);\n        } else if (input.eventType & INPUT_END) {\n            return STATE_RECOGNIZED;\n        }\n        return STATE_FAILED;\n    },\n\n    reset: function() {\n        clearTimeout(this._timer);\n    },\n\n    emit: function(input) {\n        if (this.state !== STATE_RECOGNIZED) {\n            return;\n        }\n\n        if (input && (input.eventType & INPUT_END)) {\n            this.manager.emit(this.options.event + 'up', input);\n        } else {\n            this._input.timeStamp = now();\n            this.manager.emit(this.options.event, this._input);\n        }\n    }\n});\n\n/**\n * Rotate\n * Recognized when two or more pointer are moving in a circular motion.\n * @constructor\n * @extends AttrRecognizer\n */\nfunction RotateRecognizer() {\n    AttrRecognizer.apply(this, arguments);\n}\n\ninherit(RotateRecognizer, AttrRecognizer, {\n    /**\n     * @namespace\n     * @memberof RotateRecognizer\n     */\n    defaults: {\n        event: 'rotate',\n        threshold: 0,\n        pointers: 2\n    },\n\n    getTouchAction: function() {\n        return [TOUCH_ACTION_NONE];\n    },\n\n    attrTest: function(input) {\n        return this._super.attrTest.call(this, input) &&\n            (Math.abs(input.rotation) > this.options.threshold || this.state & STATE_BEGAN);\n    }\n});\n\n/**\n * Swipe\n * Recognized when the pointer is moving fast (velocity), with enough distance in the allowed direction.\n * @constructor\n * @extends AttrRecognizer\n */\nfunction SwipeRecognizer() {\n    AttrRecognizer.apply(this, arguments);\n}\n\ninherit(SwipeRecognizer, AttrRecognizer, {\n    /**\n     * @namespace\n     * @memberof SwipeRecognizer\n     */\n    defaults: {\n        event: 'swipe',\n        threshold: 10,\n        velocity: 0.3,\n        direction: DIRECTION_HORIZONTAL | DIRECTION_VERTICAL,\n        pointers: 1\n    },\n\n    getTouchAction: function() {\n        return PanRecognizer.prototype.getTouchAction.call(this);\n    },\n\n    attrTest: function(input) {\n        var direction = this.options.direction;\n        var velocity;\n\n        if (direction & (DIRECTION_HORIZONTAL | DIRECTION_VERTICAL)) {\n            velocity = input.overallVelocity;\n        } else if (direction & DIRECTION_HORIZONTAL) {\n            velocity = input.overallVelocityX;\n        } else if (direction & DIRECTION_VERTICAL) {\n            velocity = input.overallVelocityY;\n        }\n\n        return this._super.attrTest.call(this, input) &&\n            direction & input.offsetDirection &&\n            input.distance > this.options.threshold &&\n            input.maxPointers == this.options.pointers &&\n            abs(velocity) > this.options.velocity && input.eventType & INPUT_END;\n    },\n\n    emit: function(input) {\n        var direction = directionStr(input.offsetDirection);\n        if (direction) {\n            this.manager.emit(this.options.event + direction, input);\n        }\n\n        this.manager.emit(this.options.event, input);\n    }\n});\n\n/**\n * A tap is ecognized when the pointer is doing a small tap/click. Multiple taps are recognized if they occur\n * between the given interval and position. The delay option can be used to recognize multi-taps without firing\n * a single tap.\n *\n * The eventData from the emitted event contains the property `tapCount`, which contains the amount of\n * multi-taps being recognized.\n * @constructor\n * @extends Recognizer\n */\nfunction TapRecognizer() {\n    Recognizer.apply(this, arguments);\n\n    // previous time and center,\n    // used for tap counting\n    this.pTime = false;\n    this.pCenter = false;\n\n    this._timer = null;\n    this._input = null;\n    this.count = 0;\n}\n\ninherit(TapRecognizer, Recognizer, {\n    /**\n     * @namespace\n     * @memberof PinchRecognizer\n     */\n    defaults: {\n        event: 'tap',\n        pointers: 1,\n        taps: 1,\n        interval: 300, // max time between the multi-tap taps\n        time: 250, // max time of the pointer to be down (like finger on the screen)\n        threshold: 9, // a minimal movement is ok, but keep it low\n        posThreshold: 10 // a multi-tap can be a bit off the initial position\n    },\n\n    getTouchAction: function() {\n        return [TOUCH_ACTION_MANIPULATION];\n    },\n\n    process: function(input) {\n        var options = this.options;\n\n        var validPointers = input.pointers.length === options.pointers;\n        var validMovement = input.distance < options.threshold;\n        var validTouchTime = input.deltaTime < options.time;\n\n        this.reset();\n\n        if ((input.eventType & INPUT_START) && (this.count === 0)) {\n            return this.failTimeout();\n        }\n\n        // we only allow little movement\n        // and we've reached an end event, so a tap is possible\n        if (validMovement && validTouchTime && validPointers) {\n            if (input.eventType != INPUT_END) {\n                return this.failTimeout();\n            }\n\n            var validInterval = this.pTime ? (input.timeStamp - this.pTime < options.interval) : true;\n            var validMultiTap = !this.pCenter || getDistance(this.pCenter, input.center) < options.posThreshold;\n\n            this.pTime = input.timeStamp;\n            this.pCenter = input.center;\n\n            if (!validMultiTap || !validInterval) {\n                this.count = 1;\n            } else {\n                this.count += 1;\n            }\n\n            this._input = input;\n\n            // if tap count matches we have recognized it,\n            // else it has began recognizing...\n            var tapCount = this.count % options.taps;\n            if (tapCount === 0) {\n                // no failing requirements, immediately trigger the tap event\n                // or wait as long as the multitap interval to trigger\n                if (!this.hasRequireFailures()) {\n                    return STATE_RECOGNIZED;\n                } else {\n                    this._timer = setTimeoutContext(function() {\n                        this.state = STATE_RECOGNIZED;\n                        this.tryEmit();\n                    }, options.interval, this);\n                    return STATE_BEGAN;\n                }\n            }\n        }\n        return STATE_FAILED;\n    },\n\n    failTimeout: function() {\n        this._timer = setTimeoutContext(function() {\n            this.state = STATE_FAILED;\n        }, this.options.interval, this);\n        return STATE_FAILED;\n    },\n\n    reset: function() {\n        clearTimeout(this._timer);\n    },\n\n    emit: function() {\n        if (this.state == STATE_RECOGNIZED) {\n            this._input.tapCount = this.count;\n            this.manager.emit(this.options.event, this._input);\n        }\n    }\n});\n\n/**\n * Simple way to create a manager with a default set of recognizers.\n * @param {HTMLElement} element\n * @param {Object} [options]\n * @constructor\n */\nfunction Hammer(element, options) {\n    options = options || {};\n    options.recognizers = ifUndefined(options.recognizers, Hammer.defaults.preset);\n    return new Manager(element, options);\n}\n\n/**\n * @const {string}\n */\nHammer.VERSION = '2.0.7';\n\n/**\n * default settings\n * @namespace\n */\nHammer.defaults = {\n    /**\n     * set if DOM events are being triggered.\n     * But this is slower and unused by simple implementations, so disabled by default.\n     * @type {Boolean}\n     * @default false\n     */\n    domEvents: false,\n\n    /**\n     * The value for the touchAction property/fallback.\n     * When set to `compute` it will magically set the correct value based on the added recognizers.\n     * @type {String}\n     * @default compute\n     */\n    touchAction: TOUCH_ACTION_COMPUTE,\n\n    /**\n     * @type {Boolean}\n     * @default true\n     */\n    enable: true,\n\n    /**\n     * EXPERIMENTAL FEATURE -- can be removed/changed\n     * Change the parent input target element.\n     * If Null, then it is being set the to main element.\n     * @type {Null|EventTarget}\n     * @default null\n     */\n    inputTarget: null,\n\n    /**\n     * force an input class\n     * @type {Null|Function}\n     * @default null\n     */\n    inputClass: null,\n\n    /**\n     * Default recognizer setup when calling `Hammer()`\n     * When creating a new Manager these will be skipped.\n     * @type {Array}\n     */\n    preset: [\n        // RecognizerClass, options, [recognizeWith, ...], [requireFailure, ...]\n        [RotateRecognizer, {enable: false}],\n        [PinchRecognizer, {enable: false}, ['rotate']],\n        [SwipeRecognizer, {direction: DIRECTION_HORIZONTAL}],\n        [PanRecognizer, {direction: DIRECTION_HORIZONTAL}, ['swipe']],\n        [TapRecognizer],\n        [TapRecognizer, {event: 'doubletap', taps: 2}, ['tap']],\n        [PressRecognizer]\n    ],\n\n    /**\n     * Some CSS properties can be used to improve the working of Hammer.\n     * Add them to this method and they will be set when creating a new Manager.\n     * @namespace\n     */\n    cssProps: {\n        /**\n         * Disables text selection to improve the dragging gesture. Mainly for desktop browsers.\n         * @type {String}\n         * @default 'none'\n         */\n        userSelect: 'none',\n\n        /**\n         * Disable the Windows Phone grippers when pressing an element.\n         * @type {String}\n         * @default 'none'\n         */\n        touchSelect: 'none',\n\n        /**\n         * Disables the default callout shown when you touch and hold a touch target.\n         * On iOS, when you touch and hold a touch target such as a link, Safari displays\n         * a callout containing information about the link. This property allows you to disable that callout.\n         * @type {String}\n         * @default 'none'\n         */\n        touchCallout: 'none',\n\n        /**\n         * Specifies whether zooming is enabled. Used by IE10>\n         * @type {String}\n         * @default 'none'\n         */\n        contentZooming: 'none',\n\n        /**\n         * Specifies that an entire element should be draggable instead of its contents. Mainly for desktop browsers.\n         * @type {String}\n         * @default 'none'\n         */\n        userDrag: 'none',\n\n        /**\n         * Overrides the highlight color shown when the user taps a link or a JavaScript\n         * clickable element in iOS. This property obeys the alpha value, if specified.\n         * @type {String}\n         * @default 'rgba(0,0,0,0)'\n         */\n        tapHighlightColor: 'rgba(0,0,0,0)'\n    }\n};\n\nvar STOP = 1;\nvar FORCED_STOP = 2;\n\n/**\n * Manager\n * @param {HTMLElement} element\n * @param {Object} [options]\n * @constructor\n */\nfunction Manager(element, options) {\n    this.options = assign({}, Hammer.defaults, options || {});\n\n    this.options.inputTarget = this.options.inputTarget || element;\n\n    this.handlers = {};\n    this.session = {};\n    this.recognizers = [];\n    this.oldCssProps = {};\n\n    this.element = element;\n    this.input = createInputInstance(this);\n    this.touchAction = new TouchAction(this, this.options.touchAction);\n\n    toggleCssProps(this, true);\n\n    each(this.options.recognizers, function(item) {\n        var recognizer = this.add(new (item[0])(item[1]));\n        item[2] && recognizer.recognizeWith(item[2]);\n        item[3] && recognizer.requireFailure(item[3]);\n    }, this);\n}\n\nManager.prototype = {\n    /**\n     * set options\n     * @param {Object} options\n     * @returns {Manager}\n     */\n    set: function(options) {\n        assign(this.options, options);\n\n        // Options that need a little more setup\n        if (options.touchAction) {\n            this.touchAction.update();\n        }\n        if (options.inputTarget) {\n            // Clean up existing event listeners and reinitialize\n            this.input.destroy();\n            this.input.target = options.inputTarget;\n            this.input.init();\n        }\n        return this;\n    },\n\n    /**\n     * stop recognizing for this session.\n     * This session will be discarded, when a new [input]start event is fired.\n     * When forced, the recognizer cycle is stopped immediately.\n     * @param {Boolean} [force]\n     */\n    stop: function(force) {\n        this.session.stopped = force ? FORCED_STOP : STOP;\n    },\n\n    /**\n     * run the recognizers!\n     * called by the inputHandler function on every movement of the pointers (touches)\n     * it walks through all the recognizers and tries to detect the gesture that is being made\n     * @param {Object} inputData\n     */\n    recognize: function(inputData) {\n        var session = this.session;\n        if (session.stopped) {\n            return;\n        }\n\n        // run the touch-action polyfill\n        this.touchAction.preventDefaults(inputData);\n\n        var recognizer;\n        var recognizers = this.recognizers;\n\n        // this holds the recognizer that is being recognized.\n        // so the recognizer's state needs to be BEGAN, CHANGED, ENDED or RECOGNIZED\n        // if no recognizer is detecting a thing, it is set to `null`\n        var curRecognizer = session.curRecognizer;\n\n        // reset when the last recognizer is recognized\n        // or when we're in a new session\n        if (!curRecognizer || (curRecognizer && curRecognizer.state & STATE_RECOGNIZED)) {\n            curRecognizer = session.curRecognizer = null;\n        }\n\n        var i = 0;\n        while (i < recognizers.length) {\n            recognizer = recognizers[i];\n\n            // find out if we are allowed try to recognize the input for this one.\n            // 1.   allow if the session is NOT forced stopped (see the .stop() method)\n            // 2.   allow if we still haven't recognized a gesture in this session, or the this recognizer is the one\n            //      that is being recognized.\n            // 3.   allow if the recognizer is allowed to run simultaneous with the current recognized recognizer.\n            //      this can be setup with the `recognizeWith()` method on the recognizer.\n            if (session.stopped !== FORCED_STOP && ( // 1\n                    !curRecognizer || recognizer == curRecognizer || // 2\n                    recognizer.canRecognizeWith(curRecognizer))) { // 3\n                recognizer.recognize(inputData);\n            } else {\n                recognizer.reset();\n            }\n\n            // if the recognizer has been recognizing the input as a valid gesture, we want to store this one as the\n            // current active recognizer. but only if we don't already have an active recognizer\n            if (!curRecognizer && recognizer.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED)) {\n                curRecognizer = session.curRecognizer = recognizer;\n            }\n            i++;\n        }\n    },\n\n    /**\n     * get a recognizer by its event name.\n     * @param {Recognizer|String} recognizer\n     * @returns {Recognizer|Null}\n     */\n    get: function(recognizer) {\n        if (recognizer instanceof Recognizer) {\n            return recognizer;\n        }\n\n        var recognizers = this.recognizers;\n        for (var i = 0; i < recognizers.length; i++) {\n            if (recognizers[i].options.event == recognizer) {\n                return recognizers[i];\n            }\n        }\n        return null;\n    },\n\n    /**\n     * add a recognizer to the manager\n     * existing recognizers with the same event name will be removed\n     * @param {Recognizer} recognizer\n     * @returns {Recognizer|Manager}\n     */\n    add: function(recognizer) {\n        if (invokeArrayArg(recognizer, 'add', this)) {\n            return this;\n        }\n\n        // remove existing\n        var existing = this.get(recognizer.options.event);\n        if (existing) {\n            this.remove(existing);\n        }\n\n        this.recognizers.push(recognizer);\n        recognizer.manager = this;\n\n        this.touchAction.update();\n        return recognizer;\n    },\n\n    /**\n     * remove a recognizer by name or instance\n     * @param {Recognizer|String} recognizer\n     * @returns {Manager}\n     */\n    remove: function(recognizer) {\n        if (invokeArrayArg(recognizer, 'remove', this)) {\n            return this;\n        }\n\n        recognizer = this.get(recognizer);\n\n        // let's make sure this recognizer exists\n        if (recognizer) {\n            var recognizers = this.recognizers;\n            var index = inArray(recognizers, recognizer);\n\n            if (index !== -1) {\n                recognizers.splice(index, 1);\n                this.touchAction.update();\n            }\n        }\n\n        return this;\n    },\n\n    /**\n     * bind event\n     * @param {String} events\n     * @param {Function} handler\n     * @returns {EventEmitter} this\n     */\n    on: function(events, handler) {\n        if (events === undefined) {\n            return;\n        }\n        if (handler === undefined) {\n            return;\n        }\n\n        var handlers = this.handlers;\n        each(splitStr(events), function(event) {\n            handlers[event] = handlers[event] || [];\n            handlers[event].push(handler);\n        });\n        return this;\n    },\n\n    /**\n     * unbind event, leave emit blank to remove all handlers\n     * @param {String} events\n     * @param {Function} [handler]\n     * @returns {EventEmitter} this\n     */\n    off: function(events, handler) {\n        if (events === undefined) {\n            return;\n        }\n\n        var handlers = this.handlers;\n        each(splitStr(events), function(event) {\n            if (!handler) {\n                delete handlers[event];\n            } else {\n                handlers[event] && handlers[event].splice(inArray(handlers[event], handler), 1);\n            }\n        });\n        return this;\n    },\n\n    /**\n     * emit event to the listeners\n     * @param {String} event\n     * @param {Object} data\n     */\n    emit: function(event, data) {\n        // we also want to trigger dom events\n        if (this.options.domEvents) {\n            triggerDomEvent(event, data);\n        }\n\n        // no handlers, so skip it all\n        var handlers = this.handlers[event] && this.handlers[event].slice();\n        if (!handlers || !handlers.length) {\n            return;\n        }\n\n        data.type = event;\n        data.preventDefault = function() {\n            data.srcEvent.preventDefault();\n        };\n\n        var i = 0;\n        while (i < handlers.length) {\n            handlers[i](data);\n            i++;\n        }\n    },\n\n    /**\n     * destroy the manager and unbinds all events\n     * it doesn't unbind dom events, that is the user own responsibility\n     */\n    destroy: function() {\n        this.element && toggleCssProps(this, false);\n\n        this.handlers = {};\n        this.session = {};\n        this.input.destroy();\n        this.element = null;\n    }\n};\n\n/**\n * add/remove the css properties as defined in manager.options.cssProps\n * @param {Manager} manager\n * @param {Boolean} add\n */\nfunction toggleCssProps(manager, add) {\n    var element = manager.element;\n    if (!element.style) {\n        return;\n    }\n    var prop;\n    each(manager.options.cssProps, function(value, name) {\n        prop = prefixed(element.style, name);\n        if (add) {\n            manager.oldCssProps[prop] = element.style[prop];\n            element.style[prop] = value;\n        } else {\n            element.style[prop] = manager.oldCssProps[prop] || '';\n        }\n    });\n    if (!add) {\n        manager.oldCssProps = {};\n    }\n}\n\n/**\n * trigger dom event\n * @param {String} event\n * @param {Object} data\n */\nfunction triggerDomEvent(event, data) {\n    var gestureEvent = document.createEvent('Event');\n    gestureEvent.initEvent(event, true, true);\n    gestureEvent.gesture = data;\n    data.target.dispatchEvent(gestureEvent);\n}\n\nassign(Hammer, {\n    INPUT_START: INPUT_START,\n    INPUT_MOVE: INPUT_MOVE,\n    INPUT_END: INPUT_END,\n    INPUT_CANCEL: INPUT_CANCEL,\n\n    STATE_POSSIBLE: STATE_POSSIBLE,\n    STATE_BEGAN: STATE_BEGAN,\n    STATE_CHANGED: STATE_CHANGED,\n    STATE_ENDED: STATE_ENDED,\n    STATE_RECOGNIZED: STATE_RECOGNIZED,\n    STATE_CANCELLED: STATE_CANCELLED,\n    STATE_FAILED: STATE_FAILED,\n\n    DIRECTION_NONE: DIRECTION_NONE,\n    DIRECTION_LEFT: DIRECTION_LEFT,\n    DIRECTION_RIGHT: DIRECTION_RIGHT,\n    DIRECTION_UP: DIRECTION_UP,\n    DIRECTION_DOWN: DIRECTION_DOWN,\n    DIRECTION_HORIZONTAL: DIRECTION_HORIZONTAL,\n    DIRECTION_VERTICAL: DIRECTION_VERTICAL,\n    DIRECTION_ALL: DIRECTION_ALL,\n\n    Manager: Manager,\n    Input: Input,\n    TouchAction: TouchAction,\n\n    TouchInput: TouchInput,\n    MouseInput: MouseInput,\n    PointerEventInput: PointerEventInput,\n    TouchMouseInput: TouchMouseInput,\n    SingleTouchInput: SingleTouchInput,\n\n    Recognizer: Recognizer,\n    AttrRecognizer: AttrRecognizer,\n    Tap: TapRecognizer,\n    Pan: PanRecognizer,\n    Swipe: SwipeRecognizer,\n    Pinch: PinchRecognizer,\n    Rotate: RotateRecognizer,\n    Press: PressRecognizer,\n\n    on: addEventListeners,\n    off: removeEventListeners,\n    each: each,\n    merge: merge,\n    extend: extend,\n    assign: assign,\n    inherit: inherit,\n    bindFn: bindFn,\n    prefixed: prefixed\n});\n\n// this prevents errors when Hammer is loaded in the presence of an AMD\n//  style loader but by script tag, not by the loader.\nvar freeGlobal = (typeof window !== 'undefined' ? window : (typeof self !== 'undefined' ? self : {})); // jshint ignore:line\nfreeGlobal.Hammer = Hammer;\n\nif (typeof define === 'function' && define.amd) {\n    define(function() {\n        return Hammer;\n    });\n} else if (typeof module != 'undefined' && module.exports) {\n    module.exports = Hammer;\n} else {\n    window[exportName] = Hammer;\n}\n\n})(window, document, 'Hammer');\n","/**\n * lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright jQuery Foundation and other contributors <https://jquery.org/>\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 `TypeError` message for \"Functions\" methods. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\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    funcTag = '[object Function]',\n    genTag = '[object GeneratorFunction]';\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/**\n * A faster alternative to `Function#apply`, this function invokes `func`\n * with the `this` binding of `thisArg` and the arguments of `args`.\n *\n * @private\n * @param {Function} func The function to invoke.\n * @param {*} thisArg The `this` binding of `func`.\n * @param {Array} args The arguments to invoke `func` with.\n * @returns {*} Returns the result of `func`.\n */\nfunction apply(func, thisArg, args) {\n  switch (args.length) {\n    case 0: return func.call(thisArg);\n    case 1: return func.call(thisArg, args[0]);\n    case 2: return func.call(thisArg, args[0], args[1]);\n    case 3: return func.call(thisArg, args[0], args[1], args[2]);\n  }\n  return func.apply(thisArg, args);\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/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar Symbol = root.Symbol,\n    propertyIsEnumerable = objectProto.propertyIsEnumerable,\n    spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : undefined;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max;\n\n/**\n * The base implementation of `_.flatten` with support for restricting flattening.\n *\n * @private\n * @param {Array} array The array to flatten.\n * @param {number} depth The maximum recursion depth.\n * @param {boolean} [predicate=isFlattenable] The function invoked per iteration.\n * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks.\n * @param {Array} [result=[]] The initial result value.\n * @returns {Array} Returns the new flattened array.\n */\nfunction baseFlatten(array, depth, predicate, isStrict, result) {\n  var index = -1,\n      length = array.length;\n\n  predicate || (predicate = isFlattenable);\n  result || (result = []);\n\n  while (++index < length) {\n    var value = array[index];\n    if (depth > 0 && predicate(value)) {\n      if (depth > 1) {\n        // Recursively flatten arrays (susceptible to call stack limits).\n        baseFlatten(value, depth - 1, predicate, isStrict, result);\n      } else {\n        arrayPush(result, value);\n      }\n    } else if (!isStrict) {\n      result[result.length] = value;\n    }\n  }\n  return result;\n}\n\n/**\n * The base implementation of `_.rest` which doesn't validate or coerce arguments.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @returns {Function} Returns the new function.\n */\nfunction baseRest(func, start) {\n  start = nativeMax(start === undefined ? (func.length - 1) : start, 0);\n  return function() {\n    var args = arguments,\n        index = -1,\n        length = nativeMax(args.length - start, 0),\n        array = Array(length);\n\n    while (++index < length) {\n      array[index] = args[start + index];\n    }\n    index = -1;\n    var otherArgs = Array(start + 1);\n    while (++index < start) {\n      otherArgs[index] = args[index];\n    }\n    otherArgs[start] = array;\n    return apply(func, this, otherArgs);\n  };\n}\n\n/**\n * Creates a `_.flow` or `_.flowRight` function.\n *\n * @private\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {Function} Returns the new flow function.\n */\nfunction createFlow(fromRight) {\n  return baseRest(function(funcs) {\n    funcs = baseFlatten(funcs, 1);\n\n    var length = funcs.length,\n        index = length;\n\n    if (fromRight) {\n      funcs.reverse();\n    }\n    while (index--) {\n      if (typeof funcs[index] != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n    }\n    return function() {\n      var index = 0,\n          result = length ? funcs[index].apply(this, arguments) : arguments[0];\n\n      while (++index < length) {\n        result = funcs[index].call(this, result);\n      }\n      return result;\n    };\n  });\n}\n\n/**\n * Checks if `value` is a flattenable `arguments` object or array.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is flattenable, else `false`.\n */\nfunction isFlattenable(value) {\n  return isArray(value) || isArguments(value) ||\n    !!(spreadableSymbol && value && value[spreadableSymbol]);\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 */\nfunction isArguments(value) {\n  // Safari 8.1 makes `arguments.callee` enumerable in strict mode.\n  return isArrayLikeObject(value) && hasOwnProperty.call(value, 'callee') &&\n    (!propertyIsEnumerable.call(value, 'callee') || objectToString.call(value) == argsTag);\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 * This method is like `_.isArrayLike` except that it also checks if `value`\n * is an 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 an array-like object,\n *  else `false`.\n * @example\n *\n * _.isArrayLikeObject([1, 2, 3]);\n * // => true\n *\n * _.isArrayLikeObject(document.body.children);\n * // => true\n *\n * _.isArrayLikeObject('abc');\n * // => false\n *\n * _.isArrayLikeObject(_.noop);\n * // => false\n */\nfunction isArrayLikeObject(value) {\n  return isObjectLike(value) && isArrayLike(value);\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  // The use of `Object#toString` avoids issues with the `typeof` operator\n  // in Safari 8-9 which returns 'object' for typed array and other constructors.\n  var tag = isObject(value) ? objectToString.call(value) : '';\n  return tag == funcTag || tag == genTag;\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 && (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 && typeof value == 'object';\n}\n\n/**\n * This method is like `_.flow` except that it creates a function that\n * invokes the given functions from right to left.\n *\n * @static\n * @since 3.0.0\n * @memberOf _\n * @category Util\n * @param {...(Function|Function[])} [funcs] The functions to invoke.\n * @returns {Function} Returns the new composite function.\n * @see _.flow\n * @example\n *\n * function square(n) {\n *   return n * n;\n * }\n *\n * var addSquare = _.flowRight([square, _.add]);\n * addSquare(1, 2);\n * // => 9\n */\nvar flowRight = createFlow(true);\n\nmodule.exports = flowRight;\n","/**\n * Lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>\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 detect hot functions by number of calls within a span of milliseconds. */\nvar HOT_COUNT = 800,\n    HOT_SPAN = 16;\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    proxyTag = '[object Proxy]',\n    regexpTag = '[object RegExp]',\n    setTag = '[object Set]',\n    stringTag = '[object String]',\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    // Use `util.types` for Node.js 10+.\n    var types = freeModule && freeModule.require && freeModule.require('util').types;\n\n    if (types) {\n      return types;\n    }\n\n    // Legacy `process.binding('util')` for Node.js < 10.\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 faster alternative to `Function#apply`, this function invokes `func`\n * with the `this` binding of `thisArg` and the arguments of `args`.\n *\n * @private\n * @param {Function} func The function to invoke.\n * @param {*} thisArg The `this` binding of `func`.\n * @param {Array} args The arguments to invoke `func` with.\n * @returns {*} Returns the result of `func`.\n */\nfunction apply(func, thisArg, args) {\n  switch (args.length) {\n    case 0: return func.call(thisArg);\n    case 1: return func.call(thisArg, args[0]);\n    case 2: return func.call(thisArg, args[0], args[1]);\n    case 3: return func.call(thisArg, args[0], args[1], args[2]);\n  }\n  return func.apply(thisArg, args);\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 * 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 * 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/** 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 infer the `Object` constructor. */\nvar objectCtorString = funcToString.call(Object);\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    allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined,\n    getPrototype = overArg(Object.getPrototypeOf, Object),\n    objectCreate = Object.create,\n    propertyIsEnumerable = objectProto.propertyIsEnumerable,\n    splice = arrayProto.splice,\n    symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\nvar defineProperty = (function() {\n  try {\n    var func = getNative(Object, 'defineProperty');\n    func({}, '', {});\n    return func;\n  } catch (e) {}\n}());\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined,\n    nativeMax = Math.max,\n    nativeNow = Date.now;\n\n/* Built-in method references that are verified to be native. */\nvar Map = getNative(root, 'Map'),\n    nativeCreate = getNative(Object, 'create');\n\n/**\n * The base implementation of `_.create` without support for assigning\n * properties to the created object.\n *\n * @private\n * @param {Object} proto The object to inherit from.\n * @returns {Object} Returns the new object.\n */\nvar baseCreate = (function() {\n  function object() {}\n  return function(proto) {\n    if (!isObject(proto)) {\n      return {};\n    }\n    if (objectCreate) {\n      return objectCreate(proto);\n    }\n    object.prototype = proto;\n    var result = new object;\n    object.prototype = undefined;\n    return result;\n  };\n}());\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 * 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 * This function is like `assignValue` except that it doesn't assign\n * `undefined` values.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction assignMergeValue(object, key, value) {\n  if ((value !== undefined && !eq(object[key], value)) ||\n      (value === undefined && !(key in object))) {\n    baseAssignValue(object, key, value);\n  }\n}\n\n/**\n * Assigns `value` to `key` of `object` if the existing value is not equivalent\n * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction assignValue(object, key, value) {\n  var objValue = object[key];\n  if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||\n      (value === undefined && !(key in object))) {\n    baseAssignValue(object, key, value);\n  }\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 `assignValue` and `assignMergeValue` without\n * value checks.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction baseAssignValue(object, key, value) {\n  if (key == '__proto__' && defineProperty) {\n    defineProperty(object, key, {\n      'configurable': true,\n      'enumerable': true,\n      'value': value,\n      'writable': true\n    });\n  } else {\n    object[key] = value;\n  }\n}\n\n/**\n * The base implementation of `baseForOwn` which iterates over `object`\n * properties returned by `keysFunc` and invokes `iteratee` for each property.\n * Iteratee functions may exit iteration early by explicitly returning `false`.\n *\n * @private\n * @param {Object} object The object to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @returns {Object} Returns `object`.\n */\nvar baseFor = createBaseFor();\n\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 `_.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 `_.keysIn` 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 baseKeysIn(object) {\n  if (!isObject(object)) {\n    return nativeKeysIn(object);\n  }\n  var isProto = isPrototype(object),\n      result = [];\n\n  for (var key in object) {\n    if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\n/**\n * The base implementation of `_.merge` without support for multiple sources.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @param {number} srcIndex The index of `source`.\n * @param {Function} [customizer] The function to customize merged values.\n * @param {Object} [stack] Tracks traversed source values and their merged\n *  counterparts.\n */\nfunction baseMerge(object, source, srcIndex, customizer, stack) {\n  if (object === source) {\n    return;\n  }\n  baseFor(source, function(srcValue, key) {\n    stack || (stack = new Stack);\n    if (isObject(srcValue)) {\n      baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);\n    }\n    else {\n      var newValue = customizer\n        ? customizer(safeGet(object, key), srcValue, (key + ''), object, source, stack)\n        : undefined;\n\n      if (newValue === undefined) {\n        newValue = srcValue;\n      }\n      assignMergeValue(object, key, newValue);\n    }\n  }, keysIn);\n}\n\n/**\n * A specialized version of `baseMerge` for arrays and objects which performs\n * deep merges and tracks traversed objects enabling objects with circular\n * references to be merged.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @param {string} key The key of the value to merge.\n * @param {number} srcIndex The index of `source`.\n * @param {Function} mergeFunc The function to merge values.\n * @param {Function} [customizer] The function to customize assigned values.\n * @param {Object} [stack] Tracks traversed source values and their merged\n *  counterparts.\n */\nfunction baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {\n  var objValue = safeGet(object, key),\n      srcValue = safeGet(source, key),\n      stacked = stack.get(srcValue);\n\n  if (stacked) {\n    assignMergeValue(object, key, stacked);\n    return;\n  }\n  var newValue = customizer\n    ? customizer(objValue, srcValue, (key + ''), object, source, stack)\n    : undefined;\n\n  var isCommon = newValue === undefined;\n\n  if (isCommon) {\n    var isArr = isArray(srcValue),\n        isBuff = !isArr && isBuffer(srcValue),\n        isTyped = !isArr && !isBuff && isTypedArray(srcValue);\n\n    newValue = srcValue;\n    if (isArr || isBuff || isTyped) {\n      if (isArray(objValue)) {\n        newValue = objValue;\n      }\n      else if (isArrayLikeObject(objValue)) {\n        newValue = copyArray(objValue);\n      }\n      else if (isBuff) {\n        isCommon = false;\n        newValue = cloneBuffer(srcValue, true);\n      }\n      else if (isTyped) {\n        isCommon = false;\n        newValue = cloneTypedArray(srcValue, true);\n      }\n      else {\n        newValue = [];\n      }\n    }\n    else if (isPlainObject(srcValue) || isArguments(srcValue)) {\n      newValue = objValue;\n      if (isArguments(objValue)) {\n        newValue = toPlainObject(objValue);\n      }\n      else if (!isObject(objValue) || isFunction(objValue)) {\n        newValue = initCloneObject(srcValue);\n      }\n    }\n    else {\n      isCommon = false;\n    }\n  }\n  if (isCommon) {\n    // Recursively merge objects and arrays (susceptible to call stack limits).\n    stack.set(srcValue, newValue);\n    mergeFunc(newValue, srcValue, srcIndex, customizer, stack);\n    stack['delete'](srcValue);\n  }\n  assignMergeValue(object, key, newValue);\n}\n\n/**\n * The base implementation of `_.rest` which doesn't validate or coerce arguments.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @returns {Function} Returns the new function.\n */\nfunction baseRest(func, start) {\n  return setToString(overRest(func, start, identity), func + '');\n}\n\n/**\n * The base implementation of `setToString` without support for hot loop shorting.\n *\n * @private\n * @param {Function} func The function to modify.\n * @param {Function} string The `toString` result.\n * @returns {Function} Returns `func`.\n */\nvar baseSetToString = !defineProperty ? identity : function(func, string) {\n  return defineProperty(func, 'toString', {\n    'configurable': true,\n    'enumerable': false,\n    'value': constant(string),\n    'writable': true\n  });\n};\n\n/**\n * Creates a clone of  `buffer`.\n *\n * @private\n * @param {Buffer} buffer The buffer to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Buffer} Returns the cloned buffer.\n */\nfunction cloneBuffer(buffer, isDeep) {\n  if (isDeep) {\n    return buffer.slice();\n  }\n  var length = buffer.length,\n      result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);\n\n  buffer.copy(result);\n  return result;\n}\n\n/**\n * Creates a clone of `arrayBuffer`.\n *\n * @private\n * @param {ArrayBuffer} arrayBuffer The array buffer to clone.\n * @returns {ArrayBuffer} Returns the cloned array buffer.\n */\nfunction cloneArrayBuffer(arrayBuffer) {\n  var result = new arrayBuffer.constructor(arrayBuffer.byteLength);\n  new Uint8Array(result).set(new Uint8Array(arrayBuffer));\n  return result;\n}\n\n/**\n * Creates a clone of `typedArray`.\n *\n * @private\n * @param {Object} typedArray The typed array to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned typed array.\n */\nfunction cloneTypedArray(typedArray, isDeep) {\n  var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;\n  return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);\n}\n\n/**\n * Copies the values of `source` to `array`.\n *\n * @private\n * @param {Array} source The array to copy values from.\n * @param {Array} [array=[]] The array to copy values to.\n * @returns {Array} Returns `array`.\n */\nfunction copyArray(source, array) {\n  var index = -1,\n      length = source.length;\n\n  array || (array = Array(length));\n  while (++index < length) {\n    array[index] = source[index];\n  }\n  return array;\n}\n\n/**\n * Copies properties of `source` to `object`.\n *\n * @private\n * @param {Object} source The object to copy properties from.\n * @param {Array} props The property identifiers to copy.\n * @param {Object} [object={}] The object to copy properties to.\n * @param {Function} [customizer] The function to customize copied values.\n * @returns {Object} Returns `object`.\n */\nfunction copyObject(source, props, object, customizer) {\n  var isNew = !object;\n  object || (object = {});\n\n  var index = -1,\n      length = props.length;\n\n  while (++index < length) {\n    var key = props[index];\n\n    var newValue = customizer\n      ? customizer(object[key], source[key], key, object, source)\n      : undefined;\n\n    if (newValue === undefined) {\n      newValue = source[key];\n    }\n    if (isNew) {\n      baseAssignValue(object, key, newValue);\n    } else {\n      assignValue(object, key, newValue);\n    }\n  }\n  return object;\n}\n\n/**\n * Creates a function like `_.assign`.\n *\n * @private\n * @param {Function} assigner The function to assign values.\n * @returns {Function} Returns the new assigner function.\n */\nfunction createAssigner(assigner) {\n  return baseRest(function(object, sources) {\n    var index = -1,\n        length = sources.length,\n        customizer = length > 1 ? sources[length - 1] : undefined,\n        guard = length > 2 ? sources[2] : undefined;\n\n    customizer = (assigner.length > 3 && typeof customizer == 'function')\n      ? (length--, customizer)\n      : undefined;\n\n    if (guard && isIterateeCall(sources[0], sources[1], guard)) {\n      customizer = length < 3 ? undefined : customizer;\n      length = 1;\n    }\n    object = Object(object);\n    while (++index < length) {\n      var source = sources[index];\n      if (source) {\n        assigner(object, source, index, customizer);\n      }\n    }\n    return object;\n  });\n}\n\n/**\n * Creates a base function for methods like `_.forIn` and `_.forOwn`.\n *\n * @private\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {Function} Returns the new base function.\n */\nfunction createBaseFor(fromRight) {\n  return function(object, iteratee, keysFunc) {\n    var index = -1,\n        iterable = Object(object),\n        props = keysFunc(object),\n        length = props.length;\n\n    while (length--) {\n      var key = props[fromRight ? length : ++index];\n      if (iteratee(iterable[key], key, iterable) === false) {\n        break;\n      }\n    }\n    return object;\n  };\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 * Initializes an object clone.\n *\n * @private\n * @param {Object} object The object to clone.\n * @returns {Object} Returns the initialized clone.\n */\nfunction initCloneObject(object) {\n  return (typeof object.constructor == 'function' && !isPrototype(object))\n    ? baseCreate(getPrototype(object))\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  var type = typeof value;\n  length = length == null ? MAX_SAFE_INTEGER : length;\n\n  return !!length &&\n    (type == 'number' ||\n      (type != 'symbol' && reIsUint.test(value))) &&\n        (value > -1 && value % 1 == 0 && value < length);\n}\n\n/**\n * Checks if the given arguments are from an iteratee call.\n *\n * @private\n * @param {*} value The potential iteratee value argument.\n * @param {*} index The potential iteratee index or key argument.\n * @param {*} object The potential iteratee object argument.\n * @returns {boolean} Returns `true` if the arguments are from an iteratee call,\n *  else `false`.\n */\nfunction isIterateeCall(value, index, object) {\n  if (!isObject(object)) {\n    return false;\n  }\n  var type = typeof index;\n  if (type == 'number'\n        ? (isArrayLike(object) && isIndex(index, object.length))\n        : (type == 'string' && index in object)\n      ) {\n    return eq(object[index], value);\n  }\n  return false;\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 * This function is like\n * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * except that it includes inherited enumerable properties.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction nativeKeysIn(object) {\n  var result = [];\n  if (object != null) {\n    for (var key in Object(object)) {\n      result.push(key);\n    }\n  }\n  return result;\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 * A specialized version of `baseRest` which transforms the rest array.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @param {Function} transform The rest array transform.\n * @returns {Function} Returns the new function.\n */\nfunction overRest(func, start, transform) {\n  start = nativeMax(start === undefined ? (func.length - 1) : start, 0);\n  return function() {\n    var args = arguments,\n        index = -1,\n        length = nativeMax(args.length - start, 0),\n        array = Array(length);\n\n    while (++index < length) {\n      array[index] = args[start + index];\n    }\n    index = -1;\n    var otherArgs = Array(start + 1);\n    while (++index < start) {\n      otherArgs[index] = args[index];\n    }\n    otherArgs[start] = transform(array);\n    return apply(func, this, otherArgs);\n  };\n}\n\n/**\n * Gets the value at `key`, unless `key` is \"__proto__\" or \"constructor\".\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 safeGet(object, key) {\n  if (key === 'constructor' && typeof object[key] === 'function') {\n    return;\n  }\n\n  if (key == '__proto__') {\n    return;\n  }\n\n  return object[key];\n}\n\n/**\n * Sets the `toString` method of `func` to return `string`.\n *\n * @private\n * @param {Function} func The function to modify.\n * @param {Function} string The `toString` result.\n * @returns {Function} Returns `func`.\n */\nvar setToString = shortOut(baseSetToString);\n\n/**\n * Creates a function that'll short out and invoke `identity` instead\n * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`\n * milliseconds.\n *\n * @private\n * @param {Function} func The function to restrict.\n * @returns {Function} Returns the new shortable function.\n */\nfunction shortOut(func) {\n  var count = 0,\n      lastCalled = 0;\n\n  return function() {\n    var stamp = nativeNow(),\n        remaining = HOT_SPAN - (stamp - lastCalled);\n\n    lastCalled = stamp;\n    if (remaining > 0) {\n      if (++count >= HOT_COUNT) {\n        return arguments[0];\n      }\n    } else {\n      count = 0;\n    }\n    return func.apply(undefined, arguments);\n  };\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 * This method is like `_.isArrayLike` except that it also checks if `value`\n * is an 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 an array-like object,\n *  else `false`.\n * @example\n *\n * _.isArrayLikeObject([1, 2, 3]);\n * // => true\n *\n * _.isArrayLikeObject(document.body.children);\n * // => true\n *\n * _.isArrayLikeObject('abc');\n * // => false\n *\n * _.isArrayLikeObject(_.noop);\n * // => false\n */\nfunction isArrayLikeObject(value) {\n  return isObjectLike(value) && isArrayLike(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 * 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 a plain object, that is, an object created by the\n * `Object` constructor or one with a `[[Prototype]]` of `null`.\n *\n * @static\n * @memberOf _\n * @since 0.8.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n * }\n *\n * _.isPlainObject(new Foo);\n * // => false\n *\n * _.isPlainObject([1, 2, 3]);\n * // => false\n *\n * _.isPlainObject({ 'x': 0, 'y': 0 });\n * // => true\n *\n * _.isPlainObject(Object.create(null));\n * // => true\n */\nfunction isPlainObject(value) {\n  if (!isObjectLike(value) || baseGetTag(value) != objectTag) {\n    return false;\n  }\n  var proto = getPrototype(value);\n  if (proto === null) {\n    return true;\n  }\n  var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;\n  return typeof Ctor == 'function' && Ctor instanceof Ctor &&\n    funcToString.call(Ctor) == objectCtorString;\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 * Converts `value` to a plain object flattening inherited enumerable string\n * keyed properties of `value` to own properties of the plain object.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {Object} Returns the converted plain object.\n * @example\n *\n * function Foo() {\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.assign({ 'a': 1 }, new Foo);\n * // => { 'a': 1, 'b': 2 }\n *\n * _.assign({ 'a': 1 }, _.toPlainObject(new Foo));\n * // => { 'a': 1, 'b': 2, 'c': 3 }\n */\nfunction toPlainObject(value) {\n  return copyObject(value, keysIn(value));\n}\n\n/**\n * Creates an array of the own and inherited enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keysIn(new Foo);\n * // => ['a', 'b', 'c'] (iteration order is not guaranteed)\n */\nfunction keysIn(object) {\n  return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);\n}\n\n/**\n * This method is like `_.assign` except that it recursively merges own and\n * inherited enumerable string keyed properties of source objects into the\n * destination object. Source properties that resolve to `undefined` are\n * skipped if a destination value exists. Array and plain object properties\n * are merged recursively. Other objects and value types are overridden by\n * assignment. Source objects are applied from left to right. Subsequent\n * sources overwrite property assignments of previous sources.\n *\n * **Note:** This method mutates `object`.\n *\n * @static\n * @memberOf _\n * @since 0.5.0\n * @category Object\n * @param {Object} object The destination object.\n * @param {...Object} [sources] The source objects.\n * @returns {Object} Returns `object`.\n * @example\n *\n * var object = {\n *   'a': [{ 'b': 2 }, { 'd': 4 }]\n * };\n *\n * var other = {\n *   'a': [{ 'c': 3 }, { 'e': 5 }]\n * };\n *\n * _.merge(object, other);\n * // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] }\n */\nvar merge = createAssigner(function(object, source, srcIndex) {\n  baseMerge(object, source, srcIndex);\n});\n\n/**\n * Creates a function that returns `value`.\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Util\n * @param {*} value The value to return from the new function.\n * @returns {Function} Returns the new constant function.\n * @example\n *\n * var objects = _.times(2, _.constant({ 'a': 1 }));\n *\n * console.log(objects);\n * // => [{ 'a': 1 }, { 'a': 1 }]\n *\n * console.log(objects[0] === objects[1]);\n * // => true\n */\nfunction constant(value) {\n  return function() {\n    return value;\n  };\n}\n\n/**\n * This method returns the first argument it receives.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Util\n * @param {*} value Any value.\n * @returns {*} Returns `value`.\n * @example\n *\n * var object = { 'a': 1 };\n *\n * console.log(_.identity(object) === object);\n * // => true\n */\nfunction identity(value) {\n  return value;\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 = merge;\n","/**\n * Lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>\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 detect hot functions by number of calls within a span of milliseconds. */\nvar HOT_COUNT = 800,\n    HOT_SPAN = 16;\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    proxyTag = '[object Proxy]',\n    regexpTag = '[object RegExp]',\n    setTag = '[object Set]',\n    stringTag = '[object String]',\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    // Use `util.types` for Node.js 10+.\n    var types = freeModule && freeModule.require && freeModule.require('util').types;\n\n    if (types) {\n      return types;\n    }\n\n    // Legacy `process.binding('util')` for Node.js < 10.\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 faster alternative to `Function#apply`, this function invokes `func`\n * with the `this` binding of `thisArg` and the arguments of `args`.\n *\n * @private\n * @param {Function} func The function to invoke.\n * @param {*} thisArg The `this` binding of `func`.\n * @param {Array} args The arguments to invoke `func` with.\n * @returns {*} Returns the result of `func`.\n */\nfunction apply(func, thisArg, args) {\n  switch (args.length) {\n    case 0: return func.call(thisArg);\n    case 1: return func.call(thisArg, args[0]);\n    case 2: return func.call(thisArg, args[0], args[1]);\n    case 3: return func.call(thisArg, args[0], args[1], args[2]);\n  }\n  return func.apply(thisArg, args);\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 * 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 * 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/** 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 infer the `Object` constructor. */\nvar objectCtorString = funcToString.call(Object);\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    allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined,\n    getPrototype = overArg(Object.getPrototypeOf, Object),\n    objectCreate = Object.create,\n    propertyIsEnumerable = objectProto.propertyIsEnumerable,\n    splice = arrayProto.splice,\n    symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\nvar defineProperty = (function() {\n  try {\n    var func = getNative(Object, 'defineProperty');\n    func({}, '', {});\n    return func;\n  } catch (e) {}\n}());\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined,\n    nativeMax = Math.max,\n    nativeNow = Date.now;\n\n/* Built-in method references that are verified to be native. */\nvar Map = getNative(root, 'Map'),\n    nativeCreate = getNative(Object, 'create');\n\n/**\n * The base implementation of `_.create` without support for assigning\n * properties to the created object.\n *\n * @private\n * @param {Object} proto The object to inherit from.\n * @returns {Object} Returns the new object.\n */\nvar baseCreate = (function() {\n  function object() {}\n  return function(proto) {\n    if (!isObject(proto)) {\n      return {};\n    }\n    if (objectCreate) {\n      return objectCreate(proto);\n    }\n    object.prototype = proto;\n    var result = new object;\n    object.prototype = undefined;\n    return result;\n  };\n}());\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 * 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 * This function is like `assignValue` except that it doesn't assign\n * `undefined` values.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction assignMergeValue(object, key, value) {\n  if ((value !== undefined && !eq(object[key], value)) ||\n      (value === undefined && !(key in object))) {\n    baseAssignValue(object, key, value);\n  }\n}\n\n/**\n * Assigns `value` to `key` of `object` if the existing value is not equivalent\n * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction assignValue(object, key, value) {\n  var objValue = object[key];\n  if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||\n      (value === undefined && !(key in object))) {\n    baseAssignValue(object, key, value);\n  }\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 `assignValue` and `assignMergeValue` without\n * value checks.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction baseAssignValue(object, key, value) {\n  if (key == '__proto__' && defineProperty) {\n    defineProperty(object, key, {\n      'configurable': true,\n      'enumerable': true,\n      'value': value,\n      'writable': true\n    });\n  } else {\n    object[key] = value;\n  }\n}\n\n/**\n * The base implementation of `baseForOwn` which iterates over `object`\n * properties returned by `keysFunc` and invokes `iteratee` for each property.\n * Iteratee functions may exit iteration early by explicitly returning `false`.\n *\n * @private\n * @param {Object} object The object to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @returns {Object} Returns `object`.\n */\nvar baseFor = createBaseFor();\n\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 `_.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 `_.keysIn` 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 baseKeysIn(object) {\n  if (!isObject(object)) {\n    return nativeKeysIn(object);\n  }\n  var isProto = isPrototype(object),\n      result = [];\n\n  for (var key in object) {\n    if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\n/**\n * The base implementation of `_.merge` without support for multiple sources.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @param {number} srcIndex The index of `source`.\n * @param {Function} [customizer] The function to customize merged values.\n * @param {Object} [stack] Tracks traversed source values and their merged\n *  counterparts.\n */\nfunction baseMerge(object, source, srcIndex, customizer, stack) {\n  if (object === source) {\n    return;\n  }\n  baseFor(source, function(srcValue, key) {\n    stack || (stack = new Stack);\n    if (isObject(srcValue)) {\n      baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);\n    }\n    else {\n      var newValue = customizer\n        ? customizer(safeGet(object, key), srcValue, (key + ''), object, source, stack)\n        : undefined;\n\n      if (newValue === undefined) {\n        newValue = srcValue;\n      }\n      assignMergeValue(object, key, newValue);\n    }\n  }, keysIn);\n}\n\n/**\n * A specialized version of `baseMerge` for arrays and objects which performs\n * deep merges and tracks traversed objects enabling objects with circular\n * references to be merged.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @param {string} key The key of the value to merge.\n * @param {number} srcIndex The index of `source`.\n * @param {Function} mergeFunc The function to merge values.\n * @param {Function} [customizer] The function to customize assigned values.\n * @param {Object} [stack] Tracks traversed source values and their merged\n *  counterparts.\n */\nfunction baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {\n  var objValue = safeGet(object, key),\n      srcValue = safeGet(source, key),\n      stacked = stack.get(srcValue);\n\n  if (stacked) {\n    assignMergeValue(object, key, stacked);\n    return;\n  }\n  var newValue = customizer\n    ? customizer(objValue, srcValue, (key + ''), object, source, stack)\n    : undefined;\n\n  var isCommon = newValue === undefined;\n\n  if (isCommon) {\n    var isArr = isArray(srcValue),\n        isBuff = !isArr && isBuffer(srcValue),\n        isTyped = !isArr && !isBuff && isTypedArray(srcValue);\n\n    newValue = srcValue;\n    if (isArr || isBuff || isTyped) {\n      if (isArray(objValue)) {\n        newValue = objValue;\n      }\n      else if (isArrayLikeObject(objValue)) {\n        newValue = copyArray(objValue);\n      }\n      else if (isBuff) {\n        isCommon = false;\n        newValue = cloneBuffer(srcValue, true);\n      }\n      else if (isTyped) {\n        isCommon = false;\n        newValue = cloneTypedArray(srcValue, true);\n      }\n      else {\n        newValue = [];\n      }\n    }\n    else if (isPlainObject(srcValue) || isArguments(srcValue)) {\n      newValue = objValue;\n      if (isArguments(objValue)) {\n        newValue = toPlainObject(objValue);\n      }\n      else if (!isObject(objValue) || isFunction(objValue)) {\n        newValue = initCloneObject(srcValue);\n      }\n    }\n    else {\n      isCommon = false;\n    }\n  }\n  if (isCommon) {\n    // Recursively merge objects and arrays (susceptible to call stack limits).\n    stack.set(srcValue, newValue);\n    mergeFunc(newValue, srcValue, srcIndex, customizer, stack);\n    stack['delete'](srcValue);\n  }\n  assignMergeValue(object, key, newValue);\n}\n\n/**\n * The base implementation of `_.rest` which doesn't validate or coerce arguments.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @returns {Function} Returns the new function.\n */\nfunction baseRest(func, start) {\n  return setToString(overRest(func, start, identity), func + '');\n}\n\n/**\n * The base implementation of `setToString` without support for hot loop shorting.\n *\n * @private\n * @param {Function} func The function to modify.\n * @param {Function} string The `toString` result.\n * @returns {Function} Returns `func`.\n */\nvar baseSetToString = !defineProperty ? identity : function(func, string) {\n  return defineProperty(func, 'toString', {\n    'configurable': true,\n    'enumerable': false,\n    'value': constant(string),\n    'writable': true\n  });\n};\n\n/**\n * Creates a clone of  `buffer`.\n *\n * @private\n * @param {Buffer} buffer The buffer to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Buffer} Returns the cloned buffer.\n */\nfunction cloneBuffer(buffer, isDeep) {\n  if (isDeep) {\n    return buffer.slice();\n  }\n  var length = buffer.length,\n      result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);\n\n  buffer.copy(result);\n  return result;\n}\n\n/**\n * Creates a clone of `arrayBuffer`.\n *\n * @private\n * @param {ArrayBuffer} arrayBuffer The array buffer to clone.\n * @returns {ArrayBuffer} Returns the cloned array buffer.\n */\nfunction cloneArrayBuffer(arrayBuffer) {\n  var result = new arrayBuffer.constructor(arrayBuffer.byteLength);\n  new Uint8Array(result).set(new Uint8Array(arrayBuffer));\n  return result;\n}\n\n/**\n * Creates a clone of `typedArray`.\n *\n * @private\n * @param {Object} typedArray The typed array to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned typed array.\n */\nfunction cloneTypedArray(typedArray, isDeep) {\n  var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;\n  return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);\n}\n\n/**\n * Copies the values of `source` to `array`.\n *\n * @private\n * @param {Array} source The array to copy values from.\n * @param {Array} [array=[]] The array to copy values to.\n * @returns {Array} Returns `array`.\n */\nfunction copyArray(source, array) {\n  var index = -1,\n      length = source.length;\n\n  array || (array = Array(length));\n  while (++index < length) {\n    array[index] = source[index];\n  }\n  return array;\n}\n\n/**\n * Copies properties of `source` to `object`.\n *\n * @private\n * @param {Object} source The object to copy properties from.\n * @param {Array} props The property identifiers to copy.\n * @param {Object} [object={}] The object to copy properties to.\n * @param {Function} [customizer] The function to customize copied values.\n * @returns {Object} Returns `object`.\n */\nfunction copyObject(source, props, object, customizer) {\n  var isNew = !object;\n  object || (object = {});\n\n  var index = -1,\n      length = props.length;\n\n  while (++index < length) {\n    var key = props[index];\n\n    var newValue = customizer\n      ? customizer(object[key], source[key], key, object, source)\n      : undefined;\n\n    if (newValue === undefined) {\n      newValue = source[key];\n    }\n    if (isNew) {\n      baseAssignValue(object, key, newValue);\n    } else {\n      assignValue(object, key, newValue);\n    }\n  }\n  return object;\n}\n\n/**\n * Creates a function like `_.assign`.\n *\n * @private\n * @param {Function} assigner The function to assign values.\n * @returns {Function} Returns the new assigner function.\n */\nfunction createAssigner(assigner) {\n  return baseRest(function(object, sources) {\n    var index = -1,\n        length = sources.length,\n        customizer = length > 1 ? sources[length - 1] : undefined,\n        guard = length > 2 ? sources[2] : undefined;\n\n    customizer = (assigner.length > 3 && typeof customizer == 'function')\n      ? (length--, customizer)\n      : undefined;\n\n    if (guard && isIterateeCall(sources[0], sources[1], guard)) {\n      customizer = length < 3 ? undefined : customizer;\n      length = 1;\n    }\n    object = Object(object);\n    while (++index < length) {\n      var source = sources[index];\n      if (source) {\n        assigner(object, source, index, customizer);\n      }\n    }\n    return object;\n  });\n}\n\n/**\n * Creates a base function for methods like `_.forIn` and `_.forOwn`.\n *\n * @private\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {Function} Returns the new base function.\n */\nfunction createBaseFor(fromRight) {\n  return function(object, iteratee, keysFunc) {\n    var index = -1,\n        iterable = Object(object),\n        props = keysFunc(object),\n        length = props.length;\n\n    while (length--) {\n      var key = props[fromRight ? length : ++index];\n      if (iteratee(iterable[key], key, iterable) === false) {\n        break;\n      }\n    }\n    return object;\n  };\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 * Initializes an object clone.\n *\n * @private\n * @param {Object} object The object to clone.\n * @returns {Object} Returns the initialized clone.\n */\nfunction initCloneObject(object) {\n  return (typeof object.constructor == 'function' && !isPrototype(object))\n    ? baseCreate(getPrototype(object))\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  var type = typeof value;\n  length = length == null ? MAX_SAFE_INTEGER : length;\n\n  return !!length &&\n    (type == 'number' ||\n      (type != 'symbol' && reIsUint.test(value))) &&\n        (value > -1 && value % 1 == 0 && value < length);\n}\n\n/**\n * Checks if the given arguments are from an iteratee call.\n *\n * @private\n * @param {*} value The potential iteratee value argument.\n * @param {*} index The potential iteratee index or key argument.\n * @param {*} object The potential iteratee object argument.\n * @returns {boolean} Returns `true` if the arguments are from an iteratee call,\n *  else `false`.\n */\nfunction isIterateeCall(value, index, object) {\n  if (!isObject(object)) {\n    return false;\n  }\n  var type = typeof index;\n  if (type == 'number'\n        ? (isArrayLike(object) && isIndex(index, object.length))\n        : (type == 'string' && index in object)\n      ) {\n    return eq(object[index], value);\n  }\n  return false;\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 * This function is like\n * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * except that it includes inherited enumerable properties.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction nativeKeysIn(object) {\n  var result = [];\n  if (object != null) {\n    for (var key in Object(object)) {\n      result.push(key);\n    }\n  }\n  return result;\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 * A specialized version of `baseRest` which transforms the rest array.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @param {Function} transform The rest array transform.\n * @returns {Function} Returns the new function.\n */\nfunction overRest(func, start, transform) {\n  start = nativeMax(start === undefined ? (func.length - 1) : start, 0);\n  return function() {\n    var args = arguments,\n        index = -1,\n        length = nativeMax(args.length - start, 0),\n        array = Array(length);\n\n    while (++index < length) {\n      array[index] = args[start + index];\n    }\n    index = -1;\n    var otherArgs = Array(start + 1);\n    while (++index < start) {\n      otherArgs[index] = args[index];\n    }\n    otherArgs[start] = transform(array);\n    return apply(func, this, otherArgs);\n  };\n}\n\n/**\n * Gets the value at `key`, unless `key` is \"__proto__\" or \"constructor\".\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 safeGet(object, key) {\n  if (key === 'constructor' && typeof object[key] === 'function') {\n    return;\n  }\n\n  if (key == '__proto__') {\n    return;\n  }\n\n  return object[key];\n}\n\n/**\n * Sets the `toString` method of `func` to return `string`.\n *\n * @private\n * @param {Function} func The function to modify.\n * @param {Function} string The `toString` result.\n * @returns {Function} Returns `func`.\n */\nvar setToString = shortOut(baseSetToString);\n\n/**\n * Creates a function that'll short out and invoke `identity` instead\n * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`\n * milliseconds.\n *\n * @private\n * @param {Function} func The function to restrict.\n * @returns {Function} Returns the new shortable function.\n */\nfunction shortOut(func) {\n  var count = 0,\n      lastCalled = 0;\n\n  return function() {\n    var stamp = nativeNow(),\n        remaining = HOT_SPAN - (stamp - lastCalled);\n\n    lastCalled = stamp;\n    if (remaining > 0) {\n      if (++count >= HOT_COUNT) {\n        return arguments[0];\n      }\n    } else {\n      count = 0;\n    }\n    return func.apply(undefined, arguments);\n  };\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 * This method is like `_.isArrayLike` except that it also checks if `value`\n * is an 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 an array-like object,\n *  else `false`.\n * @example\n *\n * _.isArrayLikeObject([1, 2, 3]);\n * // => true\n *\n * _.isArrayLikeObject(document.body.children);\n * // => true\n *\n * _.isArrayLikeObject('abc');\n * // => false\n *\n * _.isArrayLikeObject(_.noop);\n * // => false\n */\nfunction isArrayLikeObject(value) {\n  return isObjectLike(value) && isArrayLike(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 * 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 a plain object, that is, an object created by the\n * `Object` constructor or one with a `[[Prototype]]` of `null`.\n *\n * @static\n * @memberOf _\n * @since 0.8.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n * }\n *\n * _.isPlainObject(new Foo);\n * // => false\n *\n * _.isPlainObject([1, 2, 3]);\n * // => false\n *\n * _.isPlainObject({ 'x': 0, 'y': 0 });\n * // => true\n *\n * _.isPlainObject(Object.create(null));\n * // => true\n */\nfunction isPlainObject(value) {\n  if (!isObjectLike(value) || baseGetTag(value) != objectTag) {\n    return false;\n  }\n  var proto = getPrototype(value);\n  if (proto === null) {\n    return true;\n  }\n  var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;\n  return typeof Ctor == 'function' && Ctor instanceof Ctor &&\n    funcToString.call(Ctor) == objectCtorString;\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 * Converts `value` to a plain object flattening inherited enumerable string\n * keyed properties of `value` to own properties of the plain object.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {Object} Returns the converted plain object.\n * @example\n *\n * function Foo() {\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.assign({ 'a': 1 }, new Foo);\n * // => { 'a': 1, 'b': 2 }\n *\n * _.assign({ 'a': 1 }, _.toPlainObject(new Foo));\n * // => { 'a': 1, 'b': 2, 'c': 3 }\n */\nfunction toPlainObject(value) {\n  return copyObject(value, keysIn(value));\n}\n\n/**\n * Creates an array of the own and inherited enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keysIn(new Foo);\n * // => ['a', 'b', 'c'] (iteration order is not guaranteed)\n */\nfunction keysIn(object) {\n  return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);\n}\n\n/**\n * This method is like `_.merge` except that it accepts `customizer` which\n * is invoked to produce the merged values of the destination and source\n * properties. If `customizer` returns `undefined`, merging is handled by the\n * method instead. The `customizer` is invoked with six arguments:\n * (objValue, srcValue, key, object, source, stack).\n *\n * **Note:** This method mutates `object`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Object\n * @param {Object} object The destination object.\n * @param {...Object} sources The source objects.\n * @param {Function} customizer The function to customize assigned values.\n * @returns {Object} Returns `object`.\n * @example\n *\n * function customizer(objValue, srcValue) {\n *   if (_.isArray(objValue)) {\n *     return objValue.concat(srcValue);\n *   }\n * }\n *\n * var object = { 'a': [1], 'b': [2] };\n * var other = { 'a': [3], 'b': [4] };\n *\n * _.mergeWith(object, other, customizer);\n * // => { 'a': [1, 3], 'b': [2, 4] }\n */\nvar mergeWith = createAssigner(function(object, source, srcIndex, customizer) {\n  baseMerge(object, source, srcIndex, customizer);\n});\n\n/**\n * Creates a function that returns `value`.\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Util\n * @param {*} value The value to return from the new function.\n * @returns {Function} Returns the new constant function.\n * @example\n *\n * var objects = _.times(2, _.constant({ 'a': 1 }));\n *\n * console.log(objects);\n * // => [{ 'a': 1 }, { 'a': 1 }]\n *\n * console.log(objects[0] === objects[1]);\n * // => true\n */\nfunction constant(value) {\n  return function() {\n    return value;\n  };\n}\n\n/**\n * This method returns the first argument it receives.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Util\n * @param {*} value Any value.\n * @returns {*} Returns `value`.\n * @example\n *\n * var object = { 'a': 1 };\n *\n * console.log(_.identity(object) === object);\n * // => true\n */\nfunction identity(value) {\n  return value;\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 = mergeWith;\n","/**\n * lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright jQuery Foundation and other contributors <https://jquery.org/>\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 as references for various `Number` constants. */\nvar INFINITY = 1 / 0,\n    MAX_SAFE_INTEGER = 9007199254740991;\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n    funcTag = '[object Function]',\n    genTag = '[object GeneratorFunction]',\n    symbolTag = '[object Symbol]';\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/** 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/**\n * A faster alternative to `Function#apply`, this function invokes `func`\n * with the `this` binding of `thisArg` and the arguments of `args`.\n *\n * @private\n * @param {Function} func The function to invoke.\n * @param {*} thisArg The `this` binding of `func`.\n * @param {Array} args The arguments to invoke `func` with.\n * @returns {*} Returns the result of `func`.\n */\nfunction apply(func, thisArg, args) {\n  switch (args.length) {\n    case 0: return func.call(thisArg);\n    case 1: return func.call(thisArg, args[0]);\n    case 2: return func.call(thisArg, args[0], args[1]);\n    case 3: return func.call(thisArg, args[0], args[1], args[2]);\n  }\n  return func.apply(thisArg, args);\n}\n\n/**\n * A specialized version of `_.includes` for arrays without support for\n * specifying an index to search from.\n *\n * @private\n * @param {Array} [array] The array to inspect.\n * @param {*} target The value to search for.\n * @returns {boolean} Returns `true` if `target` is found, else `false`.\n */\nfunction arrayIncludes(array, value) {\n  var length = array ? array.length : 0;\n  return !!length && baseIndexOf(array, value, 0) > -1;\n}\n\n/**\n * This function is like `arrayIncludes` except that it accepts a comparator.\n *\n * @private\n * @param {Array} [array] The array to inspect.\n * @param {*} target The value to search for.\n * @param {Function} comparator The comparator invoked per element.\n * @returns {boolean} Returns `true` if `target` is found, else `false`.\n */\nfunction arrayIncludesWith(array, value, comparator) {\n  var index = -1,\n      length = array ? array.length : 0;\n\n  while (++index < length) {\n    if (comparator(value, array[index])) {\n      return true;\n    }\n  }\n  return false;\n}\n\n/**\n * A specialized version of `_.map` for arrays without support for iteratee\n * shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the new mapped array.\n */\nfunction arrayMap(array, iteratee) {\n  var index = -1,\n      length = array ? array.length : 0,\n      result = Array(length);\n\n  while (++index < length) {\n    result[index] = iteratee(array[index], index, array);\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 * The base implementation of `_.findIndex` and `_.findLastIndex` without\n * support for iteratee shorthands.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {Function} predicate The function invoked per iteration.\n * @param {number} fromIndex The index to search from.\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\nfunction baseFindIndex(array, predicate, fromIndex, fromRight) {\n  var length = array.length,\n      index = fromIndex + (fromRight ? 1 : -1);\n\n  while ((fromRight ? index-- : ++index < length)) {\n    if (predicate(array[index], index, array)) {\n      return index;\n    }\n  }\n  return -1;\n}\n\n/**\n * The base implementation of `_.indexOf` without `fromIndex` bounds checks.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} value The value to search for.\n * @param {number} fromIndex The index to search from.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\nfunction baseIndexOf(array, value, fromIndex) {\n  if (value !== value) {\n    return baseFindIndex(array, baseIsNaN, fromIndex);\n  }\n  var index = fromIndex - 1,\n      length = array.length;\n\n  while (++index < length) {\n    if (array[index] === value) {\n      return index;\n    }\n  }\n  return -1;\n}\n\n/**\n * The base implementation of `_.isNaN` without support for number objects.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.\n */\nfunction baseIsNaN(value) {\n  return value !== value;\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 * Checks if `value` is a host object in IE < 9.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a host object, else `false`.\n */\nfunction isHostObject(value) {\n  // Many host objects are `Object` objects that can coerce to strings\n  // despite having improperly defined `toString` methods.\n  var result = false;\n  if (value != null && typeof value.toString != 'function') {\n    try {\n      result = !!(value + '');\n    } catch (e) {}\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/** 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 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/** 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/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objectToString = 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 Symbol = root.Symbol,\n    getPrototype = overArg(Object.getPrototypeOf, Object),\n    propertyIsEnumerable = objectProto.propertyIsEnumerable,\n    splice = arrayProto.splice,\n    spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : undefined;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeGetSymbols = Object.getOwnPropertySymbols,\n    nativeMax = Math.max;\n\n/* Built-in method references that are verified to be native. */\nvar Map = getNative(root, 'Map'),\n    nativeCreate = getNative(Object, 'create');\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 ? entries.length : 0;\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}\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  return this.has(key) && delete this.__data__[key];\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  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 ? entries.length : 0;\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}\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  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    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 ? entries.length : 0;\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.__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  return getMapData(this, key)['delete'](key);\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  getMapData(this, key).set(key, value);\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 ? values.length : 0;\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 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  // Safari 8.1 makes `arguments.callee` enumerable in strict mode.\n  // Safari 9 makes `arguments.length` enumerable in strict mode.\n  var result = (isArray(value) || isArguments(value))\n    ? baseTimes(value.length, String)\n    : [];\n\n  var length = result.length,\n      skipIndexes = !!length;\n\n  for (var key in value) {\n    if ((inherited || hasOwnProperty.call(value, key)) &&\n        !(skipIndexes && (key == 'length' || isIndex(key, length)))) {\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 methods like `_.difference` without support\n * for excluding multiple arrays or iteratee shorthands.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {Array} values The values to exclude.\n * @param {Function} [iteratee] The iteratee invoked per element.\n * @param {Function} [comparator] The comparator invoked per element.\n * @returns {Array} Returns the new array of filtered values.\n */\nfunction baseDifference(array, values, iteratee, comparator) {\n  var index = -1,\n      includes = arrayIncludes,\n      isCommon = true,\n      length = array.length,\n      result = [],\n      valuesLength = values.length;\n\n  if (!length) {\n    return result;\n  }\n  if (iteratee) {\n    values = arrayMap(values, baseUnary(iteratee));\n  }\n  if (comparator) {\n    includes = arrayIncludesWith;\n    isCommon = false;\n  }\n  else if (values.length >= LARGE_ARRAY_SIZE) {\n    includes = cacheHas;\n    isCommon = false;\n    values = new SetCache(values);\n  }\n  outer:\n  while (++index < length) {\n    var value = array[index],\n        computed = iteratee ? iteratee(value) : value;\n\n    value = (comparator || value !== 0) ? value : 0;\n    if (isCommon && computed === computed) {\n      var valuesIndex = valuesLength;\n      while (valuesIndex--) {\n        if (values[valuesIndex] === computed) {\n          continue outer;\n        }\n      }\n      result.push(value);\n    }\n    else if (!includes(values, computed, comparator)) {\n      result.push(value);\n    }\n  }\n  return result;\n}\n\n/**\n * The base implementation of `_.flatten` with support for restricting flattening.\n *\n * @private\n * @param {Array} array The array to flatten.\n * @param {number} depth The maximum recursion depth.\n * @param {boolean} [predicate=isFlattenable] The function invoked per iteration.\n * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks.\n * @param {Array} [result=[]] The initial result value.\n * @returns {Array} Returns the new flattened array.\n */\nfunction baseFlatten(array, depth, predicate, isStrict, result) {\n  var index = -1,\n      length = array.length;\n\n  predicate || (predicate = isFlattenable);\n  result || (result = []);\n\n  while (++index < length) {\n    var value = array[index];\n    if (depth > 0 && predicate(value)) {\n      if (depth > 1) {\n        // Recursively flatten arrays (susceptible to call stack limits).\n        baseFlatten(value, depth - 1, predicate, isStrict, result);\n      } else {\n        arrayPush(result, value);\n      }\n    } else if (!isStrict) {\n      result[result.length] = value;\n    }\n  }\n  return result;\n}\n\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 `_.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) || isHostObject(value)) ? reIsNative : reIsHostCtor;\n  return pattern.test(toSource(value));\n}\n\n/**\n * The base implementation of `_.keysIn` 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 baseKeysIn(object) {\n  if (!isObject(object)) {\n    return nativeKeysIn(object);\n  }\n  var isProto = isPrototype(object),\n      result = [];\n\n  for (var key in object) {\n    if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\n/**\n * The base implementation of `_.pick` without support for individual\n * property identifiers.\n *\n * @private\n * @param {Object} object The source object.\n * @param {string[]} props The property identifiers to pick.\n * @returns {Object} Returns the new object.\n */\nfunction basePick(object, props) {\n  object = Object(object);\n  return basePickBy(object, props, function(value, key) {\n    return key in object;\n  });\n}\n\n/**\n * The base implementation of  `_.pickBy` without support for iteratee shorthands.\n *\n * @private\n * @param {Object} object The source object.\n * @param {string[]} props The property identifiers to pick from.\n * @param {Function} predicate The function invoked per property.\n * @returns {Object} Returns the new object.\n */\nfunction basePickBy(object, props, predicate) {\n  var index = -1,\n      length = props.length,\n      result = {};\n\n  while (++index < length) {\n    var key = props[index],\n        value = object[key];\n\n    if (predicate(value, key)) {\n      result[key] = value;\n    }\n  }\n  return result;\n}\n\n/**\n * The base implementation of `_.rest` which doesn't validate or coerce arguments.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @returns {Function} Returns the new function.\n */\nfunction baseRest(func, start) {\n  start = nativeMax(start === undefined ? (func.length - 1) : start, 0);\n  return function() {\n    var args = arguments,\n        index = -1,\n        length = nativeMax(args.length - start, 0),\n        array = Array(length);\n\n    while (++index < length) {\n      array[index] = args[start + index];\n    }\n    index = -1;\n    var otherArgs = Array(start + 1);\n    while (++index < start) {\n      otherArgs[index] = args[index];\n    }\n    otherArgs[start] = array;\n    return apply(func, this, otherArgs);\n  };\n}\n\n/**\n * Creates an array of own and inherited enumerable property names and\n * 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 getAllKeysIn(object) {\n  return baseGetAllKeys(object, keysIn, getSymbolsIn);\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 * Creates an array of the own enumerable symbol properties 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 ? overArg(nativeGetSymbols, Object) : stubArray;\n\n/**\n * Creates an array of the own and inherited enumerable symbol properties\n * of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of symbols.\n */\nvar getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) {\n  var result = [];\n  while (object) {\n    arrayPush(result, getSymbols(object));\n    object = getPrototype(object);\n  }\n  return result;\n};\n\n/**\n * Checks if `value` is a flattenable `arguments` object or array.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is flattenable, else `false`.\n */\nfunction isFlattenable(value) {\n  return isArray(value) || isArguments(value) ||\n    !!(spreadableSymbol && value && value[spreadableSymbol]);\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 * This function is like\n * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * except that it includes inherited enumerable properties.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction nativeKeysIn(object) {\n  var result = [];\n  if (object != null) {\n    for (var key in Object(object)) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\n/**\n * Converts `value` to a string key if it's not a string or symbol.\n *\n * @private\n * @param {*} value The value to inspect.\n * @returns {string|symbol} Returns the key.\n */\nfunction toKey(value) {\n  if (typeof value == 'string' || isSymbol(value)) {\n    return value;\n  }\n  var result = (value + '');\n  return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;\n}\n\n/**\n * Converts `func` to its source code.\n *\n * @private\n * @param {Function} func The function to process.\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 */\nfunction isArguments(value) {\n  // Safari 8.1 makes `arguments.callee` enumerable in strict mode.\n  return isArrayLikeObject(value) && hasOwnProperty.call(value, 'callee') &&\n    (!propertyIsEnumerable.call(value, 'callee') || objectToString.call(value) == argsTag);\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 * This method is like `_.isArrayLike` except that it also checks if `value`\n * is an 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 an array-like object,\n *  else `false`.\n * @example\n *\n * _.isArrayLikeObject([1, 2, 3]);\n * // => true\n *\n * _.isArrayLikeObject(document.body.children);\n * // => true\n *\n * _.isArrayLikeObject('abc');\n * // => false\n *\n * _.isArrayLikeObject(_.noop);\n * // => false\n */\nfunction isArrayLikeObject(value) {\n  return isObjectLike(value) && isArrayLike(value);\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  // The use of `Object#toString` avoids issues with the `typeof` operator\n  // in Safari 8-9 which returns 'object' for typed array and other constructors.\n  var tag = isObject(value) ? objectToString.call(value) : '';\n  return tag == funcTag || tag == genTag;\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 && (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 && typeof value == 'object';\n}\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or 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 a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n  return typeof value == 'symbol' ||\n    (isObjectLike(value) && objectToString.call(value) == symbolTag);\n}\n\n/**\n * Creates an array of the own and inherited enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keysIn(new Foo);\n * // => ['a', 'b', 'c'] (iteration order is not guaranteed)\n */\nfunction keysIn(object) {\n  return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);\n}\n\n/**\n * The opposite of `_.pick`; this method creates an object composed of the\n * own and inherited enumerable string keyed properties of `object` that are\n * not omitted.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The source object.\n * @param {...(string|string[])} [props] The property identifiers to omit.\n * @returns {Object} Returns the new object.\n * @example\n *\n * var object = { 'a': 1, 'b': '2', 'c': 3 };\n *\n * _.omit(object, ['a', 'c']);\n * // => { 'b': '2' }\n */\nvar omit = baseRest(function(object, props) {\n  if (object == null) {\n    return {};\n  }\n  props = arrayMap(baseFlatten(props, 1), toKey);\n  return basePick(object, baseDifference(getAllKeysIn(object), props));\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\nmodule.exports = omit;\n","'use strict';\nconst strictUriEncode = require('strict-uri-encode');\nconst decodeComponent = require('decode-uri-component');\nconst splitOnFirst = require('split-on-first');\nconst filterObject = require('filter-obj');\n\nconst isNullOrUndefined = value => value === null || value === undefined;\n\nfunction encoderForArrayFormat(options) {\n\tswitch (options.arrayFormat) {\n\t\tcase 'index':\n\t\t\treturn key => (result, value) => {\n\t\t\t\tconst index = result.length;\n\n\t\t\t\tif (\n\t\t\t\t\tvalue === undefined ||\n\t\t\t\t\t(options.skipNull && value === null) ||\n\t\t\t\t\t(options.skipEmptyString && value === '')\n\t\t\t\t) {\n\t\t\t\t\treturn result;\n\t\t\t\t}\n\n\t\t\t\tif (value === null) {\n\t\t\t\t\treturn [...result, [encode(key, options), '[', index, ']'].join('')];\n\t\t\t\t}\n\n\t\t\t\treturn [\n\t\t\t\t\t...result,\n\t\t\t\t\t[encode(key, options), '[', encode(index, options), ']=', encode(value, options)].join('')\n\t\t\t\t];\n\t\t\t};\n\n\t\tcase 'bracket':\n\t\t\treturn key => (result, value) => {\n\t\t\t\tif (\n\t\t\t\t\tvalue === undefined ||\n\t\t\t\t\t(options.skipNull && value === null) ||\n\t\t\t\t\t(options.skipEmptyString && value === '')\n\t\t\t\t) {\n\t\t\t\t\treturn result;\n\t\t\t\t}\n\n\t\t\t\tif (value === null) {\n\t\t\t\t\treturn [...result, [encode(key, options), '[]'].join('')];\n\t\t\t\t}\n\n\t\t\t\treturn [...result, [encode(key, options), '[]=', encode(value, options)].join('')];\n\t\t\t};\n\n\t\tcase 'comma':\n\t\tcase 'separator':\n\t\t\treturn key => (result, value) => {\n\t\t\t\tif (value === null || value === undefined || value.length === 0) {\n\t\t\t\t\treturn result;\n\t\t\t\t}\n\n\t\t\t\tif (result.length === 0) {\n\t\t\t\t\treturn [[encode(key, options), '=', encode(value, options)].join('')];\n\t\t\t\t}\n\n\t\t\t\treturn [[result, encode(value, options)].join(options.arrayFormatSeparator)];\n\t\t\t};\n\n\t\tdefault:\n\t\t\treturn key => (result, value) => {\n\t\t\t\tif (\n\t\t\t\t\tvalue === undefined ||\n\t\t\t\t\t(options.skipNull && value === null) ||\n\t\t\t\t\t(options.skipEmptyString && value === '')\n\t\t\t\t) {\n\t\t\t\t\treturn result;\n\t\t\t\t}\n\n\t\t\t\tif (value === null) {\n\t\t\t\t\treturn [...result, encode(key, options)];\n\t\t\t\t}\n\n\t\t\t\treturn [...result, [encode(key, options), '=', encode(value, options)].join('')];\n\t\t\t};\n\t}\n}\n\nfunction parserForArrayFormat(options) {\n\tlet result;\n\n\tswitch (options.arrayFormat) {\n\t\tcase 'index':\n\t\t\treturn (key, value, accumulator) => {\n\t\t\t\tresult = /\\[(\\d*)\\]$/.exec(key);\n\n\t\t\t\tkey = key.replace(/\\[\\d*\\]$/, '');\n\n\t\t\t\tif (!result) {\n\t\t\t\t\taccumulator[key] = value;\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tif (accumulator[key] === undefined) {\n\t\t\t\t\taccumulator[key] = {};\n\t\t\t\t}\n\n\t\t\t\taccumulator[key][result[1]] = value;\n\t\t\t};\n\n\t\tcase 'bracket':\n\t\t\treturn (key, value, accumulator) => {\n\t\t\t\tresult = /(\\[\\])$/.exec(key);\n\t\t\t\tkey = key.replace(/\\[\\]$/, '');\n\n\t\t\t\tif (!result) {\n\t\t\t\t\taccumulator[key] = value;\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tif (accumulator[key] === undefined) {\n\t\t\t\t\taccumulator[key] = [value];\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\taccumulator[key] = [].concat(accumulator[key], value);\n\t\t\t};\n\n\t\tcase 'comma':\n\t\tcase 'separator':\n\t\t\treturn (key, value, accumulator) => {\n\t\t\t\tconst isArray = typeof value === 'string' && value.includes(options.arrayFormatSeparator);\n\t\t\t\tconst isEncodedArray = (typeof value === 'string' && !isArray && decode(value, options).includes(options.arrayFormatSeparator));\n\t\t\t\tvalue = isEncodedArray ? decode(value, options) : value;\n\t\t\t\tconst newValue = isArray || isEncodedArray ? value.split(options.arrayFormatSeparator).map(item => decode(item, options)) : value === null ? value : decode(value, options);\n\t\t\t\taccumulator[key] = newValue;\n\t\t\t};\n\n\t\tdefault:\n\t\t\treturn (key, value, accumulator) => {\n\t\t\t\tif (accumulator[key] === undefined) {\n\t\t\t\t\taccumulator[key] = value;\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\taccumulator[key] = [].concat(accumulator[key], value);\n\t\t\t};\n\t}\n}\n\nfunction validateArrayFormatSeparator(value) {\n\tif (typeof value !== 'string' || value.length !== 1) {\n\t\tthrow new TypeError('arrayFormatSeparator must be single character string');\n\t}\n}\n\nfunction encode(value, options) {\n\tif (options.encode) {\n\t\treturn options.strict ? strictUriEncode(value) : encodeURIComponent(value);\n\t}\n\n\treturn value;\n}\n\nfunction decode(value, options) {\n\tif (options.decode) {\n\t\treturn decodeComponent(value);\n\t}\n\n\treturn value;\n}\n\nfunction keysSorter(input) {\n\tif (Array.isArray(input)) {\n\t\treturn input.sort();\n\t}\n\n\tif (typeof input === 'object') {\n\t\treturn keysSorter(Object.keys(input))\n\t\t\t.sort((a, b) => Number(a) - Number(b))\n\t\t\t.map(key => input[key]);\n\t}\n\n\treturn input;\n}\n\nfunction removeHash(input) {\n\tconst hashStart = input.indexOf('#');\n\tif (hashStart !== -1) {\n\t\tinput = input.slice(0, hashStart);\n\t}\n\n\treturn input;\n}\n\nfunction getHash(url) {\n\tlet hash = '';\n\tconst hashStart = url.indexOf('#');\n\tif (hashStart !== -1) {\n\t\thash = url.slice(hashStart);\n\t}\n\n\treturn hash;\n}\n\nfunction extract(input) {\n\tinput = removeHash(input);\n\tconst queryStart = input.indexOf('?');\n\tif (queryStart === -1) {\n\t\treturn '';\n\t}\n\n\treturn input.slice(queryStart + 1);\n}\n\nfunction parseValue(value, options) {\n\tif (options.parseNumbers && !Number.isNaN(Number(value)) && (typeof value === 'string' && value.trim() !== '')) {\n\t\tvalue = Number(value);\n\t} else if (options.parseBooleans && value !== null && (value.toLowerCase() === 'true' || value.toLowerCase() === 'false')) {\n\t\tvalue = value.toLowerCase() === 'true';\n\t}\n\n\treturn value;\n}\n\nfunction parse(query, options) {\n\toptions = Object.assign({\n\t\tdecode: true,\n\t\tsort: true,\n\t\tarrayFormat: 'none',\n\t\tarrayFormatSeparator: ',',\n\t\tparseNumbers: false,\n\t\tparseBooleans: false\n\t}, options);\n\n\tvalidateArrayFormatSeparator(options.arrayFormatSeparator);\n\n\tconst formatter = parserForArrayFormat(options);\n\n\t// Create an object with no prototype\n\tconst ret = Object.create(null);\n\n\tif (typeof query !== 'string') {\n\t\treturn ret;\n\t}\n\n\tquery = query.trim().replace(/^[?#&]/, '');\n\n\tif (!query) {\n\t\treturn ret;\n\t}\n\n\tfor (const param of query.split('&')) {\n\t\tif (param === '') {\n\t\t\tcontinue;\n\t\t}\n\n\t\tlet [key, value] = splitOnFirst(options.decode ? param.replace(/\\+/g, ' ') : param, '=');\n\n\t\t// Missing `=` should be `null`:\n\t\t// http://w3.org/TR/2012/WD-url-20120524/#collect-url-parameters\n\t\tvalue = value === undefined ? null : ['comma', 'separator'].includes(options.arrayFormat) ? value : decode(value, options);\n\t\tformatter(decode(key, options), value, ret);\n\t}\n\n\tfor (const key of Object.keys(ret)) {\n\t\tconst value = ret[key];\n\t\tif (typeof value === 'object' && value !== null) {\n\t\t\tfor (const k of Object.keys(value)) {\n\t\t\t\tvalue[k] = parseValue(value[k], options);\n\t\t\t}\n\t\t} else {\n\t\t\tret[key] = parseValue(value, options);\n\t\t}\n\t}\n\n\tif (options.sort === false) {\n\t\treturn ret;\n\t}\n\n\treturn (options.sort === true ? Object.keys(ret).sort() : Object.keys(ret).sort(options.sort)).reduce((result, key) => {\n\t\tconst value = ret[key];\n\t\tif (Boolean(value) && typeof value === 'object' && !Array.isArray(value)) {\n\t\t\t// Sort object keys, not values\n\t\t\tresult[key] = keysSorter(value);\n\t\t} else {\n\t\t\tresult[key] = value;\n\t\t}\n\n\t\treturn result;\n\t}, Object.create(null));\n}\n\nexports.extract = extract;\nexports.parse = parse;\n\nexports.stringify = (object, options) => {\n\tif (!object) {\n\t\treturn '';\n\t}\n\n\toptions = Object.assign({\n\t\tencode: true,\n\t\tstrict: true,\n\t\tarrayFormat: 'none',\n\t\tarrayFormatSeparator: ','\n\t}, options);\n\n\tvalidateArrayFormatSeparator(options.arrayFormatSeparator);\n\n\tconst shouldFilter = key => (\n\t\t(options.skipNull && isNullOrUndefined(object[key])) ||\n\t\t(options.skipEmptyString && object[key] === '')\n\t);\n\n\tconst formatter = encoderForArrayFormat(options);\n\n\tconst objectCopy = {};\n\n\tfor (const key of Object.keys(object)) {\n\t\tif (!shouldFilter(key)) {\n\t\t\tobjectCopy[key] = object[key];\n\t\t}\n\t}\n\n\tconst keys = Object.keys(objectCopy);\n\n\tif (options.sort !== false) {\n\t\tkeys.sort(options.sort);\n\t}\n\n\treturn keys.map(key => {\n\t\tconst value = object[key];\n\n\t\tif (value === undefined) {\n\t\t\treturn '';\n\t\t}\n\n\t\tif (value === null) {\n\t\t\treturn encode(key, options);\n\t\t}\n\n\t\tif (Array.isArray(value)) {\n\t\t\treturn value\n\t\t\t\t.reduce(formatter(key), [])\n\t\t\t\t.join('&');\n\t\t}\n\n\t\treturn encode(key, options) + '=' + encode(value, options);\n\t}).filter(x => x.length > 0).join('&');\n};\n\nexports.parseUrl = (url, options) => {\n\toptions = Object.assign({\n\t\tdecode: true\n\t}, options);\n\n\tconst [url_, hash] = splitOnFirst(url, '#');\n\n\treturn Object.assign(\n\t\t{\n\t\t\turl: url_.split('?')[0] || '',\n\t\t\tquery: parse(extract(url), options)\n\t\t},\n\t\toptions && options.parseFragmentIdentifier && hash ? {fragmentIdentifier: decode(hash, options)} : {}\n\t);\n};\n\nexports.stringifyUrl = (object, options) => {\n\toptions = Object.assign({\n\t\tencode: true,\n\t\tstrict: true\n\t}, options);\n\n\tconst url = removeHash(object.url).split('?')[0] || '';\n\tconst queryFromUrl = exports.extract(object.url);\n\tconst parsedQueryFromUrl = exports.parse(queryFromUrl, {sort: false});\n\n\tconst query = Object.assign(parsedQueryFromUrl, object.query);\n\tlet queryString = exports.stringify(query, options);\n\tif (queryString) {\n\t\tqueryString = `?${queryString}`;\n\t}\n\n\tlet hash = getHash(object.url);\n\tif (object.fragmentIdentifier) {\n\t\thash = `#${encode(object.fragmentIdentifier, options)}`;\n\t}\n\n\treturn `${url}${queryString}${hash}`;\n};\n\nexports.pick = (input, filter, options) => {\n\toptions = Object.assign({\n\t\tparseFragmentIdentifier: true\n\t}, options);\n\n\tconst {url, query, fragmentIdentifier} = exports.parseUrl(input, options);\n\treturn exports.stringifyUrl({\n\t\turl,\n\t\tquery: filterObject(query, filter),\n\t\tfragmentIdentifier\n\t}, options);\n};\n\nexports.exclude = (input, filter, options) => {\n\tconst exclusionFilter = Array.isArray(filter) ? key => !filter.includes(key) : (key, value) => !filter(key, value);\n\n\treturn exports.pick(input, exclusionFilter, options);\n};\n","var __extends = (this && this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nvar __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nimport * as React from 'react';\nvar rowSizeBase = {\n    width: '100%',\n    height: '10px',\n    top: '0px',\n    left: '0px',\n    cursor: 'row-resize',\n};\nvar colSizeBase = {\n    width: '10px',\n    height: '100%',\n    top: '0px',\n    left: '0px',\n    cursor: 'col-resize',\n};\nvar edgeBase = {\n    width: '20px',\n    height: '20px',\n    position: 'absolute',\n};\nvar styles = {\n    top: __assign(__assign({}, rowSizeBase), { top: '-5px' }),\n    right: __assign(__assign({}, colSizeBase), { left: undefined, right: '-5px' }),\n    bottom: __assign(__assign({}, rowSizeBase), { top: undefined, bottom: '-5px' }),\n    left: __assign(__assign({}, colSizeBase), { left: '-5px' }),\n    topRight: __assign(__assign({}, edgeBase), { right: '-10px', top: '-10px', cursor: 'ne-resize' }),\n    bottomRight: __assign(__assign({}, edgeBase), { right: '-10px', bottom: '-10px', cursor: 'se-resize' }),\n    bottomLeft: __assign(__assign({}, edgeBase), { left: '-10px', bottom: '-10px', cursor: 'sw-resize' }),\n    topLeft: __assign(__assign({}, edgeBase), { left: '-10px', top: '-10px', cursor: 'nw-resize' }),\n};\nvar Resizer = /** @class */ (function (_super) {\n    __extends(Resizer, _super);\n    function Resizer() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        _this.onMouseDown = function (e) {\n            _this.props.onResizeStart(e, _this.props.direction);\n        };\n        _this.onTouchStart = function (e) {\n            _this.props.onResizeStart(e, _this.props.direction);\n        };\n        return _this;\n    }\n    Resizer.prototype.render = function () {\n        return (React.createElement(\"div\", { className: this.props.className || '', style: __assign(__assign({ position: 'absolute', userSelect: 'none' }, styles[this.props.direction]), (this.props.replaceStyles || {})), onMouseDown: this.onMouseDown, onTouchStart: this.onTouchStart }, this.props.children));\n    };\n    return Resizer;\n}(React.PureComponent));\nexport { Resizer };\n","var __extends = (this && this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nvar __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nimport * as React from 'react';\nimport { flushSync } from 'react-dom';\nimport { Resizer } from './resizer';\nvar DEFAULT_SIZE = {\n    width: 'auto',\n    height: 'auto',\n};\nvar clamp = function (n, min, max) { return Math.max(Math.min(n, max), min); };\nvar snap = function (n, size) { return Math.round(n / size) * size; };\nvar hasDirection = function (dir, target) {\n    return new RegExp(dir, 'i').test(target);\n};\n// INFO: In case of window is a Proxy and does not porxy Events correctly, use isTouchEvent & isMouseEvent to distinguish event type instead of `instanceof`.\nvar isTouchEvent = function (event) {\n    return Boolean(event.touches && event.touches.length);\n};\nvar isMouseEvent = function (event) {\n    return Boolean((event.clientX || event.clientX === 0) &&\n        (event.clientY || event.clientY === 0));\n};\nvar findClosestSnap = function (n, snapArray, snapGap) {\n    if (snapGap === void 0) { snapGap = 0; }\n    var closestGapIndex = snapArray.reduce(function (prev, curr, index) { return (Math.abs(curr - n) < Math.abs(snapArray[prev] - n) ? index : prev); }, 0);\n    var gap = Math.abs(snapArray[closestGapIndex] - n);\n    return snapGap === 0 || gap < snapGap ? snapArray[closestGapIndex] : n;\n};\nvar getStringSize = function (n) {\n    n = n.toString();\n    if (n === 'auto') {\n        return n;\n    }\n    if (n.endsWith('px')) {\n        return n;\n    }\n    if (n.endsWith('%')) {\n        return n;\n    }\n    if (n.endsWith('vh')) {\n        return n;\n    }\n    if (n.endsWith('vw')) {\n        return n;\n    }\n    if (n.endsWith('vmax')) {\n        return n;\n    }\n    if (n.endsWith('vmin')) {\n        return n;\n    }\n    return n + \"px\";\n};\nvar getPixelSize = function (size, parentSize, innerWidth, innerHeight) {\n    if (size && typeof size === 'string') {\n        if (size.endsWith('px')) {\n            return Number(size.replace('px', ''));\n        }\n        if (size.endsWith('%')) {\n            var ratio = Number(size.replace('%', '')) / 100;\n            return parentSize * ratio;\n        }\n        if (size.endsWith('vw')) {\n            var ratio = Number(size.replace('vw', '')) / 100;\n            return innerWidth * ratio;\n        }\n        if (size.endsWith('vh')) {\n            var ratio = Number(size.replace('vh', '')) / 100;\n            return innerHeight * ratio;\n        }\n    }\n    return size;\n};\nvar calculateNewMax = function (parentSize, innerWidth, innerHeight, maxWidth, maxHeight, minWidth, minHeight) {\n    maxWidth = getPixelSize(maxWidth, parentSize.width, innerWidth, innerHeight);\n    maxHeight = getPixelSize(maxHeight, parentSize.height, innerWidth, innerHeight);\n    minWidth = getPixelSize(minWidth, parentSize.width, innerWidth, innerHeight);\n    minHeight = getPixelSize(minHeight, parentSize.height, innerWidth, innerHeight);\n    return {\n        maxWidth: typeof maxWidth === 'undefined' ? undefined : Number(maxWidth),\n        maxHeight: typeof maxHeight === 'undefined' ? undefined : Number(maxHeight),\n        minWidth: typeof minWidth === 'undefined' ? undefined : Number(minWidth),\n        minHeight: typeof minHeight === 'undefined' ? undefined : Number(minHeight),\n    };\n};\nvar definedProps = [\n    'as',\n    'style',\n    'className',\n    'grid',\n    'snap',\n    'bounds',\n    'boundsByDirection',\n    'size',\n    'defaultSize',\n    'minWidth',\n    'minHeight',\n    'maxWidth',\n    'maxHeight',\n    'lockAspectRatio',\n    'lockAspectRatioExtraWidth',\n    'lockAspectRatioExtraHeight',\n    'enable',\n    'handleStyles',\n    'handleClasses',\n    'handleWrapperStyle',\n    'handleWrapperClass',\n    'children',\n    'onResizeStart',\n    'onResize',\n    'onResizeStop',\n    'handleComponent',\n    'scale',\n    'resizeRatio',\n    'snapGap',\n];\n// HACK: This class is used to calculate % size.\nvar baseClassName = '__resizable_base__';\nvar Resizable = /** @class */ (function (_super) {\n    __extends(Resizable, _super);\n    function Resizable(props) {\n        var _this = _super.call(this, props) || this;\n        _this.ratio = 1;\n        _this.resizable = null;\n        // For parent boundary\n        _this.parentLeft = 0;\n        _this.parentTop = 0;\n        // For boundary\n        _this.resizableLeft = 0;\n        _this.resizableRight = 0;\n        _this.resizableTop = 0;\n        _this.resizableBottom = 0;\n        // For target boundary\n        _this.targetLeft = 0;\n        _this.targetTop = 0;\n        _this.appendBase = function () {\n            if (!_this.resizable || !_this.window) {\n                return null;\n            }\n            var parent = _this.parentNode;\n            if (!parent) {\n                return null;\n            }\n            var element = _this.window.document.createElement('div');\n            element.style.width = '100%';\n            element.style.height = '100%';\n            element.style.position = 'absolute';\n            element.style.transform = 'scale(0, 0)';\n            element.style.left = '0';\n            element.style.flex = '0 0 100%';\n            if (element.classList) {\n                element.classList.add(baseClassName);\n            }\n            else {\n                element.className += baseClassName;\n            }\n            parent.appendChild(element);\n            return element;\n        };\n        _this.removeBase = function (base) {\n            var parent = _this.parentNode;\n            if (!parent) {\n                return;\n            }\n            parent.removeChild(base);\n        };\n        _this.ref = function (c) {\n            if (c) {\n                _this.resizable = c;\n            }\n        };\n        _this.state = {\n            isResizing: false,\n            width: typeof (_this.propsSize && _this.propsSize.width) === 'undefined'\n                ? 'auto'\n                : _this.propsSize && _this.propsSize.width,\n            height: typeof (_this.propsSize && _this.propsSize.height) === 'undefined'\n                ? 'auto'\n                : _this.propsSize && _this.propsSize.height,\n            direction: 'right',\n            original: {\n                x: 0,\n                y: 0,\n                width: 0,\n                height: 0,\n            },\n            backgroundStyle: {\n                height: '100%',\n                width: '100%',\n                backgroundColor: 'rgba(0,0,0,0)',\n                cursor: 'auto',\n                opacity: 0,\n                position: 'fixed',\n                zIndex: 9999,\n                top: '0',\n                left: '0',\n                bottom: '0',\n                right: '0',\n            },\n            flexBasis: undefined,\n        };\n        _this.onResizeStart = _this.onResizeStart.bind(_this);\n        _this.onMouseMove = _this.onMouseMove.bind(_this);\n        _this.onMouseUp = _this.onMouseUp.bind(_this);\n        return _this;\n    }\n    Object.defineProperty(Resizable.prototype, \"parentNode\", {\n        get: function () {\n            if (!this.resizable) {\n                return null;\n            }\n            return this.resizable.parentNode;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(Resizable.prototype, \"window\", {\n        get: function () {\n            if (!this.resizable) {\n                return null;\n            }\n            if (!this.resizable.ownerDocument) {\n                return null;\n            }\n            return this.resizable.ownerDocument.defaultView;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(Resizable.prototype, \"propsSize\", {\n        get: function () {\n            return this.props.size || this.props.defaultSize || DEFAULT_SIZE;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(Resizable.prototype, \"size\", {\n        get: function () {\n            var width = 0;\n            var height = 0;\n            if (this.resizable && this.window) {\n                var orgWidth = this.resizable.offsetWidth;\n                var orgHeight = this.resizable.offsetHeight;\n                // HACK: Set position `relative` to get parent size.\n                //       This is because when re-resizable set `absolute`, I can not get base width correctly.\n                var orgPosition = this.resizable.style.position;\n                if (orgPosition !== 'relative') {\n                    this.resizable.style.position = 'relative';\n                }\n                // INFO: Use original width or height if set auto.\n                width = this.resizable.style.width !== 'auto' ? this.resizable.offsetWidth : orgWidth;\n                height = this.resizable.style.height !== 'auto' ? this.resizable.offsetHeight : orgHeight;\n                // Restore original position\n                this.resizable.style.position = orgPosition;\n            }\n            return { width: width, height: height };\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(Resizable.prototype, \"sizeStyle\", {\n        get: function () {\n            var _this = this;\n            var size = this.props.size;\n            var getSize = function (key) {\n                if (typeof _this.state[key] === 'undefined' || _this.state[key] === 'auto') {\n                    return 'auto';\n                }\n                if (_this.propsSize && _this.propsSize[key] && _this.propsSize[key].toString().endsWith('%')) {\n                    if (_this.state[key].toString().endsWith('%')) {\n                        return _this.state[key].toString();\n                    }\n                    var parentSize = _this.getParentSize();\n                    var value = Number(_this.state[key].toString().replace('px', ''));\n                    var percent = (value / parentSize[key]) * 100;\n                    return percent + \"%\";\n                }\n                return getStringSize(_this.state[key]);\n            };\n            var width = size && typeof size.width !== 'undefined' && !this.state.isResizing\n                ? getStringSize(size.width)\n                : getSize('width');\n            var height = size && typeof size.height !== 'undefined' && !this.state.isResizing\n                ? getStringSize(size.height)\n                : getSize('height');\n            return { width: width, height: height };\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Resizable.prototype.getParentSize = function () {\n        if (!this.parentNode) {\n            if (!this.window) {\n                return { width: 0, height: 0 };\n            }\n            return { width: this.window.innerWidth, height: this.window.innerHeight };\n        }\n        var base = this.appendBase();\n        if (!base) {\n            return { width: 0, height: 0 };\n        }\n        // INFO: To calculate parent width with flex layout\n        var wrapChanged = false;\n        var wrap = this.parentNode.style.flexWrap;\n        if (wrap !== 'wrap') {\n            wrapChanged = true;\n            this.parentNode.style.flexWrap = 'wrap';\n            // HACK: Use relative to get parent padding size\n        }\n        base.style.position = 'relative';\n        base.style.minWidth = '100%';\n        base.style.minHeight = '100%';\n        var size = {\n            width: base.offsetWidth,\n            height: base.offsetHeight,\n        };\n        if (wrapChanged) {\n            this.parentNode.style.flexWrap = wrap;\n        }\n        this.removeBase(base);\n        return size;\n    };\n    Resizable.prototype.bindEvents = function () {\n        if (this.window) {\n            this.window.addEventListener('mouseup', this.onMouseUp);\n            this.window.addEventListener('mousemove', this.onMouseMove);\n            this.window.addEventListener('mouseleave', this.onMouseUp);\n            this.window.addEventListener('touchmove', this.onMouseMove, {\n                capture: true,\n                passive: false,\n            });\n            this.window.addEventListener('touchend', this.onMouseUp);\n        }\n    };\n    Resizable.prototype.unbindEvents = function () {\n        if (this.window) {\n            this.window.removeEventListener('mouseup', this.onMouseUp);\n            this.window.removeEventListener('mousemove', this.onMouseMove);\n            this.window.removeEventListener('mouseleave', this.onMouseUp);\n            this.window.removeEventListener('touchmove', this.onMouseMove, true);\n            this.window.removeEventListener('touchend', this.onMouseUp);\n        }\n    };\n    Resizable.prototype.componentDidMount = function () {\n        if (!this.resizable || !this.window) {\n            return;\n        }\n        var computedStyle = this.window.getComputedStyle(this.resizable);\n        this.setState({\n            width: this.state.width || this.size.width,\n            height: this.state.height || this.size.height,\n            flexBasis: computedStyle.flexBasis !== 'auto' ? computedStyle.flexBasis : undefined,\n        });\n    };\n    Resizable.prototype.componentWillUnmount = function () {\n        if (this.window) {\n            this.unbindEvents();\n        }\n    };\n    Resizable.prototype.createSizeForCssProperty = function (newSize, kind) {\n        var propsSize = this.propsSize && this.propsSize[kind];\n        return this.state[kind] === 'auto' &&\n            this.state.original[kind] === newSize &&\n            (typeof propsSize === 'undefined' || propsSize === 'auto')\n            ? 'auto'\n            : newSize;\n    };\n    Resizable.prototype.calculateNewMaxFromBoundary = function (maxWidth, maxHeight) {\n        var boundsByDirection = this.props.boundsByDirection;\n        var direction = this.state.direction;\n        var widthByDirection = boundsByDirection && hasDirection('left', direction);\n        var heightByDirection = boundsByDirection && hasDirection('top', direction);\n        var boundWidth;\n        var boundHeight;\n        if (this.props.bounds === 'parent') {\n            var parent_1 = this.parentNode;\n            if (parent_1) {\n                boundWidth = widthByDirection\n                    ? this.resizableRight - this.parentLeft\n                    : parent_1.offsetWidth + (this.parentLeft - this.resizableLeft);\n                boundHeight = heightByDirection\n                    ? this.resizableBottom - this.parentTop\n                    : parent_1.offsetHeight + (this.parentTop - this.resizableTop);\n            }\n        }\n        else if (this.props.bounds === 'window') {\n            if (this.window) {\n                boundWidth = widthByDirection ? this.resizableRight : this.window.innerWidth - this.resizableLeft;\n                boundHeight = heightByDirection ? this.resizableBottom : this.window.innerHeight - this.resizableTop;\n            }\n        }\n        else if (this.props.bounds) {\n            boundWidth = widthByDirection\n                ? this.resizableRight - this.targetLeft\n                : this.props.bounds.offsetWidth + (this.targetLeft - this.resizableLeft);\n            boundHeight = heightByDirection\n                ? this.resizableBottom - this.targetTop\n                : this.props.bounds.offsetHeight + (this.targetTop - this.resizableTop);\n        }\n        if (boundWidth && Number.isFinite(boundWidth)) {\n            maxWidth = maxWidth && maxWidth < boundWidth ? maxWidth : boundWidth;\n        }\n        if (boundHeight && Number.isFinite(boundHeight)) {\n            maxHeight = maxHeight && maxHeight < boundHeight ? maxHeight : boundHeight;\n        }\n        return { maxWidth: maxWidth, maxHeight: maxHeight };\n    };\n    Resizable.prototype.calculateNewSizeFromDirection = function (clientX, clientY) {\n        var scale = this.props.scale || 1;\n        var resizeRatio = this.props.resizeRatio || 1;\n        var _a = this.state, direction = _a.direction, original = _a.original;\n        var _b = this.props, lockAspectRatio = _b.lockAspectRatio, lockAspectRatioExtraHeight = _b.lockAspectRatioExtraHeight, lockAspectRatioExtraWidth = _b.lockAspectRatioExtraWidth;\n        var newWidth = original.width;\n        var newHeight = original.height;\n        var extraHeight = lockAspectRatioExtraHeight || 0;\n        var extraWidth = lockAspectRatioExtraWidth || 0;\n        if (hasDirection('right', direction)) {\n            newWidth = original.width + ((clientX - original.x) * resizeRatio) / scale;\n            if (lockAspectRatio) {\n                newHeight = (newWidth - extraWidth) / this.ratio + extraHeight;\n            }\n        }\n        if (hasDirection('left', direction)) {\n            newWidth = original.width - ((clientX - original.x) * resizeRatio) / scale;\n            if (lockAspectRatio) {\n                newHeight = (newWidth - extraWidth) / this.ratio + extraHeight;\n            }\n        }\n        if (hasDirection('bottom', direction)) {\n            newHeight = original.height + ((clientY - original.y) * resizeRatio) / scale;\n            if (lockAspectRatio) {\n                newWidth = (newHeight - extraHeight) * this.ratio + extraWidth;\n            }\n        }\n        if (hasDirection('top', direction)) {\n            newHeight = original.height - ((clientY - original.y) * resizeRatio) / scale;\n            if (lockAspectRatio) {\n                newWidth = (newHeight - extraHeight) * this.ratio + extraWidth;\n            }\n        }\n        return { newWidth: newWidth, newHeight: newHeight };\n    };\n    Resizable.prototype.calculateNewSizeFromAspectRatio = function (newWidth, newHeight, max, min) {\n        var _a = this.props, lockAspectRatio = _a.lockAspectRatio, lockAspectRatioExtraHeight = _a.lockAspectRatioExtraHeight, lockAspectRatioExtraWidth = _a.lockAspectRatioExtraWidth;\n        var computedMinWidth = typeof min.width === 'undefined' ? 10 : min.width;\n        var computedMaxWidth = typeof max.width === 'undefined' || max.width < 0 ? newWidth : max.width;\n        var computedMinHeight = typeof min.height === 'undefined' ? 10 : min.height;\n        var computedMaxHeight = typeof max.height === 'undefined' || max.height < 0 ? newHeight : max.height;\n        var extraHeight = lockAspectRatioExtraHeight || 0;\n        var extraWidth = lockAspectRatioExtraWidth || 0;\n        if (lockAspectRatio) {\n            var extraMinWidth = (computedMinHeight - extraHeight) * this.ratio + extraWidth;\n            var extraMaxWidth = (computedMaxHeight - extraHeight) * this.ratio + extraWidth;\n            var extraMinHeight = (computedMinWidth - extraWidth) / this.ratio + extraHeight;\n            var extraMaxHeight = (computedMaxWidth - extraWidth) / this.ratio + extraHeight;\n            var lockedMinWidth = Math.max(computedMinWidth, extraMinWidth);\n            var lockedMaxWidth = Math.min(computedMaxWidth, extraMaxWidth);\n            var lockedMinHeight = Math.max(computedMinHeight, extraMinHeight);\n            var lockedMaxHeight = Math.min(computedMaxHeight, extraMaxHeight);\n            newWidth = clamp(newWidth, lockedMinWidth, lockedMaxWidth);\n            newHeight = clamp(newHeight, lockedMinHeight, lockedMaxHeight);\n        }\n        else {\n            newWidth = clamp(newWidth, computedMinWidth, computedMaxWidth);\n            newHeight = clamp(newHeight, computedMinHeight, computedMaxHeight);\n        }\n        return { newWidth: newWidth, newHeight: newHeight };\n    };\n    Resizable.prototype.setBoundingClientRect = function () {\n        // For parent boundary\n        if (this.props.bounds === 'parent') {\n            var parent_2 = this.parentNode;\n            if (parent_2) {\n                var parentRect = parent_2.getBoundingClientRect();\n                this.parentLeft = parentRect.left;\n                this.parentTop = parentRect.top;\n            }\n        }\n        // For target(html element) boundary\n        if (this.props.bounds && typeof this.props.bounds !== 'string') {\n            var targetRect = this.props.bounds.getBoundingClientRect();\n            this.targetLeft = targetRect.left;\n            this.targetTop = targetRect.top;\n        }\n        // For boundary\n        if (this.resizable) {\n            var _a = this.resizable.getBoundingClientRect(), left = _a.left, top_1 = _a.top, right = _a.right, bottom = _a.bottom;\n            this.resizableLeft = left;\n            this.resizableRight = right;\n            this.resizableTop = top_1;\n            this.resizableBottom = bottom;\n        }\n    };\n    Resizable.prototype.onResizeStart = function (event, direction) {\n        if (!this.resizable || !this.window) {\n            return;\n        }\n        var clientX = 0;\n        var clientY = 0;\n        if (event.nativeEvent && isMouseEvent(event.nativeEvent)) {\n            clientX = event.nativeEvent.clientX;\n            clientY = event.nativeEvent.clientY;\n        }\n        else if (event.nativeEvent && isTouchEvent(event.nativeEvent)) {\n            clientX = event.nativeEvent.touches[0].clientX;\n            clientY = event.nativeEvent.touches[0].clientY;\n        }\n        if (this.props.onResizeStart) {\n            if (this.resizable) {\n                var startResize = this.props.onResizeStart(event, direction, this.resizable);\n                if (startResize === false) {\n                    return;\n                }\n            }\n        }\n        // Fix #168\n        if (this.props.size) {\n            if (typeof this.props.size.height !== 'undefined' && this.props.size.height !== this.state.height) {\n                this.setState({ height: this.props.size.height });\n            }\n            if (typeof this.props.size.width !== 'undefined' && this.props.size.width !== this.state.width) {\n                this.setState({ width: this.props.size.width });\n            }\n        }\n        // For lockAspectRatio case\n        this.ratio =\n            typeof this.props.lockAspectRatio === 'number' ? this.props.lockAspectRatio : this.size.width / this.size.height;\n        var flexBasis;\n        var computedStyle = this.window.getComputedStyle(this.resizable);\n        if (computedStyle.flexBasis !== 'auto') {\n            var parent_3 = this.parentNode;\n            if (parent_3) {\n                var dir = this.window.getComputedStyle(parent_3).flexDirection;\n                this.flexDir = dir.startsWith('row') ? 'row' : 'column';\n                flexBasis = computedStyle.flexBasis;\n            }\n        }\n        // For boundary\n        this.setBoundingClientRect();\n        this.bindEvents();\n        var state = {\n            original: {\n                x: clientX,\n                y: clientY,\n                width: this.size.width,\n                height: this.size.height,\n            },\n            isResizing: true,\n            backgroundStyle: __assign(__assign({}, this.state.backgroundStyle), { cursor: this.window.getComputedStyle(event.target).cursor || 'auto' }),\n            direction: direction,\n            flexBasis: flexBasis,\n        };\n        this.setState(state);\n    };\n    Resizable.prototype.onMouseMove = function (event) {\n        var _this = this;\n        if (!this.state.isResizing || !this.resizable || !this.window) {\n            return;\n        }\n        if (this.window.TouchEvent && isTouchEvent(event)) {\n            try {\n                event.preventDefault();\n                event.stopPropagation();\n            }\n            catch (e) {\n                // Ignore on fail\n            }\n        }\n        var _a = this.props, maxWidth = _a.maxWidth, maxHeight = _a.maxHeight, minWidth = _a.minWidth, minHeight = _a.minHeight;\n        var clientX = isTouchEvent(event) ? event.touches[0].clientX : event.clientX;\n        var clientY = isTouchEvent(event) ? event.touches[0].clientY : event.clientY;\n        var _b = this.state, direction = _b.direction, original = _b.original, width = _b.width, height = _b.height;\n        var parentSize = this.getParentSize();\n        var max = calculateNewMax(parentSize, this.window.innerWidth, this.window.innerHeight, maxWidth, maxHeight, minWidth, minHeight);\n        maxWidth = max.maxWidth;\n        maxHeight = max.maxHeight;\n        minWidth = max.minWidth;\n        minHeight = max.minHeight;\n        // Calculate new size\n        var _c = this.calculateNewSizeFromDirection(clientX, clientY), newHeight = _c.newHeight, newWidth = _c.newWidth;\n        // Calculate max size from boundary settings\n        var boundaryMax = this.calculateNewMaxFromBoundary(maxWidth, maxHeight);\n        if (this.props.snap && this.props.snap.x) {\n            newWidth = findClosestSnap(newWidth, this.props.snap.x, this.props.snapGap);\n        }\n        if (this.props.snap && this.props.snap.y) {\n            newHeight = findClosestSnap(newHeight, this.props.snap.y, this.props.snapGap);\n        }\n        // Calculate new size from aspect ratio\n        var newSize = this.calculateNewSizeFromAspectRatio(newWidth, newHeight, { width: boundaryMax.maxWidth, height: boundaryMax.maxHeight }, { width: minWidth, height: minHeight });\n        newWidth = newSize.newWidth;\n        newHeight = newSize.newHeight;\n        if (this.props.grid) {\n            var newGridWidth = snap(newWidth, this.props.grid[0]);\n            var newGridHeight = snap(newHeight, this.props.grid[1]);\n            var gap = this.props.snapGap || 0;\n            newWidth = gap === 0 || Math.abs(newGridWidth - newWidth) <= gap ? newGridWidth : newWidth;\n            newHeight = gap === 0 || Math.abs(newGridHeight - newHeight) <= gap ? newGridHeight : newHeight;\n        }\n        var delta = {\n            width: newWidth - original.width,\n            height: newHeight - original.height,\n        };\n        if (width && typeof width === 'string') {\n            if (width.endsWith('%')) {\n                var percent = (newWidth / parentSize.width) * 100;\n                newWidth = percent + \"%\";\n            }\n            else if (width.endsWith('vw')) {\n                var vw = (newWidth / this.window.innerWidth) * 100;\n                newWidth = vw + \"vw\";\n            }\n            else if (width.endsWith('vh')) {\n                var vh = (newWidth / this.window.innerHeight) * 100;\n                newWidth = vh + \"vh\";\n            }\n        }\n        if (height && typeof height === 'string') {\n            if (height.endsWith('%')) {\n                var percent = (newHeight / parentSize.height) * 100;\n                newHeight = percent + \"%\";\n            }\n            else if (height.endsWith('vw')) {\n                var vw = (newHeight / this.window.innerWidth) * 100;\n                newHeight = vw + \"vw\";\n            }\n            else if (height.endsWith('vh')) {\n                var vh = (newHeight / this.window.innerHeight) * 100;\n                newHeight = vh + \"vh\";\n            }\n        }\n        var newState = {\n            width: this.createSizeForCssProperty(newWidth, 'width'),\n            height: this.createSizeForCssProperty(newHeight, 'height'),\n        };\n        if (this.flexDir === 'row') {\n            newState.flexBasis = newState.width;\n        }\n        else if (this.flexDir === 'column') {\n            newState.flexBasis = newState.height;\n        }\n        // For v18, update state sync\n        flushSync(function () {\n            _this.setState(newState);\n        });\n        if (this.props.onResize) {\n            this.props.onResize(event, direction, this.resizable, delta);\n        }\n    };\n    Resizable.prototype.onMouseUp = function (event) {\n        var _a = this.state, isResizing = _a.isResizing, direction = _a.direction, original = _a.original;\n        if (!isResizing || !this.resizable) {\n            return;\n        }\n        var delta = {\n            width: this.size.width - original.width,\n            height: this.size.height - original.height,\n        };\n        if (this.props.onResizeStop) {\n            this.props.onResizeStop(event, direction, this.resizable, delta);\n        }\n        if (this.props.size) {\n            this.setState(this.props.size);\n        }\n        this.unbindEvents();\n        this.setState({\n            isResizing: false,\n            backgroundStyle: __assign(__assign({}, this.state.backgroundStyle), { cursor: 'auto' }),\n        });\n    };\n    Resizable.prototype.updateSize = function (size) {\n        this.setState({ width: size.width, height: size.height });\n    };\n    Resizable.prototype.renderResizer = function () {\n        var _this = this;\n        var _a = this.props, enable = _a.enable, handleStyles = _a.handleStyles, handleClasses = _a.handleClasses, handleWrapperStyle = _a.handleWrapperStyle, handleWrapperClass = _a.handleWrapperClass, handleComponent = _a.handleComponent;\n        if (!enable) {\n            return null;\n        }\n        var resizers = Object.keys(enable).map(function (dir) {\n            if (enable[dir] !== false) {\n                return (React.createElement(Resizer, { key: dir, direction: dir, onResizeStart: _this.onResizeStart, replaceStyles: handleStyles && handleStyles[dir], className: handleClasses && handleClasses[dir] }, handleComponent && handleComponent[dir] ? handleComponent[dir] : null));\n            }\n            return null;\n        });\n        // #93 Wrap the resize box in span (will not break 100% width/height)\n        return (React.createElement(\"div\", { className: handleWrapperClass, style: handleWrapperStyle }, resizers));\n    };\n    Resizable.prototype.render = function () {\n        var _this = this;\n        var extendsProps = Object.keys(this.props).reduce(function (acc, key) {\n            if (definedProps.indexOf(key) !== -1) {\n                return acc;\n            }\n            acc[key] = _this.props[key];\n            return acc;\n        }, {});\n        var style = __assign(__assign(__assign({ position: 'relative', userSelect: this.state.isResizing ? 'none' : 'auto' }, this.props.style), this.sizeStyle), { maxWidth: this.props.maxWidth, maxHeight: this.props.maxHeight, minWidth: this.props.minWidth, minHeight: this.props.minHeight, boxSizing: 'border-box', flexShrink: 0 });\n        if (this.state.flexBasis) {\n            style.flexBasis = this.state.flexBasis;\n        }\n        var Wrapper = this.props.as || 'div';\n        return (React.createElement(Wrapper, __assign({ ref: this.ref, style: style, className: this.props.className }, extendsProps),\n            this.state.isResizing && React.createElement(\"div\", { style: this.state.backgroundStyle }),\n            this.props.children,\n            this.renderResizer()));\n    };\n    Resizable.defaultProps = {\n        as: 'div',\n        onResizeStart: function () { },\n        onResize: function () { },\n        onResizeStop: function () { },\n        enable: {\n            top: true,\n            right: true,\n            bottom: true,\n            left: true,\n            topRight: true,\n            bottomRight: true,\n            bottomLeft: true,\n            topLeft: true,\n        },\n        style: {},\n        grid: [1, 1],\n        lockAspectRatio: false,\n        lockAspectRatioExtraWidth: 0,\n        lockAspectRatioExtraHeight: 0,\n        scale: 1,\n        resizeRatio: 1,\n        snapGap: 0,\n    };\n    return Resizable;\n}(React.PureComponent));\nexport { Resizable };\n","'use strict';\n\nmodule.exports = (string, separator) => {\n\tif (!(typeof string === 'string' && typeof separator === 'string')) {\n\t\tthrow new TypeError('Expected the arguments to be of type `string`');\n\t}\n\n\tif (separator === '') {\n\t\treturn [string];\n\t}\n\n\tconst separatorIndex = string.indexOf(separator);\n\n\tif (separatorIndex === -1) {\n\t\treturn [string];\n\t}\n\n\treturn [\n\t\tstring.slice(0, separatorIndex),\n\t\tstring.slice(separatorIndex + separator.length)\n\t];\n};\n","'use strict';\nmodule.exports = str => encodeURIComponent(str).replace(/[!'()*]/g, x => `%${x.charCodeAt(0).toString(16).toUpperCase()}`);\n","'use strict';\nvar tryToString = require('../internals/try-to-string');\n\nvar $TypeError = TypeError;\n\nmodule.exports = function (O, P) {\n  if (!delete O[P]) throw new $TypeError('Cannot delete property ' + tryToString(P) + ' of ' + tryToString(O));\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar $findLastIndex = require('../internals/array-iteration-from-last').findLastIndex;\nvar addToUnscopables = require('../internals/add-to-unscopables');\n\n// `Array.prototype.findLastIndex` method\n// https://tc39.es/ecma262/#sec-array.prototype.findlastindex\n$({ target: 'Array', proto: true }, {\n  findLastIndex: function findLastIndex(callbackfn /* , that = undefined */) {\n    return $findLastIndex(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);\n  }\n});\n\naddToUnscopables('findLastIndex');\n","'use strict';\nvar $ = require('../internals/export');\nvar toObject = require('../internals/to-object');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar setArrayLength = require('../internals/array-set-length');\nvar deletePropertyOrThrow = require('../internals/delete-property-or-throw');\nvar doesNotExceedSafeInteger = require('../internals/does-not-exceed-safe-integer');\n\n// IE8-\nvar INCORRECT_RESULT = [].unshift(0) !== 1;\n\n// V8 ~ Chrome < 71 and Safari <= 15.4, FF < 23 throws InternalError\nvar properErrorOnNonWritableLength = function () {\n  try {\n    // eslint-disable-next-line es/no-object-defineproperty -- safe\n    Object.defineProperty([], 'length', { writable: false }).unshift();\n  } catch (error) {\n    return error instanceof TypeError;\n  }\n};\n\nvar FORCED = INCORRECT_RESULT || !properErrorOnNonWritableLength();\n\n// `Array.prototype.unshift` method\n// https://tc39.es/ecma262/#sec-array.prototype.unshift\n$({ target: 'Array', proto: true, arity: 1, forced: FORCED }, {\n  // eslint-disable-next-line no-unused-vars -- required for `.length`\n  unshift: function unshift(item) {\n    var O = toObject(this);\n    var len = lengthOfArrayLike(O);\n    var argCount = arguments.length;\n    if (argCount) {\n      doesNotExceedSafeInteger(len + argCount);\n      var k = len;\n      while (k--) {\n        var to = k + argCount;\n        if (k in O) O[to] = O[k];\n        else deletePropertyOrThrow(O, to);\n      }\n      for (var j = 0; j < argCount; j++) {\n        O[j] = arguments[j];\n      }\n    } return setArrayLength(O, len + argCount);\n  }\n});\n","import { Bezier } from \"./bezier.js\";\n\n// math-inlining.\nconst { abs, cos, sin, acos, atan2, sqrt, pow } = Math;\n\n// cube root function yielding real roots\nfunction crt(v) {\n  return v < 0 ? -pow(-v, 1 / 3) : pow(v, 1 / 3);\n}\n\n// trig constants\nconst pi = Math.PI,\n  tau = 2 * pi,\n  quart = pi / 2,\n  // float precision significant decimal\n  epsilon = 0.000001,\n  // extremas used in bbox calculation and similar algorithms\n  nMax = Number.MAX_SAFE_INTEGER || 9007199254740991,\n  nMin = Number.MIN_SAFE_INTEGER || -9007199254740991,\n  // a zero coordinate, which is surprisingly useful\n  ZERO = { x: 0, y: 0, z: 0 };\n\n// Bezier utility functions\nconst utils = {\n  // Legendre-Gauss abscissae with n=24 (x_i values, defined at i=n as the roots of the nth order Legendre polynomial Pn(x))\n  Tvalues: [\n    -0.0640568928626056260850430826247450385909,\n    0.0640568928626056260850430826247450385909,\n    -0.1911188674736163091586398207570696318404,\n    0.1911188674736163091586398207570696318404,\n    -0.3150426796961633743867932913198102407864,\n    0.3150426796961633743867932913198102407864,\n    -0.4337935076260451384870842319133497124524,\n    0.4337935076260451384870842319133497124524,\n    -0.5454214713888395356583756172183723700107,\n    0.5454214713888395356583756172183723700107,\n    -0.6480936519369755692524957869107476266696,\n    0.6480936519369755692524957869107476266696,\n    -0.7401241915785543642438281030999784255232,\n    0.7401241915785543642438281030999784255232,\n    -0.8200019859739029219539498726697452080761,\n    0.8200019859739029219539498726697452080761,\n    -0.8864155270044010342131543419821967550873,\n    0.8864155270044010342131543419821967550873,\n    -0.9382745520027327585236490017087214496548,\n    0.9382745520027327585236490017087214496548,\n    -0.9747285559713094981983919930081690617411,\n    0.9747285559713094981983919930081690617411,\n    -0.9951872199970213601799974097007368118745,\n    0.9951872199970213601799974097007368118745,\n  ],\n\n  // Legendre-Gauss weights with n=24 (w_i values, defined by a function linked to in the Bezier primer article)\n  Cvalues: [\n    0.1279381953467521569740561652246953718517,\n    0.1279381953467521569740561652246953718517,\n    0.1258374563468282961213753825111836887264,\n    0.1258374563468282961213753825111836887264,\n    0.121670472927803391204463153476262425607,\n    0.121670472927803391204463153476262425607,\n    0.1155056680537256013533444839067835598622,\n    0.1155056680537256013533444839067835598622,\n    0.1074442701159656347825773424466062227946,\n    0.1074442701159656347825773424466062227946,\n    0.0976186521041138882698806644642471544279,\n    0.0976186521041138882698806644642471544279,\n    0.086190161531953275917185202983742667185,\n    0.086190161531953275917185202983742667185,\n    0.0733464814110803057340336152531165181193,\n    0.0733464814110803057340336152531165181193,\n    0.0592985849154367807463677585001085845412,\n    0.0592985849154367807463677585001085845412,\n    0.0442774388174198061686027482113382288593,\n    0.0442774388174198061686027482113382288593,\n    0.0285313886289336631813078159518782864491,\n    0.0285313886289336631813078159518782864491,\n    0.0123412297999871995468056670700372915759,\n    0.0123412297999871995468056670700372915759,\n  ],\n\n  arcfn: function (t, derivativeFn) {\n    const d = derivativeFn(t);\n    let l = d.x * d.x + d.y * d.y;\n    if (typeof d.z !== \"undefined\") {\n      l += d.z * d.z;\n    }\n    return sqrt(l);\n  },\n\n  compute: function (t, points, _3d) {\n    // shortcuts\n    if (t === 0) {\n      points[0].t = 0;\n      return points[0];\n    }\n\n    const order = points.length - 1;\n\n    if (t === 1) {\n      points[order].t = 1;\n      return points[order];\n    }\n\n    const mt = 1 - t;\n    let p = points;\n\n    // constant?\n    if (order === 0) {\n      points[0].t = t;\n      return points[0];\n    }\n\n    // linear?\n    if (order === 1) {\n      const ret = {\n        x: mt * p[0].x + t * p[1].x,\n        y: mt * p[0].y + t * p[1].y,\n        t: t,\n      };\n      if (_3d) {\n        ret.z = mt * p[0].z + t * p[1].z;\n      }\n      return ret;\n    }\n\n    // quadratic/cubic curve?\n    if (order < 4) {\n      let mt2 = mt * mt,\n        t2 = t * t,\n        a,\n        b,\n        c,\n        d = 0;\n      if (order === 2) {\n        p = [p[0], p[1], p[2], ZERO];\n        a = mt2;\n        b = mt * t * 2;\n        c = t2;\n      } else if (order === 3) {\n        a = mt2 * mt;\n        b = mt2 * t * 3;\n        c = mt * t2 * 3;\n        d = t * t2;\n      }\n      const ret = {\n        x: a * p[0].x + b * p[1].x + c * p[2].x + d * p[3].x,\n        y: a * p[0].y + b * p[1].y + c * p[2].y + d * p[3].y,\n        t: t,\n      };\n      if (_3d) {\n        ret.z = a * p[0].z + b * p[1].z + c * p[2].z + d * p[3].z;\n      }\n      return ret;\n    }\n\n    // higher order curves: use de Casteljau's computation\n    const dCpts = JSON.parse(JSON.stringify(points));\n    while (dCpts.length > 1) {\n      for (let i = 0; i < dCpts.length - 1; i++) {\n        dCpts[i] = {\n          x: dCpts[i].x + (dCpts[i + 1].x - dCpts[i].x) * t,\n          y: dCpts[i].y + (dCpts[i + 1].y - dCpts[i].y) * t,\n        };\n        if (typeof dCpts[i].z !== \"undefined\") {\n          dCpts[i] = dCpts[i].z + (dCpts[i + 1].z - dCpts[i].z) * t;\n        }\n      }\n      dCpts.splice(dCpts.length - 1, 1);\n    }\n    dCpts[0].t = t;\n    return dCpts[0];\n  },\n\n  computeWithRatios: function (t, points, ratios, _3d) {\n    const mt = 1 - t,\n      r = ratios,\n      p = points;\n\n    let f1 = r[0],\n      f2 = r[1],\n      f3 = r[2],\n      f4 = r[3],\n      d;\n\n    // spec for linear\n    f1 *= mt;\n    f2 *= t;\n\n    if (p.length === 2) {\n      d = f1 + f2;\n      return {\n        x: (f1 * p[0].x + f2 * p[1].x) / d,\n        y: (f1 * p[0].y + f2 * p[1].y) / d,\n        z: !_3d ? false : (f1 * p[0].z + f2 * p[1].z) / d,\n        t: t,\n      };\n    }\n\n    // upgrade to quadratic\n    f1 *= mt;\n    f2 *= 2 * mt;\n    f3 *= t * t;\n\n    if (p.length === 3) {\n      d = f1 + f2 + f3;\n      return {\n        x: (f1 * p[0].x + f2 * p[1].x + f3 * p[2].x) / d,\n        y: (f1 * p[0].y + f2 * p[1].y + f3 * p[2].y) / d,\n        z: !_3d ? false : (f1 * p[0].z + f2 * p[1].z + f3 * p[2].z) / d,\n        t: t,\n      };\n    }\n\n    // upgrade to cubic\n    f1 *= mt;\n    f2 *= 1.5 * mt;\n    f3 *= 3 * mt;\n    f4 *= t * t * t;\n\n    if (p.length === 4) {\n      d = f1 + f2 + f3 + f4;\n      return {\n        x: (f1 * p[0].x + f2 * p[1].x + f3 * p[2].x + f4 * p[3].x) / d,\n        y: (f1 * p[0].y + f2 * p[1].y + f3 * p[2].y + f4 * p[3].y) / d,\n        z: !_3d\n          ? false\n          : (f1 * p[0].z + f2 * p[1].z + f3 * p[2].z + f4 * p[3].z) / d,\n        t: t,\n      };\n    }\n  },\n\n  derive: function (points, _3d) {\n    const dpoints = [];\n    for (let p = points, d = p.length, c = d - 1; d > 1; d--, c--) {\n      const list = [];\n      for (let j = 0, dpt; j < c; j++) {\n        dpt = {\n          x: c * (p[j + 1].x - p[j].x),\n          y: c * (p[j + 1].y - p[j].y),\n        };\n        if (_3d) {\n          dpt.z = c * (p[j + 1].z - p[j].z);\n        }\n        list.push(dpt);\n      }\n      dpoints.push(list);\n      p = list;\n    }\n    return dpoints;\n  },\n\n  between: function (v, m, M) {\n    return (\n      (m <= v && v <= M) ||\n      utils.approximately(v, m) ||\n      utils.approximately(v, M)\n    );\n  },\n\n  approximately: function (a, b, precision) {\n    return abs(a - b) <= (precision || epsilon);\n  },\n\n  length: function (derivativeFn) {\n    const z = 0.5,\n      len = utils.Tvalues.length;\n\n    let sum = 0;\n\n    for (let i = 0, t; i < len; i++) {\n      t = z * utils.Tvalues[i] + z;\n      sum += utils.Cvalues[i] * utils.arcfn(t, derivativeFn);\n    }\n    return z * sum;\n  },\n\n  map: function (v, ds, de, ts, te) {\n    const d1 = de - ds,\n      d2 = te - ts,\n      v2 = v - ds,\n      r = v2 / d1;\n    return ts + d2 * r;\n  },\n\n  lerp: function (r, v1, v2) {\n    const ret = {\n      x: v1.x + r * (v2.x - v1.x),\n      y: v1.y + r * (v2.y - v1.y),\n    };\n    if (v1.z !== undefined && v2.z !== undefined) {\n      ret.z = v1.z + r * (v2.z - v1.z);\n    }\n    return ret;\n  },\n\n  pointToString: function (p) {\n    let s = p.x + \"/\" + p.y;\n    if (typeof p.z !== \"undefined\") {\n      s += \"/\" + p.z;\n    }\n    return s;\n  },\n\n  pointsToString: function (points) {\n    return \"[\" + points.map(utils.pointToString).join(\", \") + \"]\";\n  },\n\n  copy: function (obj) {\n    return JSON.parse(JSON.stringify(obj));\n  },\n\n  angle: function (o, v1, v2) {\n    const dx1 = v1.x - o.x,\n      dy1 = v1.y - o.y,\n      dx2 = v2.x - o.x,\n      dy2 = v2.y - o.y,\n      cross = dx1 * dy2 - dy1 * dx2,\n      dot = dx1 * dx2 + dy1 * dy2;\n    return atan2(cross, dot);\n  },\n\n  // round as string, to avoid rounding errors\n  round: function (v, d) {\n    const s = \"\" + v;\n    const pos = s.indexOf(\".\");\n    return parseFloat(s.substring(0, pos + 1 + d));\n  },\n\n  dist: function (p1, p2) {\n    const dx = p1.x - p2.x,\n      dy = p1.y - p2.y;\n    return sqrt(dx * dx + dy * dy);\n  },\n\n  closest: function (LUT, point) {\n    let mdist = pow(2, 63),\n      mpos,\n      d;\n    LUT.forEach(function (p, idx) {\n      d = utils.dist(point, p);\n      if (d < mdist) {\n        mdist = d;\n        mpos = idx;\n      }\n    });\n    return { mdist: mdist, mpos: mpos };\n  },\n\n  abcratio: function (t, n) {\n    // see ratio(t) note on http://pomax.github.io/bezierinfo/#abc\n    if (n !== 2 && n !== 3) {\n      return false;\n    }\n    if (typeof t === \"undefined\") {\n      t = 0.5;\n    } else if (t === 0 || t === 1) {\n      return t;\n    }\n    const bottom = pow(t, n) + pow(1 - t, n),\n      top = bottom - 1;\n    return abs(top / bottom);\n  },\n\n  projectionratio: function (t, n) {\n    // see u(t) note on http://pomax.github.io/bezierinfo/#abc\n    if (n !== 2 && n !== 3) {\n      return false;\n    }\n    if (typeof t === \"undefined\") {\n      t = 0.5;\n    } else if (t === 0 || t === 1) {\n      return t;\n    }\n    const top = pow(1 - t, n),\n      bottom = pow(t, n) + top;\n    return top / bottom;\n  },\n\n  lli8: function (x1, y1, x2, y2, x3, y3, x4, y4) {\n    const nx =\n        (x1 * y2 - y1 * x2) * (x3 - x4) - (x1 - x2) * (x3 * y4 - y3 * x4),\n      ny = (x1 * y2 - y1 * x2) * (y3 - y4) - (y1 - y2) * (x3 * y4 - y3 * x4),\n      d = (x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4);\n    if (d == 0) {\n      return false;\n    }\n    return { x: nx / d, y: ny / d };\n  },\n\n  lli4: function (p1, p2, p3, p4) {\n    const x1 = p1.x,\n      y1 = p1.y,\n      x2 = p2.x,\n      y2 = p2.y,\n      x3 = p3.x,\n      y3 = p3.y,\n      x4 = p4.x,\n      y4 = p4.y;\n    return utils.lli8(x1, y1, x2, y2, x3, y3, x4, y4);\n  },\n\n  lli: function (v1, v2) {\n    return utils.lli4(v1, v1.c, v2, v2.c);\n  },\n\n  makeline: function (p1, p2) {\n    const x1 = p1.x,\n      y1 = p1.y,\n      x2 = p2.x,\n      y2 = p2.y,\n      dx = (x2 - x1) / 3,\n      dy = (y2 - y1) / 3;\n    return new Bezier(\n      x1,\n      y1,\n      x1 + dx,\n      y1 + dy,\n      x1 + 2 * dx,\n      y1 + 2 * dy,\n      x2,\n      y2\n    );\n  },\n\n  findbbox: function (sections) {\n    let mx = nMax,\n      my = nMax,\n      MX = nMin,\n      MY = nMin;\n    sections.forEach(function (s) {\n      const bbox = s.bbox();\n      if (mx > bbox.x.min) mx = bbox.x.min;\n      if (my > bbox.y.min) my = bbox.y.min;\n      if (MX < bbox.x.max) MX = bbox.x.max;\n      if (MY < bbox.y.max) MY = bbox.y.max;\n    });\n    return {\n      x: { min: mx, mid: (mx + MX) / 2, max: MX, size: MX - mx },\n      y: { min: my, mid: (my + MY) / 2, max: MY, size: MY - my },\n    };\n  },\n\n  shapeintersections: function (\n    s1,\n    bbox1,\n    s2,\n    bbox2,\n    curveIntersectionThreshold\n  ) {\n    if (!utils.bboxoverlap(bbox1, bbox2)) return [];\n    const intersections = [];\n    const a1 = [s1.startcap, s1.forward, s1.back, s1.endcap];\n    const a2 = [s2.startcap, s2.forward, s2.back, s2.endcap];\n    a1.forEach(function (l1) {\n      if (l1.virtual) return;\n      a2.forEach(function (l2) {\n        if (l2.virtual) return;\n        const iss = l1.intersects(l2, curveIntersectionThreshold);\n        if (iss.length > 0) {\n          iss.c1 = l1;\n          iss.c2 = l2;\n          iss.s1 = s1;\n          iss.s2 = s2;\n          intersections.push(iss);\n        }\n      });\n    });\n    return intersections;\n  },\n\n  makeshape: function (forward, back, curveIntersectionThreshold) {\n    const bpl = back.points.length;\n    const fpl = forward.points.length;\n    const start = utils.makeline(back.points[bpl - 1], forward.points[0]);\n    const end = utils.makeline(forward.points[fpl - 1], back.points[0]);\n    const shape = {\n      startcap: start,\n      forward: forward,\n      back: back,\n      endcap: end,\n      bbox: utils.findbbox([start, forward, back, end]),\n    };\n    shape.intersections = function (s2) {\n      return utils.shapeintersections(\n        shape,\n        shape.bbox,\n        s2,\n        s2.bbox,\n        curveIntersectionThreshold\n      );\n    };\n    return shape;\n  },\n\n  getminmax: function (curve, d, list) {\n    if (!list) return { min: 0, max: 0 };\n    let min = nMax,\n      max = nMin,\n      t,\n      c;\n    if (list.indexOf(0) === -1) {\n      list = [0].concat(list);\n    }\n    if (list.indexOf(1) === -1) {\n      list.push(1);\n    }\n    for (let i = 0, len = list.length; i < len; i++) {\n      t = list[i];\n      c = curve.get(t);\n      if (c[d] < min) {\n        min = c[d];\n      }\n      if (c[d] > max) {\n        max = c[d];\n      }\n    }\n    return { min: min, mid: (min + max) / 2, max: max, size: max - min };\n  },\n\n  align: function (points, line) {\n    const tx = line.p1.x,\n      ty = line.p1.y,\n      a = -atan2(line.p2.y - ty, line.p2.x - tx),\n      d = function (v) {\n        return {\n          x: (v.x - tx) * cos(a) - (v.y - ty) * sin(a),\n          y: (v.x - tx) * sin(a) + (v.y - ty) * cos(a),\n        };\n      };\n    return points.map(d);\n  },\n\n  roots: function (points, line) {\n    line = line || { p1: { x: 0, y: 0 }, p2: { x: 1, y: 0 } };\n\n    const order = points.length - 1;\n    const aligned = utils.align(points, line);\n    const reduce = function (t) {\n      return 0 <= t && t <= 1;\n    };\n\n    if (order === 2) {\n      const a = aligned[0].y,\n        b = aligned[1].y,\n        c = aligned[2].y,\n        d = a - 2 * b + c;\n      if (d !== 0) {\n        const m1 = -sqrt(b * b - a * c),\n          m2 = -a + b,\n          v1 = -(m1 + m2) / d,\n          v2 = -(-m1 + m2) / d;\n        return [v1, v2].filter(reduce);\n      } else if (b !== c && d === 0) {\n        return [(2 * b - c) / (2 * b - 2 * c)].filter(reduce);\n      }\n      return [];\n    }\n\n    // see http://www.trans4mind.com/personal_development/mathematics/polynomials/cubicAlgebra.htm\n    const pa = aligned[0].y,\n      pb = aligned[1].y,\n      pc = aligned[2].y,\n      pd = aligned[3].y;\n\n    let d = -pa + 3 * pb - 3 * pc + pd,\n      a = 3 * pa - 6 * pb + 3 * pc,\n      b = -3 * pa + 3 * pb,\n      c = pa;\n\n    if (utils.approximately(d, 0)) {\n      // this is not a cubic curve.\n      if (utils.approximately(a, 0)) {\n        // in fact, this is not a quadratic curve either.\n        if (utils.approximately(b, 0)) {\n          // in fact in fact, there are no solutions.\n          return [];\n        }\n        // linear solution:\n        return [-c / b].filter(reduce);\n      }\n      // quadratic solution:\n      const q = sqrt(b * b - 4 * a * c),\n        a2 = 2 * a;\n      return [(q - b) / a2, (-b - q) / a2].filter(reduce);\n    }\n\n    // at this point, we know we need a cubic solution:\n\n    a /= d;\n    b /= d;\n    c /= d;\n\n    const p = (3 * b - a * a) / 3,\n      p3 = p / 3,\n      q = (2 * a * a * a - 9 * a * b + 27 * c) / 27,\n      q2 = q / 2,\n      discriminant = q2 * q2 + p3 * p3 * p3;\n\n    let u1, v1, x1, x2, x3;\n    if (discriminant < 0) {\n      const mp3 = -p / 3,\n        mp33 = mp3 * mp3 * mp3,\n        r = sqrt(mp33),\n        t = -q / (2 * r),\n        cosphi = t < -1 ? -1 : t > 1 ? 1 : t,\n        phi = acos(cosphi),\n        crtr = crt(r),\n        t1 = 2 * crtr;\n      x1 = t1 * cos(phi / 3) - a / 3;\n      x2 = t1 * cos((phi + tau) / 3) - a / 3;\n      x3 = t1 * cos((phi + 2 * tau) / 3) - a / 3;\n      return [x1, x2, x3].filter(reduce);\n    } else if (discriminant === 0) {\n      u1 = q2 < 0 ? crt(-q2) : -crt(q2);\n      x1 = 2 * u1 - a / 3;\n      x2 = -u1 - a / 3;\n      return [x1, x2].filter(reduce);\n    } else {\n      const sd = sqrt(discriminant);\n      u1 = crt(-q2 + sd);\n      v1 = crt(q2 + sd);\n      return [u1 - v1 - a / 3].filter(reduce);\n    }\n  },\n\n  droots: function (p) {\n    // quadratic roots are easy\n    if (p.length === 3) {\n      const a = p[0],\n        b = p[1],\n        c = p[2],\n        d = a - 2 * b + c;\n      if (d !== 0) {\n        const m1 = -sqrt(b * b - a * c),\n          m2 = -a + b,\n          v1 = -(m1 + m2) / d,\n          v2 = -(-m1 + m2) / d;\n        return [v1, v2];\n      } else if (b !== c && d === 0) {\n        return [(2 * b - c) / (2 * (b - c))];\n      }\n      return [];\n    }\n\n    // linear roots are even easier\n    if (p.length === 2) {\n      const a = p[0],\n        b = p[1];\n      if (a !== b) {\n        return [a / (a - b)];\n      }\n      return [];\n    }\n\n    return [];\n  },\n\n  curvature: function (t, d1, d2, _3d, kOnly) {\n    let num,\n      dnm,\n      adk,\n      dk,\n      k = 0,\n      r = 0;\n\n    //\n    // We're using the following formula for curvature:\n    //\n    //              x'y\" - y'x\"\n    //   k(t) = ------------------\n    //           (x'² + y'²)^(3/2)\n    //\n    // from https://en.wikipedia.org/wiki/Radius_of_curvature#Definition\n    //\n    // With it corresponding 3D counterpart:\n    //\n    //          sqrt( (y'z\" - y\"z')² + (z'x\" - z\"x')² + (x'y\" - x\"y')²)\n    //   k(t) = -------------------------------------------------------\n    //                     (x'² + y'² + z'²)^(3/2)\n    //\n\n    const d = utils.compute(t, d1);\n    const dd = utils.compute(t, d2);\n    const qdsum = d.x * d.x + d.y * d.y;\n\n    if (_3d) {\n      num = sqrt(\n        pow(d.y * dd.z - dd.y * d.z, 2) +\n          pow(d.z * dd.x - dd.z * d.x, 2) +\n          pow(d.x * dd.y - dd.x * d.y, 2)\n      );\n      dnm = pow(qdsum + d.z * d.z, 3 / 2);\n    } else {\n      num = d.x * dd.y - d.y * dd.x;\n      dnm = pow(qdsum, 3 / 2);\n    }\n\n    if (num === 0 || dnm === 0) {\n      return { k: 0, r: 0 };\n    }\n\n    k = num / dnm;\n    r = dnm / num;\n\n    // We're also computing the derivative of kappa, because\n    // there is value in knowing the rate of change for the\n    // curvature along the curve. And we're just going to\n    // ballpark it based on an epsilon.\n    if (!kOnly) {\n      // compute k'(t) based on the interval before, and after it,\n      // to at least try to not introduce forward/backward pass bias.\n      const pk = utils.curvature(t - 0.001, d1, d2, _3d, true).k;\n      const nk = utils.curvature(t + 0.001, d1, d2, _3d, true).k;\n      dk = (nk - k + (k - pk)) / 2;\n      adk = (abs(nk - k) + abs(k - pk)) / 2;\n    }\n\n    return { k: k, r: r, dk: dk, adk: adk };\n  },\n\n  inflections: function (points) {\n    if (points.length < 4) return [];\n\n    // FIXME: TODO: add in inflection abstraction for quartic+ curves?\n\n    const p = utils.align(points, { p1: points[0], p2: points.slice(-1)[0] }),\n      a = p[2].x * p[1].y,\n      b = p[3].x * p[1].y,\n      c = p[1].x * p[2].y,\n      d = p[3].x * p[2].y,\n      v1 = 18 * (-3 * a + 2 * b + 3 * c - d),\n      v2 = 18 * (3 * a - b - 3 * c),\n      v3 = 18 * (c - a);\n\n    if (utils.approximately(v1, 0)) {\n      if (!utils.approximately(v2, 0)) {\n        let t = -v3 / v2;\n        if (0 <= t && t <= 1) return [t];\n      }\n      return [];\n    }\n\n    const trm = v2 * v2 - 4 * v1 * v3,\n      sq = Math.sqrt(trm),\n      d2 = 2 * v1;\n\n    if (utils.approximately(d2, 0)) return [];\n\n    return [(sq - v2) / d2, -(v2 + sq) / d2].filter(function (r) {\n      return 0 <= r && r <= 1;\n    });\n  },\n\n  bboxoverlap: function (b1, b2) {\n    const dims = [\"x\", \"y\"],\n      len = dims.length;\n\n    for (let i = 0, dim, l, t, d; i < len; i++) {\n      dim = dims[i];\n      l = b1[dim].mid;\n      t = b2[dim].mid;\n      d = (b1[dim].size + b2[dim].size) / 2;\n      if (abs(l - t) >= d) return false;\n    }\n    return true;\n  },\n\n  expandbox: function (bbox, _bbox) {\n    if (_bbox.x.min < bbox.x.min) {\n      bbox.x.min = _bbox.x.min;\n    }\n    if (_bbox.y.min < bbox.y.min) {\n      bbox.y.min = _bbox.y.min;\n    }\n    if (_bbox.z && _bbox.z.min < bbox.z.min) {\n      bbox.z.min = _bbox.z.min;\n    }\n    if (_bbox.x.max > bbox.x.max) {\n      bbox.x.max = _bbox.x.max;\n    }\n    if (_bbox.y.max > bbox.y.max) {\n      bbox.y.max = _bbox.y.max;\n    }\n    if (_bbox.z && _bbox.z.max > bbox.z.max) {\n      bbox.z.max = _bbox.z.max;\n    }\n    bbox.x.mid = (bbox.x.min + bbox.x.max) / 2;\n    bbox.y.mid = (bbox.y.min + bbox.y.max) / 2;\n    if (bbox.z) {\n      bbox.z.mid = (bbox.z.min + bbox.z.max) / 2;\n    }\n    bbox.x.size = bbox.x.max - bbox.x.min;\n    bbox.y.size = bbox.y.max - bbox.y.min;\n    if (bbox.z) {\n      bbox.z.size = bbox.z.max - bbox.z.min;\n    }\n  },\n\n  pairiteration: function (c1, c2, curveIntersectionThreshold) {\n    const c1b = c1.bbox(),\n      c2b = c2.bbox(),\n      r = 100000,\n      threshold = curveIntersectionThreshold || 0.5;\n\n    if (\n      c1b.x.size + c1b.y.size < threshold &&\n      c2b.x.size + c2b.y.size < threshold\n    ) {\n      return [\n        (((r * (c1._t1 + c1._t2)) / 2) | 0) / r +\n          \"/\" +\n          (((r * (c2._t1 + c2._t2)) / 2) | 0) / r,\n      ];\n    }\n\n    let cc1 = c1.split(0.5),\n      cc2 = c2.split(0.5),\n      pairs = [\n        { left: cc1.left, right: cc2.left },\n        { left: cc1.left, right: cc2.right },\n        { left: cc1.right, right: cc2.right },\n        { left: cc1.right, right: cc2.left },\n      ];\n\n    pairs = pairs.filter(function (pair) {\n      return utils.bboxoverlap(pair.left.bbox(), pair.right.bbox());\n    });\n\n    let results = [];\n\n    if (pairs.length === 0) return results;\n\n    pairs.forEach(function (pair) {\n      results = results.concat(\n        utils.pairiteration(pair.left, pair.right, threshold)\n      );\n    });\n\n    results = results.filter(function (v, i) {\n      return results.indexOf(v) === i;\n    });\n\n    return results;\n  },\n\n  getccenter: function (p1, p2, p3) {\n    const dx1 = p2.x - p1.x,\n      dy1 = p2.y - p1.y,\n      dx2 = p3.x - p2.x,\n      dy2 = p3.y - p2.y,\n      dx1p = dx1 * cos(quart) - dy1 * sin(quart),\n      dy1p = dx1 * sin(quart) + dy1 * cos(quart),\n      dx2p = dx2 * cos(quart) - dy2 * sin(quart),\n      dy2p = dx2 * sin(quart) + dy2 * cos(quart),\n      // chord midpoints\n      mx1 = (p1.x + p2.x) / 2,\n      my1 = (p1.y + p2.y) / 2,\n      mx2 = (p2.x + p3.x) / 2,\n      my2 = (p2.y + p3.y) / 2,\n      // midpoint offsets\n      mx1n = mx1 + dx1p,\n      my1n = my1 + dy1p,\n      mx2n = mx2 + dx2p,\n      my2n = my2 + dy2p,\n      // intersection of these lines:\n      arc = utils.lli8(mx1, my1, mx1n, my1n, mx2, my2, mx2n, my2n),\n      r = utils.dist(arc, p1);\n\n    // arc start/end values, over mid point:\n    let s = atan2(p1.y - arc.y, p1.x - arc.x),\n      m = atan2(p2.y - arc.y, p2.x - arc.x),\n      e = atan2(p3.y - arc.y, p3.x - arc.x),\n      _;\n\n    // determine arc direction (cw/ccw correction)\n    if (s < e) {\n      // if s<m<e, arc(s, e)\n      // if m<s<e, arc(e, s + tau)\n      // if s<e<m, arc(e, s + tau)\n      if (s > m || m > e) {\n        s += tau;\n      }\n      if (s > e) {\n        _ = e;\n        e = s;\n        s = _;\n      }\n    } else {\n      // if e<m<s, arc(e, s)\n      // if m<e<s, arc(s, e + tau)\n      // if e<s<m, arc(s, e + tau)\n      if (e < m && m < s) {\n        _ = e;\n        e = s;\n        s = _;\n      } else {\n        e += tau;\n      }\n    }\n    // assign and done.\n    arc.s = s;\n    arc.e = e;\n    arc.r = r;\n    return arc;\n  },\n\n  numberSort: function (a, b) {\n    return a - b;\n  },\n};\n\nexport { utils };\n","import { utils } from \"./utils.js\";\n\n/**\n * Poly Bezier\n * @param {[type]} curves [description]\n */\nclass PolyBezier {\n  constructor(curves) {\n    this.curves = [];\n    this._3d = false;\n    if (!!curves) {\n      this.curves = curves;\n      this._3d = this.curves[0]._3d;\n    }\n  }\n\n  valueOf() {\n    return this.toString();\n  }\n\n  toString() {\n    return (\n      \"[\" +\n      this.curves\n        .map(function (curve) {\n          return utils.pointsToString(curve.points);\n        })\n        .join(\", \") +\n      \"]\"\n    );\n  }\n\n  addCurve(curve) {\n    this.curves.push(curve);\n    this._3d = this._3d || curve._3d;\n  }\n\n  length() {\n    return this.curves\n      .map(function (v) {\n        return v.length();\n      })\n      .reduce(function (a, b) {\n        return a + b;\n      });\n  }\n\n  curve(idx) {\n    return this.curves[idx];\n  }\n\n  bbox() {\n    const c = this.curves;\n    var bbox = c[0].bbox();\n    for (var i = 1; i < c.length; i++) {\n      utils.expandbox(bbox, c[i].bbox());\n    }\n    return bbox;\n  }\n\n  offset(d) {\n    const offset = [];\n    this.curves.forEach(function (v) {\n      offset.push(...v.offset(d));\n    });\n    return new PolyBezier(offset);\n  }\n}\n\nexport { PolyBezier };\n","/**\n  A javascript Bezier curve library by Pomax.\n\n  Based on http://pomax.github.io/bezierinfo\n\n  This code is MIT licensed.\n**/\n\nimport { utils } from \"./utils.js\";\nimport { PolyBezier } from \"./poly-bezier.js\";\n\n// math-inlining.\nconst { abs, min, max, cos, sin, acos, sqrt } = Math;\nconst pi = Math.PI;\n// a zero coordinate, which is surprisingly useful\nconst ZERO = { x: 0, y: 0, z: 0 };\n\n/**\n * Bezier curve constructor.\n *\n * ...docs pending...\n */\nclass Bezier {\n  constructor(coords) {\n    let args =\n      coords && coords.forEach ? coords : Array.from(arguments).slice();\n    let coordlen = false;\n\n    if (typeof args[0] === \"object\") {\n      coordlen = args.length;\n      const newargs = [];\n      args.forEach(function (point) {\n        [\"x\", \"y\", \"z\"].forEach(function (d) {\n          if (typeof point[d] !== \"undefined\") {\n            newargs.push(point[d]);\n          }\n        });\n      });\n      args = newargs;\n    }\n\n    let higher = false;\n    const len = args.length;\n\n    if (coordlen) {\n      if (coordlen > 4) {\n        if (arguments.length !== 1) {\n          throw new Error(\n            \"Only new Bezier(point[]) is accepted for 4th and higher order curves\"\n          );\n        }\n        higher = true;\n      }\n    } else {\n      if (len !== 6 && len !== 8 && len !== 9 && len !== 12) {\n        if (arguments.length !== 1) {\n          throw new Error(\n            \"Only new Bezier(point[]) is accepted for 4th and higher order curves\"\n          );\n        }\n      }\n    }\n\n    const _3d = (this._3d =\n      (!higher && (len === 9 || len === 12)) ||\n      (coords && coords[0] && typeof coords[0].z !== \"undefined\"));\n\n    const points = (this.points = []);\n    for (let idx = 0, step = _3d ? 3 : 2; idx < len; idx += step) {\n      var point = {\n        x: args[idx],\n        y: args[idx + 1],\n      };\n      if (_3d) {\n        point.z = args[idx + 2];\n      }\n      points.push(point);\n    }\n    const order = (this.order = points.length - 1);\n\n    const dims = (this.dims = [\"x\", \"y\"]);\n    if (_3d) dims.push(\"z\");\n    this.dimlen = dims.length;\n\n    const aligned = utils.align(points, { p1: points[0], p2: points[order] });\n    this._linear = !aligned.some((p) => abs(p.y) > 0.0001);\n\n    this._lut = [];\n\n    this._t1 = 0;\n    this._t2 = 1;\n    this.update();\n  }\n\n  static quadraticFromPoints(p1, p2, p3, t) {\n    if (typeof t === \"undefined\") {\n      t = 0.5;\n    }\n    // shortcuts, although they're really dumb\n    if (t === 0) {\n      return new Bezier(p2, p2, p3);\n    }\n    if (t === 1) {\n      return new Bezier(p1, p2, p2);\n    }\n    // real fitting.\n    const abc = Bezier.getABC(2, p1, p2, p3, t);\n    return new Bezier(p1, abc.A, p3);\n  }\n\n  static cubicFromPoints(S, B, E, t, d1) {\n    if (typeof t === \"undefined\") {\n      t = 0.5;\n    }\n    const abc = Bezier.getABC(3, S, B, E, t);\n    if (typeof d1 === \"undefined\") {\n      d1 = utils.dist(B, abc.C);\n    }\n    const d2 = (d1 * (1 - t)) / t;\n\n    const selen = utils.dist(S, E),\n      lx = (E.x - S.x) / selen,\n      ly = (E.y - S.y) / selen,\n      bx1 = d1 * lx,\n      by1 = d1 * ly,\n      bx2 = d2 * lx,\n      by2 = d2 * ly;\n    // derivation of new hull coordinates\n    const e1 = { x: B.x - bx1, y: B.y - by1 },\n      e2 = { x: B.x + bx2, y: B.y + by2 },\n      A = abc.A,\n      v1 = { x: A.x + (e1.x - A.x) / (1 - t), y: A.y + (e1.y - A.y) / (1 - t) },\n      v2 = { x: A.x + (e2.x - A.x) / t, y: A.y + (e2.y - A.y) / t },\n      nc1 = { x: S.x + (v1.x - S.x) / t, y: S.y + (v1.y - S.y) / t },\n      nc2 = {\n        x: E.x + (v2.x - E.x) / (1 - t),\n        y: E.y + (v2.y - E.y) / (1 - t),\n      };\n    // ...done\n    return new Bezier(S, nc1, nc2, E);\n  }\n\n  static getUtils() {\n    return utils;\n  }\n\n  getUtils() {\n    return Bezier.getUtils();\n  }\n\n  static get PolyBezier() {\n    return PolyBezier;\n  }\n\n  valueOf() {\n    return this.toString();\n  }\n\n  toString() {\n    return utils.pointsToString(this.points);\n  }\n\n  toSVG() {\n    if (this._3d) return false;\n    const p = this.points,\n      x = p[0].x,\n      y = p[0].y,\n      s = [\"M\", x, y, this.order === 2 ? \"Q\" : \"C\"];\n    for (let i = 1, last = p.length; i < last; i++) {\n      s.push(p[i].x);\n      s.push(p[i].y);\n    }\n    return s.join(\" \");\n  }\n\n  setRatios(ratios) {\n    if (ratios.length !== this.points.length) {\n      throw new Error(\"incorrect number of ratio values\");\n    }\n    this.ratios = ratios;\n    this._lut = []; //  invalidate any precomputed LUT\n  }\n\n  verify() {\n    const print = this.coordDigest();\n    if (print !== this._print) {\n      this._print = print;\n      this.update();\n    }\n  }\n\n  coordDigest() {\n    return this.points\n      .map(function (c, pos) {\n        return \"\" + pos + c.x + c.y + (c.z ? c.z : 0);\n      })\n      .join(\"\");\n  }\n\n  update() {\n    // invalidate any precomputed LUT\n    this._lut = [];\n    this.dpoints = utils.derive(this.points, this._3d);\n    this.computedirection();\n  }\n\n  computedirection() {\n    const points = this.points;\n    const angle = utils.angle(points[0], points[this.order], points[1]);\n    this.clockwise = angle > 0;\n  }\n\n  length() {\n    return utils.length(this.derivative.bind(this));\n  }\n\n  static getABC(order = 2, S, B, E, t = 0.5) {\n    const u = utils.projectionratio(t, order),\n      um = 1 - u,\n      C = {\n        x: u * S.x + um * E.x,\n        y: u * S.y + um * E.y,\n      },\n      s = utils.abcratio(t, order),\n      A = {\n        x: B.x + (B.x - C.x) / s,\n        y: B.y + (B.y - C.y) / s,\n      };\n    return { A, B, C, S, E };\n  }\n\n  getABC(t, B) {\n    B = B || this.get(t);\n    let S = this.points[0];\n    let E = this.points[this.order];\n    return Bezier.getABC(this.order, S, B, E, t);\n  }\n\n  getLUT(steps) {\n    this.verify();\n    steps = steps || 100;\n    if (this._lut.length === steps) {\n      return this._lut;\n    }\n    this._lut = [];\n    // We want a range from 0 to 1 inclusive, so\n    // we decrement and then use <= rather than <:\n    steps--;\n    for (let i = 0, p, t; i < steps; i++) {\n      t = i / (steps - 1);\n      p = this.compute(t);\n      p.t = t;\n      this._lut.push(p);\n    }\n    return this._lut;\n  }\n\n  on(point, error) {\n    error = error || 5;\n    const lut = this.getLUT(),\n      hits = [];\n    for (let i = 0, c, t = 0; i < lut.length; i++) {\n      c = lut[i];\n      if (utils.dist(c, point) < error) {\n        hits.push(c);\n        t += i / lut.length;\n      }\n    }\n    if (!hits.length) return false;\n    return (t /= hits.length);\n  }\n\n  project(point) {\n    // step 1: coarse check\n    const LUT = this.getLUT(),\n      l = LUT.length - 1,\n      closest = utils.closest(LUT, point),\n      mpos = closest.mpos,\n      t1 = (mpos - 1) / l,\n      t2 = (mpos + 1) / l,\n      step = 0.1 / l;\n\n    // step 2: fine check\n    let mdist = closest.mdist,\n      t = t1,\n      ft = t,\n      p;\n    mdist += 1;\n    for (let d; t < t2 + step; t += step) {\n      p = this.compute(t);\n      d = utils.dist(point, p);\n      if (d < mdist) {\n        mdist = d;\n        ft = t;\n      }\n    }\n    ft = ft < 0 ? 0 : ft > 1 ? 1 : ft;\n    p = this.compute(ft);\n    p.t = ft;\n    p.d = mdist;\n    return p;\n  }\n\n  get(t) {\n    return this.compute(t);\n  }\n\n  point(idx) {\n    return this.points[idx];\n  }\n\n  compute(t) {\n    if (this.ratios) {\n      return utils.computeWithRatios(t, this.points, this.ratios, this._3d);\n    }\n    return utils.compute(t, this.points, this._3d, this.ratios);\n  }\n\n  raise() {\n    const p = this.points,\n      np = [p[0]],\n      k = p.length;\n    for (let i = 1, pi, pim; i < k; i++) {\n      pi = p[i];\n      pim = p[i - 1];\n      np[i] = {\n        x: ((k - i) / k) * pi.x + (i / k) * pim.x,\n        y: ((k - i) / k) * pi.y + (i / k) * pim.y,\n      };\n    }\n    np[k] = p[k - 1];\n    return new Bezier(np);\n  }\n\n  derivative(t) {\n    return utils.compute(t, this.dpoints[0], this._3d);\n  }\n\n  dderivative(t) {\n    return utils.compute(t, this.dpoints[1], this._3d);\n  }\n\n  align() {\n    let p = this.points;\n    return new Bezier(utils.align(p, { p1: p[0], p2: p[p.length - 1] }));\n  }\n\n  curvature(t) {\n    return utils.curvature(t, this.dpoints[0], this.dpoints[1], this._3d);\n  }\n\n  inflections() {\n    return utils.inflections(this.points);\n  }\n\n  normal(t) {\n    return this._3d ? this.__normal3(t) : this.__normal2(t);\n  }\n\n  __normal2(t) {\n    const d = this.derivative(t);\n    const q = sqrt(d.x * d.x + d.y * d.y);\n    return { x: -d.y / q, y: d.x / q };\n  }\n\n  __normal3(t) {\n    // see http://stackoverflow.com/questions/25453159\n    const r1 = this.derivative(t),\n      r2 = this.derivative(t + 0.01),\n      q1 = sqrt(r1.x * r1.x + r1.y * r1.y + r1.z * r1.z),\n      q2 = sqrt(r2.x * r2.x + r2.y * r2.y + r2.z * r2.z);\n    r1.x /= q1;\n    r1.y /= q1;\n    r1.z /= q1;\n    r2.x /= q2;\n    r2.y /= q2;\n    r2.z /= q2;\n    // cross product\n    const c = {\n      x: r2.y * r1.z - r2.z * r1.y,\n      y: r2.z * r1.x - r2.x * r1.z,\n      z: r2.x * r1.y - r2.y * r1.x,\n    };\n    const m = sqrt(c.x * c.x + c.y * c.y + c.z * c.z);\n    c.x /= m;\n    c.y /= m;\n    c.z /= m;\n    // rotation matrix\n    const R = [\n      c.x * c.x,\n      c.x * c.y - c.z,\n      c.x * c.z + c.y,\n      c.x * c.y + c.z,\n      c.y * c.y,\n      c.y * c.z - c.x,\n      c.x * c.z - c.y,\n      c.y * c.z + c.x,\n      c.z * c.z,\n    ];\n    // normal vector:\n    const n = {\n      x: R[0] * r1.x + R[1] * r1.y + R[2] * r1.z,\n      y: R[3] * r1.x + R[4] * r1.y + R[5] * r1.z,\n      z: R[6] * r1.x + R[7] * r1.y + R[8] * r1.z,\n    };\n    return n;\n  }\n\n  hull(t) {\n    let p = this.points,\n      _p = [],\n      q = [],\n      idx = 0;\n    q[idx++] = p[0];\n    q[idx++] = p[1];\n    q[idx++] = p[2];\n    if (this.order === 3) {\n      q[idx++] = p[3];\n    }\n    // we lerp between all points at each iteration, until we have 1 point left.\n    while (p.length > 1) {\n      _p = [];\n      for (let i = 0, pt, l = p.length - 1; i < l; i++) {\n        pt = utils.lerp(t, p[i], p[i + 1]);\n        q[idx++] = pt;\n        _p.push(pt);\n      }\n      p = _p;\n    }\n    return q;\n  }\n\n  split(t1, t2) {\n    // shortcuts\n    if (t1 === 0 && !!t2) {\n      return this.split(t2).left;\n    }\n    if (t2 === 1) {\n      return this.split(t1).right;\n    }\n\n    // no shortcut: use \"de Casteljau\" iteration.\n    const q = this.hull(t1);\n    const result = {\n      left:\n        this.order === 2\n          ? new Bezier([q[0], q[3], q[5]])\n          : new Bezier([q[0], q[4], q[7], q[9]]),\n      right:\n        this.order === 2\n          ? new Bezier([q[5], q[4], q[2]])\n          : new Bezier([q[9], q[8], q[6], q[3]]),\n      span: q,\n    };\n\n    // make sure we bind _t1/_t2 information!\n    result.left._t1 = utils.map(0, 0, 1, this._t1, this._t2);\n    result.left._t2 = utils.map(t1, 0, 1, this._t1, this._t2);\n    result.right._t1 = utils.map(t1, 0, 1, this._t1, this._t2);\n    result.right._t2 = utils.map(1, 0, 1, this._t1, this._t2);\n\n    // if we have no t2, we're done\n    if (!t2) {\n      return result;\n    }\n\n    // if we have a t2, split again:\n    t2 = utils.map(t2, t1, 1, 0, 1);\n    return result.right.split(t2).left;\n  }\n\n  extrema() {\n    const result = {};\n    let roots = [];\n\n    this.dims.forEach(\n      function (dim) {\n        let mfn = function (v) {\n          return v[dim];\n        };\n        let p = this.dpoints[0].map(mfn);\n        result[dim] = utils.droots(p);\n        if (this.order === 3) {\n          p = this.dpoints[1].map(mfn);\n          result[dim] = result[dim].concat(utils.droots(p));\n        }\n        result[dim] = result[dim].filter(function (t) {\n          return t >= 0 && t <= 1;\n        });\n        roots = roots.concat(result[dim].sort(utils.numberSort));\n      }.bind(this)\n    );\n\n    result.values = roots.sort(utils.numberSort).filter(function (v, idx) {\n      return roots.indexOf(v) === idx;\n    });\n\n    return result;\n  }\n\n  bbox() {\n    const extrema = this.extrema(),\n      result = {};\n    this.dims.forEach(\n      function (d) {\n        result[d] = utils.getminmax(this, d, extrema[d]);\n      }.bind(this)\n    );\n    return result;\n  }\n\n  overlaps(curve) {\n    const lbbox = this.bbox(),\n      tbbox = curve.bbox();\n    return utils.bboxoverlap(lbbox, tbbox);\n  }\n\n  offset(t, d) {\n    if (typeof d !== \"undefined\") {\n      const c = this.get(t),\n        n = this.normal(t);\n      const ret = {\n        c: c,\n        n: n,\n        x: c.x + n.x * d,\n        y: c.y + n.y * d,\n      };\n      if (this._3d) {\n        ret.z = c.z + n.z * d;\n      }\n      return ret;\n    }\n    if (this._linear) {\n      const nv = this.normal(0),\n        coords = this.points.map(function (p) {\n          const ret = {\n            x: p.x + t * nv.x,\n            y: p.y + t * nv.y,\n          };\n          if (p.z && nv.z) {\n            ret.z = p.z + t * nv.z;\n          }\n          return ret;\n        });\n      return [new Bezier(coords)];\n    }\n    return this.reduce().map(function (s) {\n      if (s._linear) {\n        return s.offset(t)[0];\n      }\n      return s.scale(t);\n    });\n  }\n\n  simple() {\n    if (this.order === 3) {\n      const a1 = utils.angle(this.points[0], this.points[3], this.points[1]);\n      const a2 = utils.angle(this.points[0], this.points[3], this.points[2]);\n      if ((a1 > 0 && a2 < 0) || (a1 < 0 && a2 > 0)) return false;\n    }\n    const n1 = this.normal(0);\n    const n2 = this.normal(1);\n    let s = n1.x * n2.x + n1.y * n2.y;\n    if (this._3d) {\n      s += n1.z * n2.z;\n    }\n    return abs(acos(s)) < pi / 3;\n  }\n\n  reduce() {\n    // TODO: examine these var types in more detail...\n    let i,\n      t1 = 0,\n      t2 = 0,\n      step = 0.01,\n      segment,\n      pass1 = [],\n      pass2 = [];\n    // first pass: split on extrema\n    let extrema = this.extrema().values;\n    if (extrema.indexOf(0) === -1) {\n      extrema = [0].concat(extrema);\n    }\n    if (extrema.indexOf(1) === -1) {\n      extrema.push(1);\n    }\n\n    for (t1 = extrema[0], i = 1; i < extrema.length; i++) {\n      t2 = extrema[i];\n      segment = this.split(t1, t2);\n      segment._t1 = t1;\n      segment._t2 = t2;\n      pass1.push(segment);\n      t1 = t2;\n    }\n\n    // second pass: further reduce these segments to simple segments\n    pass1.forEach(function (p1) {\n      t1 = 0;\n      t2 = 0;\n      while (t2 <= 1) {\n        for (t2 = t1 + step; t2 <= 1 + step; t2 += step) {\n          segment = p1.split(t1, t2);\n          if (!segment.simple()) {\n            t2 -= step;\n            if (abs(t1 - t2) < step) {\n              // we can never form a reduction\n              return [];\n            }\n            segment = p1.split(t1, t2);\n            segment._t1 = utils.map(t1, 0, 1, p1._t1, p1._t2);\n            segment._t2 = utils.map(t2, 0, 1, p1._t1, p1._t2);\n            pass2.push(segment);\n            t1 = t2;\n            break;\n          }\n        }\n      }\n      if (t1 < 1) {\n        segment = p1.split(t1, 1);\n        segment._t1 = utils.map(t1, 0, 1, p1._t1, p1._t2);\n        segment._t2 = p1._t2;\n        pass2.push(segment);\n      }\n    });\n    return pass2;\n  }\n\n  scale(d) {\n    const order = this.order;\n    let distanceFn = false;\n    if (typeof d === \"function\") {\n      distanceFn = d;\n    }\n    if (distanceFn && order === 2) {\n      return this.raise().scale(distanceFn);\n    }\n\n    // TODO: add special handling for degenerate (=linear) curves.\n    const clockwise = this.clockwise;\n    const r1 = distanceFn ? distanceFn(0) : d;\n    const r2 = distanceFn ? distanceFn(1) : d;\n    const v = [this.offset(0, 10), this.offset(1, 10)];\n    const points = this.points;\n    const np = [];\n    const o = utils.lli4(v[0], v[0].c, v[1], v[1].c);\n\n    if (!o) {\n      throw new Error(\"cannot scale this curve. Try reducing it first.\");\n    }\n    // move all points by distance 'd' wrt the origin 'o'\n\n    // move end points by fixed distance along normal.\n    [0, 1].forEach(function (t) {\n      const p = (np[t * order] = utils.copy(points[t * order]));\n      p.x += (t ? r2 : r1) * v[t].n.x;\n      p.y += (t ? r2 : r1) * v[t].n.y;\n    });\n\n    if (!distanceFn) {\n      // move control points to lie on the intersection of the offset\n      // derivative vector, and the origin-through-control vector\n      [0, 1].forEach((t) => {\n        if (order === 2 && !!t) return;\n        const p = np[t * order];\n        const d = this.derivative(t);\n        const p2 = { x: p.x + d.x, y: p.y + d.y };\n        np[t + 1] = utils.lli4(p, p2, o, points[t + 1]);\n      });\n      return new Bezier(np);\n    }\n\n    // move control points by \"however much necessary to\n    // ensure the correct tangent to endpoint\".\n    [0, 1].forEach(function (t) {\n      if (order === 2 && !!t) return;\n      var p = points[t + 1];\n      var ov = {\n        x: p.x - o.x,\n        y: p.y - o.y,\n      };\n      var rc = distanceFn ? distanceFn((t + 1) / order) : d;\n      if (distanceFn && !clockwise) rc = -rc;\n      var m = sqrt(ov.x * ov.x + ov.y * ov.y);\n      ov.x /= m;\n      ov.y /= m;\n      np[t + 1] = {\n        x: p.x + rc * ov.x,\n        y: p.y + rc * ov.y,\n      };\n    });\n    return new Bezier(np);\n  }\n\n  outline(d1, d2, d3, d4) {\n    d2 = typeof d2 === \"undefined\" ? d1 : d2;\n    const reduced = this.reduce(),\n      len = reduced.length,\n      fcurves = [];\n\n    let bcurves = [],\n      p,\n      alen = 0,\n      tlen = this.length();\n\n    const graduated = typeof d3 !== \"undefined\" && typeof d4 !== \"undefined\";\n\n    function linearDistanceFunction(s, e, tlen, alen, slen) {\n      return function (v) {\n        const f1 = alen / tlen,\n          f2 = (alen + slen) / tlen,\n          d = e - s;\n        return utils.map(v, 0, 1, s + f1 * d, s + f2 * d);\n      };\n    }\n\n    // form curve oulines\n    reduced.forEach(function (segment) {\n      const slen = segment.length();\n      if (graduated) {\n        fcurves.push(\n          segment.scale(linearDistanceFunction(d1, d3, tlen, alen, slen))\n        );\n        bcurves.push(\n          segment.scale(linearDistanceFunction(-d2, -d4, tlen, alen, slen))\n        );\n      } else {\n        fcurves.push(segment.scale(d1));\n        bcurves.push(segment.scale(-d2));\n      }\n      alen += slen;\n    });\n\n    // reverse the \"return\" outline\n    bcurves = bcurves\n      .map(function (s) {\n        p = s.points;\n        if (p[3]) {\n          s.points = [p[3], p[2], p[1], p[0]];\n        } else {\n          s.points = [p[2], p[1], p[0]];\n        }\n        return s;\n      })\n      .reverse();\n\n    // form the endcaps as lines\n    const fs = fcurves[0].points[0],\n      fe = fcurves[len - 1].points[fcurves[len - 1].points.length - 1],\n      bs = bcurves[len - 1].points[bcurves[len - 1].points.length - 1],\n      be = bcurves[0].points[0],\n      ls = utils.makeline(bs, fs),\n      le = utils.makeline(fe, be),\n      segments = [ls].concat(fcurves).concat([le]).concat(bcurves),\n      slen = segments.length;\n\n    return new PolyBezier(segments);\n  }\n\n  outlineshapes(d1, d2, curveIntersectionThreshold) {\n    d2 = d2 || d1;\n    const outline = this.outline(d1, d2).curves;\n    const shapes = [];\n    for (let i = 1, len = outline.length; i < len / 2; i++) {\n      const shape = utils.makeshape(\n        outline[i],\n        outline[len - i],\n        curveIntersectionThreshold\n      );\n      shape.startcap.virtual = i > 1;\n      shape.endcap.virtual = i < len / 2 - 1;\n      shapes.push(shape);\n    }\n    return shapes;\n  }\n\n  intersects(curve, curveIntersectionThreshold) {\n    if (!curve) return this.selfintersects(curveIntersectionThreshold);\n    if (curve.p1 && curve.p2) {\n      return this.lineIntersects(curve);\n    }\n    if (curve instanceof Bezier) {\n      curve = curve.reduce();\n    }\n    return this.curveintersects(\n      this.reduce(),\n      curve,\n      curveIntersectionThreshold\n    );\n  }\n\n  lineIntersects(line) {\n    const mx = min(line.p1.x, line.p2.x),\n      my = min(line.p1.y, line.p2.y),\n      MX = max(line.p1.x, line.p2.x),\n      MY = max(line.p1.y, line.p2.y);\n    return utils.roots(this.points, line).filter((t) => {\n      var p = this.get(t);\n      return utils.between(p.x, mx, MX) && utils.between(p.y, my, MY);\n    });\n  }\n\n  selfintersects(curveIntersectionThreshold) {\n    // \"simple\" curves cannot intersect with their direct\n    // neighbour, so for each segment X we check whether\n    // it intersects [0:x-2][x+2:last].\n\n    const reduced = this.reduce(),\n      len = reduced.length - 2,\n      results = [];\n\n    for (let i = 0, result, left, right; i < len; i++) {\n      left = reduced.slice(i, i + 1);\n      right = reduced.slice(i + 2);\n      result = this.curveintersects(left, right, curveIntersectionThreshold);\n      results.push(...result);\n    }\n    return results;\n  }\n\n  curveintersects(c1, c2, curveIntersectionThreshold) {\n    const pairs = [];\n    // step 1: pair off any overlapping segments\n    c1.forEach(function (l) {\n      c2.forEach(function (r) {\n        if (l.overlaps(r)) {\n          pairs.push({ left: l, right: r });\n        }\n      });\n    });\n    // step 2: for each pairing, run through the convergence algorithm.\n    let intersections = [];\n    pairs.forEach(function (pair) {\n      const result = utils.pairiteration(\n        pair.left,\n        pair.right,\n        curveIntersectionThreshold\n      );\n      if (result.length > 0) {\n        intersections = intersections.concat(result);\n      }\n    });\n    return intersections;\n  }\n\n  arcs(errorThreshold) {\n    errorThreshold = errorThreshold || 0.5;\n    return this._iterate(errorThreshold, []);\n  }\n\n  _error(pc, np1, s, e) {\n    const q = (e - s) / 4,\n      c1 = this.get(s + q),\n      c2 = this.get(e - q),\n      ref = utils.dist(pc, np1),\n      d1 = utils.dist(pc, c1),\n      d2 = utils.dist(pc, c2);\n    return abs(d1 - ref) + abs(d2 - ref);\n  }\n\n  _iterate(errorThreshold, circles) {\n    let t_s = 0,\n      t_e = 1,\n      safety;\n    // we do a binary search to find the \"good `t` closest to no-longer-good\"\n    do {\n      safety = 0;\n\n      // step 1: start with the maximum possible arc\n      t_e = 1;\n\n      // points:\n      let np1 = this.get(t_s),\n        np2,\n        np3,\n        arc,\n        prev_arc;\n\n      // booleans:\n      let curr_good = false,\n        prev_good = false,\n        done;\n\n      // numbers:\n      let t_m = t_e,\n        prev_e = 1,\n        step = 0;\n\n      // step 2: find the best possible arc\n      do {\n        prev_good = curr_good;\n        prev_arc = arc;\n        t_m = (t_s + t_e) / 2;\n        step++;\n\n        np2 = this.get(t_m);\n        np3 = this.get(t_e);\n\n        arc = utils.getccenter(np1, np2, np3);\n\n        //also save the t values\n        arc.interval = {\n          start: t_s,\n          end: t_e,\n        };\n\n        let error = this._error(arc, np1, t_s, t_e);\n        curr_good = error <= errorThreshold;\n\n        done = prev_good && !curr_good;\n        if (!done) prev_e = t_e;\n\n        // this arc is fine: we can move 'e' up to see if we can find a wider arc\n        if (curr_good) {\n          // if e is already at max, then we're done for this arc.\n          if (t_e >= 1) {\n            // make sure we cap at t=1\n            arc.interval.end = prev_e = 1;\n            prev_arc = arc;\n            // if we capped the arc segment to t=1 we also need to make sure that\n            // the arc's end angle is correct with respect to the bezier end point.\n            if (t_e > 1) {\n              let d = {\n                x: arc.x + arc.r * cos(arc.e),\n                y: arc.y + arc.r * sin(arc.e),\n              };\n              arc.e += utils.angle({ x: arc.x, y: arc.y }, d, this.get(1));\n            }\n            break;\n          }\n          // if not, move it up by half the iteration distance\n          t_e = t_e + (t_e - t_s) / 2;\n        } else {\n          // this is a bad arc: we need to move 'e' down to find a good arc\n          t_e = t_m;\n        }\n      } while (!done && safety++ < 100);\n\n      if (safety >= 100) {\n        break;\n      }\n\n      // console.log(\"L835: [F] arc found\", t_s, prev_e, prev_arc.x, prev_arc.y, prev_arc.s, prev_arc.e);\n\n      prev_arc = prev_arc ? prev_arc : arc;\n      circles.push(prev_arc);\n      t_s = prev_e;\n    } while (t_e < 1);\n    return circles;\n  }\n}\n\nexport { Bezier };\n"],"names":["module","exports","Collection","Events","Instance","Log","Model","Module","Singleton","Spine","association","createObject","makeArray","moduleKeywords","singularize","underscore","slice","indexOf","item","i","l","this","length","extend","child","parent","key","hasProp","call","ctor","constructor","prototype","__super__","hasOwnProperty","on","ev","callback","base","evs","j","len","name","split","_callbacks","push","one","handler","off","apply","arguments","trigger","args","list","ref","shift","listenTo","obj","listeningTo","listenToOnce","listeningToOnce","idx","lt","splice","stopListening","events","e","evts","k","len1","len2","len3","m","n","ref1","ref2","len4","p","results","join","trim","bind","unbind","trace","logPrefix","log","unshift","console","init","include","value","Error","included","extended","proxy","func","_this","superClass","atts","uuid","cid","id","uid","load","records","irecords","attributes","configure","className","deleteAll","toString","find","notFound","clone","findAll","ids","exists","Boolean","addRecord","record","root","refresh","values","options","result","clear","fromJSON","Array","isArray","sort","cloneArray","select","findByAttribute","findAllByAttribute","each","all","begin","end","first","last","count","destroyAll","destroy","update","updateAttributes","create","save","change","callbackOrParams","concat","fetch","toJSON","beforeFromJSON","objects","JSON","parse","comparator","array","idCounter","prefix","isNew","isValid","validate","eql","rec","error","stripCloneAttrs","updateAttribute","changeID","remove","destroyed","dup","newRecord","reload","original","stringify","Object","o","Func","version","sub","instances","statics","Result","setup","Class","model","associated","cb","fkey","add","str","replace","toLowerCase","Ctor","hasMany","belongsTo","hasOne","addBusinessDays","dirtyDate","dirtyAmount","requiredArgs","date","toDate","startedOnWeekend","isWeekend","amount","toInteger","isNaN","Date","NaN","hours","getHours","sign","fullWeeks","setDate","getDate","restDays","Math","abs","getDay","isSaturday","isSunday","setHours","addYears","eachDayOfInterval","dirtyInterval","_options$step","interval","startDate","start","endTime","getTime","RangeError","dates","currentDate","step","Number","isSameDay","dirtyDateLeft","dirtyDateRight","dateLeftStartOfDay","dateRightStartOfDay","isSameMonth","dateLeft","dateRight","getFullYear","getMonth","isSameWeek","dateLeftStartOfWeek","dateRightStartOfWeek","day","isWithinInterval","time","startTime","lastDayOfMonth","month","setFullYear","lastDayOfWeek","_ref","_ref2","_ref3","_options$weekStartsOn","_options$locale","_options$locale$optio","_defaultOptions$local","_defaultOptions$local2","defaultOptions","weekStartsOn","locale","diff","setMonth","dirtyMonth","year","dateWithDesiredMonth","daysInMonth","monthIndex","getDaysInMonth","min","set","minutes","setMinutes","seconds","setSeconds","milliseconds","setMilliseconds","startOfMonth","startOfWeek","startOfYear","cleanDate","subYears","token","singleMatcher","RegExp","multiMatcher","decodeComponents","components","decodeURIComponent","err","left","right","decode","input","tokens","match","encodedURI","TypeError","replaceMap","exec","entries","keys","customDecodeURIComponent","predicate","ret","isArr","val","window","document","exportName","undefined","assign","VENDOR_PREFIXES","TEST_ELEMENT","createElement","TYPE_FUNCTION","round","now","setTimeoutContext","fn","timeout","context","setTimeout","bindFn","invokeArrayArg","arg","iterator","forEach","deprecate","method","message","deprecationMessage","stack","warn","target","output","index","source","nextKey","dest","src","merge","inherit","properties","childP","baseP","_super","boolOrFn","ifUndefined","val1","val2","addEventListeners","types","splitStr","type","addEventListener","removeEventListeners","removeEventListener","hasParent","node","parentNode","inStr","inArray","findByKey","toArray","uniqueArray","a","b","prefixed","property","prop","camelProp","toUpperCase","_uniqueId","getWindowForElement","element","doc","ownerDocument","defaultView","parentWindow","SUPPORT_TOUCH","SUPPORT_POINTER_EVENTS","SUPPORT_ONLY_TOUCH","test","navigator","userAgent","INPUT_TYPE_TOUCH","INPUT_TYPE_MOUSE","COMPUTE_INTERVAL","INPUT_START","INPUT_END","INPUT_CANCEL","DIRECTION_NONE","DIRECTION_LEFT","DIRECTION_RIGHT","DIRECTION_UP","DIRECTION_DOWN","DIRECTION_HORIZONTAL","DIRECTION_VERTICAL","DIRECTION_ALL","PROPS_XY","PROPS_CLIENT_XY","Input","manager","self","inputTarget","domHandler","enable","inputHandler","eventType","pointersLen","pointers","changedPointersLen","changedPointers","isFirst","isFinal","session","pointersLength","firstInput","simpleCloneInputData","firstMultiple","offsetCenter","center","getCenter","timeStamp","deltaTime","angle","getAngle","distance","getDistance","offset","offsetDelta","prevDelta","prevInput","x","deltaX","y","deltaY","computeDeltaXY","offsetDirection","getDirection","overallVelocity","getVelocity","overallVelocityX","overallVelocityY","scale","rotation","getRotation","maxPointers","velocity","velocityX","velocityY","direction","lastInterval","v","computeIntervalInputData","srcEvent","computeInputData","emit","recognize","clientX","clientY","p1","p2","props","sqrt","atan2","PI","evEl","evTarget","evWin","MOUSE_INPUT_MAP","mousedown","mousemove","mouseup","MOUSE_ELEMENT_EVENTS","MOUSE_WINDOW_EVENTS","MouseInput","pressed","button","which","pointerType","POINTER_INPUT_MAP","pointerdown","pointermove","pointerup","pointercancel","pointerout","IE10_POINTER_TYPE_ENUM","POINTER_ELEMENT_EVENTS","POINTER_WINDOW_EVENTS","PointerEventInput","store","pointerEvents","MSPointerEvent","PointerEvent","removePointer","eventTypeNormalized","isTouch","storeIndex","pointerId","SINGLE_TOUCH_INPUT_MAP","touchstart","touchmove","touchend","touchcancel","SingleTouchInput","started","normalizeSingleTouches","touches","changed","changedTouches","TOUCH_INPUT_MAP","TOUCH_TARGET_EVENTS","TouchInput","targetIds","getTouches","allTouches","identifier","targetTouches","changedTargetTouches","filter","touch","DEDUP_TIMEOUT","TouchMouseInput","mouse","primaryTouch","lastTouches","recordTouches","eventData","setLastTouch","lastTouch","lts","isSyntheticEvent","t","dx","dy","inputEvent","inputData","isMouse","sourceCapabilities","firesTouchEvents","PREFIXED_TOUCH_ACTION","style","NATIVE_TOUCH_ACTION","TOUCH_ACTION_COMPUTE","TOUCH_ACTION_AUTO","TOUCH_ACTION_MANIPULATION","TOUCH_ACTION_NONE","TOUCH_ACTION_PAN_X","TOUCH_ACTION_PAN_Y","TOUCH_ACTION_MAP","touchMap","cssSupports","CSS","supports","getTouchActionProps","TouchAction","compute","actions","touchAction","recognizers","recognizer","getTouchAction","hasPanX","hasPanY","cleanTouchActions","preventDefaults","prevented","preventDefault","hasNone","isTapPointer","isTapMovement","isTapTouchTime","preventSrc","STATE_POSSIBLE","STATE_FAILED","Recognizer","defaults","state","simultaneous","requireFail","stateStr","directionStr","getRecognizerByNameIfManager","otherRecognizer","get","AttrRecognizer","PanRecognizer","pX","pY","PinchRecognizer","PressRecognizer","_timer","_input","RotateRecognizer","SwipeRecognizer","TapRecognizer","pTime","pCenter","Hammer","preset","Manager","recognizeWith","dropRecognizeWith","requireFailure","dropRequireFailure","hasRequireFailures","canRecognizeWith","event","additionalEvent","tryEmit","canEmit","inputDataClone","reset","process","attrTest","optionPointers","isRecognized","threshold","directionTest","hasMoved","inOut","validPointers","validMovement","validTime","clearTimeout","taps","posThreshold","validTouchTime","failTimeout","validInterval","validMultiTap","tapCount","VERSION","domEvents","inputClass","cssProps","userSelect","touchSelect","touchCallout","contentZooming","userDrag","tapHighlightColor","handlers","oldCssProps","toggleCssProps","stop","force","stopped","curRecognizer","existing","data","gestureEvent","createEvent","initEvent","gesture","dispatchEvent","triggerDomEvent","INPUT_MOVE","STATE_BEGAN","STATE_CHANGED","STATE_ENDED","STATE_RECOGNIZED","STATE_CANCELLED","Tap","Pan","Swipe","Pinch","Rotate","Press","MAX_SAFE_INTEGER","argsTag","funcTag","genTag","freeGlobal","g","freeSelf","Function","arrayPush","objectProto","objectToString","Symbol","propertyIsEnumerable","spreadableSymbol","isConcatSpreadable","nativeMax","max","baseFlatten","depth","isStrict","isFlattenable","isObjectLike","isLength","tag","isObject","isFunction","isArrayLike","isArrayLikeObject","isArguments","fromRight","flowRight","funcs","reverse","otherArgs","thisArg","HASH_UNDEFINED","asyncTag","nullTag","objectTag","proxyTag","undefinedTag","reIsHostCtor","reIsUint","typedArrayTags","freeExports","nodeType","freeModule","moduleExports","freeProcess","nodeUtil","require","binding","nodeIsTypedArray","isTypedArray","transform","arrayProto","funcProto","coreJsData","funcToString","maskSrcKey","IE_PROTO","nativeObjectToString","objectCtorString","reIsNative","Buffer","Uint8Array","allocUnsafe","getPrototype","getPrototypeOf","objectCreate","symToStringTag","toStringTag","defineProperty","getNative","nativeIsBuffer","isBuffer","nativeNow","Map","nativeCreate","baseCreate","object","proto","Hash","entry","ListCache","MapCache","Stack","__data__","size","arrayLikeKeys","inherited","isArg","isBuff","isType","skipIndexes","iteratee","baseTimes","String","isIndex","assignMergeValue","eq","baseAssignValue","assignValue","objValue","assocIndexOf","has","pop","getMapData","pairs","LARGE_ARRAY_SIZE","baseFor","keysFunc","iterable","baseGetTag","isOwn","unmasked","getRawTag","baseIsArguments","baseIsNative","isMasked","toSource","baseKeysIn","nativeKeysIn","isProto","isPrototype","baseMerge","srcIndex","customizer","srcValue","mergeFunc","safeGet","stacked","newValue","isCommon","isTyped","copyArray","buffer","isDeep","copy","cloneBuffer","typedArray","arrayBuffer","byteLength","byteOffset","isPlainObject","copyObject","keysIn","toPlainObject","initCloneObject","baseMergeDeep","baseRest","setToString","overRest","identity","baseSetToString","string","map","getValue","lastCalled","stamp","remaining","shortOut","other","baseUnary","assigner","sources","guard","isIterateeCall","mergeWith","symbolTag","arrayIncludes","fromIndex","baseFindIndex","baseIsNaN","baseIndexOf","arrayIncludesWith","arrayMap","cacheHas","cache","overArg","nativeGetSymbols","getOwnPropertySymbols","SetCache","pattern","isHostObject","getAllKeysIn","symbolsFunc","baseGetAllKeys","getSymbolsIn","getSymbols","stubArray","toKey","isSymbol","omit","basePickBy","basePick","includes","valuesLength","outer","computed","valuesIndex","baseDifference","strictUriEncode","decodeComponent","splitOnFirst","filterObject","validateArrayFormatSeparator","encode","strict","encodeURIComponent","keysSorter","removeHash","hashStart","extract","queryStart","parseValue","parseNumbers","parseBooleans","query","arrayFormat","arrayFormatSeparator","formatter","accumulator","isEncodedArray","parserForArrayFormat","param","reduce","shouldFilter","skipNull","skipEmptyString","encoderForArrayFormat","objectCopy","parseUrl","url","url_","hash","parseFragmentIdentifier","fragmentIdentifier","stringifyUrl","queryFromUrl","parsedQueryFromUrl","queryString","getHash","pick","exclude","exclusionFilter","extendStatics","__extends","d","setPrototypeOf","__proto__","__","__assign","s","rowSizeBase","width","height","top","cursor","colSizeBase","edgeBase","position","styles","bottom","topRight","bottomRight","bottomLeft","topLeft","Resizer","onMouseDown","onResizeStart","onTouchStart","render","replaceStyles","children","DEFAULT_SIZE","clamp","snap","hasDirection","dir","isTouchEvent","findClosestSnap","snapArray","snapGap","closestGapIndex","prev","curr","gap","getStringSize","endsWith","getPixelSize","parentSize","innerWidth","innerHeight","definedProps","baseClassName","Resizable","ratio","resizable","parentLeft","parentTop","resizableLeft","resizableRight","resizableTop","resizableBottom","targetLeft","targetTop","appendBase","flex","classList","appendChild","removeBase","removeChild","c","isResizing","propsSize","backgroundStyle","backgroundColor","opacity","zIndex","flexBasis","onMouseMove","onMouseUp","enumerable","configurable","defaultSize","orgWidth","offsetWidth","orgHeight","offsetHeight","orgPosition","getSize","getParentSize","wrapChanged","wrap","flexWrap","minWidth","minHeight","bindEvents","capture","passive","unbindEvents","componentDidMount","computedStyle","getComputedStyle","setState","componentWillUnmount","createSizeForCssProperty","newSize","kind","calculateNewMaxFromBoundary","maxWidth","maxHeight","boundWidth","boundHeight","boundsByDirection","widthByDirection","heightByDirection","bounds","parent_1","isFinite","calculateNewSizeFromDirection","resizeRatio","_a","_b","lockAspectRatio","lockAspectRatioExtraHeight","lockAspectRatioExtraWidth","newWidth","newHeight","extraHeight","extraWidth","calculateNewSizeFromAspectRatio","computedMinWidth","computedMaxWidth","computedMinHeight","computedMaxHeight","extraMinWidth","extraMaxWidth","extraMinHeight","extraMaxHeight","lockedMinWidth","lockedMaxWidth","lockedMinHeight","lockedMaxHeight","setBoundingClientRect","parent_2","parentRect","getBoundingClientRect","targetRect","top_1","nativeEvent","isMouseEvent","parent_3","flexDirection","flexDir","startsWith","TouchEvent","stopPropagation","calculateNewMax","_c","boundaryMax","grid","newGridWidth","newGridHeight","delta","newState","flushSync","onResize","onResizeStop","updateSize","renderResizer","handleStyles","handleClasses","handleWrapperStyle","handleWrapperClass","handleComponent","resizers","extendsProps","acc","sizeStyle","boxSizing","flexShrink","Wrapper","as","defaultProps","separator","separatorIndex","charCodeAt","tryToString","$TypeError","O","P","$","$findLastIndex","addToUnscopables","findLastIndex","callbackfn","toObject","lengthOfArrayLike","setArrayLength","deletePropertyOrThrow","doesNotExceedSafeInteger","arity","forced","writable","properErrorOnNonWritableLength","argCount","to","cos","sin","acos","pow","crt","pi","tau","quart","nMax","nMin","MIN_SAFE_INTEGER","ZERO","z","utils","Tvalues","Cvalues","arcfn","derivativeFn","points","_3d","order","mt","mt2","t2","dCpts","computeWithRatios","ratios","r","f1","f2","f3","f4","derive","dpoints","dpt","between","M","approximately","precision","sum","ds","de","ts","te","lerp","v1","v2","pointToString","pointsToString","dx1","dy1","dx2","dy2","pos","parseFloat","substring","dist","closest","LUT","point","mpos","mdist","abcratio","projectionratio","lli8","x1","y1","x2","y2","x3","y3","x4","y4","lli4","p3","p4","lli","makeline","Bezier","findbbox","sections","mx","my","MX","MY","bbox","mid","shapeintersections","s1","bbox1","s2","bbox2","curveIntersectionThreshold","bboxoverlap","intersections","a1","startcap","forward","back","endcap","a2","l1","virtual","l2","iss","intersects","c1","c2","makeshape","bpl","fpl","shape","getminmax","curve","align","line","tx","ty","roots","aligned","m1","m2","pa","pb","pc","q","q2","discriminant","u1","mp3","phi","t1","sd","droots","curvature","d1","d2","kOnly","num","dnm","adk","dk","dd","qdsum","pk","nk","inflections","v3","trm","sq","b1","b2","dims","dim","expandbox","_bbox","pairiteration","c1b","c2b","_t1","_t2","cc1","cc2","pair","getccenter","dx1p","dy1p","dx2p","dy2p","mx1","my1","mx2","my2","mx1n","my1n","mx2n","my2n","arc","_","numberSort","PolyBezier","curves","valueOf","addCurve","coords","from","coordlen","newargs","higher","dimlen","_linear","some","_lut","quadraticFromPoints","abc","getABC","A","cubicFromPoints","S","B","E","C","selen","lx","ly","bx1","by1","bx2","by2","e1","e2","nc1","nc2","getUtils","toSVG","setRatios","verify","print","coordDigest","_print","computedirection","clockwise","derivative","u","um","getLUT","steps","lut","hits","project","ft","raise","np","pim","dderivative","normal","__normal3","__normal2","r1","r2","q1","R","hull","_p","pt","span","extrema","mfn","overlaps","lbbox","tbbox","nv","simple","n1","n2","segment","pass1","pass2","distanceFn","ov","rc","outline","d3","d4","reduced","fcurves","bcurves","alen","tlen","graduated","linearDistanceFunction","slen","fs","fe","bs","be","ls","le","segments","outlineshapes","shapes","lineIntersects","curveintersects","selfintersects","arcs","errorThreshold","_iterate","_error","np1","circles","safety","t_s","t_e","np2","np3","prev_arc","done","curr_good","prev_good","t_m","prev_e"],"sourceRoot":""}