docs: function tick (timestamp) {
          /* An empty timestamp argument indicates that this is the first tick occurence since ticking was turned on.
             We leverage this metadata to fully ignore the first tick pass since RAF's initial pass is fired whenever
             the browser's next tick sync time occurs, which results in the first elements subjected to Velocity
             calls being animated out of sync with any elements animated immediately thereafter. In short, we ignore
             the first RAF tick pass so that elements being immediately consecutively animated -- instead of simultaneously animated
             by the same Velocity call -- are properly batched into the same initial RAF tick and consequently remain in sync thereafter. */
          if (timestamp) {
              /* We ignore RAF's high resolution timestamp since it can be significantly offset when the browser is
                 under high stress; we opt for choppiness over allowing the browser to drop huge chunks of frames. */
              var timeCurrent = (new Date).getTime();
  
              /********************
                 Call Iteration
              ********************/
  
              /* Iterate through each active call. */
              for (var i = 0, callsLength = Velocity.State.calls.length; i < callsLength; i++) {
                  /* When a velocity call is completed, its Velocity.State.calls entry is set to false. Continue on to the next call. */
                  if (!Velocity.State.calls[i]) {
                      continue;
                  }
  
                  /************************
                     Call-Wide Variables
                  ************************/
  
                  var callContainer = Velocity.State.calls[i],
                      call = callContainer[0],
                      opts = callContainer[2],
                      timeStart = callContainer[3];
  
                  /* If timeStart is undefined, then this is the first time that this call has been processed by tick().
                     We assign timeStart now so that its value is as close to the real animation start time as possible.
                     (Conversely, had timeStart been defined when this call was added to Velocity.State.calls, the delay
                     between that time and now would cause the first few frames of the tween to be skipped since
                     percentComplete is calculated relative to timeStart.) */
                  /* Further, subtract 16ms (the approximate resolution of RAF) from the current time value so that the
                     first tick iteration isn't wasted by animating at 0% tween completion, which would produce the
                     same style value as the element's current value. */
                  if (!timeStart) {
                      timeStart = Velocity.State.calls[i][3] = timeCurrent - 16;
                  }
  
                  /* The tween's completion percentage is relative to the tween's start time, not the tween's start value
                     (which would result in unpredictable tween durations since JavaScript's timers are not particularly accurate).
                     Accordingly, we ensure that percentComplete does not exceed 1. */
                  var percentComplete = Math.min((timeCurrent - timeStart) / opts.duration, 1);
  
                  /**********************
                     Element Iteration
                  **********************/
  
                  /* For every call, iterate through each of the elements in its set. */
                  for (var j = 0, callLength = call.length; j < callLength; j++) {
                      var tweensContainer = call[j],
                          element = tweensContainer.element;
  
                      /* Check to see if this element has been deleted midway through the animation by checking for the
                         continued existence of its data cache. If it's gone, skip animating this element. */
                      if (!Data(element)) {
                          continue;
                      }
  
                      var transformPropertyExists = false;
  
                      /**********************************
                         Display & Visibility Toggling
                      **********************************/
  
                      /* If the display option is set to non-"none", set it upfront so that the element can become visible before tweening begins.
                         (Otherwise, display's "none" value is set in completeCall() once the animation has completed.) */
                      if (opts.display && opts.display !== "none") {
                          CSS.setPropertyValue(element, "display", opts.display);
                      }
  
                      /* Same goes with the visibility option, but its "none" equivalent is "hidden". */
                      if (opts.visibility && opts.visibility !== "hidden") {
                          CSS.setPropertyValue(element, "visibility", opts.visibility);
                      }
  
                      /************************
                         Property Iteration
                      ************************/
  
                      /* For every element, iterate through each property. */
                      for (var property in tweensContainer) {
                          /* Note: In addition to property tween data, tweensContainer contains a reference to its associated element. */
                          if (property !== "element") {
                              var tween = tweensContainer[property],
                                  currentValue,
                                  /* Easing can either be a pre-genereated function or a string that references a pre-registered easing
                                     on the Velocity.Easings object. In either case, return the appropriate easing *function*. */
                                  easing = Type.isString(tween.easing) ? Velocity.Easings[tween.easing] : tween.easing;
  
                              /******************************
                                 Current Value Calculation
                              ******************************/
  
                              /* If this is the last tick pass (if we've reached 100% completion for this tween),
                                 ensure that currentValue is explicitly set to its target endValue so that it's not subjected to any rounding. */
                              if (percentComplete === 1) {
                                  currentValue = tween.endValue;
                              /* Otherwise, calculate currentValue based on the current delta from startValue. */
                              } else {
                                  currentValue = tween.startValue + ((tween.endValue - tween.startValue) * easing(percentComplete));
                              }
  
                              tween.currentValue = currentValue;
  
                              /******************
                                 Hooks: Part I
                              ******************/
  
                              /* For hooked properties, the newly-updated rootPropertyValueCache is cached onto the element so that it can be used
                                 for subsequent hooks in this call that are associated with the same root property. If we didn't cache the updated
                                 rootPropertyValue, each subsequent update to the root property in this tick pass would reset the previous hook's
                                 updates to rootPropertyValue prior to injection. A nice performance byproduct of rootPropertyValue caching is that
                                 subsequently chained animations using the same hookRoot but a different hook can use this cached rootPropertyValue. */
                              if (CSS.Hooks.registered[property]) {
                                  var hookRoot = CSS.Hooks.getRoot(property),
                                      rootPropertyValueCache = Data(element).rootPropertyValueCache[hookRoot];
  
                                  if (rootPropertyValueCache) {
                                      tween.rootPropertyValue = rootPropertyValueCache;
                                  }
                              }
  
                              /*****************
                                  DOM Update
                              *****************/
  
                              /* setPropertyValue() returns an array of the property name and property value post any normalization that may have been performed. */
                              /* Note: To solve an IE<=8 positioning bug, the unit type is dropped when setting a property value of 0. */
                              var adjustedSetData = CSS.setPropertyValue(element, /* SET */
                                                                         property,
                                                                         tween.currentValue + (parseFloat(currentValue) === 0 ? "" : tween.unitType),
                                                                         tween.rootPropertyValue,
                                                                         tween.scrollData);
  
                              /*******************
                                 Hooks: Part II
                              *******************/
  
                              /* Now that we have the hook's updated rootPropertyValue (the post-processed value provided by adjustedSetData), cache it onto the element. */
                              if (CSS.Hooks.registered[property]) {
                                  /* Since adjustedSetData contains normalized data ready for DOM updating, the rootPropertyValue needs to be re-extracted from its normalized form. ?? */
                                  if (CSS.Normalizations.registered[hookRoot]) {
                                      Data(element).rootPropertyValueCache[hookRoot] = CSS.Normalizations.registered[hookRoot]("extract", null, adjustedSetData[1]);
                                  } else {
                                      Data(element).rootPropertyValueCache[hookRoot] = adjustedSetData[1];
                                  }
                              }
  
                              /***************
                                 Transforms
                              ***************/
  
                              /* Flag whether a transform property is being animated so that flushTransformCache() can be triggered once this tick pass is complete. */
                              if (adjustedSetData[0] === "transform") {
                                  transformPropertyExists = true;
                              }
                          }
                      }
  
                      /****************
                          mobileHA
                      ****************/
  
                      /* If mobileHA is enabled, set the translate3d transform to null to force hardware acceleration.
                         It's safe to override this property since Velocity doesn't actually support its animation (hooks are used in its place). */
                      if (opts.mobileHA) {
                          /* Don't set the null transform hack if we've already done so. */
                          if (Data(element).transformCache.translate3d === undefined) {
                              /* All entries on the transformCache object are later concatenated into a single transform string via flushTransformCache(). */
                              Data(element).transformCache.translate3d = "(0px, 0px, 0px)";
  
                              transformPropertyExists = true;
                          }
                      }
  
                      if (transformPropertyExists) {
                          CSS.flushTransformCache(element);
                      }
                  }
  
                  /* The non-"none" display value is only applied to an element once -- when its associated call is first ticked through.
                     Accordingly, it's set to false so that it isn't re-processed by this call in the next tick. */
                  if (opts.display && opts.display !== "none") {
                      Velocity.State.calls[i][2].display = false;
                  }
  
                  if (opts.visibility && opts.visibility !== "hidden") {
                      Velocity.State.calls[i][2].visibility = false;
                  }
  
                  /* Pass the elements and the timing data (percentComplete, msRemaining, and timeStart) into the progress callback. */
                  if (opts.progress) {
                      opts.progress.call(callContainer[1],
                                         callContainer[1],
                                         percentComplete,
                                         Math.max(0, (timeStart + opts.duration) - timeCurrent),
                                         timeStart);
                  }
  
                  /* If this call has finished tweening, pass its index to completeCall() to handle call cleanup. */
                  if (percentComplete === 1) {
                      completeCall(i);
                  }
              }
          }
  
          /* Note: completeCall() sets the isTicking flag to false when the last call on Velocity.State.calls has completed. */
          if (Velocity.State.isTicking) {
              rAF(tick);
          }
      }