docs: function(element, property, propertyValue, rootPropertyValue, scrollData) {
              var propertyName = property;
  
              /* In order to be subjected to call options and element queueing, scroll animation is routed through Velocity as if it were a standard CSS property. */
              if (property === "scroll") {
                  /* If a container option is present, scroll the container instead of the browser window. */
                  if (scrollData.container) {
                      scrollData.container["scroll" + scrollData.direction] = propertyValue;
                  /* Otherwise, Velocity defaults to scrolling the browser window. */
                  } else {
                      if (scrollData.direction === "Left") {
                          window.scrollTo(propertyValue, scrollData.alternateValue);
                      } else {
                          window.scrollTo(scrollData.alternateValue, propertyValue);
                      }
                  }
              } else {
                  /* Transforms (translateX, rotateZ, etc.) are applied to a per-element transformCache object, which is manually flushed via flushTransformCache().
                     Thus, for now, we merely cache transforms being SET. */
                  if (CSS.Normalizations.registered[property] && CSS.Normalizations.registered[property]("name", element) === "transform") {
                      /* Perform a normalization injection. */
                      /* Note: The normalization logic handles the transformCache updating. */
                      CSS.Normalizations.registered[property]("inject", element, propertyValue);
  
                      propertyName = "transform";
                      propertyValue = Data(element).transformCache[property];
                  } else {
                      /* Inject hooks. */
                      if (CSS.Hooks.registered[property]) {
                          var hookName = property,
                              hookRoot = CSS.Hooks.getRoot(property);
  
                          /* If a cached rootPropertyValue was not provided, query the DOM for the hookRoot's current value. */
                          rootPropertyValue = rootPropertyValue || CSS.getPropertyValue(element, hookRoot); /* GET */
  
                          propertyValue = CSS.Hooks.injectValue(hookName, propertyValue, rootPropertyValue);
                          property = hookRoot;
                      }
  
                      /* Normalize names and values. */
                      if (CSS.Normalizations.registered[property]) {
                          propertyValue = CSS.Normalizations.registered[property]("inject", element, propertyValue);
                          property = CSS.Normalizations.registered[property]("name", element);
                      }
  
                      /* Assign the appropriate vendor prefix before performing an official style update. */
                      propertyName = CSS.Names.prefixCheck(property)[0];
  
                      /* A try/catch is used for IE<=8, which throws an error when "invalid" CSS values are set, e.g. a negative width.
                         Try/catch is avoided for other browsers since it incurs a performance overhead. */
                      if (IE <= 8) {
                          try {
                              element.style[propertyName] = propertyValue;
                          } catch (error) { if (Velocity.debug) console.log("Browser does not support [" + propertyValue + "] for [" + propertyName + "]"); }
                      /* SVG elements have their dimensional properties (width, height, x, y, cx, etc.) applied directly as attributes instead of as styles. */
                      /* Note: IE8 does not support SVG elements, so it's okay that we skip it for SVG animation. */
                      } else if (Data(element) && Data(element).isSVG && CSS.Names.SVGAttribute(property)) {
                          /* Note: For SVG attributes, vendor-prefixed property names are never used. */
                          /* Note: Not all CSS properties can be animated via attributes, but the browser won't throw an error for unsupported properties. */
                          element.setAttribute(property, propertyValue);
                      } else {
                          element.style[propertyName] = propertyValue;
                      }
  
                      if (Velocity.debug >= 2) console.log("Set " + property + " (" + propertyName + "): " + propertyValue);
                  }
              }
  
              /* Return the normalized property name and value in case the caller wants to know how these values were modified before being applied to the DOM. */
              return [ propertyName, propertyValue ];
          }