three-render-objects 1.28.1 → 1.28.2

package/dist/three-render-objects.js

@@ -1,4 +1,4 @@
-// Version 1.28.1 three-render-objects - https://github.com/vasturiano/three-render-objects
+// Version 1.28.2 three-render-objects - https://github.com/vasturiano/three-render-objects
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('three')) :
   typeof define === 'function' && define.amd ? define(['three'], factory) :
@@ -162,6 +162,9 @@
   		this.minDistance = 0;
   		this.maxDistance = Infinity;
 
+  		this.minZoom = 0;
+  		this.maxZoom = Infinity;
+
   		this.keys = [ 'KeyA' /*A*/, 'KeyS' /*S*/, 'KeyD' /*D*/ ];
 
   		this.mouseButtons = { LEFT: three$1.MOUSE.ROTATE, MIDDLE: three$1.MOUSE.DOLLY, RIGHT: three$1.MOUSE.PAN };
@@ -324,8 +327,13 @@
 
   				} else if ( scope.object.isOrthographicCamera ) {
 
-  					scope.object.zoom /= factor;
-  					scope.object.updateProjectionMatrix();
+  						scope.object.zoom = three$1.MathUtils.clamp( scope.object.zoom / factor, scope.minZoom, scope.maxZoom );
+  						
+  						if ( lastZoom !== scope.object.zoom ) {
+
+  							scope.object.updateProjectionMatrix();
+  							
+  						}
 
   				} else {
 
@@ -345,8 +353,13 @@
 
   					} else if ( scope.object.isOrthographicCamera ) {
 
-  						scope.object.zoom /= factor;
-  						scope.object.updateProjectionMatrix();
+  						scope.object.zoom = three$1.MathUtils.clamp( scope.object.zoom / factor, scope.minZoom, scope.maxZoom );
+  						
+  						if ( lastZoom !== scope.object.zoom ) {
+
+  							scope.object.updateProjectionMatrix();
+  							
+  						}
 
   					} else {
 
@@ -930,7 +943,7 @@
 
   }
 
-  // This set of controls performs orbiting, dollying (zooming), and panning.
+  // OrbitControls performs orbiting, dollying (zooming), and panning.
   // Unlike TrackballControls, it maintains the "up" direction object.up (+Y by default).
   //
   //    Orbit - left mouse / touch: one-finger move
@@ -1046,6 +1059,13 @@
 
   		};
 
+  		this.stopListenToKeyEvents = function () {
+
+  			this._domElementKeyEvents.removeEventListener( 'keydown', onKeyDown );
+  			this._domElementKeyEvents = null;
+
+  		};
+
   		this.saveState = function () {
 
   			scope.target0.copy( scope.target );
@@ -1216,7 +1236,7 @@
   			scope.domElement.removeEventListener( 'contextmenu', onContextMenu );
 
   			scope.domElement.removeEventListener( 'pointerdown', onPointerDown );
-  			scope.domElement.removeEventListener( 'pointercancel', onPointerCancel );
+  			scope.domElement.removeEventListener( 'pointercancel', onPointerUp );
   			scope.domElement.removeEventListener( 'wheel', onMouseWheel );
 
   			scope.domElement.removeEventListener( 'pointermove', onPointerMove );
@@ -1226,6 +1246,7 @@
   			if ( scope._domElementKeyEvents !== null ) {
 
   				scope._domElementKeyEvents.removeEventListener( 'keydown', onKeyDown );
+  				scope._domElementKeyEvents = null;
 
   			}
 
@@ -1797,26 +1818,20 @@
 
   		function onPointerUp( event ) {
 
-  		    removePointer( event );
-
-  		    if ( pointers.length === 0 ) {
-
-  		        scope.domElement.releasePointerCapture( event.pointerId );
-
-  		        scope.domElement.removeEventListener( 'pointermove', onPointerMove );
-  		        scope.domElement.removeEventListener( 'pointerup', onPointerUp );
+  			removePointer( event );
 
-  		    }
+  			if ( pointers.length === 0 ) {
 
-  		    scope.dispatchEvent( _endEvent );
+  				scope.domElement.releasePointerCapture( event.pointerId );
 
-  		    state = STATE.NONE;
+  				scope.domElement.removeEventListener( 'pointermove', onPointerMove );
+  				scope.domElement.removeEventListener( 'pointerup', onPointerUp );
 
-  		}
+  			}
 
-  		function onPointerCancel( event ) {
+  			scope.dispatchEvent( _endEvent );
 
-  			removePointer( event );
+  			state = STATE.NONE;
 
   		}
 
@@ -2168,7 +2183,7 @@
   		scope.domElement.addEventListener( 'contextmenu', onContextMenu );
 
   		scope.domElement.addEventListener( 'pointerdown', onPointerDown );
-  		scope.domElement.addEventListener( 'pointercancel', onPointerCancel );
+  		scope.domElement.addEventListener( 'pointercancel', onPointerUp );
   		scope.domElement.addEventListener( 'wheel', onMouseWheel, { passive: false } );
 
   		// force an update at start
@@ -2502,6 +2517,8 @@
 
   	constructor() {
 
+  		this.isPass = true;
+
   		// if set to true, the pass is processed by the composer
   		this.enabled = true;
 
@@ -3788,13 +3805,22 @@
   /**
    * The Ease class provides a collection of easing functions for use with tween.js.
    */
-  var Easing = {
-      Linear: {
+  var Easing = Object.freeze({
+      Linear: Object.freeze({
           None: function (amount) {
               return amount;
           },
-      },
-      Quadratic: {
+          In: function (amount) {
+              return this.None(amount);
+          },
+          Out: function (amount) {
+              return this.None(amount);
+          },
+          InOut: function (amount) {
+              return this.None(amount);
+          },
+      }),
+      Quadratic: Object.freeze({
           In: function (amount) {
               return amount * amount;
           },
@@ -3807,8 +3833,8 @@
               }
               return -0.5 * (--amount * (amount - 2) - 1);
           },
-      },
-      Cubic: {
+      }),
+      Cubic: Object.freeze({
           In: function (amount) {
               return amount * amount * amount;
           },
@@ -3821,8 +3847,8 @@
               }
               return 0.5 * ((amount -= 2) * amount * amount + 2);
           },
-      },
-      Quartic: {
+      }),
+      Quartic: Object.freeze({
           In: function (amount) {
               return amount * amount * amount * amount;
           },
@@ -3835,8 +3861,8 @@
               }
               return -0.5 * ((amount -= 2) * amount * amount * amount - 2);
           },
-      },
-      Quintic: {
+      }),
+      Quintic: Object.freeze({
           In: function (amount) {
               return amount * amount * amount * amount * amount;
           },
@@ -3849,19 +3875,19 @@
               }
               return 0.5 * ((amount -= 2) * amount * amount * amount * amount + 2);
           },
-      },
-      Sinusoidal: {
+      }),
+      Sinusoidal: Object.freeze({
           In: function (amount) {
-              return 1 - Math.cos((amount * Math.PI) / 2);
+              return 1 - Math.sin(((1.0 - amount) * Math.PI) / 2);
           },
           Out: function (amount) {
               return Math.sin((amount * Math.PI) / 2);
           },
           InOut: function (amount) {
-              return 0.5 * (1 - Math.cos(Math.PI * amount));
+              return 0.5 * (1 - Math.sin(Math.PI * (0.5 - amount)));
           },
-      },
-      Exponential: {
+      }),
+      Exponential: Object.freeze({
           In: function (amount) {
               return amount === 0 ? 0 : Math.pow(1024, amount - 1);
           },
@@ -3880,8 +3906,8 @@
               }
               return 0.5 * (-Math.pow(2, -10 * (amount - 1)) + 2);
           },
-      },
-      Circular: {
+      }),
+      Circular: Object.freeze({
           In: function (amount) {
               return 1 - Math.sqrt(1 - amount * amount);
           },
@@ -3894,8 +3920,8 @@
               }
               return 0.5 * (Math.sqrt(1 - (amount -= 2) * amount) + 1);
           },
-      },
-      Elastic: {
+      }),
+      Elastic: Object.freeze({
           In: function (amount) {
               if (amount === 0) {
                   return 0;
@@ -3927,15 +3953,15 @@
               }
               return 0.5 * Math.pow(2, -10 * (amount - 1)) * Math.sin((amount - 1.1) * 5 * Math.PI) + 1;
           },
-      },
-      Back: {
+      }),
+      Back: Object.freeze({
           In: function (amount) {
               var s = 1.70158;
-              return amount * amount * ((s + 1) * amount - s);
+              return amount === 1 ? 1 : amount * amount * ((s + 1) * amount - s);
           },
           Out: function (amount) {
               var s = 1.70158;
-              return --amount * amount * ((s + 1) * amount + s) + 1;
+              return amount === 0 ? 0 : --amount * amount * ((s + 1) * amount + s) + 1;
           },
           InOut: function (amount) {
               var s = 1.70158 * 1.525;
@@ -3944,8 +3970,8 @@
               }
               return 0.5 * ((amount -= 2) * amount * ((s + 1) * amount + s) + 2);
           },
-      },
-      Bounce: {
+      }),
+      Bounce: Object.freeze({
           In: function (amount) {
               return 1 - Easing.Bounce.Out(1 - amount);
           },
@@ -3969,16 +3995,35 @@
               }
               return Easing.Bounce.Out(amount * 2 - 1) * 0.5 + 0.5;
           },
+      }),
+      generatePow: function (power) {
+          if (power === void 0) { power = 4; }
+          power = power < Number.EPSILON ? Number.EPSILON : power;
+          power = power > 10000 ? 10000 : power;
+          return {
+              In: function (amount) {
+                  return Math.pow(amount, power);
+              },
+              Out: function (amount) {
+                  return 1 - Math.pow((1 - amount), power);
+              },
+              InOut: function (amount) {
+                  if (amount < 0.5) {
+                      return Math.pow((amount * 2), power) / 2;
+                  }
+                  return (1 - Math.pow((2 - amount * 2), power)) / 2 + 0.5;
+              },
+          };
       },
-  };
+  });
 
-  var now;
+  var now$2;
   // Include a performance.now polyfill.
   // In node.js, use process.hrtime.
   // eslint-disable-next-line
   // @ts-ignore
   if (typeof self === 'undefined' && typeof process !== 'undefined' && process.hrtime) {
-      now = function () {
+      now$2 = function () {
           // eslint-disable-next-line
           // @ts-ignore
           var time = process.hrtime();
@@ -3990,19 +4035,19 @@
   else if (typeof self !== 'undefined' && self.performance !== undefined && self.performance.now !== undefined) {
       // This must be bound, because directly assigning this function
       // leads to an invocation exception in Chrome.
-      now = self.performance.now.bind(self.performance);
+      now$2 = self.performance.now.bind(self.performance);
   }
   // Use Date.now if it is available.
   else if (Date.now !== undefined) {
-      now = Date.now;
+      now$2 = Date.now;
   }
   // Otherwise, use 'new Date().getTime()'.
   else {
-      now = function () {
+      now$2 = function () {
           return new Date().getTime();
       };
   }
-  var now$1 = now;
+  var now$1$1 = now$2;
 
   /**
    * Controlling groups of tweens
@@ -4033,7 +4078,7 @@
           delete this._tweensAddedDuringUpdate[tween.getId()];
       };
       Group.prototype.update = function (time, preserve) {
-          if (time === void 0) { time = now$1(); }
+          if (time === void 0) { time = now$1$1(); }
           if (preserve === void 0) { preserve = false; }
           var tweenIds = Object.keys(this._tweens);
           if (tweenIds.length === 0) {
@@ -4183,8 +4228,10 @@
           this._startTime = 0;
           this._easingFunction = Easing.Linear.None;
           this._interpolationFunction = Interpolation.Linear;
+          // eslint-disable-next-line
           this._chainedTweens = [];
           this._onStartCallbackFired = false;
+          this._onEveryStartCallbackFired = false;
           this._id = Sequence.nextId();
           this._isChainStopped = false;
           this._goToEnd = false;
@@ -4210,10 +4257,13 @@
           return this;
       };
       Tween.prototype.duration = function (d) {
+          if (d === void 0) { d = 1000; }
           this._duration = d;
           return this;
       };
-      Tween.prototype.start = function (time) {
+      Tween.prototype.start = function (time, overrideStartingValues) {
+          if (time === void 0) { time = now$1$1(); }
+          if (overrideStartingValues === void 0) { overrideStartingValues = false; }
           if (this._isPlaying) {
               return this;
           }
@@ -4232,13 +4282,17 @@
           this._isPlaying = true;
           this._isPaused = false;
           this._onStartCallbackFired = false;
+          this._onEveryStartCallbackFired = false;
           this._isChainStopped = false;
-          this._startTime = time !== undefined ? (typeof time === 'string' ? now$1() + parseFloat(time) : time) : now$1();
+          this._startTime = time;
           this._startTime += this._delayTime;
-          this._setupProperties(this._object, this._valuesStart, this._valuesEnd, this._valuesStartRepeat);
+          this._setupProperties(this._object, this._valuesStart, this._valuesEnd, this._valuesStartRepeat, overrideStartingValues);
           return this;
       };
-      Tween.prototype._setupProperties = function (_object, _valuesStart, _valuesEnd, _valuesStartRepeat) {
+      Tween.prototype.startFromCurrentValues = function (time) {
+          return this.start(time, true);
+      };
+      Tween.prototype._setupProperties = function (_object, _valuesStart, _valuesEnd, _valuesStartRepeat, overrideStartingValues) {
           for (var property in _valuesEnd) {
               var startValue = _object[property];
               var startValueIsArray = Array.isArray(startValue);
@@ -4258,7 +4312,9 @@
                   // handle an array of relative values
                   endValues = endValues.map(this._handleRelativeValue.bind(this, startValue));
                   // Create a local copy of the Array with the start value at the front
-                  _valuesEnd[property] = [startValue].concat(endValues);
+                  if (_valuesStart[property] === undefined) {
+                      _valuesEnd[property] = [startValue].concat(endValues);
+                  }
               }
               // handle the deepness of the values
               if ((propType === 'object' || startValueIsArray) && startValue && !isInterpolationList) {
@@ -4272,11 +4328,11 @@
                   _valuesStartRepeat[property] = startValueIsArray ? [] : {}; // TODO? repeat nested values? And yoyo? And array values?
                   // eslint-disable-next-line
                   // @ts-ignore FIXME?
-                  this._setupProperties(startValue, _valuesStart[property], _valuesEnd[property], _valuesStartRepeat[property]);
+                  this._setupProperties(startValue, _valuesStart[property], _valuesEnd[property], _valuesStartRepeat[property], overrideStartingValues);
               }
               else {
-                  // Save the starting value, but only once.
-                  if (typeof _valuesStart[property] === 'undefined') {
+                  // Save the starting value, but only once unless override is requested.
+                  if (typeof _valuesStart[property] === 'undefined' || overrideStartingValues) {
                       _valuesStart[property] = startValue;
                   }
                   if (!startValueIsArray) {
@@ -4318,7 +4374,7 @@
           return this;
       };
       Tween.prototype.pause = function (time) {
-          if (time === void 0) { time = now$1(); }
+          if (time === void 0) { time = now$1$1(); }
           if (this._isPaused || !this._isPlaying) {
               return this;
           }
@@ -4329,7 +4385,7 @@
           return this;
       };
       Tween.prototype.resume = function (time) {
-          if (time === void 0) { time = now$1(); }
+          if (time === void 0) { time = now$1$1(); }
           if (!this._isPaused || !this._isPlaying) {
               return this;
           }
@@ -4347,14 +4403,17 @@
           return this;
       };
       Tween.prototype.group = function (group) {
+          if (group === void 0) { group = mainGroup; }
           this._group = group;
           return this;
       };
       Tween.prototype.delay = function (amount) {
+          if (amount === void 0) { amount = 0; }
           this._delayTime = amount;
           return this;
       };
       Tween.prototype.repeat = function (times) {
+          if (times === void 0) { times = 0; }
           this._initialRepeat = times;
           this._repeat = times;
           return this;
@@ -4364,17 +4423,21 @@
           return this;
       };
       Tween.prototype.yoyo = function (yoyo) {
+          if (yoyo === void 0) { yoyo = false; }
           this._yoyo = yoyo;
           return this;
       };
       Tween.prototype.easing = function (easingFunction) {
+          if (easingFunction === void 0) { easingFunction = Easing.Linear.None; }
           this._easingFunction = easingFunction;
           return this;
       };
       Tween.prototype.interpolation = function (interpolationFunction) {
+          if (interpolationFunction === void 0) { interpolationFunction = Interpolation.Linear; }
           this._interpolationFunction = interpolationFunction;
           return this;
       };
+      // eslint-disable-next-line
       Tween.prototype.chain = function () {
           var tweens = [];
           for (var _i = 0; _i < arguments.length; _i++) {
@@ -4387,6 +4450,10 @@
           this._onStartCallback = callback;
           return this;
       };
+      Tween.prototype.onEveryStart = function (callback) {
+          this._onEveryStartCallback = callback;
+          return this;
+      };
       Tween.prototype.onUpdate = function (callback) {
           this._onUpdateCallback = callback;
           return this;
@@ -4409,7 +4476,7 @@
        * it is still playing, just paused).
        */
       Tween.prototype.update = function (time, autoStart) {
-          if (time === void 0) { time = now$1(); }
+          if (time === void 0) { time = now$1$1(); }
           if (autoStart === void 0) { autoStart = true; }
           if (this._isPaused)
               return true;
@@ -4420,7 +4487,7 @@
               if (time > endTime)
                   return false;
               if (autoStart)
-                  this.start(time);
+                  this.start(time, true);
           }
           this._goToEnd = false;
           if (time < this._startTime) {
@@ -4432,6 +4499,12 @@
               }
               this._onStartCallbackFired = true;
           }
+          if (this._onEveryStartCallbackFired === false) {
+              if (this._onEveryStartCallback) {
+                  this._onEveryStartCallback(this._object);
+              }
+              this._onEveryStartCallbackFired = true;
+          }
           elapsed = (time - this._startTime) / this._duration;
           elapsed = this._duration === 0 || elapsed > 1 ? 1 : elapsed;
           var value = this._easingFunction(elapsed);
@@ -4470,6 +4543,7 @@
                   if (this._onRepeatCallback) {
                       this._onRepeatCallback(this._object);
                   }
+                  this._onEveryStartCallbackFired = false;
                   return true;
               }
               else {
@@ -4479,7 +4553,7 @@
                   for (var i = 0, numChainedTweens = this._chainedTweens.length; i < numChainedTweens; i++) {
                       // Make the chained tweens start exactly at the time they should,
                       // even if the `update()` method was called way past the duration of the tween
-                      this._chainedTweens[i].start(this._startTime + this._duration);
+                      this._chainedTweens[i].start(this._startTime + this._duration, false);
                   }
                   this._isPlaying = false;
                   return false;
@@ -4543,7 +4617,7 @@
       return Tween;
   }());
 
-  var VERSION = '18.6.4';
+  var VERSION = '19.0.0';
 
   /**
    * Tween.js - Licensed under the MIT license
@@ -4574,7 +4648,7 @@
       Easing: Easing,
       Group: Group,
       Interpolation: Interpolation,
-      now: now$1,
+      now: now$1$1,
       Sequence: Sequence,
       nextId: nextId,
       Tween: Tween,
@@ -4596,75 +4670,494 @@
     };
   }); // constant
 
+  /** Detect free variable `global` from Node.js. */
+  var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;
+
+  var freeGlobal$1 = freeGlobal;
+
+  /** Detect free variable `self`. */
+  var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
+
+  /** Used as a reference to the global object. */
+  var root = freeGlobal$1 || freeSelf || Function('return this')();
+
+  var root$1 = root;
+
+  /** Built-in value references. */
+  var Symbol$1 = root$1.Symbol;
+
+  var Symbol$2 = Symbol$1;
+
+  /** Used for built-in method references. */
+  var objectProto$1 = Object.prototype;
+
+  /** Used to check objects for own properties. */
+  var hasOwnProperty = objectProto$1.hasOwnProperty;
+
   /**
-   * Returns a function, that, as long as it continues to be invoked, will not
-   * be triggered. The function will be called after it stops being called for
-   * N milliseconds. If `immediate` is passed, trigger the function on the
-   * leading edge, instead of the trailing. The function also has a property 'clear' 
-   * that is a function which will clear the timer to prevent previously scheduled executions. 
-   *
-   * @source underscore.js
-   * @see http://unscriptable.com/2009/03/20/debouncing-javascript-methods/
-   * @param {Function} function to wrap
-   * @param {Number} timeout in ms (`100`)
-   * @param {Boolean} whether to execute at the beginning (`false`)
-   * @api public
+   * Used to resolve the
+   * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+   * of values.
    */
+  var nativeObjectToString$1 = objectProto$1.toString;
 
-  function debounce(func, wait, immediate){
-    var timeout, args, context, timestamp, result;
-    if (null == wait) wait = 100;
+  /** Built-in value references. */
+  var symToStringTag$1 = Symbol$2 ? Symbol$2.toStringTag : undefined;
 
-    function later() {
-      var last = Date.now() - timestamp;
+  /**
+   * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
+   *
+   * @private
+   * @param {*} value The value to query.
+   * @returns {string} Returns the raw `toStringTag`.
+   */
+  function getRawTag(value) {
+    var isOwn = hasOwnProperty.call(value, symToStringTag$1),
+        tag = value[symToStringTag$1];
 
-      if (last < wait && last >= 0) {
-        timeout = setTimeout(later, wait - last);
+    try {
+      value[symToStringTag$1] = undefined;
+      var unmasked = true;
+    } catch (e) {}
+
+    var result = nativeObjectToString$1.call(value);
+    if (unmasked) {
+      if (isOwn) {
+        value[symToStringTag$1] = tag;
       } else {
-        timeout = null;
-        if (!immediate) {
-          result = func.apply(context, args);
-          context = args = null;
-        }
+        delete value[symToStringTag$1];
       }
     }
-    var debounced = function(){
-      context = this;
-      args = arguments;
-      timestamp = Date.now();
-      var callNow = immediate && !timeout;
-      if (!timeout) timeout = setTimeout(later, wait);
-      if (callNow) {
-        result = func.apply(context, args);
-        context = args = null;
-      }
+    return result;
+  }
+
+  /** Used for built-in method references. */
+  var objectProto = Object.prototype;
+
+  /**
+   * Used to resolve the
+   * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+   * of values.
+   */
+  var nativeObjectToString = objectProto.toString;
+
+  /**
+   * Converts `value` to a string using `Object.prototype.toString`.
+   *
+   * @private
+   * @param {*} value The value to convert.
+   * @returns {string} Returns the converted string.
+   */
+  function objectToString(value) {
+    return nativeObjectToString.call(value);
+  }
+
+  /** `Object#toString` result references. */
+  var nullTag = '[object Null]',
+      undefinedTag = '[object Undefined]';
+
+  /** Built-in value references. */
+  var symToStringTag = Symbol$2 ? Symbol$2.toStringTag : undefined;
+
+  /**
+   * The base implementation of `getTag` without fallbacks for buggy environments.
+   *
+   * @private
+   * @param {*} value The value to query.
+   * @returns {string} Returns the `toStringTag`.
+   */
+  function baseGetTag(value) {
+    if (value == null) {
+      return value === undefined ? undefinedTag : nullTag;
+    }
+    return (symToStringTag && symToStringTag in Object(value))
+      ? getRawTag(value)
+      : objectToString(value);
+  }
+
+  /**
+   * Checks if `value` is object-like. A value is object-like if it's not `null`
+   * and has a `typeof` result of "object".
+   *
+   * @static
+   * @memberOf _
+   * @since 4.0.0
+   * @category Lang
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+   * @example
+   *
+   * _.isObjectLike({});
+   * // => true
+   *
+   * _.isObjectLike([1, 2, 3]);
+   * // => true
+   *
+   * _.isObjectLike(_.noop);
+   * // => false
+   *
+   * _.isObjectLike(null);
+   * // => false
+   */
+  function isObjectLike(value) {
+    return value != null && typeof value == 'object';
+  }
+
+  /** `Object#toString` result references. */
+  var symbolTag = '[object Symbol]';
+
+  /**
+   * Checks if `value` is classified as a `Symbol` primitive or object.
+   *
+   * @static
+   * @memberOf _
+   * @since 4.0.0
+   * @category Lang
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
+   * @example
+   *
+   * _.isSymbol(Symbol.iterator);
+   * // => true
+   *
+   * _.isSymbol('abc');
+   * // => false
+   */
+  function isSymbol(value) {
+    return typeof value == 'symbol' ||
+      (isObjectLike(value) && baseGetTag(value) == symbolTag);
+  }
+
+  /** Used to match a single whitespace character. */
+  var reWhitespace = /\s/;
+
+  /**
+   * Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace
+   * character of `string`.
+   *
+   * @private
+   * @param {string} string The string to inspect.
+   * @returns {number} Returns the index of the last non-whitespace character.
+   */
+  function trimmedEndIndex(string) {
+    var index = string.length;
+
+    while (index-- && reWhitespace.test(string.charAt(index))) {}
+    return index;
+  }
+
+  /** Used to match leading whitespace. */
+  var reTrimStart = /^\s+/;
+
+  /**
+   * The base implementation of `_.trim`.
+   *
+   * @private
+   * @param {string} string The string to trim.
+   * @returns {string} Returns the trimmed string.
+   */
+  function baseTrim(string) {
+    return string
+      ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, '')
+      : string;
+  }
+
+  /**
+   * Checks if `value` is the
+   * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
+   * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+   *
+   * @static
+   * @memberOf _
+   * @since 0.1.0
+   * @category Lang
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is an object, else `false`.
+   * @example
+   *
+   * _.isObject({});
+   * // => true
+   *
+   * _.isObject([1, 2, 3]);
+   * // => true
+   *
+   * _.isObject(_.noop);
+   * // => true
+   *
+   * _.isObject(null);
+   * // => false
+   */
+  function isObject(value) {
+    var type = typeof value;
+    return value != null && (type == 'object' || type == 'function');
+  }
+
+  /** Used as references for various `Number` constants. */
+  var NAN = 0 / 0;
+
+  /** Used to detect bad signed hexadecimal string values. */
+  var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
+
+  /** Used to detect binary string values. */
+  var reIsBinary = /^0b[01]+$/i;
+
+  /** Used to detect octal string values. */
+  var reIsOctal = /^0o[0-7]+$/i;
+
+  /** Built-in method references without a dependency on `root`. */
+  var freeParseInt = parseInt;
+
+  /**
+   * Converts `value` to a number.
+   *
+   * @static
+   * @memberOf _
+   * @since 4.0.0
+   * @category Lang
+   * @param {*} value The value to process.
+   * @returns {number} Returns the number.
+   * @example
+   *
+   * _.toNumber(3.2);
+   * // => 3.2
+   *
+   * _.toNumber(Number.MIN_VALUE);
+   * // => 5e-324
+   *
+   * _.toNumber(Infinity);
+   * // => Infinity
+   *
+   * _.toNumber('3.2');
+   * // => 3.2
+   */
+  function toNumber(value) {
+    if (typeof value == 'number') {
+      return value;
+    }
+    if (isSymbol(value)) {
+      return NAN;
+    }
+    if (isObject(value)) {
+      var other = typeof value.valueOf == 'function' ? value.valueOf() : value;
+      value = isObject(other) ? (other + '') : other;
+    }
+    if (typeof value != 'string') {
+      return value === 0 ? value : +value;
+    }
+    value = baseTrim(value);
+    var isBinary = reIsBinary.test(value);
+    return (isBinary || reIsOctal.test(value))
+      ? freeParseInt(value.slice(2), isBinary ? 2 : 8)
+      : (reIsBadHex.test(value) ? NAN : +value);
+  }
+
+  /**
+   * Gets the timestamp of the number of milliseconds that have elapsed since
+   * the Unix epoch (1 January 1970 00:00:00 UTC).
+   *
+   * @static
+   * @memberOf _
+   * @since 2.4.0
+   * @category Date
+   * @returns {number} Returns the timestamp.
+   * @example
+   *
+   * _.defer(function(stamp) {
+   *   console.log(_.now() - stamp);
+   * }, _.now());
+   * // => Logs the number of milliseconds it took for the deferred invocation.
+   */
+  var now = function() {
+    return root$1.Date.now();
+  };
+
+  var now$1 = now;
+
+  /** Error message constants. */
+  var FUNC_ERROR_TEXT = 'Expected a function';
+
+  /* Built-in method references for those with the same name as other `lodash` methods. */
+  var nativeMax = Math.max,
+      nativeMin = Math.min;
 
+  /**
+   * Creates a debounced function that delays invoking `func` until after `wait`
+   * milliseconds have elapsed since the last time the debounced function was
+   * invoked. The debounced function comes with a `cancel` method to cancel
+   * delayed `func` invocations and a `flush` method to immediately invoke them.
+   * Provide `options` to indicate whether `func` should be invoked on the
+   * leading and/or trailing edge of the `wait` timeout. The `func` is invoked
+   * with the last arguments provided to the debounced function. Subsequent
+   * calls to the debounced function return the result of the last `func`
+   * invocation.
+   *
+   * **Note:** If `leading` and `trailing` options are `true`, `func` is
+   * invoked on the trailing edge of the timeout only if the debounced function
+   * is invoked more than once during the `wait` timeout.
+   *
+   * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
+   * until to the next tick, similar to `setTimeout` with a timeout of `0`.
+   *
+   * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
+   * for details over the differences between `_.debounce` and `_.throttle`.
+   *
+   * @static
+   * @memberOf _
+   * @since 0.1.0
+   * @category Function
+   * @param {Function} func The function to debounce.
+   * @param {number} [wait=0] The number of milliseconds to delay.
+   * @param {Object} [options={}] The options object.
+   * @param {boolean} [options.leading=false]
+   *  Specify invoking on the leading edge of the timeout.
+   * @param {number} [options.maxWait]
+   *  The maximum time `func` is allowed to be delayed before it's invoked.
+   * @param {boolean} [options.trailing=true]
+   *  Specify invoking on the trailing edge of the timeout.
+   * @returns {Function} Returns the new debounced function.
+   * @example
+   *
+   * // Avoid costly calculations while the window size is in flux.
+   * jQuery(window).on('resize', _.debounce(calculateLayout, 150));
+   *
+   * // Invoke `sendMail` when clicked, debouncing subsequent calls.
+   * jQuery(element).on('click', _.debounce(sendMail, 300, {
+   *   'leading': true,
+   *   'trailing': false
+   * }));
+   *
+   * // Ensure `batchLog` is invoked once after 1 second of debounced calls.
+   * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });
+   * var source = new EventSource('/stream');
+   * jQuery(source).on('message', debounced);
+   *
+   * // Cancel the trailing debounced invocation.
+   * jQuery(window).on('popstate', debounced.cancel);
+   */
+  function debounce(func, wait, options) {
+    var lastArgs,
+        lastThis,
+        maxWait,
+        result,
+        timerId,
+        lastCallTime,
+        lastInvokeTime = 0,
+        leading = false,
+        maxing = false,
+        trailing = true;
+
+    if (typeof func != 'function') {
+      throw new TypeError(FUNC_ERROR_TEXT);
+    }
+    wait = toNumber(wait) || 0;
+    if (isObject(options)) {
+      leading = !!options.leading;
+      maxing = 'maxWait' in options;
+      maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;
+      trailing = 'trailing' in options ? !!options.trailing : trailing;
+    }
+
+    function invokeFunc(time) {
+      var args = lastArgs,
+          thisArg = lastThis;
+
+      lastArgs = lastThis = undefined;
+      lastInvokeTime = time;
+      result = func.apply(thisArg, args);
       return result;
-    };
+    }
+
+    function leadingEdge(time) {
+      // Reset any `maxWait` timer.
+      lastInvokeTime = time;
+      // Start the timer for the trailing edge.
+      timerId = setTimeout(timerExpired, wait);
+      // Invoke the leading edge.
+      return leading ? invokeFunc(time) : result;
+    }
+
+    function remainingWait(time) {
+      var timeSinceLastCall = time - lastCallTime,
+          timeSinceLastInvoke = time - lastInvokeTime,
+          timeWaiting = wait - timeSinceLastCall;
 
-    debounced.clear = function() {
-      if (timeout) {
-        clearTimeout(timeout);
-        timeout = null;
+      return maxing
+        ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke)
+        : timeWaiting;
+    }
+
+    function shouldInvoke(time) {
+      var timeSinceLastCall = time - lastCallTime,
+          timeSinceLastInvoke = time - lastInvokeTime;
+
+      // Either this is the first call, activity has stopped and we're at the
+      // trailing edge, the system time has gone backwards and we're treating
+      // it as the trailing edge, or we've hit the `maxWait` limit.
+      return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||
+        (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));
+    }
+
+    function timerExpired() {
+      var time = now$1();
+      if (shouldInvoke(time)) {
+        return trailingEdge(time);
       }
-    };
-    
-    debounced.flush = function() {
-      if (timeout) {
-        result = func.apply(context, args);
-        context = args = null;
-        
-        clearTimeout(timeout);
-        timeout = null;
+      // Restart the timer.
+      timerId = setTimeout(timerExpired, remainingWait(time));
+    }
+
+    function trailingEdge(time) {
+      timerId = undefined;
+
+      // Only invoke if we have `lastArgs` which means `func` has been
+      // debounced at least once.
+      if (trailing && lastArgs) {
+        return invokeFunc(time);
       }
-    };
+      lastArgs = lastThis = undefined;
+      return result;
+    }
+
+    function cancel() {
+      if (timerId !== undefined) {
+        clearTimeout(timerId);
+      }
+      lastInvokeTime = 0;
+      lastArgs = lastCallTime = lastThis = timerId = undefined;
+    }
+
+    function flush() {
+      return timerId === undefined ? result : trailingEdge(now$1());
+    }
 
+    function debounced() {
+      var time = now$1(),
+          isInvoking = shouldInvoke(time);
+
+      lastArgs = arguments;
+      lastThis = this;
+      lastCallTime = time;
+
+      if (isInvoking) {
+        if (timerId === undefined) {
+          return leadingEdge(lastCallTime);
+        }
+        if (maxing) {
+          // Handle invocations in a tight loop.
+          clearTimeout(timerId);
+          timerId = setTimeout(timerExpired, wait);
+          return invokeFunc(lastCallTime);
+        }
+      }
+      if (timerId === undefined) {
+        timerId = setTimeout(timerExpired, wait);
+      }
+      return result;
+    }
+    debounced.cancel = cancel;
+    debounced.flush = flush;
     return debounced;
   }
-  // Adds compatibility for ES modules
-  debounce.debounce = debounce;
-
-  var debounce_1 = debounce;
 
   function _iterableToArrayLimit(arr, i) {
     var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"];
@@ -4806,7 +5299,7 @@
         initFn.call(comp, nodeElement, state, options);
         state.initialised = true;
       };
-      var digest = debounce_1(function () {
+      var digest = debounce(function () {
         if (!state.initialised) {
           return;
         }