docs: function calculateUnitRatios () {
                              /* The properties below are used to determine whether the element differs sufficiently from this same call's
                                 prior element (in the overall element set) 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 = {
                                      parent: element.parentNode, /* GET */
                                      position: CSS.getPropertyValue(element, "position"), /* GET */
                                      fontSize: CSS.getPropertyValue(element, "fontSize") /* GET */
                                  },
                                  /* Determine if the same % ratio can be used. % is relative to the element's position value and the parent's width and height dimensions. */
                                  sameBasePercent = ((sameRatioIndicators.position === unitConversionRatios.lastPosition) && (sameRatioIndicators.parent === unitConversionRatios.lastParent)),
                                  /* Determine if the same em ratio can be used. em is relative to the element's fontSize, which itself is relative to the parent's fontSize. */
                                  sameBaseEm = ((sameRatioIndicators.fontSize === unitConversionRatios.lastFontSize) && (sameRatioIndicators.parent === unitConversionRatios.lastParent));
  
                              /* Store these ratio indicators call-wide for the next element to compare against. */
                              unitConversionRatios.lastParent = sameRatioIndicators.parent;
                              unitConversionRatios.lastPosition = sameRatioIndicators.position;
                              unitConversionRatios.lastFontSize = sameRatioIndicators.fontSize;
  
                              /* Whereas % and em ratios are determined on a per-element basis, the rem unit type only needs to be checked
                                 once per call since it is 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 (unitConversionRatios.remToPx === null) {
                                  /* Default to most browsers' default fontSize of 16px in the case of 0. */
                                  unitConversionRatios.remToPx = parseFloat(CSS.getPropertyValue(document.body, "fontSize")) || 16; /* GET */
                              }
  
                              /* The viewport units are relative to the window's inner dimensions. */
                              if (unitConversionRatios.vwToPx === null) {
                                  unitConversionRatios.vwToPx = parseFloat(window.innerWidth) / 100; /* GET */
                                  unitConversionRatios.vhToPx = parseFloat(window.innerHeight) / 100; /* GET */
                              }
  
                              var originalValues = {
                                      /* To accurately and consistently calculate conversion ratios, the element's overflow and box-sizing are temporarily removed.
                                         Both properties modify an element's visible dimensions. */
                                      /* Note: Overflow must be manipulated on a per-axis basis since the plain overflow property overwrites its subproperties' values. */
                                      overflowX: null,
                                      overflowY: null,
                                      boxSizing: null,
                                      /* width and height act as our proxy properties for measuring the horizontal and vertical % ratios.
                                         Since they can be artificially constrained by their min-/max- equivalents, those properties are converted as well. */
                                      width: null,
                                      minWidth: null,
                                      maxWidth: null,
                                      height: null,
                                      minHeight: null,
                                      maxHeight: null,
                                      /* paddingLeft arbitrarily acts as our proxy for the em ratio. */
                                      paddingLeft: null
                                  },
                                  elementUnitRatios = {},
                                  /* Note: IE<=8 round to the nearest pixel when returning CSS values, thus we perform conversions using a measurement
                                     of 10 (instead of 1) to give our ratios a precision of at least 1 decimal value. */
                                  measurement = 10;
  
                              /* For organizational purposes, current ratio calculations are consolidated onto the elementUnitRatios object. */
                              elementUnitRatios.remToPx = unitConversionRatios.remToPx;
                              elementUnitRatios.vwToPx = unitConversionRatios.vwToPx;
                              elementUnitRatios.vhToPx = unitConversionRatios.vhToPx;
  
                              /* After temporary unit conversion logic runs, width and height properties that were originally set to "auto" must be set back
                                 to "auto" instead of to the actual corresponding pixel value. Leaving the values at their hard-coded pixel value equivalents
                                 would inherently prevent the elements from vertically adjusting as the height of its inner content changes. */
                              /* IE tells us whether or not the property is set to "auto". Other browsers provide no way of determing "auto" values on height/width,
                                 and thus we have to trigger additional layout thrashing (see below) to solve this. */
                              if (IE && !Data(element).isSVG) {
                                  var isIEWidthAuto = /^auto$/i.test(element.currentStyle.width),
                                      isIEHeightAuto = /^auto$/i.test(element.currentStyle.height);
                              }
  
                              /* Note: To minimize layout thrashing, the ensuing unit conversion logic is split into batches to synchronize GETs and SETs. */
                              if (!sameBasePercent || !sameBaseEm) {
                                  /* SVG elements have no concept of document flow, and don't support the full range of CSS properties,
                                     so we skip the unnecessary stripping of unapplied properties to avoid dirtying their HTML. */
                                  if (!Data(element).isSVG) {
                                      originalValues.overflowX = CSS.getPropertyValue(element, "overflowX"); /* GET */
                                      originalValues.overflowY = CSS.getPropertyValue(element, "overflowY"); /* GET */
                                      originalValues.boxSizing = CSS.getPropertyValue(element, "boxSizing"); /* GET */
  
                                      /* Since % values are relative to their respective axes, ratios are calculated for both width and height.
                                         In contrast, only a single ratio is required for rem and em. */
                                      /* When calculating % values, we set a flag to indiciate that we want the computed value instead of offsetWidth/Height,
                                         which incorporate additional dimensions (such as padding and border-width) into their values. */
                                      originalValues.minWidth = CSS.getPropertyValue(element, "minWidth"); /* GET */
                                      /* Note: max-width/height must default to "none" when 0 is returned, otherwise the element cannot have its width/height set. */
                                      originalValues.maxWidth = CSS.getPropertyValue(element, "maxWidth") || "none"; /* GET */
  
                                      originalValues.minHeight = CSS.getPropertyValue(element, "minHeight"); /* GET */
                                      originalValues.maxHeight = CSS.getPropertyValue(element, "maxHeight") || "none"; /* GET */
  
                                      originalValues.paddingLeft = CSS.getPropertyValue(element, "paddingLeft"); /* GET */
                                  }
  
                                  originalValues.width = CSS.getPropertyValue(element, "width", null, true); /* GET */
                                  originalValues.height = CSS.getPropertyValue(element, "height", null, true); /* GET */
                              }
  
                              if (sameBasePercent) {
                                  elementUnitRatios.percentToPxRatioWidth = unitConversionRatios.lastPercentToPxWidth;
                                  elementUnitRatios.percentToPxRatioHeight = unitConversionRatios.lastPercentToPxHeight;
                              } else {
                                  if (!Data(element).isSVG) {
                                      CSS.setPropertyValue(element, "overflowX",  "hidden"); /* SET */
                                      CSS.setPropertyValue(element, "overflowY",  "hidden"); /* SET */
                                      CSS.setPropertyValue(element, "boxSizing",  "content-box"); /* SET */
  
                                      CSS.setPropertyValue(element, "minWidth", measurement + "%"); /* SET */
                                      CSS.setPropertyValue(element, "maxWidth", measurement + "%"); /* SET */
  
                                      CSS.setPropertyValue(element, "minHeight",  measurement + "%"); /* SET */
                                      CSS.setPropertyValue(element, "maxHeight",  measurement + "%"); /* SET */
                                  }
  
                                  CSS.setPropertyValue(element, "width", measurement + "%"); /* SET */
                                  CSS.setPropertyValue(element, "height",  measurement + "%"); /* SET */
                              }
  
                              if (sameBaseEm) {
                                  elementUnitRatios.emToPx = unitConversionRatios.lastEmToPx;
                              } else if (!Data(element).isSVG) {
                                  CSS.setPropertyValue(element, "paddingLeft", measurement + "em"); /* SET */
                              }
  
                              /* The following pixel-value GETs cannot be batched with the prior GETs since they depend upon the values
                                 temporarily set immediately above; layout thrashing cannot be avoided here. */
                              if (!sameBasePercent) {
                                  /* Divide the returned value by the measurement value to get the ratio between 1% and 1px.
                                     Default to 1 since conversion logic using 0 can produce Infinite. */
                                  elementUnitRatios.percentToPxRatioWidth = unitConversionRatios.lastPercentToPxWidth = (parseFloat(CSS.getPropertyValue(element, "width", null, true)) || 1) / measurement; /* GET */
                                  elementUnitRatios.percentToPxRatioHeight = unitConversionRatios.lastPercentToPxHeight = (parseFloat(CSS.getPropertyValue(element, "height", null, true)) || 1) / measurement; /* GET */
                              }
  
                              if (!sameBaseEm) {
                                  elementUnitRatios.emToPx = unitConversionRatios.lastEmToPx = (parseFloat(CSS.getPropertyValue(element, "paddingLeft")) || 1) / measurement; /* GET */
                              }
  
                              /* Revert each used test property to its original value. */
                              for (var originalValueProperty in originalValues) {
                                  if (originalValues[originalValueProperty] !== null) {
                                      CSS.setPropertyValue(element, originalValueProperty, originalValues[originalValueProperty]); /* SETs */
                                  }
                              }
  
                              /* SVG dimensions do not accept an "auto" value, so we skip this reset process for them. */
                              if (!Data(element).isSVG) {
                                  /* In IE, revert to "auto" for width and height if it was originally set. */
                                  if (IE) {
                                      if (isIEWidthAuto) {
                                          CSS.setPropertyValue(element, "width", "auto"); /* SET */
                                      }
  
                                      if (isIEHeightAuto) {
                                          CSS.setPropertyValue(element, "height", "auto"); /* SET */
                                      }
                                  /* For other browsers, additional layout thrashing must unfortunately be triggered to determine whether a dimension property was originally "auto". */
                                  } else {
                                      /* Set height to "auto" then compare the returned value against the element's current height value.
                                         If they're identical, leave height set to "auto". If they're different, then "auto" wasn't originally
                                         set on the element prior to our conversions, and we revert it to its actual value. */
                                      /* Note: The following GETs and SETs cannot be batched together due to the cross-effect setting one axis to "auto" has on the other. */
                                      CSS.setPropertyValue(element, "height", "auto"); /* SET */
                                      if (originalValues.height !== CSS.getPropertyValue(element, "height", null, true)) { /* GET */
                                          CSS.setPropertyValue(element, "height", originalValues.height); /* SET */
                                      }
  
                                      CSS.setPropertyValue(element, "width", "auto"); /* SET */
                                      if (originalValues.width !== CSS.getPropertyValue(element, "width", null, true)) { /* GET */
                                          CSS.setPropertyValue(element, "width", originalValues.width); /* SET */
                                      }
                                  }
                              }
  
                              if (Velocity.debug >= 1) console.log("Unit ratios: " + JSON.stringify(elementUnitRatios), element);
  
                              return elementUnitRatios;
                          }