docs: function parsePropertyValue (valueData, skipResolvingEasing) {
                          var endValue = undefined,
                              easing = undefined,
                              startValue = undefined;
  
                          /* Handle the array format, which can be structured as one of three potential overloads:
                             A) [ endValue, easing, startValue ], B) [ endValue, easing ], or C) [ endValue, startValue ] */
                          if (Type.isArray(valueData)) {
                              /* endValue is always the first item in the array. Don't bother validating endValue's value now
                                 since the ensuing property cycling logic does that. */
                              endValue = valueData[0];
  
                              /* Two-item array format: If the second item is a number, function, or hex string, treat it as a
                                 start value since easings can only be non-hex strings or arrays. */
                              if ((!Type.isArray(valueData[1]) && /^[\d-]/.test(valueData[1])) || Type.isFunction(valueData[1]) || CSS.RegEx.isHex.test(valueData[1])) {
                                  startValue = valueData[1];
                              /* Two or three-item array: If the second item is a non-hex string or an array, treat it as an easing. */
                              } else if ((Type.isString(valueData[1]) && !CSS.RegEx.isHex.test(valueData[1])) || Type.isArray(valueData[1])) {
                                  easing = skipResolvingEasing ? valueData[1] : getEasing(valueData[1], opts.duration);
  
                                  /* Don't bother validating startValue's value now since the ensuing property cycling logic inherently does that. */
                                  if (valueData[2] !== undefined) {
                                      startValue = valueData[2];
                                  }
                              }
                          /* Handle the single-value format. */
                          } else {
                              endValue = valueData;
                          }
  
                          /* Default to the call's easing if a per-property easing type was not defined. */
                          easing = easing || opts.easing;
  
                          /* If functions were passed in as values, pass the function the current element as its context,
                             plus the element's index and the element set's size as arguments. Then, assign the returned value. */
                          if (Type.isFunction(endValue)) {
                              endValue = endValue.call(element, elementsIndex, elementsLength);
                          }
  
                          if (Type.isFunction(startValue)) {
                              startValue = startValue.call(element, elementsIndex, elementsLength);
                          }
  
                          /* Allow startValue to be left as undefined to indicate to the ensuing code that its value was not forcefed. */
                          return [ endValue || 0, easing, startValue ];
                      }