docs: function calculateUnitRatios () {
  
                              /************************
                                  Same Ratio Checks
                              ************************/
  
                              /* The properties below are used to determine whether the element differs sufficiently from this call's
                                 previously iterated element to also differ in its unit conversion ratios. If the properties match up with those
                                 of the prior element, the prior element's conversion ratios are used. Like most optimizations in Velocity,
                                 this is done to minimize DOM querying. */
                              var sameRatioIndicators = {
                                      myParent: element.parentNode || document.body, /* GET */
                                      position: CSS.getPropertyValue(element, "position"), /* GET */
                                      fontSize: CSS.getPropertyValue(element, "fontSize") /* GET */
                                  },
                                  /* Determine if the same % ratio can be used. % is based on the element's position value and its parent's width and height dimensions. */
                                  samePercentRatio = ((sameRatioIndicators.position === callUnitConversionData.lastPosition) && (sameRatioIndicators.myParent === callUnitConversionData.lastParent)),
                                  /* Determine if the same em ratio can be used. em is relative to the element's fontSize. */
                                  sameEmRatio = (sameRatioIndicators.fontSize === callUnitConversionData.lastFontSize);
  
                              /* Store these ratio indicators call-wide for the next element to compare against. */
                              callUnitConversionData.lastParent = sameRatioIndicators.myParent;
                              callUnitConversionData.lastPosition = sameRatioIndicators.position;
                              callUnitConversionData.lastFontSize = sameRatioIndicators.fontSize;
  
                              /***************************
                                 Element-Specific Units
                              ***************************/
  
                              /* Note: IE8 rounds to the nearest pixel when returning CSS values, thus we perform conversions using a measurement
                                 of 100 (instead of 1) to give our ratios a precision of at least 2 decimal values. */
                              var measurement = 100,
                                  unitRatios = {};
  
                              if (!sameEmRatio || !samePercentRatio) {
                                  var dummy = Data(element).isSVG ? document.createElementNS("http://www.w3.org/2000/svg", "rect") : document.createElement("div");
  
                                  Velocity.init(dummy);
                                  sameRatioIndicators.myParent.appendChild(dummy);
  
                                  /* To accurately and consistently calculate conversion ratios, the element's cascaded overflow and box-sizing are stripped.
                                     Similarly, since width/height can be artificially constrained by their min-/max- equivalents, these are controlled for as well. */
                                  /* Note: Overflow must be also be controlled for per-axis since the overflow property overwrites its per-axis values. */
                                  $.each([ "overflow", "overflowX", "overflowY" ], function(i, property) {
                                      Velocity.CSS.setPropertyValue(dummy, property, "hidden");
                                  });
                                  Velocity.CSS.setPropertyValue(dummy, "position", sameRatioIndicators.position);
                                  Velocity.CSS.setPropertyValue(dummy, "fontSize", sameRatioIndicators.fontSize);
                                  Velocity.CSS.setPropertyValue(dummy, "boxSizing", "content-box");
  
                                  /* width and height act as our proxy properties for measuring the horizontal and vertical % ratios. */
                                  $.each([ "minWidth", "maxWidth", "width", "minHeight", "maxHeight", "height" ], function(i, property) {
                                      Velocity.CSS.setPropertyValue(dummy, property, measurement + "%");
                                  });
                                  /* paddingLeft arbitrarily acts as our proxy property for the em ratio. */
                                  Velocity.CSS.setPropertyValue(dummy, "paddingLeft", measurement + "em");
  
                                  /* Divide the returned value by the measurement to get the ratio between 1% and 1px. Default to 1 since working with 0 can produce Infinite. */
                                  unitRatios.percentToPxWidth = callUnitConversionData.lastPercentToPxWidth = (parseFloat(CSS.getPropertyValue(dummy, "width", null, true)) || 1) / measurement; /* GET */
                                  unitRatios.percentToPxHeight = callUnitConversionData.lastPercentToPxHeight = (parseFloat(CSS.getPropertyValue(dummy, "height", null, true)) || 1) / measurement; /* GET */
                                  unitRatios.emToPx = callUnitConversionData.lastEmToPx = (parseFloat(CSS.getPropertyValue(dummy, "paddingLeft")) || 1) / measurement; /* GET */
  
                                  sameRatioIndicators.myParent.removeChild(dummy);
                              } else {
                                  unitRatios.emToPx = callUnitConversionData.lastEmToPx;
                                  unitRatios.percentToPxWidth = callUnitConversionData.lastPercentToPxWidth;
                                  unitRatios.percentToPxHeight = callUnitConversionData.lastPercentToPxHeight;
                              }
  
                              /***************************
                                 Element-Agnostic Units
                              ***************************/
  
                              /* Whereas % and em ratios are determined on a per-element basis, the rem unit only needs to be checked
                                 once per call since it's exclusively dependant upon document.body's fontSize. If this is the first time
                                 that calculateUnitRatios() is being run during this call, remToPx will still be set to its default value of null,
                                 so we calculate it now. */
                              if (callUnitConversionData.remToPx === null) {
                                  /* Default to browsers' default fontSize of 16px in the case of 0. */
                                  callUnitConversionData.remToPx = parseFloat(CSS.getPropertyValue(document.body, "fontSize")) || 16; /* GET */
                              }
  
                              /* Similarly, viewport units are %-relative to the window's inner dimensions. */
                              if (callUnitConversionData.vwToPx === null) {
                                  callUnitConversionData.vwToPx = parseFloat(window.innerWidth) / 100; /* GET */
                                  callUnitConversionData.vhToPx = parseFloat(window.innerHeight) / 100; /* GET */
                              }
  
                              unitRatios.remToPx = callUnitConversionData.remToPx;
                              unitRatios.vwToPx = callUnitConversionData.vwToPx;
                              unitRatios.vhToPx = callUnitConversionData.vhToPx;
  
                              if (Velocity.debug >= 1) console.log("Unit ratios: " + JSON.stringify(unitRatios), element);
  
                              return unitRatios;
                          }