{"version":3,"file":"6224.d1a1c33a.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/add/index.js","webpack://@finviz/website/../node_modules/date-fns/esm/eachDayOfInterval/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/date-fns/esm/addYears/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/internals/engine-is-browser.js","webpack://@finviz/website/../node_modules/core-js/internals/engine-is-deno.js","webpack://@finviz/website/../node_modules/core-js/internals/iterate.js","webpack://@finviz/website/../node_modules/core-js/internals/perform.js","webpack://@finviz/website/../node_modules/core-js/internals/promise-constructor-detection.js","webpack://@finviz/website/../node_modules/core-js/internals/promise-statics-incorrect-iteration.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/core-js/modules/es.promise.all-settled.js","webpack://@finviz/website/../node_modules/core-js/modules/web.url.to-json.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 */\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); // Get remaining days not part of a full week\n\n  var restDays = Math.abs(amount % 5); // Loops over remaining days\n\n  while (restDays > 0) {\n    date.setDate(date.getDate() + sign);\n    if (!isWeekend(date)) restDays -= 1;\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\n\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  } // Restore hours to avoid DST lag\n\n\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 * ### v2.0.0 breaking changes:\n *\n * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).\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 * var result = isSaturday(new Date(2014, 8, 27))\n * //=> true\n */\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 * ### v2.0.0 breaking changes:\n *\n * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).\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 * var result = isSunday(new Date(2014, 8, 21))\n * //=> true\n */\n\nexport default function isSunday(dirtyDate) {\n  requiredArgs(1, arguments);\n  return toDate(dirtyDate).getDay() === 0;\n}","import addDays from \"../addDays/index.js\";\nimport addMonths from \"../addMonths/index.js\";\nimport toDate from \"../toDate/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\nimport toInteger from \"../_lib/toInteger/index.js\";\n\n/**\n * @name add\n * @category Common Helpers\n * @summary Add the specified years, months, weeks, days, hours, minutes and seconds to the given date.\n *\n * @description\n * Add the specified years, months, weeks, days, hours, minutes and seconds to the given date.\n *\n * @param {Date|Number} date - the date to be changed\n * @param {Duration} duration - the object with years, months, weeks, days, hours, minutes and seconds to be added. Positive decimals will be rounded using `Math.floor`, decimals less than zero will be rounded using `Math.ceil`.\n *\n * | Key            | Description                        |\n * |----------------|------------------------------------|\n * | years          | Amount of years to be added        |\n * | months         | Amount of months to be added       |\n * | weeks          | Amount of weeks to be added        |\n * | days           | Amount of days to be added         |\n * | hours          | Amount of hours to be added        |\n * | minutes        | Amount of minutes to be added      |\n * | seconds        | Amount of seconds to be added      |\n *\n * All values default to 0\n *\n * @returns {Date} the new date with the seconds added\n * @throws {TypeError} 2 arguments required\n *\n * @example\n * // Add the following duration to 1 September 2014, 10:19:50\n * const result = add(new Date(2014, 8, 1, 10, 19, 50), {\n *   years: 2,\n *   months: 9,\n *   weeks: 1,\n *   days: 7,\n *   hours: 5,\n *   minutes: 9,\n *   seconds: 30,\n * })\n * //=> Thu Jun 15 2017 15:29:20\n */\nexport default function add(dirtyDate, duration) {\n  requiredArgs(2, arguments);\n  if (!duration || typeof duration !== 'object') return new Date(NaN);\n  var years = duration.years ? toInteger(duration.years) : 0;\n  var months = duration.months ? toInteger(duration.months) : 0;\n  var weeks = duration.weeks ? toInteger(duration.weeks) : 0;\n  var days = duration.days ? toInteger(duration.days) : 0;\n  var hours = duration.hours ? toInteger(duration.hours) : 0;\n  var minutes = duration.minutes ? toInteger(duration.minutes) : 0;\n  var seconds = duration.seconds ? toInteger(duration.seconds) : 0; // Add years and months\n\n  var date = toDate(dirtyDate);\n  var dateWithMonths = months || years ? addMonths(date, months + years * 12) : date; // Add weeks and days\n\n  var dateWithDays = days || weeks ? addDays(dateWithMonths, days + weeks * 7) : dateWithMonths; // Add days, hours, minutes and seconds\n\n  var minutesToAdd = minutes + hours * 60;\n  var secondsToAdd = seconds + minutesToAdd * 60;\n  var msToAdd = secondsToAdd * 1000;\n  var finalDate = new Date(dateWithDays.getTime() + msToAdd);\n  return finalDate;\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 * ### v2.0.0 breaking changes:\n *\n * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).\n *\n * - The function was renamed from `eachDay` to `eachDayOfInterval`.\n *   This change was made to mirror the use of the word \"interval\" in standard ISO 8601:2004 terminology:\n *\n *   ```\n *   2.1.3\n *   time interval\n *   part of the time axis limited by two instants\n *   ```\n *\n *   Also, this function now accepts an object with `start` and `end` properties\n *   instead of two arguments as an interval.\n *   This function now throws `RangeError` if the start of the interval is after its end\n *   or if any date in the interval is `Invalid Date`.\n *\n *   ```javascript\n *   // Before v2.0.0\n *\n *   eachDay(new Date(2014, 0, 10), new Date(2014, 0, 20))\n *\n *   // v2.0.0 onward\n *\n *   eachDayOfInterval(\n *     { start: new Date(2014, 0, 10), end: new Date(2014, 0, 20) }\n *   )\n *   ```\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 */\n\nexport default function eachDayOfInterval(dirtyInterval, options) {\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(); // Throw an exception if start date is after end date or if any date is `Invalid Date`\n\n  if (!(startDate.getTime() <= endTime)) {\n    throw new RangeError('Invalid interval');\n  }\n\n  var dates = [];\n  var currentDate = startDate;\n  currentDate.setHours(0, 0, 0, 0);\n  var step = options && 'step' in options ? Number(options.step) : 1;\n  if (step < 1 || isNaN(step)) throw new RangeError('`options.step` must be a number greater than 1');\n\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\n  return dates;\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 * ### v2.0.0 breaking changes:\n *\n * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).\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 * var 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 * var result = isSameMonth(new Date(2014, 8, 2), new Date(2015, 8, 25))\n * //=> false\n */\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/**\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 * ### v2.0.0 breaking changes:\n *\n * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).\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 * var 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 * var 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 * var result = isSameWeek(new Date(2014, 0, 1), new Date(2015, 0, 1))\n * //=> false\n */\nexport default function isSameWeek(dirtyDateLeft, dirtyDateRight, dirtyOptions) {\n  requiredArgs(2, arguments);\n  var dateLeftStartOfWeek = startOfWeek(dirtyDateLeft, dirtyOptions);\n  var dateRightStartOfWeek = startOfWeek(dirtyDateRight, dirtyOptions);\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 * ### v2.0.0 breaking changes:\n *\n * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).\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 */\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/**\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 * ### v2.0.0 breaking changes:\n *\n * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).\n *\n * - The function was renamed from `isWithinRange` to `isWithinInterval`.\n *   This change was made to mirror the use of the word \"interval\" in standard ISO 8601:2004 terminology:\n *\n *   ```\n *   2.1.3\n *   time interval\n *   part of the time axis limited by two instants\n *   ```\n *\n *   Also, this function now accepts an object with `start` and `end` properties\n *   instead of two arguments as an interval.\n *   This function now throws `RangeError` if the start of the interval is after its end\n *   or if any date in the interval is `Invalid Date`.\n *\n *   ```javascript\n *   // Before v2.0.0\n *\n *   isWithinRange(\n *     new Date(2014, 0, 3),\n *     new Date(2014, 0, 1), new Date(2014, 0, 7)\n *   )\n *\n *   // v2.0.0 onward\n *\n *   isWithinInterval(\n *     new Date(2014, 0, 3),\n *     { start: new Date(2014, 0, 1), end: new Date(2014, 0, 7) }\n *   )\n *   ```\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(); // Throw an exception if start date is after end date or if any date is `Invalid Date`\n\n  if (!(startTime <= endTime)) {\n    throw new RangeError('Invalid interval');\n  }\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 * ### v2.0.0 breaking changes:\n *\n * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).\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 * var result = lastDayOfMonth(new Date(2014, 8, 2, 11, 55, 0))\n * //=> Tue Sep 30 2014 00:00:00\n */\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\";\n\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 * ### v2.0.0 breaking changes:\n *\n * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).\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 * var 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 * var 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, dirtyOptions) {\n  requiredArgs(1, arguments);\n  var options = dirtyOptions || {};\n  var locale = options.locale;\n  var localeWeekStartsOn = locale && locale.options && locale.options.weekStartsOn;\n  var defaultWeekStartsOn = localeWeekStartsOn == null ? 0 : toInteger(localeWeekStartsOn);\n  var weekStartsOn = options.weekStartsOn == null ? defaultWeekStartsOn : toInteger(options.weekStartsOn); // Test if weekStartsOn is between 0 and 6 _and_ is not NaN\n\n  if (!(weekStartsOn >= 0 && weekStartsOn <= 6)) {\n    throw new RangeError('weekStartsOn must be between 0 and 6');\n  }\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 * ### v2.0.0 breaking changes:\n *\n * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).\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 */\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); // Set the last day of the new month\n  // if the original date was the last day of the longer month\n\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 * ### v2.0.0 breaking changes:\n *\n * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).\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 */\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 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/**\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 * var 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 * var 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\n  if (typeof values !== 'object' || values === null) {\n    throw new RangeError('values parameter must be an object');\n  }\n\n  var date = toDate(dirtyDate); // Check if date is Invalid Date because Date.prototype.setFullYear ignores the value of Invalid Date\n\n  if (isNaN(date.getTime())) {\n    return new Date(NaN);\n  }\n\n  if (values.year != null) {\n    date.setFullYear(values.year);\n  }\n\n  if (values.month != null) {\n    date = setMonth(date, values.month);\n  }\n\n  if (values.date != null) {\n    date.setDate(toInteger(values.date));\n  }\n\n  if (values.hours != null) {\n    date.setHours(toInteger(values.hours));\n  }\n\n  if (values.minutes != null) {\n    date.setMinutes(toInteger(values.minutes));\n  }\n\n  if (values.seconds != null) {\n    date.setSeconds(toInteger(values.seconds));\n  }\n\n  if (values.milliseconds != null) {\n    date.setMilliseconds(toInteger(values.milliseconds));\n  }\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 * ### v2.0.0 breaking changes:\n *\n * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).\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 */\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\";\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 * ### v2.0.0 breaking changes:\n *\n * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).\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 */\n\nexport default function startOfWeek(dirtyDate, dirtyOptions) {\n  requiredArgs(1, arguments);\n  var options = dirtyOptions || {};\n  var locale = options.locale;\n  var localeWeekStartsOn = locale && locale.options && locale.options.weekStartsOn;\n  var defaultWeekStartsOn = localeWeekStartsOn == null ? 0 : toInteger(localeWeekStartsOn);\n  var weekStartsOn = options.weekStartsOn == null ? defaultWeekStartsOn : toInteger(options.weekStartsOn); // Test if weekStartsOn is between 0 and 6 _and_ is not NaN\n\n  if (!(weekStartsOn >= 0 && weekStartsOn <= 6)) {\n    throw new RangeError('weekStartsOn must be between 0 and 6 inclusively');\n  }\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 * ### v2.0.0 breaking changes:\n *\n * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).\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 */\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 * ### v2.0.0 breaking changes:\n *\n * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).\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 */\n\nexport default function subYears(dirtyDate, dirtyAmount) {\n  requiredArgs(2, arguments);\n  var amount = toInteger(dirtyAmount);\n  return addYears(dirtyDate, -amount);\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 * ### v2.0.0 breaking changes:\n *\n * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).\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 */\n\nexport default function addYears(dirtyDate, dirtyAmount) {\n  requiredArgs(2, arguments);\n  var amount = toInteger(dirtyAmount);\n  return addMonths(dirtyDate, amount * 12);\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 IS_DENO = require('../internals/engine-is-deno');\nvar IS_NODE = require('../internals/engine-is-node');\n\nmodule.exports = !IS_DENO && !IS_NODE\n  && typeof window == 'object'\n  && typeof document == 'object';\n","'use strict';\n/* global Deno -- Deno case */\nmodule.exports = typeof Deno == 'object' && Deno && typeof Deno.version == 'object';\n","'use strict';\nvar bind = require('../internals/function-bind-context');\nvar call = require('../internals/function-call');\nvar anObject = require('../internals/an-object');\nvar tryToString = require('../internals/try-to-string');\nvar isArrayIteratorMethod = require('../internals/is-array-iterator-method');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\nvar getIterator = require('../internals/get-iterator');\nvar getIteratorMethod = require('../internals/get-iterator-method');\nvar iteratorClose = require('../internals/iterator-close');\n\nvar $TypeError = TypeError;\n\nvar Result = function (stopped, result) {\n  this.stopped = stopped;\n  this.result = result;\n};\n\nvar ResultPrototype = Result.prototype;\n\nmodule.exports = function (iterable, unboundFunction, options) {\n  var that = options && options.that;\n  var AS_ENTRIES = !!(options && options.AS_ENTRIES);\n  var IS_RECORD = !!(options && options.IS_RECORD);\n  var IS_ITERATOR = !!(options && options.IS_ITERATOR);\n  var INTERRUPTED = !!(options && options.INTERRUPTED);\n  var fn = bind(unboundFunction, that);\n  var iterator, iterFn, index, length, result, next, step;\n\n  var stop = function (condition) {\n    if (iterator) iteratorClose(iterator, 'normal', condition);\n    return new Result(true, condition);\n  };\n\n  var callFn = function (value) {\n    if (AS_ENTRIES) {\n      anObject(value);\n      return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);\n    } return INTERRUPTED ? fn(value, stop) : fn(value);\n  };\n\n  if (IS_RECORD) {\n    iterator = iterable.iterator;\n  } else if (IS_ITERATOR) {\n    iterator = iterable;\n  } else {\n    iterFn = getIteratorMethod(iterable);\n    if (!iterFn) throw new $TypeError(tryToString(iterable) + ' is not iterable');\n    // optimisation for array iterators\n    if (isArrayIteratorMethod(iterFn)) {\n      for (index = 0, length = lengthOfArrayLike(iterable); length > index; index++) {\n        result = callFn(iterable[index]);\n        if (result && isPrototypeOf(ResultPrototype, result)) return result;\n      } return new Result(false);\n    }\n    iterator = getIterator(iterable, iterFn);\n  }\n\n  next = IS_RECORD ? iterable.next : iterator.next;\n  while (!(step = call(next, iterator)).done) {\n    try {\n      result = callFn(step.value);\n    } catch (error) {\n      iteratorClose(iterator, 'throw', error);\n    }\n    if (typeof result == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result;\n  } return new Result(false);\n};\n","'use strict';\nmodule.exports = function (exec) {\n  try {\n    return { error: false, value: exec() };\n  } catch (error) {\n    return { error: true, value: error };\n  }\n};\n","'use strict';\nvar global = require('../internals/global');\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar isCallable = require('../internals/is-callable');\nvar isForced = require('../internals/is-forced');\nvar inspectSource = require('../internals/inspect-source');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar IS_BROWSER = require('../internals/engine-is-browser');\nvar IS_DENO = require('../internals/engine-is-deno');\nvar IS_PURE = require('../internals/is-pure');\nvar V8_VERSION = require('../internals/engine-v8-version');\n\nvar NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;\nvar SPECIES = wellKnownSymbol('species');\nvar SUBCLASSING = false;\nvar NATIVE_PROMISE_REJECTION_EVENT = isCallable(global.PromiseRejectionEvent);\n\nvar FORCED_PROMISE_CONSTRUCTOR = isForced('Promise', function () {\n  var PROMISE_CONSTRUCTOR_SOURCE = inspectSource(NativePromiseConstructor);\n  var GLOBAL_CORE_JS_PROMISE = PROMISE_CONSTRUCTOR_SOURCE !== String(NativePromiseConstructor);\n  // V8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables\n  // https://bugs.chromium.org/p/chromium/issues/detail?id=830565\n  // We can't detect it synchronously, so just check versions\n  if (!GLOBAL_CORE_JS_PROMISE && V8_VERSION === 66) return true;\n  // We need Promise#{ catch, finally } in the pure version for preventing prototype pollution\n  if (IS_PURE && !(NativePromisePrototype['catch'] && NativePromisePrototype['finally'])) return true;\n  // We can't use @@species feature detection in V8 since it causes\n  // deoptimization and performance degradation\n  // https://github.com/zloirock/core-js/issues/679\n  if (!V8_VERSION || V8_VERSION < 51 || !/native code/.test(PROMISE_CONSTRUCTOR_SOURCE)) {\n    // Detect correctness of subclassing with @@species support\n    var promise = new NativePromiseConstructor(function (resolve) { resolve(1); });\n    var FakePromise = function (exec) {\n      exec(function () { /* empty */ }, function () { /* empty */ });\n    };\n    var constructor = promise.constructor = {};\n    constructor[SPECIES] = FakePromise;\n    SUBCLASSING = promise.then(function () { /* empty */ }) instanceof FakePromise;\n    if (!SUBCLASSING) return true;\n  // Unhandled rejections tracking support, NodeJS Promise without it fails @@species test\n  } return !GLOBAL_CORE_JS_PROMISE && (IS_BROWSER || IS_DENO) && !NATIVE_PROMISE_REJECTION_EVENT;\n});\n\nmodule.exports = {\n  CONSTRUCTOR: FORCED_PROMISE_CONSTRUCTOR,\n  REJECTION_EVENT: NATIVE_PROMISE_REJECTION_EVENT,\n  SUBCLASSING: SUBCLASSING\n};\n","'use strict';\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration');\nvar FORCED_PROMISE_CONSTRUCTOR = require('../internals/promise-constructor-detection').CONSTRUCTOR;\n\nmodule.exports = FORCED_PROMISE_CONSTRUCTOR || !checkCorrectnessOfIteration(function (iterable) {\n  NativePromiseConstructor.all(iterable).then(undefined, function () { /* empty */ });\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","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar aCallable = require('../internals/a-callable');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar perform = require('../internals/perform');\nvar iterate = require('../internals/iterate');\nvar PROMISE_STATICS_INCORRECT_ITERATION = require('../internals/promise-statics-incorrect-iteration');\n\n// `Promise.allSettled` method\n// https://tc39.es/ecma262/#sec-promise.allsettled\n$({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, {\n  allSettled: function allSettled(iterable) {\n    var C = this;\n    var capability = newPromiseCapabilityModule.f(C);\n    var resolve = capability.resolve;\n    var reject = capability.reject;\n    var result = perform(function () {\n      var promiseResolve = aCallable(C.resolve);\n      var values = [];\n      var counter = 0;\n      var remaining = 1;\n      iterate(iterable, function (promise) {\n        var index = counter++;\n        var alreadyCalled = false;\n        remaining++;\n        call(promiseResolve, C, promise).then(function (value) {\n          if (alreadyCalled) return;\n          alreadyCalled = true;\n          values[index] = { status: 'fulfilled', value: value };\n          --remaining || resolve(values);\n        }, function (error) {\n          if (alreadyCalled) return;\n          alreadyCalled = true;\n          values[index] = { status: 'rejected', reason: error };\n          --remaining || resolve(values);\n        });\n      });\n      --remaining || resolve(values);\n    });\n    if (result.error) reject(result.value);\n    return capability.promise;\n  }\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\n\n// `URL.prototype.toJSON` method\n// https://url.spec.whatwg.org/#dom-url-tojson\n$({ target: 'URL', proto: true, enumerable: true }, {\n  toJSON: function toJSON() {\n    return call(URL.prototype.toString, this);\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","duration","years","months","weeks","days","minutes","seconds","dateWithMonths","dateWithDays","msToAdd","getTime","eachDayOfInterval","dirtyInterval","interval","startDate","start","endTime","RangeError","dates","currentDate","step","Number","isSameMonth","dirtyDateLeft","dirtyDateRight","dateLeft","dateRight","getFullYear","getMonth","isSameWeek","dirtyOptions","dateLeftStartOfWeek","dateRightStartOfWeek","day","isWithinInterval","time","startTime","lastDayOfMonth","month","setFullYear","lastDayOfWeek","locale","localeWeekStartsOn","weekStartsOn","defaultWeekStartsOn","diff","setMonth","dirtyMonth","year","dateWithDesiredMonth","daysInMonth","monthIndex","getDaysInMonth","min","set","setMinutes","setSeconds","milliseconds","setMilliseconds","startOfMonth","startOfWeek","startOfYear","cleanDate","subYears","addMonths","addYears","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","IS_DENO","IS_NODE","Deno","anObject","isArrayIteratorMethod","lengthOfArrayLike","isPrototypeOf","getIterator","getIteratorMethod","iteratorClose","ResultPrototype","unboundFunction","iterFn","next","that","AS_ENTRIES","IS_RECORD","IS_ITERATOR","INTERRUPTED","condition","callFn","done","global","NativePromiseConstructor","isCallable","isForced","inspectSource","wellKnownSymbol","IS_BROWSER","IS_PURE","V8_VERSION","NativePromisePrototype","SPECIES","SUBCLASSING","NATIVE_PROMISE_REJECTION_EVENT","PromiseRejectionEvent","FORCED_PROMISE_CONSTRUCTOR","PROMISE_CONSTRUCTOR_SOURCE","GLOBAL_CORE_JS_PROMISE","promise","resolve","FakePromise","then","CONSTRUCTOR","REJECTION_EVENT","checkCorrectnessOfIteration","$","$findLastIndex","addToUnscopables","findLastIndex","callbackfn","toObject","setArrayLength","deletePropertyOrThrow","doesNotExceedSafeInteger","arity","forced","writable","properErrorOnNonWritableLength","argCount","to","aCallable","newPromiseCapabilityModule","perform","iterate","stat","allSettled","C","capability","f","reject","promiseResolve","counter","alreadyCalled","status","reason","URL","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","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","curr_good","prev_good","t_m","prev_e"],"sourceRoot":""}