docs: function completeCall (callIndex, isStopped) {
          /* Ensure the call exists. */
          if (!Velocity.State.calls[callIndex]) {
              return false;
          }
  
          /* Pull the metadata from the call. */
          var call = Velocity.State.calls[callIndex][0],
              elements = Velocity.State.calls[callIndex][1],
              opts = Velocity.State.calls[callIndex][2],
              resolver = Velocity.State.calls[callIndex][4];
  
          var remainingCallsExist = false;
  
          /*************************
             Element Finalization
          *************************/
  
          for (var i = 0, callLength = call.length; i < callLength; i++) {
              var element = call[i].element;
  
              /* If the user set display to "none" (intending to hide the element), set it now that the animation has completed. */
              /* Note: display:none isn't set when calls are manually stopped (via Velocity("stop"). */
              /* Note: Display gets ignored with "reverse" calls and infinite loops, since this behavior would be undesirable. */
              if (!isStopped && !opts.loop) {
                  if (opts.display === "none") {
                      CSS.setPropertyValue(element, "display", opts.display);
                  }
  
                  if (opts.visibility === "hidden") {
                      CSS.setPropertyValue(element, "visibility", opts.visibility);
                  }
              }
  
              /* If the element's queue is empty (if only the "inprogress" item is left at position 0) or if its queue is about to run
                 a non-Velocity-initiated entry, turn off the isAnimating flag. A non-Velocity-initiatied queue entry's logic might alter
                 an element's CSS values and thereby cause Velocity's cached value data to go stale. To detect if a queue entry was initiated by Velocity,
                 we check for the existence of our special Velocity.queueEntryFlag declaration, which minifiers won't rename since the flag
                 is assigned to jQuery's global $ object and thus exists out of Velocity's own scope. */
              if (opts.loop !== true && ($.queue(element)[1] === undefined || !/\.velocityQueueEntryFlag/i.test($.queue(element)[1]))) {
                  /* The element may have been deleted. Ensure that its data cache still exists before acting on it. */
                  if (Data(element)) {
                      Data(element).isAnimating = false;
                      /* Clear the element's rootPropertyValueCache, which will become stale. */
                      Data(element).rootPropertyValueCache = {};
  
                      var transformHAPropertyExists = false;
                      /* If any 3D transform subproperty is at its default value (regardless of unit type), remove it. */
                      $.each(CSS.Lists.transforms3D, function(i, transformName) {
                          var defaultValue = /^scale/.test(transformName) ? 1 : 0,
                              currentValue = Data(element).transformCache[transformName];
  
                          if (Data(element).transformCache[transformName] !== undefined && new RegExp("^\\(" + defaultValue + "[^.]").test(currentValue)) {
                              transformHAPropertyExists = true;
  
                              delete Data(element).transformCache[transformName];
                          }
                      });
  
                      /* Mobile devices have hardware acceleration removed at the end of the animation in order to avoid hogging the GPU's memory. */
                      if (opts.mobileHA) {
                          transformHAPropertyExists = true;
                          delete Data(element).transformCache.translate3d;
                      }
  
                      /* Flush the subproperty removals to the DOM. */
                      if (transformHAPropertyExists) {
                          CSS.flushTransformCache(element);
                      }
  
                      /* Remove the "velocity-animating" indicator class. */
                      CSS.Values.removeClass(element, "velocity-animating");
                  }
              }
  
              /*********************
                 Option: Complete
              *********************/
  
              /* Complete is fired once per call (not once per element) and is passed the full raw DOM element set as both its context and its first argument. */
              /* Note: Callbacks aren't fired when calls are manually stopped (via Velocity("stop"). */
              if (!isStopped && opts.complete && !opts.loop && (i === callLength - 1)) {
                  /* We throw callbacks in a setTimeout so that thrown errors don't halt the execution of Velocity itself. */
                  try {
                      opts.complete.call(elements, elements);
                  } catch (error) {
                      setTimeout(function() { throw error; }, 1);
                  }
              }
  
              /**********************
                 Promise Resolving
              **********************/
  
              /* Note: Infinite loops don't return promises. */
              if (resolver && opts.loop !== true) {
                  resolver(elements);
              }
  
              /****************************
                 Option: Loop (Infinite)
              ****************************/
  
              if (Data(element) && opts.loop === true && !isStopped) {
                  /* If a rotateX/Y/Z property is being animated to 360 deg with loop:true, swap tween start/end values to enable
                     continuous iterative rotation looping. (Otherise, the element would just rotate back and forth.) */
                  $.each(Data(element).tweensContainer, function(propertyName, tweenContainer) {
                      if (/^rotate/.test(propertyName) && parseFloat(tweenContainer.endValue) === 360) {
                          tweenContainer.endValue = 0;
                          tweenContainer.startValue = 360;
                      }
  
                      if (/^backgroundPosition/.test(propertyName) && parseFloat(tweenContainer.endValue) === 100 && tweenContainer.unitType === "%") {
                          tweenContainer.endValue = 0;
                          tweenContainer.startValue = 100;
                      }
                  });
  
                  Velocity(element, "reverse", { loop: true, delay: opts.delay });
              }
  
              /***************
                 Dequeueing
              ***************/
  
              /* Fire the next call in the queue so long as this call's queue wasn't set to false (to trigger a parallel animation),
                 which would have already caused the next call to fire. Note: Even if the end of the animation queue has been reached,
                 $.dequeue() must still be called in order to completely clear jQuery's animation queue. */
              if (opts.queue !== false) {
                  $.dequeue(element, opts.queue);
              }
          }
  
          /************************
             Calls Array Cleanup
          ************************/
  
          /* Since this call is complete, set it to false so that the rAF tick skips it. This array is later compacted via compactSparseArray().
            (For performance reasons, the call is set to false instead of being deleted from the array: http://www.html5rocks.com/en/tutorials/speed/v8/) */
          Velocity.State.calls[callIndex] = false;
  
          /* Iterate through the calls array to determine if this was the final in-progress animation.
             If so, set a flag to end ticking and clear the calls array. */
          for (var j = 0, callsLength = Velocity.State.calls.length; j < callsLength; j++) {
              if (Velocity.State.calls[j] !== false) {
                  remainingCallsExist = true;
  
                  break;
              }
          }
  
          if (remainingCallsExist === false) {
              /* tick() will detect this flag upon its next iteration and subsequently turn itself off. */
              Velocity.State.isTicking = false;
  
              /* Clear the calls array so that its length is reset. */
              delete Velocity.State.calls;
              Velocity.State.calls = [];
          }
      }