Server : Apache/2.4.41 (Ubuntu) System : Linux absol.cf 5.4.0-198-generic #218-Ubuntu SMP Fri Sep 27 20:18:53 UTC 2024 x86_64 User : www-data ( 33) PHP Version : 7.4.33 Disable Function : pcntl_alarm,pcntl_fork,pcntl_waitpid,pcntl_wait,pcntl_wifexited,pcntl_wifstopped,pcntl_wifsignaled,pcntl_wifcontinued,pcntl_wexitstatus,pcntl_wtermsig,pcntl_wstopsig,pcntl_signal,pcntl_signal_get_handler,pcntl_signal_dispatch,pcntl_get_last_error,pcntl_strerror,pcntl_sigprocmask,pcntl_sigwaitinfo,pcntl_sigtimedwait,pcntl_exec,pcntl_getpriority,pcntl_setpriority,pcntl_async_signals,pcntl_unshare, Directory :  /opt/mattermost/client/

Upload File : current_dir [ Writeable ] document_root [ Writeable ]

{"version":3,"file":"9867.6a0bf83a4fef7d2ee11d.js","mappings":"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","sources":["webpack://mattermost-webapp/../node_modules/eventemitter3/index.js","webpack://mattermost-webapp/../node_modules/inobounce/inobounce.js","webpack://mattermost-webapp/../node_modules/rebound/dist/rebound.js","webpack://mattermost-webapp/../node_modules/p-queue/node_modules/p-timeout/index.js","webpack://mattermost-webapp/../node_modules/p-queue/dist/priority-queue.js","webpack://mattermost-webapp/../node_modules/p-queue/dist/lower-bound.js","webpack://mattermost-webapp/../node_modules/p-queue/dist/index.js"],"sourcesContent":["'use strict';\n\nvar has = Object.prototype.hasOwnProperty\n  , prefix = '~';\n\n/**\n * Constructor to create a storage for our `EE` objects.\n * An `Events` instance is a plain object whose properties are event names.\n *\n * @constructor\n * @private\n */\nfunction Events() {}\n\n//\n// We try to not inherit from `Object.prototype`. In some engines creating an\n// instance in this way is faster than calling `Object.create(null)` directly.\n// If `Object.create(null)` is not supported we prefix the event names with a\n// character to make sure that the built-in object properties are not\n// overridden or used as an attack vector.\n//\nif (Object.create) {\n  Events.prototype = Object.create(null);\n\n  //\n  // This hack is needed because the `__proto__` property is still inherited in\n  // some old browsers like Android 4, iPhone 5.1, Opera 11 and Safari 5.\n  //\n  if (!new Events().__proto__) prefix = false;\n}\n\n/**\n * Representation of a single event listener.\n *\n * @param {Function} fn The listener function.\n * @param {*} context The context to invoke the listener with.\n * @param {Boolean} [once=false] Specify if the listener is a one-time listener.\n * @constructor\n * @private\n */\nfunction EE(fn, context, once) {\n  this.fn = fn;\n  this.context = context;\n  this.once = once || false;\n}\n\n/**\n * Add a listener for a given event.\n *\n * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.\n * @param {(String|Symbol)} event The event name.\n * @param {Function} fn The listener function.\n * @param {*} context The context to invoke the listener with.\n * @param {Boolean} once Specify if the listener is a one-time listener.\n * @returns {EventEmitter}\n * @private\n */\nfunction addListener(emitter, event, fn, context, once) {\n  if (typeof fn !== 'function') {\n    throw new TypeError('The listener must be a function');\n  }\n\n  var listener = new EE(fn, context || emitter, once)\n    , evt = prefix ? prefix + event : event;\n\n  if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;\n  else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);\n  else emitter._events[evt] = [emitter._events[evt], listener];\n\n  return emitter;\n}\n\n/**\n * Clear event by name.\n *\n * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.\n * @param {(String|Symbol)} evt The Event name.\n * @private\n */\nfunction clearEvent(emitter, evt) {\n  if (--emitter._eventsCount === 0) emitter._events = new Events();\n  else delete emitter._events[evt];\n}\n\n/**\n * Minimal `EventEmitter` interface that is molded against the Node.js\n * `EventEmitter` interface.\n *\n * @constructor\n * @public\n */\nfunction EventEmitter() {\n  this._events = new Events();\n  this._eventsCount = 0;\n}\n\n/**\n * Return an array listing the events for which the emitter has registered\n * listeners.\n *\n * @returns {Array}\n * @public\n */\nEventEmitter.prototype.eventNames = function eventNames() {\n  var names = []\n    , events\n    , name;\n\n  if (this._eventsCount === 0) return names;\n\n  for (name in (events = this._events)) {\n    if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);\n  }\n\n  if (Object.getOwnPropertySymbols) {\n    return names.concat(Object.getOwnPropertySymbols(events));\n  }\n\n  return names;\n};\n\n/**\n * Return the listeners registered for a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @returns {Array} The registered listeners.\n * @public\n */\nEventEmitter.prototype.listeners = function listeners(event) {\n  var evt = prefix ? prefix + event : event\n    , handlers = this._events[evt];\n\n  if (!handlers) return [];\n  if (handlers.fn) return [handlers.fn];\n\n  for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {\n    ee[i] = handlers[i].fn;\n  }\n\n  return ee;\n};\n\n/**\n * Return the number of listeners listening to a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @returns {Number} The number of listeners.\n * @public\n */\nEventEmitter.prototype.listenerCount = function listenerCount(event) {\n  var evt = prefix ? prefix + event : event\n    , listeners = this._events[evt];\n\n  if (!listeners) return 0;\n  if (listeners.fn) return 1;\n  return listeners.length;\n};\n\n/**\n * Calls each of the listeners registered for a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @returns {Boolean} `true` if the event had listeners, else `false`.\n * @public\n */\nEventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {\n  var evt = prefix ? prefix + event : event;\n\n  if (!this._events[evt]) return false;\n\n  var listeners = this._events[evt]\n    , len = arguments.length\n    , args\n    , i;\n\n  if (listeners.fn) {\n    if (listeners.once) this.removeListener(event, listeners.fn, undefined, true);\n\n    switch (len) {\n      case 1: return listeners.fn.call(listeners.context), true;\n      case 2: return listeners.fn.call(listeners.context, a1), true;\n      case 3: return listeners.fn.call(listeners.context, a1, a2), true;\n      case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true;\n      case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;\n      case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;\n    }\n\n    for (i = 1, args = new Array(len -1); i < len; i++) {\n      args[i - 1] = arguments[i];\n    }\n\n    listeners.fn.apply(listeners.context, args);\n  } else {\n    var length = listeners.length\n      , j;\n\n    for (i = 0; i < length; i++) {\n      if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true);\n\n      switch (len) {\n        case 1: listeners[i].fn.call(listeners[i].context); break;\n        case 2: listeners[i].fn.call(listeners[i].context, a1); break;\n        case 3: listeners[i].fn.call(listeners[i].context, a1, a2); break;\n        case 4: listeners[i].fn.call(listeners[i].context, a1, a2, a3); break;\n        default:\n          if (!args) for (j = 1, args = new Array(len -1); j < len; j++) {\n            args[j - 1] = arguments[j];\n          }\n\n          listeners[i].fn.apply(listeners[i].context, args);\n      }\n    }\n  }\n\n  return true;\n};\n\n/**\n * Add a listener for a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @param {Function} fn The listener function.\n * @param {*} [context=this] The context to invoke the listener with.\n * @returns {EventEmitter} `this`.\n * @public\n */\nEventEmitter.prototype.on = function on(event, fn, context) {\n  return addListener(this, event, fn, context, false);\n};\n\n/**\n * Add a one-time listener for a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @param {Function} fn The listener function.\n * @param {*} [context=this] The context to invoke the listener with.\n * @returns {EventEmitter} `this`.\n * @public\n */\nEventEmitter.prototype.once = function once(event, fn, context) {\n  return addListener(this, event, fn, context, true);\n};\n\n/**\n * Remove the listeners of a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @param {Function} fn Only remove the listeners that match this function.\n * @param {*} context Only remove the listeners that have this context.\n * @param {Boolean} once Only remove one-time listeners.\n * @returns {EventEmitter} `this`.\n * @public\n */\nEventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {\n  var evt = prefix ? prefix + event : event;\n\n  if (!this._events[evt]) return this;\n  if (!fn) {\n    clearEvent(this, evt);\n    return this;\n  }\n\n  var listeners = this._events[evt];\n\n  if (listeners.fn) {\n    if (\n      listeners.fn === fn &&\n      (!once || listeners.once) &&\n      (!context || listeners.context === context)\n    ) {\n      clearEvent(this, evt);\n    }\n  } else {\n    for (var i = 0, events = [], length = listeners.length; i < length; i++) {\n      if (\n        listeners[i].fn !== fn ||\n        (once && !listeners[i].once) ||\n        (context && listeners[i].context !== context)\n      ) {\n        events.push(listeners[i]);\n      }\n    }\n\n    //\n    // Reset the array, or remove it completely if we have no more listeners.\n    //\n    if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;\n    else clearEvent(this, evt);\n  }\n\n  return this;\n};\n\n/**\n * Remove all listeners, or those of the specified event.\n *\n * @param {(String|Symbol)} [event] The event name.\n * @returns {EventEmitter} `this`.\n * @public\n */\nEventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {\n  var evt;\n\n  if (event) {\n    evt = prefix ? prefix + event : event;\n    if (this._events[evt]) clearEvent(this, evt);\n  } else {\n    this._events = new Events();\n    this._eventsCount = 0;\n  }\n\n  return this;\n};\n\n//\n// Alias methods names because people roll like that.\n//\nEventEmitter.prototype.off = EventEmitter.prototype.removeListener;\nEventEmitter.prototype.addListener = EventEmitter.prototype.on;\n\n//\n// Expose the prefix.\n//\nEventEmitter.prefixed = prefix;\n\n//\n// Allow `EventEmitter` to be imported as module namespace.\n//\nEventEmitter.EventEmitter = EventEmitter;\n\n//\n// Expose the module.\n//\nif ('undefined' !== typeof module) {\n  module.exports = EventEmitter;\n}\n","/*! iNoBounce - v0.2.0\n* https://github.com/lazd/iNoBounce/\n* Copyright (c) 2013 Larry Davis <lazdnet@gmail.com>; Licensed BSD */\n(function(global) {\n\t// Stores the Y position where the touch started\n\tvar startY = 0;\n\n\t// Store enabled status\n\tvar enabled = false;\n\n\tvar supportsPassiveOption = false;\n\ttry {\n\t\tvar opts = Object.defineProperty({}, 'passive', {\n\t\t\tget: function() {\n\t\t\t\tsupportsPassiveOption = true;\n\t\t\t}\n\t\t});\n\t\twindow.addEventListener('test', null, opts);\n\t} catch (e) {}\n\n\tvar handleTouchmove = function(evt) {\n\t\t// Get the element that was scrolled upon\n\t\tvar el = evt.target;\n\n\t\t// Allow zooming\n\t\tvar zoom = window.innerWidth / window.document.documentElement.clientWidth;\n\t\tif (evt.touches.length > 1 || zoom !== 1) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Check all parent elements for scrollability\n\t\twhile (el !== document.body && el !== document) {\n\t\t\t// Get some style properties\n\t\t\tvar style = window.getComputedStyle(el);\n\n\t\t\tif (!style) {\n\t\t\t\t// If we've encountered an element we can't compute the style for, get out\n\t\t\t\tbreak;\n\t\t\t}\n\n\t\t\t// Ignore range input element\n\t\t\tif (el.nodeName === 'INPUT' && el.getAttribute('type') === 'range') {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tvar scrolling = style.getPropertyValue('-webkit-overflow-scrolling');\n\t\t\tvar overflowY = style.getPropertyValue('overflow-y');\n\t\t\tvar height = parseInt(style.getPropertyValue('height'), 10);\n\n\t\t\t// Determine if the element should scroll\n\t\t\tvar isScrollable = scrolling === 'touch' && (overflowY === 'auto' || overflowY === 'scroll');\n\t\t\tvar canScroll = el.scrollHeight > el.offsetHeight;\n\n\t\t\tif (isScrollable && canScroll) {\n\t\t\t\t// Get the current Y position of the touch\n\t\t\t\tvar curY = evt.touches ? evt.touches[0].screenY : evt.screenY;\n\n\t\t\t\t// Determine if the user is trying to scroll past the top or bottom\n\t\t\t\t// In this case, the window will bounce, so we have to prevent scrolling completely\n\t\t\t\tvar isAtTop = (startY <= curY && el.scrollTop === 0);\n\t\t\t\tvar isAtBottom = (startY >= curY && el.scrollHeight - el.scrollTop === height);\n\n\t\t\t\t// Stop a bounce bug when at the bottom or top of the scrollable element\n\t\t\t\tif (isAtTop || isAtBottom) {\n\t\t\t\t\tevt.preventDefault();\n\t\t\t\t}\n\n\t\t\t\t// No need to continue up the DOM, we've done our job\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// Test the next parent\n\t\t\tel = el.parentNode;\n\t\t}\n\n\t\t// Stop the bouncing -- no parents are scrollable\n\t\tevt.preventDefault();\n\t};\n\n\tvar handleTouchstart = function(evt) {\n\t\t// Store the first Y position of the touch\n\t\tstartY = evt.touches ? evt.touches[0].screenY : evt.screenY;\n\t};\n\n\tvar enable = function() {\n\t\t// Listen to a couple key touch events\n\t\twindow.addEventListener('touchstart', handleTouchstart, supportsPassiveOption ? { passive : false } : false);\n\t\twindow.addEventListener('touchmove', handleTouchmove, supportsPassiveOption ? { passive : false } : false);\n\t\tenabled = true;\n\t};\n\n\tvar disable = function() {\n\t\t// Stop listening\n\t\twindow.removeEventListener('touchstart', handleTouchstart, false);\n\t\twindow.removeEventListener('touchmove', handleTouchmove, false);\n\t\tenabled = false;\n\t};\n\n\tvar isEnabled = function() {\n\t\treturn enabled;\n\t};\n\n\t// Enable by default if the browser supports -webkit-overflow-scrolling\n\t// Test this by setting the property with JavaScript on an element that exists in the DOM\n\t// Then, see if the property is reflected in the computed style\n\tvar testDiv = document.createElement('div');\n\tdocument.documentElement.appendChild(testDiv);\n\ttestDiv.style.WebkitOverflowScrolling = 'touch';\n\tvar isScrollSupported = 'getComputedStyle' in window && window.getComputedStyle(testDiv)['-webkit-overflow-scrolling'] === 'touch';\n\tdocument.documentElement.removeChild(testDiv);\n\n\tif (isScrollSupported) {\n\t\tenable();\n\t}\n\n\t// A module to support enabling/disabling iNoBounce\n\tvar iNoBounce = {\n\t\tenable: enable,\n\t\tdisable: disable,\n\t\tisEnabled: isEnabled,\n\t\tisScrollSupported: isScrollSupported\n\t};\n\n\tif (typeof module !== 'undefined' && module.exports) {\n\t\t// Node.js Support\n\t\tmodule.exports = iNoBounce;\n\t}\n\tif (typeof global.define === 'function') {\n\t\t// AMD Support\n\t\t(function(define) {\n\t\t\tdefine('iNoBounce', [], function() { return iNoBounce; });\n\t\t}(global.define));\n\t}\n\telse {\n\t\t// Browser support\n\t\tglobal.iNoBounce = iNoBounce;\n\t}\n}(this));\n","/**\n *  Copyright (c) 2013, Facebook, Inc.\n *  All rights reserved.\n *\n *  This source code is licensed under the BSD-style license found in the\n *  LICENSE file in the root directory of this source tree. An additional grant\n *  of patent rights can be found in the PATENTS file in the same directory.\n */\n(function (global, factory) {\n\ttypeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :\n\ttypeof define === 'function' && define.amd ? define(factory) :\n\t(global.rebound = factory());\n}(this, (function () { 'use strict';\n\nvar _onFrame = void 0;\nif (typeof window !== 'undefined') {\n  _onFrame = window.requestAnimationFrame || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame || window.msRequestAnimationFrame || window.oRequestAnimationFrame;\n}\n\nif (!_onFrame && typeof process !== 'undefined' && process.title === 'node') {\n  _onFrame = setImmediate;\n}\n\n_onFrame = _onFrame || function (callback) {\n  window.setTimeout(callback, 1000 / 60);\n};\n\nvar _onFrame$1 = _onFrame;\n\n/* eslint-disable flowtype/no-weak-types */\n\nvar concat = Array.prototype.concat;\nvar slice = Array.prototype.slice;\n\n// Bind a function to a context object.\nfunction bind(func, context) {\n  for (var _len = arguments.length, outerArgs = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {\n    outerArgs[_key - 2] = arguments[_key];\n  }\n\n  return function () {\n    for (var _len2 = arguments.length, innerArgs = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n      innerArgs[_key2] = arguments[_key2];\n    }\n\n    func.apply(context, concat.call(outerArgs, slice.call(innerArgs)));\n  };\n}\n\n// Add all the properties in the source to the target.\nfunction extend(target, source) {\n  for (var key in source) {\n    if (source.hasOwnProperty(key)) {\n      target[key] = source[key];\n    }\n  }\n}\n\n// Cross browser/node timer functions.\nfunction onFrame(func) {\n  return _onFrame$1(func);\n}\n\n// Lop off the first occurence of the reference in the Array.\nfunction removeFirst(array, item) {\n  var idx = array.indexOf(item);\n  idx !== -1 && array.splice(idx, 1);\n}\n\nvar colorCache = {};\n/**\n * Converts a hex-formatted color string to its rgb-formatted equivalent. Handy\n * when performing color tweening animations\n * @public\n * @param colorString A hex-formatted color string\n * @return An rgb-formatted color string\n */\nfunction hexToRGB(colorString) {\n  if (colorCache[colorString]) {\n    return colorCache[colorString];\n  }\n  var normalizedColor = colorString.replace('#', '');\n  if (normalizedColor.length === 3) {\n    normalizedColor = normalizedColor[0] + normalizedColor[0] + normalizedColor[1] + normalizedColor[1] + normalizedColor[2] + normalizedColor[2];\n  }\n  var parts = normalizedColor.match(/.{2}/g);\n  if (!parts || parts.length < 3) {\n    throw new Error('Expected a color string of format #rrggbb');\n  }\n\n  var ret = {\n    r: parseInt(parts[0], 16),\n    g: parseInt(parts[1], 16),\n    b: parseInt(parts[2], 16)\n  };\n\n  colorCache[colorString] = ret;\n  return ret;\n}\n\n/**\n * Converts a rgb-formatted color string to its hex-formatted equivalent. Handy\n * when performing color tweening animations\n * @public\n * @param colorString An rgb-formatted color string\n * @return A hex-formatted color string\n */\nfunction rgbToHex(rNum, gNum, bNum) {\n  var r = rNum.toString(16);\n  var g = gNum.toString(16);\n  var b = bNum.toString(16);\n  r = r.length < 2 ? '0' + r : r;\n  g = g.length < 2 ? '0' + g : g;\n  b = b.length < 2 ? '0' + b : b;\n  return '#' + r + g + b;\n}\n\nvar util = Object.freeze({\n\tbind: bind,\n\textend: extend,\n\tonFrame: onFrame,\n\tremoveFirst: removeFirst,\n\thexToRGB: hexToRGB,\n\trgbToHex: rgbToHex\n});\n\n/**\n * This helper function does a linear interpolation of a value from\n * one range to another. This can be very useful for converting the\n * motion of a Spring to a range of UI property values. For example a\n * spring moving from position 0 to 1 could be interpolated to move a\n * view from pixel 300 to 350 and scale it from 0.5 to 1. The current\n * position of the `Spring` just needs to be run through this method\n * taking its input range in the _from_ parameters with the property\n * animation range in the _to_ parameters.\n * @public\n */\nfunction mapValueInRange(value, fromLow, fromHigh, toLow, toHigh) {\n  var fromRangeSize = fromHigh - fromLow;\n  var toRangeSize = toHigh - toLow;\n  var valueScale = (value - fromLow) / fromRangeSize;\n  return toLow + valueScale * toRangeSize;\n}\n\n/**\n * Interpolate two hex colors in a 0 - 1 range or optionally provide a\n * custom range with fromLow,fromHight. The output will be in hex by default\n * unless asRGB is true in which case it will be returned as an rgb string.\n *\n * @public\n * @param asRGB Whether to return an rgb-style string\n * @return A string in hex color format unless asRGB is true, in which case a string in rgb format\n */\nfunction interpolateColor(val, startColorStr, endColorStr) {\n  var fromLow = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;\n  var fromHigh = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1;\n  var asRGB = arguments[5];\n\n  var startColor = hexToRGB(startColorStr);\n  var endColor = hexToRGB(endColorStr);\n  var r = Math.floor(mapValueInRange(val, fromLow, fromHigh, startColor.r, endColor.r));\n  var g = Math.floor(mapValueInRange(val, fromLow, fromHigh, startColor.g, endColor.g));\n  var b = Math.floor(mapValueInRange(val, fromLow, fromHigh, startColor.b, endColor.b));\n  if (asRGB) {\n    return 'rgb(' + r + ',' + g + ',' + b + ')';\n  } else {\n    return rgbToHex(r, g, b);\n  }\n}\n\nfunction degreesToRadians(deg) {\n  return deg * Math.PI / 180;\n}\n\nfunction radiansToDegrees(rad) {\n  return rad * 180 / Math.PI;\n}\n\nvar MathUtil = Object.freeze({\n\tmapValueInRange: mapValueInRange,\n\tinterpolateColor: interpolateColor,\n\tdegreesToRadians: degreesToRadians,\n\tradiansToDegrees: radiansToDegrees\n});\n\n// Math for converting from\n// [Origami](http://facebook.github.io/origami/) to\n// [Rebound](http://facebook.github.io/rebound).\n// You mostly don't need to worry about this, just use\n// SpringConfig.fromOrigamiTensionAndFriction(v, v);\n\nfunction tensionFromOrigamiValue(oValue) {\n  return (oValue - 30.0) * 3.62 + 194.0;\n}\n\nfunction origamiValueFromTension(tension) {\n  return (tension - 194.0) / 3.62 + 30.0;\n}\n\nfunction frictionFromOrigamiValue(oValue) {\n  return (oValue - 8.0) * 3.0 + 25.0;\n}\n\nfunction origamiFromFriction(friction) {\n  return (friction - 25.0) / 3.0 + 8.0;\n}\n\nvar OrigamiValueConverter = Object.freeze({\n\ttensionFromOrigamiValue: tensionFromOrigamiValue,\n\torigamiValueFromTension: origamiValueFromTension,\n\tfrictionFromOrigamiValue: frictionFromOrigamiValue,\n\torigamiFromFriction: origamiFromFriction\n});\n\nvar classCallCheck = function (instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n};\n\n\n\n\n\n\n\n\n\nvar _extends = Object.assign || function (target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i];\n\n    for (var key in source) {\n      if (Object.prototype.hasOwnProperty.call(source, key)) {\n        target[key] = source[key];\n      }\n    }\n  }\n\n  return target;\n};\n\n/**\n * Plays each frame of the SpringSystem on animation\n * timing loop. This is the default type of looper for a new spring system\n * as it is the most common when developing UI.\n * @public\n */\n/**\n *  Copyright (c) 2013, Facebook, Inc.\n *  All rights reserved.\n *\n *  This source code is licensed under the BSD-style license found in the\n *  LICENSE file in the root directory of this source tree. An additional grant\n *  of patent rights can be found in the PATENTS file in the same directory.\n *\n * \n */\n\nvar AnimationLooper = function () {\n  function AnimationLooper() {\n    classCallCheck(this, AnimationLooper);\n    this.springSystem = null;\n  }\n\n  AnimationLooper.prototype.run = function run() {\n    var springSystem = getSpringSystem.call(this);\n\n    onFrame(function () {\n      springSystem.loop(Date.now());\n    });\n  };\n\n  return AnimationLooper;\n}();\n\n/**\n * Resolves the SpringSystem to a resting state in a\n * tight and blocking loop. This is useful for synchronously generating\n * pre-recorded animations that can then be played on a timing loop later.\n * Sometimes this lead to better performance to pre-record a single spring\n * curve and use it to drive many animations; however, it can make dynamic\n * response to user input a bit trickier to implement.\n * @public\n */\nvar SimulationLooper = function () {\n  function SimulationLooper(timestep) {\n    classCallCheck(this, SimulationLooper);\n    this.springSystem = null;\n    this.time = 0;\n    this.running = false;\n\n    this.timestep = timestep || 16.667;\n  }\n\n  SimulationLooper.prototype.run = function run() {\n    var springSystem = getSpringSystem.call(this);\n\n    if (this.running) {\n      return;\n    }\n    this.running = true;\n    while (!springSystem.getIsIdle()) {\n      springSystem.loop(this.time += this.timestep);\n    }\n    this.running = false;\n  };\n\n  return SimulationLooper;\n}();\n\n/**\n * Resolves the SpringSystem one step at a\n * time controlled by an outside loop. This is useful for testing and\n * verifying the behavior of a SpringSystem or if you want to control your own\n * timing loop for some reason e.g. slowing down or speeding up the\n * simulation.\n * @public\n */\nvar SteppingSimulationLooper = function () {\n  function SteppingSimulationLooper() {\n    classCallCheck(this, SteppingSimulationLooper);\n    this.springSystem = null;\n    this.time = 0;\n    this.running = false;\n  }\n\n  SteppingSimulationLooper.prototype.run = function run() {}\n  // this.run is NOOP'd here to allow control from the outside using\n  // this.step.\n\n\n  // Perform one step toward resolving the SpringSystem.\n  ;\n\n  SteppingSimulationLooper.prototype.step = function step(timestep) {\n    var springSystem = getSpringSystem.call(this);\n    springSystem.loop(this.time += timestep);\n  };\n\n  return SteppingSimulationLooper;\n}();\n\nfunction getSpringSystem() {\n  if (this.springSystem == null) {\n    throw new Error('cannot run looper without a springSystem');\n  }\n  return this.springSystem;\n}\n\n\n\nvar Loopers = Object.freeze({\n\tAnimationLooper: AnimationLooper,\n\tSimulationLooper: SimulationLooper,\n\tSteppingSimulationLooper: SteppingSimulationLooper\n});\n\n/**\n * Provides math for converting from Origami PopAnimation\n * config values to regular Origami tension and friction values. If you are\n * trying to replicate prototypes made with PopAnimation patches in Origami,\n * then you should create your springs with\n * SpringSystem.createSpringWithBouncinessAndSpeed, which uses this Math\n * internally to create a spring to match the provided PopAnimation\n * configuration from Origami.\n */\nvar BouncyConversion = function () {\n  function BouncyConversion(bounciness, speed) {\n    classCallCheck(this, BouncyConversion);\n\n    this.bounciness = bounciness;\n    this.speed = speed;\n\n    var b = this.normalize(bounciness / 1.7, 0, 20.0);\n    b = this.projectNormal(b, 0.0, 0.8);\n    var s = this.normalize(speed / 1.7, 0, 20.0);\n\n    this.bouncyTension = this.projectNormal(s, 0.5, 200);\n    this.bouncyFriction = this.quadraticOutInterpolation(b, this.b3Nobounce(this.bouncyTension), 0.01);\n  }\n\n  BouncyConversion.prototype.normalize = function normalize(value, startValue, endValue) {\n    return (value - startValue) / (endValue - startValue);\n  };\n\n  BouncyConversion.prototype.projectNormal = function projectNormal(n, start, end) {\n    return start + n * (end - start);\n  };\n\n  BouncyConversion.prototype.linearInterpolation = function linearInterpolation(t, start, end) {\n    return t * end + (1.0 - t) * start;\n  };\n\n  BouncyConversion.prototype.quadraticOutInterpolation = function quadraticOutInterpolation(t, start, end) {\n    return this.linearInterpolation(2 * t - t * t, start, end);\n  };\n\n  BouncyConversion.prototype.b3Friction1 = function b3Friction1(x) {\n    return 0.0007 * Math.pow(x, 3) - 0.031 * Math.pow(x, 2) + 0.64 * x + 1.28;\n  };\n\n  BouncyConversion.prototype.b3Friction2 = function b3Friction2(x) {\n    return 0.000044 * Math.pow(x, 3) - 0.006 * Math.pow(x, 2) + 0.36 * x + 2;\n  };\n\n  BouncyConversion.prototype.b3Friction3 = function b3Friction3(x) {\n    return 0.00000045 * Math.pow(x, 3) - 0.000332 * Math.pow(x, 2) + 0.1078 * x + 5.84;\n  };\n\n  BouncyConversion.prototype.b3Nobounce = function b3Nobounce(tension) {\n    var friction = 0;\n    if (tension <= 18) {\n      friction = this.b3Friction1(tension);\n    } else if (tension > 18 && tension <= 44) {\n      friction = this.b3Friction2(tension);\n    } else {\n      friction = this.b3Friction3(tension);\n    }\n    return friction;\n  };\n\n  return BouncyConversion;\n}();\n\n/**\n * Maintains a set of tension and friction constants\n * for a Spring. You can use fromOrigamiTensionAndFriction to convert\n * values from the [Origami](http://facebook.github.io/origami/)\n * design tool directly to Rebound spring constants.\n * @public\n */\n\nvar SpringConfig = function () {\n\n  /**\n   * Convert an origami Spring tension and friction to Rebound spring\n   * constants. If you are prototyping a design with Origami, this\n   * makes it easy to make your springs behave exactly the same in\n   * Rebound.\n   * @public\n   */\n  SpringConfig.fromOrigamiTensionAndFriction = function fromOrigamiTensionAndFriction(tension, friction) {\n    return new SpringConfig(tensionFromOrigamiValue(tension), frictionFromOrigamiValue(friction));\n  };\n\n  /**\n   * Convert an origami PopAnimation Spring bounciness and speed to Rebound\n   * spring constants. If you are using PopAnimation patches in Origami, this\n   * utility will provide springs that match your prototype.\n   * @public\n   */\n\n\n  SpringConfig.fromBouncinessAndSpeed = function fromBouncinessAndSpeed(bounciness, speed) {\n    var bouncyConversion = new BouncyConversion(bounciness, speed);\n    return SpringConfig.fromOrigamiTensionAndFriction(bouncyConversion.bouncyTension, bouncyConversion.bouncyFriction);\n  };\n\n  /**\n   * Create a SpringConfig with no tension or a coasting spring with some\n   * amount of Friction so that it does not coast infininitely.\n   * @public\n   */\n\n\n  SpringConfig.coastingConfigWithOrigamiFriction = function coastingConfigWithOrigamiFriction(friction) {\n    return new SpringConfig(0, frictionFromOrigamiValue(friction));\n  };\n\n  function SpringConfig(tension, friction) {\n    classCallCheck(this, SpringConfig);\n\n    this.tension = tension;\n    this.friction = friction;\n  }\n\n  return SpringConfig;\n}();\n\nSpringConfig.DEFAULT_ORIGAMI_SPRING_CONFIG = SpringConfig.fromOrigamiTensionAndFriction(40, 7);\n\n/**\n * Consists of a position and velocity. A Spring uses\n * this internally to keep track of its current and prior position and\n * velocity values.\n */\nvar PhysicsState = function PhysicsState() {\n  classCallCheck(this, PhysicsState);\n  this.position = 0;\n  this.velocity = 0;\n};\n\n/**\n * Provides a model of a classical spring acting to\n * resolve a body to equilibrium. Springs have configurable\n * tension which is a force multipler on the displacement of the\n * spring from its rest point or `endValue` as defined by [Hooke's\n * law](http://en.wikipedia.org/wiki/Hooke's_law). Springs also have\n * configurable friction, which ensures that they do not oscillate\n * infinitely. When a Spring is displaced by updating it's resting\n * or `currentValue`, the SpringSystems that contain that Spring\n * will automatically start looping to solve for equilibrium. As each\n * timestep passes, `SpringListener` objects attached to the Spring\n * will be notified of the updates providing a way to drive an\n * animation off of the spring's resolution curve.\n * @public\n */\n\nvar Spring = function () {\n  function Spring(springSystem) {\n    classCallCheck(this, Spring);\n    this.listeners = [];\n    this._startValue = 0;\n    this._currentState = new PhysicsState();\n    this._displacementFromRestThreshold = 0.001;\n    this._endValue = 0;\n    this._overshootClampingEnabled = false;\n    this._previousState = new PhysicsState();\n    this._restSpeedThreshold = 0.001;\n    this._tempState = new PhysicsState();\n    this._timeAccumulator = 0;\n    this._wasAtRest = true;\n\n    this._id = 's' + Spring._ID++;\n    this._springSystem = springSystem;\n  }\n\n  /**\n   * Remove a Spring from simulation and clear its listeners.\n   * @public\n   */\n\n\n  Spring.prototype.destroy = function destroy() {\n    this.listeners = [];\n    this._springSystem.deregisterSpring(this);\n  };\n\n  /**\n   * Get the id of the spring, which can be used to retrieve it from\n   * the SpringSystems it participates in later.\n   * @public\n   */\n\n\n  Spring.prototype.getId = function getId() {\n    return this._id;\n  };\n\n  /**\n   * Set the configuration values for this Spring. A SpringConfig\n   * contains the tension and friction values used to solve for the\n   * equilibrium of the Spring in the physics loop.\n   * @public\n   */\n\n\n  Spring.prototype.setSpringConfig = function setSpringConfig(springConfig) {\n    this._springConfig = springConfig;\n    return this;\n  };\n\n  /**\n   * Retrieve the SpringConfig used by this Spring.\n   * @public\n   */\n\n\n  Spring.prototype.getSpringConfig = function getSpringConfig() {\n    return this._springConfig;\n  };\n\n  /**\n   * Set the current position of this Spring. Listeners will be updated\n   * with this value immediately. If the rest or `endValue` is not\n   * updated to match this value, then the spring will be dispalced and\n   * the SpringSystem will start to loop to restore the spring to the\n   * `endValue`.\n   *\n   * A common pattern is to move a Spring around without animation by\n   * calling.\n   *\n   * ```\n   * spring.setCurrentValue(n).setAtRest();\n   * ```\n   *\n   * This moves the Spring to a new position `n`, sets the endValue\n   * to `n`, and removes any velocity from the `Spring`. By doing\n   * this you can allow the `SpringListener` to manage the position\n   * of UI elements attached to the spring even when moving without\n   * animation. For example, when dragging an element you can\n   * update the position of an attached view through a spring\n   * by calling `spring.setCurrentValue(x)`. When\n   * the gesture ends you can update the Springs\n   * velocity and endValue\n   * `spring.setVelocity(gestureEndVelocity).setEndValue(flingTarget)`\n   * to cause it to naturally animate the UI element to the resting\n   * position taking into account existing velocity. The codepaths for\n   * synchronous movement and spring driven animation can\n   * be unified using this technique.\n   * @public\n   */\n\n\n  Spring.prototype.setCurrentValue = function setCurrentValue(currentValue, skipSetAtRest) {\n    this._startValue = currentValue;\n    this._currentState.position = currentValue;\n    if (!skipSetAtRest) {\n      this.setAtRest();\n    }\n    this.notifyPositionUpdated(false, false);\n    return this;\n  };\n\n  /**\n   * Get the position that the most recent animation started at. This\n   * can be useful for determining the number off oscillations that\n   * have occurred.\n   * @public\n   */\n\n\n  Spring.prototype.getStartValue = function getStartValue() {\n    return this._startValue;\n  };\n\n  /**\n   * Retrieve the current value of the Spring.\n   * @public\n   */\n\n\n  Spring.prototype.getCurrentValue = function getCurrentValue() {\n    return this._currentState.position;\n  };\n\n  /**\n   * Get the absolute distance of the Spring from its resting endValue\n   * position.\n   * @public\n   */\n\n\n  Spring.prototype.getCurrentDisplacementDistance = function getCurrentDisplacementDistance() {\n    return this.getDisplacementDistanceForState(this._currentState);\n  };\n\n  /**\n   * Get the absolute distance of the Spring from a given state value\n   */\n\n\n  Spring.prototype.getDisplacementDistanceForState = function getDisplacementDistanceForState(state) {\n    return Math.abs(this._endValue - state.position);\n  };\n\n  /**\n   * Set the endValue or resting position of the spring. If this\n   * value is different than the current value, the SpringSystem will\n   * be notified and will begin running its solver loop to resolve\n   * the Spring to equilibrium. Any listeners that are registered\n   * for onSpringEndStateChange will also be notified of this update\n   * immediately.\n   * @public\n   */\n\n\n  Spring.prototype.setEndValue = function setEndValue(endValue) {\n    if (this._endValue === endValue && this.isAtRest()) {\n      return this;\n    }\n    this._startValue = this.getCurrentValue();\n    this._endValue = endValue;\n    this._springSystem.activateSpring(this.getId());\n    for (var i = 0, len = this.listeners.length; i < len; i++) {\n      var listener = this.listeners[i];\n      var onChange = listener.onSpringEndStateChange;\n      onChange && onChange(this);\n    }\n    return this;\n  };\n\n  /**\n   * Retrieve the endValue or resting position of this spring.\n   * @public\n   */\n\n\n  Spring.prototype.getEndValue = function getEndValue() {\n    return this._endValue;\n  };\n\n  /**\n   * Set the current velocity of the Spring, in pixels per second. As\n   * previously mentioned, this can be useful when you are performing\n   * a direct manipulation gesture. When a UI element is released you\n   * may call setVelocity on its animation Spring so that the Spring\n   * continues with the same velocity as the gesture ended with. The\n   * friction, tension, and displacement of the Spring will then\n   * govern its motion to return to rest on a natural feeling curve.\n   * @public\n   */\n\n\n  Spring.prototype.setVelocity = function setVelocity(velocity) {\n    if (velocity === this._currentState.velocity) {\n      return this;\n    }\n    this._currentState.velocity = velocity;\n    this._springSystem.activateSpring(this.getId());\n    return this;\n  };\n\n  /**\n   * Get the current velocity of the Spring, in pixels per second.\n   * @public\n   */\n\n\n  Spring.prototype.getVelocity = function getVelocity() {\n    return this._currentState.velocity;\n  };\n\n  /**\n   * Set a threshold value for the movement speed of the Spring below\n   * which it will be considered to be not moving or resting.\n   * @public\n   */\n\n\n  Spring.prototype.setRestSpeedThreshold = function setRestSpeedThreshold(restSpeedThreshold) {\n    this._restSpeedThreshold = restSpeedThreshold;\n    return this;\n  };\n\n  /**\n   * Retrieve the rest speed threshold for this Spring.\n   * @public\n   */\n\n\n  Spring.prototype.getRestSpeedThreshold = function getRestSpeedThreshold() {\n    return this._restSpeedThreshold;\n  };\n\n  /**\n   * Set a threshold value for displacement below which the Spring\n   * will be considered to be not displaced i.e. at its resting\n   * `endValue`.\n   * @public\n   */\n\n\n  Spring.prototype.setRestDisplacementThreshold = function setRestDisplacementThreshold(displacementFromRestThreshold) {\n    this._displacementFromRestThreshold = displacementFromRestThreshold;\n  };\n\n  /**\n   * Retrieve the rest displacement threshold for this spring.\n   * @public\n   */\n\n\n  Spring.prototype.getRestDisplacementThreshold = function getRestDisplacementThreshold() {\n    return this._displacementFromRestThreshold;\n  };\n\n  /**\n   * Enable overshoot clamping. This means that the Spring will stop\n   * immediately when it reaches its resting position regardless of\n   * any existing momentum it may have. This can be useful for certain\n   * types of animations that should not oscillate such as a scale\n   * down to 0 or alpha fade.\n   * @public\n   */\n\n\n  Spring.prototype.setOvershootClampingEnabled = function setOvershootClampingEnabled(enabled) {\n    this._overshootClampingEnabled = enabled;\n    return this;\n  };\n\n  /**\n   * Check if overshoot clamping is enabled for this spring.\n   * @public\n   */\n\n\n  Spring.prototype.isOvershootClampingEnabled = function isOvershootClampingEnabled() {\n    return this._overshootClampingEnabled;\n  };\n\n  /**\n   * Check if the Spring has gone past its end point by comparing\n   * the direction it was moving in when it started to the current\n   * position and end value.\n   * @public\n   */\n\n\n  Spring.prototype.isOvershooting = function isOvershooting() {\n    var start = this._startValue;\n    var end = this._endValue;\n    return this._springConfig.tension > 0 && (start < end && this.getCurrentValue() > end || start > end && this.getCurrentValue() < end);\n  };\n\n  /**\n   * The main solver method for the Spring. It takes\n   * the current time and delta since the last time step and performs\n   * an RK4 integration to get the new position and velocity state\n   * for the Spring based on the tension, friction, velocity, and\n   * displacement of the Spring.\n   * @public\n   */\n\n\n  Spring.prototype.advance = function advance(time, realDeltaTime) {\n    var isAtRest = this.isAtRest();\n\n    if (isAtRest && this._wasAtRest) {\n      return;\n    }\n\n    var adjustedDeltaTime = realDeltaTime;\n    if (realDeltaTime > Spring.MAX_DELTA_TIME_SEC) {\n      adjustedDeltaTime = Spring.MAX_DELTA_TIME_SEC;\n    }\n\n    this._timeAccumulator += adjustedDeltaTime;\n\n    var tension = this._springConfig.tension;\n    var friction = this._springConfig.friction;\n    var position = this._currentState.position;\n    var velocity = this._currentState.velocity;\n    var tempPosition = this._tempState.position;\n    var tempVelocity = this._tempState.velocity;\n    var aVelocity = void 0;\n    var aAcceleration = void 0;\n    var bVelocity = void 0;\n    var bAcceleration = void 0;\n    var cVelocity = void 0;\n    var cAcceleration = void 0;\n    var dVelocity = void 0;\n    var dAcceleration = void 0;\n    var dxdt = void 0;\n    var dvdt = void 0;\n\n    while (this._timeAccumulator >= Spring.SOLVER_TIMESTEP_SEC) {\n      this._timeAccumulator -= Spring.SOLVER_TIMESTEP_SEC;\n\n      if (this._timeAccumulator < Spring.SOLVER_TIMESTEP_SEC) {\n        this._previousState.position = position;\n        this._previousState.velocity = velocity;\n      }\n\n      aVelocity = velocity;\n      aAcceleration = tension * (this._endValue - tempPosition) - friction * velocity;\n\n      tempPosition = position + aVelocity * Spring.SOLVER_TIMESTEP_SEC * 0.5;\n      tempVelocity = velocity + aAcceleration * Spring.SOLVER_TIMESTEP_SEC * 0.5;\n      bVelocity = tempVelocity;\n      bAcceleration = tension * (this._endValue - tempPosition) - friction * tempVelocity;\n\n      tempPosition = position + bVelocity * Spring.SOLVER_TIMESTEP_SEC * 0.5;\n      tempVelocity = velocity + bAcceleration * Spring.SOLVER_TIMESTEP_SEC * 0.5;\n      cVelocity = tempVelocity;\n      cAcceleration = tension * (this._endValue - tempPosition) - friction * tempVelocity;\n\n      tempPosition = position + cVelocity * Spring.SOLVER_TIMESTEP_SEC;\n      tempVelocity = velocity + cAcceleration * Spring.SOLVER_TIMESTEP_SEC;\n      dVelocity = tempVelocity;\n      dAcceleration = tension * (this._endValue - tempPosition) - friction * tempVelocity;\n\n      dxdt = 1.0 / 6.0 * (aVelocity + 2.0 * (bVelocity + cVelocity) + dVelocity);\n      dvdt = 1.0 / 6.0 * (aAcceleration + 2.0 * (bAcceleration + cAcceleration) + dAcceleration);\n\n      position += dxdt * Spring.SOLVER_TIMESTEP_SEC;\n      velocity += dvdt * Spring.SOLVER_TIMESTEP_SEC;\n    }\n\n    this._tempState.position = tempPosition;\n    this._tempState.velocity = tempVelocity;\n\n    this._currentState.position = position;\n    this._currentState.velocity = velocity;\n\n    if (this._timeAccumulator > 0) {\n      this._interpolate(this._timeAccumulator / Spring.SOLVER_TIMESTEP_SEC);\n    }\n\n    if (this.isAtRest() || this._overshootClampingEnabled && this.isOvershooting()) {\n      if (this._springConfig.tension > 0) {\n        this._startValue = this._endValue;\n        this._currentState.position = this._endValue;\n      } else {\n        this._endValue = this._currentState.position;\n        this._startValue = this._endValue;\n      }\n      this.setVelocity(0);\n      isAtRest = true;\n    }\n\n    var notifyActivate = false;\n    if (this._wasAtRest) {\n      this._wasAtRest = false;\n      notifyActivate = true;\n    }\n\n    var notifyAtRest = false;\n    if (isAtRest) {\n      this._wasAtRest = true;\n      notifyAtRest = true;\n    }\n\n    this.notifyPositionUpdated(notifyActivate, notifyAtRest);\n  };\n\n  Spring.prototype.notifyPositionUpdated = function notifyPositionUpdated(notifyActivate, notifyAtRest) {\n    for (var i = 0, len = this.listeners.length; i < len; i++) {\n      var listener = this.listeners[i];\n      if (notifyActivate && listener.onSpringActivate) {\n        listener.onSpringActivate(this);\n      }\n\n      if (listener.onSpringUpdate) {\n        listener.onSpringUpdate(this);\n      }\n\n      if (notifyAtRest && listener.onSpringAtRest) {\n        listener.onSpringAtRest(this);\n      }\n    }\n  };\n\n  /**\n   * Check if the SpringSystem should advance. Springs are advanced\n   * a final frame after they reach equilibrium to ensure that the\n   * currentValue is exactly the requested endValue regardless of the\n   * displacement threshold.\n   * @public\n   */\n\n\n  Spring.prototype.systemShouldAdvance = function systemShouldAdvance() {\n    return !this.isAtRest() || !this.wasAtRest();\n  };\n\n  Spring.prototype.wasAtRest = function wasAtRest() {\n    return this._wasAtRest;\n  };\n\n  /**\n   * Check if the Spring is atRest meaning that it's currentValue and\n   * endValue are the same and that it has no velocity. The previously\n   * described thresholds for speed and displacement define the bounds\n   * of this equivalence check. If the Spring has 0 tension, then it will\n   * be considered at rest whenever its absolute velocity drops below the\n   * restSpeedThreshold.\n   * @public\n   */\n\n\n  Spring.prototype.isAtRest = function isAtRest() {\n    return Math.abs(this._currentState.velocity) < this._restSpeedThreshold && (this.getDisplacementDistanceForState(this._currentState) <= this._displacementFromRestThreshold || this._springConfig.tension === 0);\n  };\n\n  /**\n   * Force the spring to be at rest at its current position. As\n   * described in the documentation for setCurrentValue, this method\n   * makes it easy to do synchronous non-animated updates to ui\n   * elements that are attached to springs via SpringListeners.\n   * @public\n   */\n\n\n  Spring.prototype.setAtRest = function setAtRest() {\n    this._endValue = this._currentState.position;\n    this._tempState.position = this._currentState.position;\n    this._currentState.velocity = 0;\n    return this;\n  };\n\n  Spring.prototype._interpolate = function _interpolate(alpha) {\n    this._currentState.position = this._currentState.position * alpha + this._previousState.position * (1 - alpha);\n    this._currentState.velocity = this._currentState.velocity * alpha + this._previousState.velocity * (1 - alpha);\n  };\n\n  Spring.prototype.getListeners = function getListeners() {\n    return this.listeners;\n  };\n\n  Spring.prototype.addListener = function addListener(newListener) {\n    this.listeners.push(newListener);\n    return this;\n  };\n\n  Spring.prototype.removeListener = function removeListener(listenerToRemove) {\n    removeFirst(this.listeners, listenerToRemove);\n    return this;\n  };\n\n  Spring.prototype.removeAllListeners = function removeAllListeners() {\n    this.listeners = [];\n    return this;\n  };\n\n  Spring.prototype.currentValueIsApproximately = function currentValueIsApproximately(value) {\n    return Math.abs(this.getCurrentValue() - value) <= this.getRestDisplacementThreshold();\n  };\n\n  return Spring;\n}();\n\nSpring._ID = 0;\nSpring.MAX_DELTA_TIME_SEC = 0.064;\nSpring.SOLVER_TIMESTEP_SEC = 0.001;\n\n/**\n * A set of Springs that all run on the same physics\n * timing loop. To get started with a Rebound animation, first\n * create a new SpringSystem and then add springs to it.\n * @public\n */\n\nvar SpringSystem = function () {\n  function SpringSystem(looper) {\n    classCallCheck(this, SpringSystem);\n    this.listeners = [];\n    this._activeSprings = [];\n    this._idleSpringIndices = [];\n    this._isIdle = true;\n    this._lastTimeMillis = -1;\n    this._springRegistry = {};\n\n    this.looper = looper || new AnimationLooper();\n    this.looper.springSystem = this;\n  }\n\n  /**\n   * A SpringSystem is iterated by a looper. The looper is responsible\n   * for executing each frame as the SpringSystem is resolved to idle.\n   * There are three types of Loopers described below AnimationLooper,\n   * SimulationLooper, and SteppingSimulationLooper. AnimationLooper is\n   * the default as it is the most useful for common UI animations.\n   * @public\n   */\n\n\n  SpringSystem.prototype.setLooper = function setLooper(looper) {\n    this.looper = looper;\n    looper.springSystem = this;\n  };\n\n  /**\n   * Add a new spring to this SpringSystem. This Spring will now be solved for\n   * during the physics iteration loop. By default the spring will use the\n   * default Origami spring config with 40 tension and 7 friction, but you can\n   * also provide your own values here.\n   * @public\n   */\n\n\n  SpringSystem.prototype.createSpring = function createSpring(tension, friction) {\n    var springConfig = void 0;\n    if (tension === undefined || friction === undefined) {\n      springConfig = SpringConfig.DEFAULT_ORIGAMI_SPRING_CONFIG;\n    } else {\n      springConfig = SpringConfig.fromOrigamiTensionAndFriction(tension, friction);\n    }\n    return this.createSpringWithConfig(springConfig);\n  };\n\n  /**\n   * Add a spring with a specified bounciness and speed. To replicate Origami\n   * compositions based on PopAnimation patches, use this factory method to\n   * create matching springs.\n   * @public\n   */\n\n\n  SpringSystem.prototype.createSpringWithBouncinessAndSpeed = function createSpringWithBouncinessAndSpeed(bounciness, speed) {\n    var springConfig = void 0;\n    if (bounciness === undefined || speed === undefined) {\n      springConfig = SpringConfig.DEFAULT_ORIGAMI_SPRING_CONFIG;\n    } else {\n      springConfig = SpringConfig.fromBouncinessAndSpeed(bounciness, speed);\n    }\n    return this.createSpringWithConfig(springConfig);\n  };\n\n  /**\n   * Add a spring with the provided SpringConfig.\n   * @public\n   */\n\n\n  SpringSystem.prototype.createSpringWithConfig = function createSpringWithConfig(springConfig) {\n    var spring = new Spring(this);\n    this.registerSpring(spring);\n    spring.setSpringConfig(springConfig);\n    return spring;\n  };\n\n  /**\n   * Check if a SpringSystem is idle or active. If all of the Springs in the\n   * SpringSystem are at rest, i.e. the physics forces have reached equilibrium,\n   * then this method will return true.\n   * @public\n   */\n\n\n  SpringSystem.prototype.getIsIdle = function getIsIdle() {\n    return this._isIdle;\n  };\n\n  /**\n   * Retrieve a specific Spring from the SpringSystem by id. This\n   * can be useful for inspecting the state of a spring before\n   * or after an integration loop in the SpringSystem executes.\n   * @public\n   */\n\n\n  SpringSystem.prototype.getSpringById = function getSpringById(id) {\n    return this._springRegistry[id];\n  };\n\n  /**\n   * Get a listing of all the springs registered with this\n   * SpringSystem.\n   * @public\n   */\n\n\n  SpringSystem.prototype.getAllSprings = function getAllSprings() {\n    var vals = [];\n    for (var _id in this._springRegistry) {\n      if (this._springRegistry.hasOwnProperty(_id)) {\n        vals.push(this._springRegistry[_id]);\n      }\n    }\n    return vals;\n  };\n\n  /**\n   * Manually add a spring to this system. This is called automatically\n   * if a Spring is created with SpringSystem#createSpring.\n   *\n   * This method sets the spring up in the registry so that it can be solved\n   * in the solver loop.\n   * @public\n   */\n\n\n  SpringSystem.prototype.registerSpring = function registerSpring(spring) {\n    this._springRegistry[spring.getId()] = spring;\n  };\n\n  /**\n   * Deregister a spring with this SpringSystem. The SpringSystem will\n   * no longer consider this Spring during its integration loop once\n   * this is called. This is normally done automatically for you when\n   * you call Spring#destroy.\n   * @public\n   */\n\n\n  SpringSystem.prototype.deregisterSpring = function deregisterSpring(spring) {\n    removeFirst(this._activeSprings, spring);\n    delete this._springRegistry[spring.getId()];\n  };\n\n  SpringSystem.prototype.advance = function advance(time, deltaTime) {\n    while (this._idleSpringIndices.length > 0) {\n      this._idleSpringIndices.pop();\n    }\n    for (var i = 0, len = this._activeSprings.length; i < len; i++) {\n      var spring = this._activeSprings[i];\n      if (spring.systemShouldAdvance()) {\n        spring.advance(time / 1000.0, deltaTime / 1000.0);\n      } else {\n        this._idleSpringIndices.push(this._activeSprings.indexOf(spring));\n      }\n    }\n    while (this._idleSpringIndices.length > 0) {\n      var idx = this._idleSpringIndices.pop();\n      idx >= 0 && this._activeSprings.splice(idx, 1);\n    }\n  };\n\n  /**\n   * This is the main solver loop called to move the simulation\n   * forward through time. Before each pass in the solver loop\n   * onBeforeIntegrate is called on an any listeners that have\n   * registered themeselves with the SpringSystem. This gives you\n   * an opportunity to apply any constraints or adjustments to\n   * the springs that should be enforced before each iteration\n   * loop. Next the advance method is called to move each Spring in\n   * the systemShouldAdvance forward to the current time. After the\n   * integration step runs in advance, onAfterIntegrate is called\n   * on any listeners that have registered themselves with the\n   * SpringSystem. This gives you an opportunity to run any post\n   * integration constraints or adjustments on the Springs in the\n   * SpringSystem.\n   * @public\n   */\n\n\n  SpringSystem.prototype.loop = function loop(currentTimeMillis) {\n    var listener = void 0;\n    if (this._lastTimeMillis === -1) {\n      this._lastTimeMillis = currentTimeMillis - 1;\n    }\n    var ellapsedMillis = currentTimeMillis - this._lastTimeMillis;\n    this._lastTimeMillis = currentTimeMillis;\n\n    var i = 0;\n    var len = this.listeners.length;\n    for (i = 0; i < len; i++) {\n      listener = this.listeners[i];\n      listener.onBeforeIntegrate && listener.onBeforeIntegrate(this);\n    }\n\n    this.advance(currentTimeMillis, ellapsedMillis);\n    if (this._activeSprings.length === 0) {\n      this._isIdle = true;\n      this._lastTimeMillis = -1;\n    }\n\n    for (i = 0; i < len; i++) {\n      listener = this.listeners[i];\n      listener.onAfterIntegrate && listener.onAfterIntegrate(this);\n    }\n\n    if (!this._isIdle) {\n      this.looper.run();\n    }\n  };\n\n  /**\n   * Used to notify the SpringSystem that a Spring has become displaced.\n   * The system responds by starting its solver loop up if it is currently idle.\n   */\n\n\n  SpringSystem.prototype.activateSpring = function activateSpring(springId) {\n    var spring = this._springRegistry[springId];\n    if (this._activeSprings.indexOf(spring) === -1) {\n      this._activeSprings.push(spring);\n    }\n    if (this.getIsIdle()) {\n      this._isIdle = false;\n      this.looper.run();\n    }\n  };\n\n  /**\n   * Add a listener to the SpringSystem to receive before/after integration\n   * notifications allowing Springs to be constrained or adjusted.\n   * @public\n   */\n\n\n  SpringSystem.prototype.addListener = function addListener(listener) {\n    this.listeners.push(listener);\n  };\n\n  /**\n   * Remove a previously added listener on the SpringSystem.\n   * @public\n   */\n\n\n  SpringSystem.prototype.removeListener = function removeListener(listener) {\n    removeFirst(this.listeners, listener);\n  };\n\n  /**\n   * Remove all previously added listeners on the SpringSystem.\n   * @public\n   */\n\n\n  SpringSystem.prototype.removeAllListeners = function removeAllListeners() {\n    this.listeners = [];\n  };\n\n  return SpringSystem;\n}();\n\nvar index = _extends({}, Loopers, {\n  OrigamiValueConverter: OrigamiValueConverter,\n  MathUtil: MathUtil,\n  Spring: Spring,\n  SpringConfig: SpringConfig,\n  SpringSystem: SpringSystem,\n  util: _extends({}, util, MathUtil)\n});\n\nreturn index;\n\n})));\n","export class TimeoutError extends Error {\n\tconstructor(message) {\n\t\tsuper(message);\n\t\tthis.name = 'TimeoutError';\n\t}\n}\n\n/**\nAn error to be thrown when the request is aborted by AbortController.\nDOMException is thrown instead of this Error when DOMException is available.\n*/\nexport class AbortError extends Error {\n\tconstructor(message) {\n\t\tsuper();\n\t\tthis.name = 'AbortError';\n\t\tthis.message = message;\n\t}\n}\n\n/**\nTODO: Remove AbortError and just throw DOMException when targeting Node 18.\n*/\nconst getDOMException = errorMessage => globalThis.DOMException === undefined ?\n\tnew AbortError(errorMessage) :\n\tnew DOMException(errorMessage);\n\n/**\nTODO: Remove below function and just 'reject(signal.reason)' when targeting Node 18.\n*/\nconst getAbortedReason = signal => {\n\tconst reason = signal.reason === undefined ?\n\t\tgetDOMException('This operation was aborted.') :\n\t\tsignal.reason;\n\n\treturn reason instanceof Error ? reason : getDOMException(reason);\n};\n\nexport default function pTimeout(promise, milliseconds, fallback, options) {\n\tlet timer;\n\n\tconst cancelablePromise = new Promise((resolve, reject) => {\n\t\tif (typeof milliseconds !== 'number' || Math.sign(milliseconds) !== 1) {\n\t\t\tthrow new TypeError(`Expected \\`milliseconds\\` to be a positive number, got \\`${milliseconds}\\``);\n\t\t}\n\n\t\tif (milliseconds === Number.POSITIVE_INFINITY) {\n\t\t\tresolve(promise);\n\t\t\treturn;\n\t\t}\n\n\t\toptions = {\n\t\t\tcustomTimers: {setTimeout, clearTimeout},\n\t\t\t...options\n\t\t};\n\n\t\tif (options.signal) {\n\t\t\tconst {signal} = options;\n\t\t\tif (signal.aborted) {\n\t\t\t\treject(getAbortedReason(signal));\n\t\t\t}\n\n\t\t\tsignal.addEventListener('abort', () => {\n\t\t\t\treject(getAbortedReason(signal));\n\t\t\t});\n\t\t}\n\n\t\ttimer = options.customTimers.setTimeout.call(undefined, () => {\n\t\t\tif (typeof fallback === 'function') {\n\t\t\t\ttry {\n\t\t\t\t\tresolve(fallback());\n\t\t\t\t} catch (error) {\n\t\t\t\t\treject(error);\n\t\t\t\t}\n\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tconst message = typeof fallback === 'string' ? fallback : `Promise timed out after ${milliseconds} milliseconds`;\n\t\t\tconst timeoutError = fallback instanceof Error ? fallback : new TimeoutError(message);\n\n\t\t\tif (typeof promise.cancel === 'function') {\n\t\t\t\tpromise.cancel();\n\t\t\t}\n\n\t\t\treject(timeoutError);\n\t\t}, milliseconds);\n\n\t\t(async () => {\n\t\t\ttry {\n\t\t\t\tresolve(await promise);\n\t\t\t} catch (error) {\n\t\t\t\treject(error);\n\t\t\t} finally {\n\t\t\t\toptions.customTimers.clearTimeout.call(undefined, timer);\n\t\t\t}\n\t\t})();\n\t});\n\n\tcancelablePromise.clear = () => {\n\t\tclearTimeout(timer);\n\t\ttimer = undefined;\n\t};\n\n\treturn cancelablePromise;\n}\n","var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar _PriorityQueue_queue;\nimport lowerBound from './lower-bound.js';\nexport default class PriorityQueue {\n    constructor() {\n        _PriorityQueue_queue.set(this, []);\n    }\n    enqueue(run, options) {\n        options = {\n            priority: 0,\n            ...options,\n        };\n        const element = {\n            priority: options.priority,\n            run,\n        };\n        if (this.size && __classPrivateFieldGet(this, _PriorityQueue_queue, \"f\")[this.size - 1].priority >= options.priority) {\n            __classPrivateFieldGet(this, _PriorityQueue_queue, \"f\").push(element);\n            return;\n        }\n        const index = lowerBound(__classPrivateFieldGet(this, _PriorityQueue_queue, \"f\"), element, (a, b) => b.priority - a.priority);\n        __classPrivateFieldGet(this, _PriorityQueue_queue, \"f\").splice(index, 0, element);\n    }\n    dequeue() {\n        const item = __classPrivateFieldGet(this, _PriorityQueue_queue, \"f\").shift();\n        return item === null || item === void 0 ? void 0 : item.run;\n    }\n    filter(options) {\n        return __classPrivateFieldGet(this, _PriorityQueue_queue, \"f\").filter((element) => element.priority === options.priority).map((element) => element.run);\n    }\n    get size() {\n        return __classPrivateFieldGet(this, _PriorityQueue_queue, \"f\").length;\n    }\n}\n_PriorityQueue_queue = new WeakMap();\n","// Port of lower_bound from https://en.cppreference.com/w/cpp/algorithm/lower_bound\n// Used to compute insertion index to keep queue sorted after insertion\nexport default function lowerBound(array, value, comparator) {\n    let first = 0;\n    let count = array.length;\n    while (count > 0) {\n        const step = Math.trunc(count / 2);\n        let it = first + step;\n        if (comparator(array[it], value) <= 0) {\n            first = ++it;\n            count -= step + 1;\n        }\n        else {\n            count = step;\n        }\n    }\n    return first;\n}\n","var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n};\nvar __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar _PQueue_instances, _PQueue_carryoverConcurrencyCount, _PQueue_isIntervalIgnored, _PQueue_intervalCount, _PQueue_intervalCap, _PQueue_interval, _PQueue_intervalEnd, _PQueue_intervalId, _PQueue_timeoutId, _PQueue_queue, _PQueue_queueClass, _PQueue_pendingCount, _PQueue_concurrency, _PQueue_isPaused, _PQueue_throwOnTimeout, _PQueue_doesIntervalAllowAnother_get, _PQueue_doesConcurrentAllowAnother_get, _PQueue_next, _PQueue_emitEvents, _PQueue_onResumeInterval, _PQueue_isIntervalPaused_get, _PQueue_tryToStartAnother, _PQueue_initializeIntervalIfNeeded, _PQueue_onInterval, _PQueue_processQueue, _PQueue_onEvent;\nimport EventEmitter from 'eventemitter3';\nimport pTimeout, { TimeoutError } from 'p-timeout';\nimport PriorityQueue from './priority-queue.js';\nconst timeoutError = new TimeoutError();\n/**\nThe error thrown by `queue.add()` when a job is aborted before it is run. See `signal`.\n*/\nexport class AbortError extends Error {\n}\n/**\nPromise queue with concurrency control.\n*/\nexport default class PQueue extends EventEmitter {\n    constructor(options) {\n        var _a, _b, _c, _d;\n        super();\n        _PQueue_instances.add(this);\n        _PQueue_carryoverConcurrencyCount.set(this, void 0);\n        _PQueue_isIntervalIgnored.set(this, void 0);\n        _PQueue_intervalCount.set(this, 0);\n        _PQueue_intervalCap.set(this, void 0);\n        _PQueue_interval.set(this, void 0);\n        _PQueue_intervalEnd.set(this, 0);\n        _PQueue_intervalId.set(this, void 0);\n        _PQueue_timeoutId.set(this, void 0);\n        _PQueue_queue.set(this, void 0);\n        _PQueue_queueClass.set(this, void 0);\n        _PQueue_pendingCount.set(this, 0);\n        // The `!` is needed because of https://github.com/microsoft/TypeScript/issues/32194\n        _PQueue_concurrency.set(this, void 0);\n        _PQueue_isPaused.set(this, void 0);\n        _PQueue_throwOnTimeout.set(this, void 0);\n        /**\n        Per-operation timeout in milliseconds. Operations fulfill once `timeout` elapses if they haven't already.\n    \n        Applies to each future operation.\n        */\n        Object.defineProperty(this, \"timeout\", {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: void 0\n        });\n        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions\n        options = {\n            carryoverConcurrencyCount: false,\n            intervalCap: Number.POSITIVE_INFINITY,\n            interval: 0,\n            concurrency: Number.POSITIVE_INFINITY,\n            autoStart: true,\n            queueClass: PriorityQueue,\n            ...options,\n        };\n        if (!(typeof options.intervalCap === 'number' && options.intervalCap >= 1)) {\n            throw new TypeError(`Expected \\`intervalCap\\` to be a number from 1 and up, got \\`${(_b = (_a = options.intervalCap) === null || _a === void 0 ? void 0 : _a.toString()) !== null && _b !== void 0 ? _b : ''}\\` (${typeof options.intervalCap})`);\n        }\n        if (options.interval === undefined || !(Number.isFinite(options.interval) && options.interval >= 0)) {\n            throw new TypeError(`Expected \\`interval\\` to be a finite number >= 0, got \\`${(_d = (_c = options.interval) === null || _c === void 0 ? void 0 : _c.toString()) !== null && _d !== void 0 ? _d : ''}\\` (${typeof options.interval})`);\n        }\n        __classPrivateFieldSet(this, _PQueue_carryoverConcurrencyCount, options.carryoverConcurrencyCount, \"f\");\n        __classPrivateFieldSet(this, _PQueue_isIntervalIgnored, options.intervalCap === Number.POSITIVE_INFINITY || options.interval === 0, \"f\");\n        __classPrivateFieldSet(this, _PQueue_intervalCap, options.intervalCap, \"f\");\n        __classPrivateFieldSet(this, _PQueue_interval, options.interval, \"f\");\n        __classPrivateFieldSet(this, _PQueue_queue, new options.queueClass(), \"f\");\n        __classPrivateFieldSet(this, _PQueue_queueClass, options.queueClass, \"f\");\n        this.concurrency = options.concurrency;\n        this.timeout = options.timeout;\n        __classPrivateFieldSet(this, _PQueue_throwOnTimeout, options.throwOnTimeout === true, \"f\");\n        __classPrivateFieldSet(this, _PQueue_isPaused, options.autoStart === false, \"f\");\n    }\n    get concurrency() {\n        return __classPrivateFieldGet(this, _PQueue_concurrency, \"f\");\n    }\n    set concurrency(newConcurrency) {\n        if (!(typeof newConcurrency === 'number' && newConcurrency >= 1)) {\n            throw new TypeError(`Expected \\`concurrency\\` to be a number from 1 and up, got \\`${newConcurrency}\\` (${typeof newConcurrency})`);\n        }\n        __classPrivateFieldSet(this, _PQueue_concurrency, newConcurrency, \"f\");\n        __classPrivateFieldGet(this, _PQueue_instances, \"m\", _PQueue_processQueue).call(this);\n    }\n    /**\n    Adds a sync or async task to the queue. Always returns a promise.\n    */\n    async add(fn, options = {}) {\n        return new Promise((resolve, reject) => {\n            const run = async () => {\n                var _a;\n                var _b, _c;\n                __classPrivateFieldSet(this, _PQueue_pendingCount, (_b = __classPrivateFieldGet(this, _PQueue_pendingCount, \"f\"), _b++, _b), \"f\");\n                __classPrivateFieldSet(this, _PQueue_intervalCount, (_c = __classPrivateFieldGet(this, _PQueue_intervalCount, \"f\"), _c++, _c), \"f\");\n                try {\n                    if ((_a = options.signal) === null || _a === void 0 ? void 0 : _a.aborted) {\n                        // TODO: Use ABORT_ERR code when targeting Node.js 16 (https://nodejs.org/docs/latest-v16.x/api/errors.html#abort_err)\n                        reject(new AbortError('The task was aborted.'));\n                        return;\n                    }\n                    const operation = (this.timeout === undefined && options.timeout === undefined) ? fn({ signal: options.signal }) : pTimeout(Promise.resolve(fn({ signal: options.signal })), (options.timeout === undefined ? this.timeout : options.timeout), () => {\n                        if (options.throwOnTimeout === undefined ? __classPrivateFieldGet(this, _PQueue_throwOnTimeout, \"f\") : options.throwOnTimeout) {\n                            reject(timeoutError);\n                        }\n                        return undefined;\n                    });\n                    const result = await operation;\n                    resolve(result);\n                    this.emit('completed', result);\n                }\n                catch (error) {\n                    reject(error);\n                    this.emit('error', error);\n                }\n                __classPrivateFieldGet(this, _PQueue_instances, \"m\", _PQueue_next).call(this);\n            };\n            __classPrivateFieldGet(this, _PQueue_queue, \"f\").enqueue(run, options);\n            __classPrivateFieldGet(this, _PQueue_instances, \"m\", _PQueue_tryToStartAnother).call(this);\n            this.emit('add');\n        });\n    }\n    /**\n    Same as `.add()`, but accepts an array of sync or async functions.\n\n    @returns A promise that resolves when all functions are resolved.\n    */\n    async addAll(functions, options) {\n        return Promise.all(functions.map(async (function_) => this.add(function_, options)));\n    }\n    /**\n    Start (or resume) executing enqueued tasks within concurrency limit. No need to call this if queue is not paused (via `options.autoStart = false` or by `.pause()` method.)\n    */\n    start() {\n        if (!__classPrivateFieldGet(this, _PQueue_isPaused, \"f\")) {\n            return this;\n        }\n        __classPrivateFieldSet(this, _PQueue_isPaused, false, \"f\");\n        __classPrivateFieldGet(this, _PQueue_instances, \"m\", _PQueue_processQueue).call(this);\n        return this;\n    }\n    /**\n    Put queue execution on hold.\n    */\n    pause() {\n        __classPrivateFieldSet(this, _PQueue_isPaused, true, \"f\");\n    }\n    /**\n    Clear the queue.\n    */\n    clear() {\n        __classPrivateFieldSet(this, _PQueue_queue, new (__classPrivateFieldGet(this, _PQueue_queueClass, \"f\"))(), \"f\");\n    }\n    /**\n    Can be called multiple times. Useful if you for example add additional items at a later time.\n\n    @returns A promise that settles when the queue becomes empty.\n    */\n    async onEmpty() {\n        // Instantly resolve if the queue is empty\n        if (__classPrivateFieldGet(this, _PQueue_queue, \"f\").size === 0) {\n            return;\n        }\n        await __classPrivateFieldGet(this, _PQueue_instances, \"m\", _PQueue_onEvent).call(this, 'empty');\n    }\n    /**\n    @returns A promise that settles when the queue size is less than the given limit: `queue.size < limit`.\n\n    If you want to avoid having the queue grow beyond a certain size you can `await queue.onSizeLessThan()` before adding a new item.\n\n    Note that this only limits the number of items waiting to start. There could still be up to `concurrency` jobs already running that this call does not include in its calculation.\n    */\n    async onSizeLessThan(limit) {\n        // Instantly resolve if the queue is empty.\n        if (__classPrivateFieldGet(this, _PQueue_queue, \"f\").size < limit) {\n            return;\n        }\n        await __classPrivateFieldGet(this, _PQueue_instances, \"m\", _PQueue_onEvent).call(this, 'next', () => __classPrivateFieldGet(this, _PQueue_queue, \"f\").size < limit);\n    }\n    /**\n    The difference with `.onEmpty` is that `.onIdle` guarantees that all work from the queue has finished. `.onEmpty` merely signals that the queue is empty, but it could mean that some promises haven't completed yet.\n\n    @returns A promise that settles when the queue becomes empty, and all promises have completed; `queue.size === 0 && queue.pending === 0`.\n    */\n    async onIdle() {\n        // Instantly resolve if none pending and if nothing else is queued\n        if (__classPrivateFieldGet(this, _PQueue_pendingCount, \"f\") === 0 && __classPrivateFieldGet(this, _PQueue_queue, \"f\").size === 0) {\n            return;\n        }\n        await __classPrivateFieldGet(this, _PQueue_instances, \"m\", _PQueue_onEvent).call(this, 'idle');\n    }\n    /**\n    Size of the queue, the number of queued items waiting to run.\n    */\n    get size() {\n        return __classPrivateFieldGet(this, _PQueue_queue, \"f\").size;\n    }\n    /**\n    Size of the queue, filtered by the given options.\n\n    For example, this can be used to find the number of items remaining in the queue with a specific priority level.\n    */\n    sizeBy(options) {\n        // eslint-disable-next-line unicorn/no-array-callback-reference\n        return __classPrivateFieldGet(this, _PQueue_queue, \"f\").filter(options).length;\n    }\n    /**\n    Number of running items (no longer in the queue).\n    */\n    get pending() {\n        return __classPrivateFieldGet(this, _PQueue_pendingCount, \"f\");\n    }\n    /**\n    Whether the queue is currently paused.\n    */\n    get isPaused() {\n        return __classPrivateFieldGet(this, _PQueue_isPaused, \"f\");\n    }\n}\n_PQueue_carryoverConcurrencyCount = new WeakMap(), _PQueue_isIntervalIgnored = new WeakMap(), _PQueue_intervalCount = new WeakMap(), _PQueue_intervalCap = new WeakMap(), _PQueue_interval = new WeakMap(), _PQueue_intervalEnd = new WeakMap(), _PQueue_intervalId = new WeakMap(), _PQueue_timeoutId = new WeakMap(), _PQueue_queue = new WeakMap(), _PQueue_queueClass = new WeakMap(), _PQueue_pendingCount = new WeakMap(), _PQueue_concurrency = new WeakMap(), _PQueue_isPaused = new WeakMap(), _PQueue_throwOnTimeout = new WeakMap(), _PQueue_instances = new WeakSet(), _PQueue_doesIntervalAllowAnother_get = function _PQueue_doesIntervalAllowAnother_get() {\n    return __classPrivateFieldGet(this, _PQueue_isIntervalIgnored, \"f\") || __classPrivateFieldGet(this, _PQueue_intervalCount, \"f\") < __classPrivateFieldGet(this, _PQueue_intervalCap, \"f\");\n}, _PQueue_doesConcurrentAllowAnother_get = function _PQueue_doesConcurrentAllowAnother_get() {\n    return __classPrivateFieldGet(this, _PQueue_pendingCount, \"f\") < __classPrivateFieldGet(this, _PQueue_concurrency, \"f\");\n}, _PQueue_next = function _PQueue_next() {\n    var _a;\n    __classPrivateFieldSet(this, _PQueue_pendingCount, (_a = __classPrivateFieldGet(this, _PQueue_pendingCount, \"f\"), _a--, _a), \"f\");\n    __classPrivateFieldGet(this, _PQueue_instances, \"m\", _PQueue_tryToStartAnother).call(this);\n    this.emit('next');\n}, _PQueue_emitEvents = function _PQueue_emitEvents() {\n    this.emit('empty');\n    if (__classPrivateFieldGet(this, _PQueue_pendingCount, \"f\") === 0) {\n        this.emit('idle');\n    }\n}, _PQueue_onResumeInterval = function _PQueue_onResumeInterval() {\n    __classPrivateFieldGet(this, _PQueue_instances, \"m\", _PQueue_onInterval).call(this);\n    __classPrivateFieldGet(this, _PQueue_instances, \"m\", _PQueue_initializeIntervalIfNeeded).call(this);\n    __classPrivateFieldSet(this, _PQueue_timeoutId, undefined, \"f\");\n}, _PQueue_isIntervalPaused_get = function _PQueue_isIntervalPaused_get() {\n    const now = Date.now();\n    if (__classPrivateFieldGet(this, _PQueue_intervalId, \"f\") === undefined) {\n        const delay = __classPrivateFieldGet(this, _PQueue_intervalEnd, \"f\") - now;\n        if (delay < 0) {\n            // Act as the interval was done\n            // We don't need to resume it here because it will be resumed on line 160\n            __classPrivateFieldSet(this, _PQueue_intervalCount, (__classPrivateFieldGet(this, _PQueue_carryoverConcurrencyCount, \"f\")) ? __classPrivateFieldGet(this, _PQueue_pendingCount, \"f\") : 0, \"f\");\n        }\n        else {\n            // Act as the interval is pending\n            if (__classPrivateFieldGet(this, _PQueue_timeoutId, \"f\") === undefined) {\n                __classPrivateFieldSet(this, _PQueue_timeoutId, setTimeout(() => {\n                    __classPrivateFieldGet(this, _PQueue_instances, \"m\", _PQueue_onResumeInterval).call(this);\n                }, delay), \"f\");\n            }\n            return true;\n        }\n    }\n    return false;\n}, _PQueue_tryToStartAnother = function _PQueue_tryToStartAnother() {\n    if (__classPrivateFieldGet(this, _PQueue_queue, \"f\").size === 0) {\n        // We can clear the interval (\"pause\")\n        // Because we can redo it later (\"resume\")\n        if (__classPrivateFieldGet(this, _PQueue_intervalId, \"f\")) {\n            clearInterval(__classPrivateFieldGet(this, _PQueue_intervalId, \"f\"));\n        }\n        __classPrivateFieldSet(this, _PQueue_intervalId, undefined, \"f\");\n        __classPrivateFieldGet(this, _PQueue_instances, \"m\", _PQueue_emitEvents).call(this);\n        return false;\n    }\n    if (!__classPrivateFieldGet(this, _PQueue_isPaused, \"f\")) {\n        const canInitializeInterval = !__classPrivateFieldGet(this, _PQueue_instances, \"a\", _PQueue_isIntervalPaused_get);\n        if (__classPrivateFieldGet(this, _PQueue_instances, \"a\", _PQueue_doesIntervalAllowAnother_get) && __classPrivateFieldGet(this, _PQueue_instances, \"a\", _PQueue_doesConcurrentAllowAnother_get)) {\n            const job = __classPrivateFieldGet(this, _PQueue_queue, \"f\").dequeue();\n            if (!job) {\n                return false;\n            }\n            this.emit('active');\n            job();\n            if (canInitializeInterval) {\n                __classPrivateFieldGet(this, _PQueue_instances, \"m\", _PQueue_initializeIntervalIfNeeded).call(this);\n            }\n            return true;\n        }\n    }\n    return false;\n}, _PQueue_initializeIntervalIfNeeded = function _PQueue_initializeIntervalIfNeeded() {\n    if (__classPrivateFieldGet(this, _PQueue_isIntervalIgnored, \"f\") || __classPrivateFieldGet(this, _PQueue_intervalId, \"f\") !== undefined) {\n        return;\n    }\n    __classPrivateFieldSet(this, _PQueue_intervalId, setInterval(() => {\n        __classPrivateFieldGet(this, _PQueue_instances, \"m\", _PQueue_onInterval).call(this);\n    }, __classPrivateFieldGet(this, _PQueue_interval, \"f\")), \"f\");\n    __classPrivateFieldSet(this, _PQueue_intervalEnd, Date.now() + __classPrivateFieldGet(this, _PQueue_interval, \"f\"), \"f\");\n}, _PQueue_onInterval = function _PQueue_onInterval() {\n    if (__classPrivateFieldGet(this, _PQueue_intervalCount, \"f\") === 0 && __classPrivateFieldGet(this, _PQueue_pendingCount, \"f\") === 0 && __classPrivateFieldGet(this, _PQueue_intervalId, \"f\")) {\n        clearInterval(__classPrivateFieldGet(this, _PQueue_intervalId, \"f\"));\n        __classPrivateFieldSet(this, _PQueue_intervalId, undefined, \"f\");\n    }\n    __classPrivateFieldSet(this, _PQueue_intervalCount, __classPrivateFieldGet(this, _PQueue_carryoverConcurrencyCount, \"f\") ? __classPrivateFieldGet(this, _PQueue_pendingCount, \"f\") : 0, \"f\");\n    __classPrivateFieldGet(this, _PQueue_instances, \"m\", _PQueue_processQueue).call(this);\n}, _PQueue_processQueue = function _PQueue_processQueue() {\n    // eslint-disable-next-line no-empty\n    while (__classPrivateFieldGet(this, _PQueue_instances, \"m\", _PQueue_tryToStartAnother).call(this)) { }\n}, _PQueue_onEvent = async function _PQueue_onEvent(event, filter) {\n    return new Promise(resolve => {\n        const listener = () => {\n            if (filter && !filter()) {\n                return;\n            }\n            this.off(event, listener);\n            resolve();\n        };\n        this.on(event, listener);\n    });\n};\n"],"names":["has","Object","prototype","hasOwnProperty","prefix","Events","EE","fn","context","once","this","addListener","emitter","event","TypeError","listener","evt","_events","push","_eventsCount","clearEvent","EventEmitter","create","__proto__","eventNames","events","name","names","call","slice","getOwnPropertySymbols","concat","listeners","handlers","i","l","length","ee","Array","listenerCount","emit","a1","a2","a3","a4","a5","args","len","arguments","removeListener","undefined","apply","j","on","removeAllListeners","off","prefixed","module","exports","global","startY","enabled","supportsPassiveOption","opts","defineProperty","get","window","addEventListener","e","handleTouchmove","el","target","zoom","innerWidth","document","documentElement","clientWidth","touches","body","style","getComputedStyle","nodeName","getAttribute","scrolling","getPropertyValue","overflowY","height","parseInt","isScrollable","canScroll","scrollHeight","offsetHeight","curY","screenY","isAtTop","scrollTop","isAtBottom","preventDefault","parentNode","handleTouchstart","enable","passive","testDiv","createElement","appendChild","WebkitOverflowScrolling","isScrollSupported","removeChild","iNoBounce","disable","removeEventListener","isEnabled","define","_onFrame","requestAnimationFrame","webkitRequestAnimationFrame","mozRequestAnimationFrame","msRequestAnimationFrame","oRequestAnimationFrame","process","title","setImmediate","_onFrame$1","callback","setTimeout","onFrame","func","removeFirst","array","item","idx","indexOf","splice","colorCache","hexToRGB","colorString","normalizedColor","replace","parts","match","Error","ret","r","g","b","rgbToHex","rNum","gNum","bNum","toString","util","freeze","bind","_len","outerArgs","_key","_len2","innerArgs","_key2","extend","source","key","mapValueInRange","value","fromLow","fromHigh","toLow","toHigh","MathUtil","interpolateColor","val","startColorStr","endColorStr","asRGB","startColor","endColor","Math","floor","degreesToRadians","deg","PI","radiansToDegrees","rad","tensionFromOrigamiValue","oValue","frictionFromOrigamiValue","OrigamiValueConverter","origamiValueFromTension","tension","origamiFromFriction","friction","classCallCheck","instance","Constructor","_extends","assign","AnimationLooper","springSystem","run","getSpringSystem","loop","Date","now","SimulationLooper","timestep","time","running","getIsIdle","SteppingSimulationLooper","step","Loopers","BouncyConversion","bounciness","speed","normalize","projectNormal","s","bouncyTension","bouncyFriction","quadraticOutInterpolation","b3Nobounce","startValue","endValue","n","start","end","linearInterpolation","t","b3Friction1","x","pow","b3Friction2","b3Friction3","SpringConfig","fromOrigamiTensionAndFriction","fromBouncinessAndSpeed","bouncyConversion","coastingConfigWithOrigamiFriction","DEFAULT_ORIGAMI_SPRING_CONFIG","PhysicsState","position","velocity","Spring","_startValue","_currentState","_displacementFromRestThreshold","_endValue","_overshootClampingEnabled","_previousState","_restSpeedThreshold","_tempState","_timeAccumulator","_wasAtRest","_id","_ID","_springSystem","destroy","deregisterSpring","getId","setSpringConfig","springConfig","_springConfig","getSpringConfig","setCurrentValue","currentValue","skipSetAtRest","setAtRest","notifyPositionUpdated","getStartValue","getCurrentValue","getCurrentDisplacementDistance","getDisplacementDistanceForState","state","abs","setEndValue","isAtRest","activateSpring","onChange","onSpringEndStateChange","getEndValue","setVelocity","getVelocity","setRestSpeedThreshold","restSpeedThreshold","getRestSpeedThreshold","setRestDisplacementThreshold","displacementFromRestThreshold","getRestDisplacementThreshold","setOvershootClampingEnabled","isOvershootClampingEnabled","isOvershooting","advance","realDeltaTime","adjustedDeltaTime","MAX_DELTA_TIME_SEC","tempPosition","tempVelocity","aVelocity","aAcceleration","bVelocity","bAcceleration","cVelocity","cAcceleration","dVelocity","dvdt","SOLVER_TIMESTEP_SEC","_interpolate","notifyActivate","notifyAtRest","onSpringActivate","onSpringUpdate","onSpringAtRest","systemShouldAdvance","wasAtRest","alpha","getListeners","newListener","listenerToRemove","currentValueIsApproximately","SpringSystem","looper","_activeSprings","_idleSpringIndices","_isIdle","_lastTimeMillis","_springRegistry","setLooper","createSpring","createSpringWithConfig","createSpringWithBouncinessAndSpeed","spring","registerSpring","getSpringById","id","getAllSprings","vals","deltaTime","pop","currentTimeMillis","ellapsedMillis","onBeforeIntegrate","onAfterIntegrate","springId","factory","TimeoutError","constructor","message","super","AbortError","getDOMException","errorMessage","globalThis","DOMException","getAbortedReason","signal","reason","_PriorityQueue_queue","__classPrivateFieldGet","receiver","kind","f","PriorityQueue","set","enqueue","options","element","priority","size","index","first","count","trunc","it","a","lowerBound","dequeue","shift","filter","map","WeakMap","_PQueue_instances","_PQueue_carryoverConcurrencyCount","_PQueue_isIntervalIgnored","_PQueue_intervalCount","_PQueue_intervalCap","_PQueue_interval","_PQueue_intervalEnd","_PQueue_intervalId","_PQueue_timeoutId","_PQueue_queue","_PQueue_queueClass","_PQueue_pendingCount","_PQueue_concurrency","_PQueue_isPaused","_PQueue_throwOnTimeout","_PQueue_doesIntervalAllowAnother_get","_PQueue_doesConcurrentAllowAnother_get","_PQueue_next","_PQueue_emitEvents","_PQueue_onResumeInterval","_PQueue_isIntervalPaused_get","_PQueue_tryToStartAnother","_PQueue_initializeIntervalIfNeeded","_PQueue_onInterval","_PQueue_processQueue","_PQueue_onEvent","__classPrivateFieldSet","timeoutError","PQueue","_a","_b","_c","_d","add","enumerable","configurable","writable","carryoverConcurrencyCount","intervalCap","Number","POSITIVE_INFINITY","interval","concurrency","autoStart","queueClass","isFinite","timeout","throwOnTimeout","newConcurrency","Promise","resolve","reject","async","aborted","operation","promise","milliseconds","fallback","timer","cancelablePromise","sign","customTimers","clearTimeout","error","clear","pTimeout","result","addAll","functions","all","function_","pause","onEmpty","onSizeLessThan","limit","onIdle","sizeBy","pending","isPaused","WeakSet","delay","clearInterval","canInitializeInterval","job","setInterval"],"sourceRoot":""}