text: /*
    html2canvas 0.4.1 <http://html2canvas.hertzen.com>
    Copyright (c) 2013 Niklas von Hertzen
  
    Released under MIT License
  */
  
  (function(window, document, undefined){
  
      "use strict";
      
      var _html2canvas = {},
      previousElement,
      computedCSS,
      html2canvas;
      
      _html2canvas.Util = {};
      
      _html2canvas.Util.log = function(a) {
        if (_html2canvas.logging && window.console && window.console.log) {
          window.console.log(a);
        }
      };
      
      _html2canvas.Util.trimText = (function(isNative){
        return function(input) {
          return isNative ? isNative.apply(input) : ((input || '') + '').replace( /^\s+|\s+$/g , '' );
        };
      })(String.prototype.trim);
      
      _html2canvas.Util.asFloat = function(v) {
        return parseFloat(v);
      };
      
      (function() {
        // TODO: support all possible length values
        var TEXT_SHADOW_PROPERTY = /((rgba|rgb)\([^\)]+\)(\s-?\d+px){0,})/g;
        var TEXT_SHADOW_VALUES = /(-?\d+px)|(#.+)|(rgb\(.+\))|(rgba\(.+\))/g;
        _html2canvas.Util.parseTextShadows = function (value) {
          if (!value || value === 'none') {
            return [];
          }
      
          // find multiple shadow declarations
          var shadows = value.match(TEXT_SHADOW_PROPERTY),
            results = [];
          for (var i = 0; shadows && (i < shadows.length); i++) {
            var s = shadows[i].match(TEXT_SHADOW_VALUES);
            results.push({
              color: s[0],
              offsetX: s[1] ? s[1].replace('px', '') : 0,
              offsetY: s[2] ? s[2].replace('px', '') : 0,
              blur: s[3] ? s[3].replace('px', '') : 0
            });
          }
          return results;
        };
      })();
      
      
      _html2canvas.Util.parseBackgroundImage = function (value) {
          var whitespace = ' \r\n\t',
              method, definition, prefix, prefix_i, block, results = [],
              c, mode = 0, numParen = 0, quote, args;
      
          var appendResult = function(){
              if(method) {
                  if(definition.substr( 0, 1 ) === '"') {
                      definition = definition.substr( 1, definition.length - 2 );
                  }
                  if(definition) {
                      args.push(definition);
                  }
                  if(method.substr( 0, 1 ) === '-' &&
                          (prefix_i = method.indexOf( '-', 1 ) + 1) > 0) {
                      prefix = method.substr( 0, prefix_i);
                      method = method.substr( prefix_i );
                  }
                  results.push({
                      prefix: prefix,
                      method: method.toLowerCase(),
                      value: block,
                      args: args
                  });
              }
              args = []; //for some odd reason, setting .length = 0 didn't work in safari
              method =
                  prefix =
                  definition =
                  block = '';
          };
      
          appendResult();
          for(var i = 0, ii = value.length; i<ii; i++) {
              c = value[i];
              if(mode === 0 && whitespace.indexOf( c ) > -1){
                  continue;
              }
              switch(c) {
                  case '"':
                      if(!quote) {
                          quote = c;
                      }
                      else if(quote === c) {
                          quote = null;
                      }
                      break;
      
                  case '(':
                      if(quote) { break; }
                      else if(mode === 0) {
                          mode = 1;
                          block += c;
                          continue;
                      } else {
                          numParen++;
                      }
                      break;
      
                  case ')':
                      if(quote) { break; }
                      else if(mode === 1) {
                          if(numParen === 0) {
                              mode = 0;
                              block += c;
                              appendResult();
                              continue;
                          } else {
                              numParen--;
                          }
                      }
                      break;
      
                  case ',':
                      if(quote) { break; }
                      else if(mode === 0) {
                          appendResult();
                          continue;
                      }
                      else if (mode === 1) {
                          if(numParen === 0 && !method.match(/^url$/i)) {
                              args.push(definition);
                              definition = '';
                              block += c;
                              continue;
                          }
                      }
                      break;
              }
      
              block += c;
              if(mode === 0) { method += c; }
              else { definition += c; }
          }
          appendResult();
      
          return results;
      };
      
      _html2canvas.Util.Bounds = function (element) {
        var clientRect, bounds = {};
      
        if (element.getBoundingClientRect){
          clientRect = element.getBoundingClientRect();
      
          // TODO add scroll position to bounds, so no scrolling of window necessary
          bounds.top = clientRect.top;
          bounds.bottom = clientRect.bottom || (clientRect.top + clientRect.height);
          bounds.left = clientRect.left;
      
          bounds.width = element.offsetWidth;
          bounds.height = element.offsetHeight;
        }
      
        return bounds;
      };
      
      // TODO ideally, we'd want everything to go through this function instead of Util.Bounds,
      // but would require further work to calculate the correct positions for elements with offsetParents
      _html2canvas.Util.OffsetBounds = function (element) {
        var parent = element.offsetParent ? _html2canvas.Util.OffsetBounds(element.offsetParent) : {top: 0, left: 0};
      
        return {
          top: element.offsetTop + parent.top,
          bottom: element.offsetTop + element.offsetHeight + parent.top,
          left: element.offsetLeft + parent.left,
          width: element.offsetWidth,
          height: element.offsetHeight
        };
      };
      
      function toPX(element, attribute, value ) {
          var rsLeft = element.runtimeStyle && element.runtimeStyle[attribute],
              left,
              style = element.style;
      
          // Check if we are not dealing with pixels, (Opera has issues with this)
          // Ported from jQuery css.js
          // From the awesome hack by Dean Edwards
          // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
      
          // If we're not dealing with a regular pixel number
          // but a number that has a weird ending, we need to convert it to pixels
      
          if ( !/^-?[0-9]+\.?[0-9]*(?:px)?$/i.test( value ) && /^-?\d/.test(value) ) {
              // Remember the original values
              left = style.left;
      
              // Put in the new values to get a computed value out
              if (rsLeft) {
                  element.runtimeStyle.left = element.currentStyle.left;
              }
              style.left = attribute === "fontSize" ? "1em" : (value || 0);
              value = style.pixelLeft + "px";
      
              // Revert the changed values
              style.left = left;
              if (rsLeft) {
                  element.runtimeStyle.left = rsLeft;
              }
          }
      
          if (!/^(thin|medium|thick)$/i.test(value)) {
              return Math.round(parseFloat(value)) + "px";
          }
      
          return value;
      }
      
      function asInt(val) {
          return parseInt(val, 10);
      }
      
      function parseBackgroundSizePosition(value, element, attribute, index) {
          value = (value || '').split(',');
          value = value[index || 0] || value[0] || 'auto';
          value = _html2canvas.Util.trimText(value).split(' ');
      
          if(attribute === 'backgroundSize' && (!value[0] || value[0].match(/cover|contain|auto/))) {
              //these values will be handled in the parent function
          } else {
              value[0] = (value[0].indexOf( "%" ) === -1) ? toPX(element, attribute + "X", value[0]) : value[0];
              if(value[1] === undefined) {
                  if(attribute === 'backgroundSize') {
                      value[1] = 'auto';
                      return value;
                  } else {
                      // IE 9 doesn't return double digit always
                      value[1] = value[0];
                  }
              }
              value[1] = (value[1].indexOf("%") === -1) ? toPX(element, attribute + "Y", value[1]) : value[1];
          }
          return value;
      }
      
      _html2canvas.Util.getCSS = function (element, attribute, index) {
          if (previousElement !== element) {
            computedCSS = document.defaultView.getComputedStyle(element, null);
          }
      
          var value = computedCSS[attribute];
      
          if (/^background(Size|Position)$/.test(attribute)) {
              return parseBackgroundSizePosition(value, element, attribute, index);
          } else if (/border(Top|Bottom)(Left|Right)Radius/.test(attribute)) {
            var arr = value.split(" ");
            if (arr.length <= 1) {
                arr[1] = arr[0];
            }
            return arr.map(asInt);
          }
      
        return value;
      };
      
      _html2canvas.Util.resizeBounds = function( current_width, current_height, target_width, target_height, stretch_mode ){
        var target_ratio = target_width / target_height,
          current_ratio = current_width / current_height,
          output_width, output_height;
      
        if(!stretch_mode || stretch_mode === 'auto') {
          output_width = target_width;
          output_height = target_height;
        } else if(target_ratio < current_ratio ^ stretch_mode === 'contain') {
          output_height = target_height;
          output_width = target_height * current_ratio;
        } else {
          output_width = target_width;
          output_height = target_width / current_ratio;
        }
      
        return {
          width: output_width,
          height: output_height
        };
      };
      
      function backgroundBoundsFactory( prop, el, bounds, image, imageIndex, backgroundSize ) {
          var bgposition =  _html2canvas.Util.getCSS( el, prop, imageIndex ) ,
          topPos,
          left,
          percentage,
          val;
      
          if (bgposition.length === 1){
            val = bgposition[0];
      
            bgposition = [];
      
            bgposition[0] = val;
            bgposition[1] = val;
          }
      
          if (bgposition[0].toString().indexOf("%") !== -1){
            percentage = (parseFloat(bgposition[0])/100);
            left = bounds.width * percentage;
            if(prop !== 'backgroundSize') {
              left -= (backgroundSize || image).width*percentage;
            }
          } else {
            if(prop === 'backgroundSize') {
              if(bgposition[0] === 'auto') {
                left = image.width;
              } else {
                if (/contain|cover/.test(bgposition[0])) {
                  var resized = _html2canvas.Util.resizeBounds(image.width, image.height, bounds.width, bounds.height, bgposition[0]);
                  left = resized.width;
                  topPos = resized.height;
                } else {
                  left = parseInt(bgposition[0], 10);
                }
              }
            } else {
              left = parseInt( bgposition[0], 10);
            }
          }
      
      
          if(bgposition[1] === 'auto') {
            topPos = left / image.width * image.height;
          } else if (bgposition[1].toString().indexOf("%") !== -1){
            percentage = (parseFloat(bgposition[1])/100);
            topPos =  bounds.height * percentage;
            if(prop !== 'backgroundSize') {
              topPos -= (backgroundSize || image).height * percentage;
            }
      
          } else {
            topPos = parseInt(bgposition[1],10);
          }
      
          return [left, topPos];
      }
      
      _html2canvas.Util.BackgroundPosition = function( el, bounds, image, imageIndex, backgroundSize ) {
          var result = backgroundBoundsFactory( 'backgroundPosition', el, bounds, image, imageIndex, backgroundSize );
          return { left: result[0], top: result[1] };
      };
      
      _html2canvas.Util.BackgroundSize = function( el, bounds, image, imageIndex ) {
          var result = backgroundBoundsFactory( 'backgroundSize', el, bounds, image, imageIndex );
          return { width: result[0], height: result[1] };
      };
      
      _html2canvas.Util.Extend = function (options, defaults) {
        for (var key in options) {
          if (options.hasOwnProperty(key)) {
            defaults[key] = options[key];
          }
        }
        return defaults;
      };
      
      
      /*
       * Derived from jQuery.contents()
       * Copyright 2010, John Resig
       * Dual licensed under the MIT or GPL Version 2 licenses.
       * http://jquery.org/license
       */
      _html2canvas.Util.Children = function( elem ) {
        var children;
        try {
          children = (elem.nodeName && elem.nodeName.toUpperCase() === "IFRAME") ? elem.contentDocument || elem.contentWindow.document : (function(array) {
            var ret = [];
            if (array !== null) {
              (function(first, second ) {
                var i = first.length,
                j = 0;
      
                if (typeof second.length === "number") {
                  for (var l = second.length; j < l; j++) {
                    first[i++] = second[j];
                  }
                } else {
                  while (second[j] !== undefined) {
                    first[i++] = second[j++];
                  }
                }
      
                first.length = i;
      
                return first;
              })(ret, array);
            }
            return ret;
          })(elem.childNodes);
      
        } catch (ex) {
          _html2canvas.Util.log("html2canvas.Util.Children failed with exception: " + ex.message);
          children = [];
        }
        return children;
      };
      
      _html2canvas.Util.isTransparent = function(backgroundColor) {
        return (backgroundColor === "transparent" || backgroundColor === "rgba(0, 0, 0, 0)");
      };
      _html2canvas.Util.Font = (function () {
      
        var fontData = {};
      
        return function(font, fontSize, doc) {
          if (fontData[font + "-" + fontSize] !== undefined) {
            return fontData[font + "-" + fontSize];
          }
      
          var container = doc.createElement('div'),
          img = doc.createElement('img'),
          span = doc.createElement('span'),
          sampleText = 'Hidden Text',
          baseline,
          middle,
          metricsObj;
      
          container.style.visibility = "hidden";
          container.style.fontFamily = font;
          container.style.fontSize = fontSize;
          container.style.margin = 0;
          container.style.padding = 0;
      
          doc.body.appendChild(container);
      
          // http://probablyprogramming.com/2009/03/15/the-tiniest-gif-ever (handtinywhite.gif)
          img.src = "data:image/gif;base64,R0lGODlhAQABAIABAP///wAAACwAAAAAAQABAAACAkQBADs=";
          img.width = 1;
          img.height = 1;
      
          img.style.margin = 0;
          img.style.padding = 0;
          img.style.verticalAlign = "baseline";
      
          span.style.fontFamily = font;
          span.style.fontSize = fontSize;
          span.style.margin = 0;
          span.style.padding = 0;
      
          span.appendChild(doc.createTextNode(sampleText));
          container.appendChild(span);
          container.appendChild(img);
          baseline = (img.offsetTop - span.offsetTop) + 1;
      
          container.removeChild(span);
          container.appendChild(doc.createTextNode(sampleText));
      
          container.style.lineHeight = "normal";
          img.style.verticalAlign = "super";
      
          middle = (img.offsetTop-container.offsetTop) + 1;
          metricsObj = {
            baseline: baseline,
            lineWidth: 1,
            middle: middle
          };
      
          fontData[font + "-" + fontSize] = metricsObj;
      
          doc.body.removeChild(container);
      
          return metricsObj;
        };
      })();
      
      (function(){
        var Util = _html2canvas.Util,
          Generate = {};
      
        _html2canvas.Generate = Generate;
      
        var reGradients = [
        /^(-webkit-linear-gradient)\(([a-z\s]+)([\w\d\.\s,%\(\)]+)\)$/,
        /^(-o-linear-gradient)\(([a-z\s]+)([\w\d\.\s,%\(\)]+)\)$/,
        /^(-webkit-gradient)\((linear|radial),\s((?:\d{1,3}%?)\s(?:\d{1,3}%?),\s(?:\d{1,3}%?)\s(?:\d{1,3}%?))([\w\d\.\s,%\(\)\-]+)\)$/,
        /^(-moz-linear-gradient)\(((?:\d{1,3}%?)\s(?:\d{1,3}%?))([\w\d\.\s,%\(\)]+)\)$/,
        /^(-webkit-radial-gradient)\(((?:\d{1,3}%?)\s(?:\d{1,3}%?)),\s(\w+)\s([a-z\-]+)([\w\d\.\s,%\(\)]+)\)$/,
        /^(-moz-radial-gradient)\(((?:\d{1,3}%?)\s(?:\d{1,3}%?)),\s(\w+)\s?([a-z\-]*)([\w\d\.\s,%\(\)]+)\)$/,
        /^(-o-radial-gradient)\(((?:\d{1,3}%?)\s(?:\d{1,3}%?)),\s(\w+)\s([a-z\-]+)([\w\d\.\s,%\(\)]+)\)$/
        ];
      
        /*
       * TODO: Add IE10 vendor prefix (-ms) support
       * TODO: Add W3C gradient (linear-gradient) support
       * TODO: Add old Webkit -webkit-gradient(radial, ...) support
       * TODO: Maybe some RegExp optimizations are possible ;o)
       */
        Generate.parseGradient = function(css, bounds) {
          var gradient, i, len = reGradients.length, m1, stop, m2, m2Len, step, m3, tl,tr,br,bl;
      
          for(i = 0; i < len; i+=1){
            m1 = css.match(reGradients[i]);
            if(m1) {
              break;
            }
          }
      
          if(m1) {
            switch(m1[1]) {
              case '-webkit-linear-gradient':
              case '-o-linear-gradient':
      
                gradient = {
                  type: 'linear',
                  x0: null,
                  y0: null,
                  x1: null,
                  y1: null,
                  colorStops: []
                };
      
                // get coordinates
                m2 = m1[2].match(/\w+/g);
                if(m2){
                  m2Len = m2.length;
                  for(i = 0; i < m2Len; i+=1){
                    switch(m2[i]) {
                      case 'top':
                        gradient.y0 = 0;
                        gradient.y1 = bounds.height;
                        break;
      
                      case 'right':
                        gradient.x0 = bounds.width;
                        gradient.x1 = 0;
                        break;
      
                      case 'bottom':
                        gradient.y0 = bounds.height;
                        gradient.y1 = 0;
                        break;
      
                      case 'left':
                        gradient.x0 = 0;
                        gradient.x1 = bounds.width;
                        break;
                    }
                  }
                }
                if(gradient.x0 === null && gradient.x1 === null){ // center
                  gradient.x0 = gradient.x1 = bounds.width / 2;
                }
                if(gradient.y0 === null && gradient.y1 === null){ // center
                  gradient.y0 = gradient.y1 = bounds.height / 2;
                }
      
                // get colors and stops
                m2 = m1[3].match(/((?:rgb|rgba)\(\d{1,3},\s\d{1,3},\s\d{1,3}(?:,\s[0-9\.]+)?\)(?:\s\d{1,3}(?:%|px))?)+/g);
                if(m2){
                  m2Len = m2.length;
                  step = 1 / Math.max(m2Len - 1, 1);
                  for(i = 0; i < m2Len; i+=1){
                    m3 = m2[i].match(/((?:rgb|rgba)\(\d{1,3},\s\d{1,3},\s\d{1,3}(?:,\s[0-9\.]+)?\))\s*(\d{1,3})?(%|px)?/);
                    if(m3[2]){
                      stop = parseFloat(m3[2]);
                      if(m3[3] === '%'){
                        stop /= 100;
                      } else { // px - stupid opera
                        stop /= bounds.width;
                      }
                    } else {
                      stop = i * step;
                    }
                    gradient.colorStops.push({
                      color: m3[1],
                      stop: stop
                    });
                  }
                }
                break;
      
              case '-webkit-gradient':
      
                gradient = {
                  type: m1[2] === 'radial' ? 'circle' : m1[2], // TODO: Add radial gradient support for older mozilla definitions
                  x0: 0,
                  y0: 0,
                  x1: 0,
                  y1: 0,
                  colorStops: []
                };
      
                // get coordinates
                m2 = m1[3].match(/(\d{1,3})%?\s(\d{1,3})%?,\s(\d{1,3})%?\s(\d{1,3})%?/);
                if(m2){
                  gradient.x0 = (m2[1] * bounds.width) / 100;
                  gradient.y0 = (m2[2] * bounds.height) / 100;
                  gradient.x1 = (m2[3] * bounds.width) / 100;
                  gradient.y1 = (m2[4] * bounds.height) / 100;
                }
      
                // get colors and stops
                m2 = m1[4].match(/((?:from|to|color-stop)\((?:[0-9\.]+,\s)?(?:rgb|rgba)\(\d{1,3},\s\d{1,3},\s\d{1,3}(?:,\s[0-9\.]+)?\)\))+/g);
                if(m2){
                  m2Len = m2.length;
                  for(i = 0; i < m2Len; i+=1){
                    m3 = m2[i].match(/(from|to|color-stop)\(([0-9\.]+)?(?:,\s)?((?:rgb|rgba)\(\d{1,3},\s\d{1,3},\s\d{1,3}(?:,\s[0-9\.]+)?\))\)/);
                    stop = parseFloat(m3[2]);
                    if(m3[1] === 'from') {
                      stop = 0.0;
                    }
                    if(m3[1] === 'to') {
                      stop = 1.0;
                    }
                    gradient.colorStops.push({
                      color: m3[3],
                      stop: stop
                    });
                  }
                }
                break;
      
              case '-moz-linear-gradient':
      
                gradient = {
                  type: 'linear',
                  x0: 0,
                  y0: 0,
                  x1: 0,
                  y1: 0,
                  colorStops: []
                };
      
                // get coordinates
                m2 = m1[2].match(/(\d{1,3})%?\s(\d{1,3})%?/);
      
                // m2[1] == 0%   -> left
                // m2[1] == 50%  -> center
                // m2[1] == 100% -> right
      
                // m2[2] == 0%   -> top
                // m2[2] == 50%  -> center
                // m2[2] == 100% -> bottom
      
                if(m2){
                  gradient.x0 = (m2[1] * bounds.width) / 100;
                  gradient.y0 = (m2[2] * bounds.height) / 100;
                  gradient.x1 = bounds.width - gradient.x0;
                  gradient.y1 = bounds.height - gradient.y0;
                }
      
                // get colors and stops
                m2 = m1[3].match(/((?:rgb|rgba)\(\d{1,3},\s\d{1,3},\s\d{1,3}(?:,\s[0-9\.]+)?\)(?:\s\d{1,3}%)?)+/g);
                if(m2){
                  m2Len = m2.length;
                  step = 1 / Math.max(m2Len - 1, 1);
                  for(i = 0; i < m2Len; i+=1){
                    m3 = m2[i].match(/((?:rgb|rgba)\(\d{1,3},\s\d{1,3},\s\d{1,3}(?:,\s[0-9\.]+)?\))\s*(\d{1,3})?(%)?/);
                    if(m3[2]){
                      stop = parseFloat(m3[2]);
                      if(m3[3]){ // percentage
                        stop /= 100;
                      }
                    } else {
                      stop = i * step;
                    }
                    gradient.colorStops.push({
                      color: m3[1],
                      stop: stop
                    });
                  }
                }
                break;
      
              case '-webkit-radial-gradient':
              case '-moz-radial-gradient':
              case '-o-radial-gradient':
      
                gradient = {
                  type: 'circle',
                  x0: 0,
                  y0: 0,
                  x1: bounds.width,
                  y1: bounds.height,
                  cx: 0,
                  cy: 0,
                  rx: 0,
                  ry: 0,
                  colorStops: []
                };
      
                // center
                m2 = m1[2].match(/(\d{1,3})%?\s(\d{1,3})%?/);
                if(m2){
                  gradient.cx = (m2[1] * bounds.width) / 100;
                  gradient.cy = (m2[2] * bounds.height) / 100;
                }
      
                // size
                m2 = m1[3].match(/\w+/);
                m3 = m1[4].match(/[a-z\-]*/);
                if(m2 && m3){
                  switch(m3[0]){
                    case 'farthest-corner':
                    case 'cover': // is equivalent to farthest-corner
                    case '': // mozilla removes "cover" from definition :(
                      tl = Math.sqrt(Math.pow(gradient.cx, 2) + Math.pow(gradient.cy, 2));
                      tr = Math.sqrt(Math.pow(gradient.cx, 2) + Math.pow(gradient.y1 - gradient.cy, 2));
                      br = Math.sqrt(Math.pow(gradient.x1 - gradient.cx, 2) + Math.pow(gradient.y1 - gradient.cy, 2));
                      bl = Math.sqrt(Math.pow(gradient.x1 - gradient.cx, 2) + Math.pow(gradient.cy, 2));
                      gradient.rx = gradient.ry = Math.max(tl, tr, br, bl);
                      break;
                    case 'closest-corner':
                      tl = Math.sqrt(Math.pow(gradient.cx, 2) + Math.pow(gradient.cy, 2));
                      tr = Math.sqrt(Math.pow(gradient.cx, 2) + Math.pow(gradient.y1 - gradient.cy, 2));
                      br = Math.sqrt(Math.pow(gradient.x1 - gradient.cx, 2) + Math.pow(gradient.y1 - gradient.cy, 2));
                      bl = Math.sqrt(Math.pow(gradient.x1 - gradient.cx, 2) + Math.pow(gradient.cy, 2));
                      gradient.rx = gradient.ry = Math.min(tl, tr, br, bl);
                      break;
                    case 'farthest-side':
                      if(m2[0] === 'circle'){
                        gradient.rx = gradient.ry = Math.max(
                          gradient.cx,
                          gradient.cy,
                          gradient.x1 - gradient.cx,
                          gradient.y1 - gradient.cy
                          );
                      } else { // ellipse
      
                        gradient.type = m2[0];
      
                        gradient.rx = Math.max(
                          gradient.cx,
                          gradient.x1 - gradient.cx
                          );
                        gradient.ry = Math.max(
                          gradient.cy,
                          gradient.y1 - gradient.cy
                          );
                      }
                      break;
                    case 'closest-side':
                    case 'contain': // is equivalent to closest-side
                      if(m2[0] === 'circle'){
                        gradient.rx = gradient.ry = Math.min(
                          gradient.cx,
                          gradient.cy,
                          gradient.x1 - gradient.cx,
                          gradient.y1 - gradient.cy
                          );
                      } else { // ellipse
      
                        gradient.type = m2[0];
      
                        gradient.rx = Math.min(
                          gradient.cx,
                          gradient.x1 - gradient.cx
                          );
                        gradient.ry = Math.min(
                          gradient.cy,
                          gradient.y1 - gradient.cy
                          );
                      }
                      break;
      
                  // TODO: add support for "30px 40px" sizes (webkit only)
                  }
                }
      
                // color stops
                m2 = m1[5].match(/((?:rgb|rgba)\(\d{1,3},\s\d{1,3},\s\d{1,3}(?:,\s[0-9\.]+)?\)(?:\s\d{1,3}(?:%|px))?)+/g);
                if(m2){
                  m2Len = m2.length;
                  step = 1 / Math.max(m2Len - 1, 1);
                  for(i = 0; i < m2Len; i+=1){
                    m3 = m2[i].match(/((?:rgb|rgba)\(\d{1,3},\s\d{1,3},\s\d{1,3}(?:,\s[0-9\.]+)?\))\s*(\d{1,3})?(%|px)?/);
                    if(m3[2]){
                      stop = parseFloat(m3[2]);
                      if(m3[3] === '%'){
                        stop /= 100;
                      } else { // px - stupid opera
                        stop /= bounds.width;
                      }
                    } else {
                      stop = i * step;
                    }
                    gradient.colorStops.push({
                      color: m3[1],
                      stop: stop
                    });
                  }
                }
                break;
            }
          }
      
          return gradient;
        };
      
        function addScrollStops(grad) {
          return function(colorStop) {
            try {
              grad.addColorStop(colorStop.stop, colorStop.color);
            }
            catch(e) {
              Util.log(['failed to add color stop: ', e, '; tried to add: ', colorStop]);
            }
          };
        }
      
        Generate.Gradient = function(src, bounds) {
          if(bounds.width === 0 || bounds.height === 0) {
            return;
          }
      
          var canvas = document.createElement('canvas'),
          ctx = canvas.getContext('2d'),
          gradient, grad;
      
          canvas.width = bounds.width;
          canvas.height = bounds.height;
      
          // TODO: add support for multi defined background gradients
          gradient = _html2canvas.Generate.parseGradient(src, bounds);
      
          if(gradient) {
            switch(gradient.type) {
              case 'linear':
                grad = ctx.createLinearGradient(gradient.x0, gradient.y0, gradient.x1, gradient.y1);
                gradient.colorStops.forEach(addScrollStops(grad));
                ctx.fillStyle = grad;
                ctx.fillRect(0, 0, bounds.width, bounds.height);
                break;
      
              case 'circle':
                grad = ctx.createRadialGradient(gradient.cx, gradient.cy, 0, gradient.cx, gradient.cy, gradient.rx);
                gradient.colorStops.forEach(addScrollStops(grad));
                ctx.fillStyle = grad;
                ctx.fillRect(0, 0, bounds.width, bounds.height);
                break;
      
              case 'ellipse':
                var canvasRadial = document.createElement('canvas'),
                  ctxRadial = canvasRadial.getContext('2d'),
                  ri = Math.max(gradient.rx, gradient.ry),
                  di = ri * 2;
      
                canvasRadial.width = canvasRadial.height = di;
      
                grad = ctxRadial.createRadialGradient(gradient.rx, gradient.ry, 0, gradient.rx, gradient.ry, ri);
                gradient.colorStops.forEach(addScrollStops(grad));
      
                ctxRadial.fillStyle = grad;
                ctxRadial.fillRect(0, 0, di, di);
      
                ctx.fillStyle = gradient.colorStops[gradient.colorStops.length - 1].color;
                ctx.fillRect(0, 0, canvas.width, canvas.height);
                ctx.drawImage(canvasRadial, gradient.cx - gradient.rx, gradient.cy - gradient.ry, 2 * gradient.rx, 2 * gradient.ry);
                break;
            }
          }
      
          return canvas;
        };
      
        Generate.ListAlpha = function(number) {
          var tmp = "",
          modulus;
      
          do {
            modulus = number % 26;
            tmp = String.fromCharCode((modulus) + 64) + tmp;
            number = number / 26;
          }while((number*26) > 26);
      
          return tmp;
        };
      
        Generate.ListRoman = function(number) {
          var romanArray = ["M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"],
          decimal = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1],
          roman = "",
          v,
          len = romanArray.length;
      
          if (number <= 0 || number >= 4000) {
            return number;
          }
      
          for (v=0; v < len; v+=1) {
            while (number >= decimal[v]) {
              number -= decimal[v];
              roman += romanArray[v];
            }
          }
      
          return roman;
        };
      })();
      function h2cRenderContext(width, height) {
        var storage = [];
        return {
          storage: storage,
          width: width,
          height: height,
          clip: function() {
            storage.push({
              type: "function",
              name: "clip",
              'arguments': arguments
            });
          },
          translate: function() {
            storage.push({
              type: "function",
              name: "translate",
              'arguments': arguments
            });
          },
          fill: function() {
            storage.push({
              type: "function",
              name: "fill",
              'arguments': arguments
            });
          },
          save: function() {
            storage.push({
              type: "function",
              name: "save",
              'arguments': arguments
            });
          },
          restore: function() {
            storage.push({
              type: "function",
              name: "restore",
              'arguments': arguments
            });
          },
          fillRect: function () {
            storage.push({
              type: "function",
              name: "fillRect",
              'arguments': arguments
            });
          },
          createPattern: function() {
            storage.push({
              type: "function",
              name: "createPattern",
              'arguments': arguments
            });
          },
          drawShape: function() {
      
            var shape = [];
      
            storage.push({
              type: "function",
              name: "drawShape",
              'arguments': shape
            });
      
            return {
              moveTo: function() {
                shape.push({
                  name: "moveTo",
                  'arguments': arguments
                });
              },
              lineTo: function() {
                shape.push({
                  name: "lineTo",
                  'arguments': arguments
                });
              },
              arcTo: function() {
                shape.push({
                  name: "arcTo",
                  'arguments': arguments
                });
              },
              bezierCurveTo: function() {
                shape.push({
                  name: "bezierCurveTo",
                  'arguments': arguments
                });
              },
              quadraticCurveTo: function() {
                shape.push({
                  name: "quadraticCurveTo",
                  'arguments': arguments
                });
              }
            };
      
          },
          drawImage: function () {
            storage.push({
              type: "function",
              name: "drawImage",
              'arguments': arguments
            });
          },
          fillText: function () {
            storage.push({
              type: "function",
              name: "fillText",
              'arguments': arguments
            });
          },
          setVariable: function (variable, value) {
            storage.push({
              type: "variable",
              name: variable,
              'arguments': value
            });
            return value;
          }
        };
      }
      _html2canvas.Parse = function (images, options) {
        window.scroll(0,0);
      
        var element = (( options.elements === undefined ) ? document.body : options.elements[0]), // select body by default
        numDraws = 0,
        doc = element.ownerDocument,
        Util = _html2canvas.Util,
        support = Util.Support(options, doc),
        ignoreElementsRegExp = new RegExp("(" + options.ignoreElements + ")"),
        body = doc.body,
        getCSS = Util.getCSS,
        pseudoHide = "___html2canvas___pseudoelement",
        hidePseudoElements = doc.createElement('style');
      
        hidePseudoElements.innerHTML = '.' + pseudoHide + '-before:before { content: "" !important; display: none !important; }' +
        '.' + pseudoHide + '-after:after { content: "" !important; display: none !important; }';
      
        body.appendChild(hidePseudoElements);
      
        images = images || {};
      
        function documentWidth () {
          return Math.max(
            Math.max(doc.body.scrollWidth, doc.documentElement.scrollWidth),
            Math.max(doc.body.offsetWidth, doc.documentElement.offsetWidth),
            Math.max(doc.body.clientWidth, doc.documentElement.clientWidth)
            );
        }
      
        function documentHeight () {
          return Math.max(
            Math.max(doc.body.scrollHeight, doc.documentElement.scrollHeight),
            Math.max(doc.body.offsetHeight, doc.documentElement.offsetHeight),
            Math.max(doc.body.clientHeight, doc.documentElement.clientHeight)
            );
        }
      
        function getCSSInt(element, attribute) {
          var val = parseInt(getCSS(element, attribute), 10);
          return (isNaN(val)) ? 0 : val; // borders in old IE are throwing 'medium' for demo.html
        }
      
        function renderRect (ctx, x, y, w, h, bgcolor) {
          if (bgcolor !== "transparent"){
            ctx.setVariable("fillStyle", bgcolor);
            ctx.fillRect(x, y, w, h);
            numDraws+=1;
          }
        }
      
        function capitalize(m, p1, p2) {
          if (m.length > 0) {
            return p1 + p2.toUpperCase();
          }
        }
      
        function textTransform (text, transform) {
          switch(transform){
            case "lowercase":
              return text.toLowerCase();
            case "capitalize":
              return text.replace( /(^|\s|:|-|\(|\))([a-z])/g, capitalize);
            case "uppercase":
              return text.toUpperCase();
            default:
              return text;
          }
        }
      
        function noLetterSpacing(letter_spacing) {
          return (/^(normal|none|0px)$/.test(letter_spacing));
        }
      
        function drawText(currentText, x, y, ctx){
          if (currentText !== null && Util.trimText(currentText).length > 0) {
            ctx.fillText(currentText, x, y);
            numDraws+=1;
          }
        }
      
        function setTextVariables(ctx, el, text_decoration, color) {
          var align = false,
          bold = getCSS(el, "fontWeight"),
          family = getCSS(el, "fontFamily"),
          size = getCSS(el, "fontSize"),
          shadows = Util.parseTextShadows(getCSS(el, "textShadow"));
      
          switch(parseInt(bold, 10)){
            case 401:
              bold = "bold";
              break;
            case 400:
              bold = "normal";
              break;
          }
      
          ctx.setVariable("fillStyle", color);
          ctx.setVariable("font", [getCSS(el, "fontStyle"), getCSS(el, "fontVariant"), bold, size, family].join(" "));
          ctx.setVariable("textAlign", (align) ? "right" : "left");
      
          if (shadows.length) {
            // TODO: support multiple text shadows
            // apply the first text shadow
            ctx.setVariable("shadowColor", shadows[0].color);
            ctx.setVariable("shadowOffsetX", shadows[0].offsetX);
            ctx.setVariable("shadowOffsetY", shadows[0].offsetY);
            ctx.setVariable("shadowBlur", shadows[0].blur);
          }
      
          if (text_decoration !== "none"){
            return Util.Font(family, size, doc);
          }
        }
      
        function renderTextDecoration(ctx, text_decoration, bounds, metrics, color) {
          switch(text_decoration) {
            case "underline":
              // Draws a line at the baseline of the font
              // TODO As some browsers display the line as more than 1px if the font-size is big, need to take that into account both in position and size
              renderRect(ctx, bounds.left, Math.round(bounds.top + metrics.baseline + metrics.lineWidth), bounds.width, 1, color);
              break;
            case "overline":
              renderRect(ctx, bounds.left, Math.round(bounds.top), bounds.width, 1, color);
              break;
            case "line-through":
              // TODO try and find exact position for line-through
              renderRect(ctx, bounds.left, Math.ceil(bounds.top + metrics.middle + metrics.lineWidth), bounds.width, 1, color);
              break;
          }
        }
      
        function getTextBounds(state, text, textDecoration, isLast, transform) {
          var bounds;
          if (support.rangeBounds && !transform) {
            if (textDecoration !== "none" || Util.trimText(text).length !== 0) {
              bounds = textRangeBounds(text, state.node, state.textOffset);
            }
            state.textOffset += text.length;
          } else if (state.node && typeof state.node.nodeValue === "string" ){
            var newTextNode = (isLast) ? state.node.splitText(text.length) : null;
            bounds = textWrapperBounds(state.node, transform);
            state.node = newTextNode;
          }
          return bounds;
        }
      
        function textRangeBounds(text, textNode, textOffset) {
          var range = doc.createRange();
          range.setStart(textNode, textOffset);
          range.setEnd(textNode, textOffset + text.length);
          return range.getBoundingClientRect();
        }
      
        function textWrapperBounds(oldTextNode, transform) {
          var parent = oldTextNode.parentNode,
          wrapElement = doc.createElement('wrapper'),
          backupText = oldTextNode.cloneNode(true);
      
          wrapElement.appendChild(oldTextNode.cloneNode(true));
          parent.replaceChild(wrapElement, oldTextNode);
      
          var bounds = transform ? Util.OffsetBounds(wrapElement) : Util.Bounds(wrapElement);
          parent.replaceChild(backupText, wrapElement);
          return bounds;
        }
      
        function renderText(el, textNode, stack) {
          var ctx = stack.ctx,
          color = getCSS(el, "color"),
          textDecoration = getCSS(el, "textDecoration"),
          textAlign = getCSS(el, "textAlign"),
          metrics,
          textList,
          state = {
            node: textNode,
            textOffset: 0
          };
      
          if (Util.trimText(textNode.nodeValue).length > 0) {
            textNode.nodeValue = textTransform(textNode.nodeValue, getCSS(el, "textTransform"));
            textAlign = textAlign.replace(["-webkit-auto"],["auto"]);
      
            textList = (!options.letterRendering && /^(left|right|justify|auto)$/.test(textAlign) && noLetterSpacing(getCSS(el, "letterSpacing"))) ?
            textNode.nodeValue.split(/(\b| )/)
            : textNode.nodeValue.split("");
      
            metrics = setTextVariables(ctx, el, textDecoration, color);
      
            if (options.chinese) {
              textList.forEach(function(word, index) {
                if (/.*[\u4E00-\u9FA5].*$/.test(word)) {
                  word = word.split("");
                  word.unshift(index, 1);
                  textList.splice.apply(textList, word);
                }
              });
            }
      
            textList.forEach(function(text, index) {
              var bounds = getTextBounds(state, text, textDecoration, (index < textList.length - 1), stack.transform.matrix);
              if (bounds) {
                drawText(text, bounds.left, bounds.bottom, ctx);
                renderTextDecoration(ctx, textDecoration, bounds, metrics, color);
              }
            });
          }
        }
      
        function listPosition (element, val) {
          var boundElement = doc.createElement( "boundelement" ),
          originalType,
          bounds;
      
          boundElement.style.display = "inline";
      
          originalType = element.style.listStyleType;
          element.style.listStyleType = "none";
      
          boundElement.appendChild(doc.createTextNode(val));
      
          element.insertBefore(boundElement, element.firstChild);
      
          bounds = Util.Bounds(boundElement);
          element.removeChild(boundElement);
          element.style.listStyleType = originalType;
          return bounds;
        }
      
        function elementIndex(el) {
          var i = -1,
          count = 1,
          childs = el.parentNode.childNodes;
      
          if (el.parentNode) {
            while(childs[++i] !== el) {
              if (childs[i].nodeType === 1) {
                count++;
              }
            }
            return count;
          } else {
            return -1;
          }
        }
      
        function listItemText(element, type) {
          var currentIndex = elementIndex(element), text;
          switch(type){
            case "decimal":
              text = currentIndex;
              break;
            case "decimal-leading-zero":
              text = (currentIndex.toString().length === 1) ? currentIndex = "0" + currentIndex.toString() : currentIndex.toString();
              break;
            case "upper-roman":
              text = _html2canvas.Generate.ListRoman( currentIndex );
              break;
            case "lower-roman":
              text = _html2canvas.Generate.ListRoman( currentIndex ).toLowerCase();
              break;
            case "lower-alpha":
              text = _html2canvas.Generate.ListAlpha( currentIndex ).toLowerCase();
              break;
            case "upper-alpha":
              text = _html2canvas.Generate.ListAlpha( currentIndex );
              break;
          }
      
          return text + ". ";
        }
      
        function renderListItem(element, stack, elBounds) {
          var x,
          text,
          ctx = stack.ctx,
          type = getCSS(element, "listStyleType"),
          listBounds;
      
          if (/^(decimal|decimal-leading-zero|upper-alpha|upper-latin|upper-roman|lower-alpha|lower-greek|lower-latin|lower-roman)$/i.test(type)) {
            text = listItemText(element, type);
            listBounds = listPosition(element, text);
            setTextVariables(ctx, element, "none", getCSS(element, "color"));
      
            if (getCSS(element, "listStylePosition") === "inside") {
              ctx.setVariable("textAlign", "left");
              x = elBounds.left;
            } else {
              return;
            }
      
            drawText(text, x, listBounds.bottom, ctx);
          }
        }
      
        function loadImage (src){
          var img = images[src];
          return (img && img.succeeded === true) ? img.img : false;
        }
      
        function clipBounds(src, dst){
          var x = Math.max(src.left, dst.left),
          y = Math.max(src.top, dst.top),
          x2 = Math.min((src.left + src.width), (dst.left + dst.width)),
          y2 = Math.min((src.top + src.height), (dst.top + dst.height));
      
          return {
            left:x,
            top:y,
            width:x2-x,
            height:y2-y
          };
        }
      
        function setZ(element, stack, parentStack){
          var newContext,
          isPositioned = stack.cssPosition !== 'static',
          zIndex = isPositioned ? getCSS(element, 'zIndex') : 'auto',
          opacity = getCSS(element, 'opacity'),
          isFloated = getCSS(element, 'cssFloat') !== 'none';
      
          // https://developer.mozilla.org/en-US/docs/Web/Guide/CSS/Understanding_z_index/The_stacking_context
          // When a new stacking context should be created:
          // the root element (HTML),
          // positioned (absolutely or relatively) with a z-index value other than "auto",
          // elements with an opacity value less than 1. (See the specification for opacity),
          // on mobile WebKit and Chrome 22+, position: fixed always creates a new stacking context, even when z-index is "auto" (See this post)
      
          stack.zIndex = newContext = h2czContext(zIndex);
          newContext.isPositioned = isPositioned;
          newContext.isFloated = isFloated;
          newContext.opacity = opacity;
          newContext.ownStacking = (zIndex !== 'auto' || opacity < 1);
      
          if (parentStack) {
            parentStack.zIndex.children.push(stack);
          }
        }
      
        function renderImage(ctx, element, image, bounds, borders) {
      
          var paddingLeft = getCSSInt(element, 'paddingLeft'),
          paddingTop = getCSSInt(element, 'paddingTop'),
          paddingRight = getCSSInt(element, 'paddingRight'),
          paddingBottom = getCSSInt(element, 'paddingBottom');
      
          drawImage(
            ctx,
            image,
            0, //sx
            0, //sy
            image.width, //sw
            image.height, //sh
            bounds.left + paddingLeft + borders[3].width, //dx
            bounds.top + paddingTop + borders[0].width, // dy
            bounds.width - (borders[1].width + borders[3].width + paddingLeft + paddingRight), //dw
            bounds.height - (borders[0].width + borders[2].width + paddingTop + paddingBottom) //dh
            );
        }
      
        function getBorderData(element) {
          return ["Top", "Right", "Bottom", "Left"].map(function(side) {
            return {
              width: getCSSInt(element, 'border' + side + 'Width'),
              color: getCSS(element, 'border' + side + 'Color')
            };
          });
        }
      
        function getBorderRadiusData(element) {
          return ["TopLeft", "TopRight", "BottomRight", "BottomLeft"].map(function(side) {
            return getCSS(element, 'border' + side + 'Radius');
          });
        }
      
        var getCurvePoints = (function(kappa) {
      
          return function(x, y, r1, r2) {
            var ox = (r1) * kappa, // control point offset horizontal
            oy = (r2) * kappa, // control point offset vertical
            xm = x + r1, // x-middle
            ym = y + r2; // y-middle
            return {
              topLeft: bezierCurve({
                x:x,
                y:ym
              }, {
                x:x,
                y:ym - oy
              }, {
                x:xm - ox,
                y:y
              }, {
                x:xm,
                y:y
              }),
              topRight: bezierCurve({
                x:x,
                y:y
              }, {
                x:x + ox,
                y:y
              }, {
                x:xm,
                y:ym - oy
              }, {
                x:xm,
                y:ym
              }),
              bottomRight: bezierCurve({
                x:xm,
                y:y
              }, {
                x:xm,
                y:y + oy
              }, {
                x:x + ox,
                y:ym
              }, {
                x:x,
                y:ym
              }),
              bottomLeft: bezierCurve({
                x:xm,
                y:ym
              }, {
                x:xm - ox,
                y:ym
              }, {
                x:x,
                y:y + oy
              }, {
                x:x,
                y:y
              })
            };
          };
        })(4 * ((Math.sqrt(2) - 1) / 3));
      
        function bezierCurve(start, startControl, endControl, end) {
      
          var lerp = function (a, b, t) {
            return {
              x:a.x + (b.x - a.x) * t,
              y:a.y + (b.y - a.y) * t
            };
          };
      
          return {
            start: start,
            startControl: startControl,
            endControl: endControl,
            end: end,
            subdivide: function(t) {
              var ab = lerp(start, startControl, t),
              bc = lerp(startControl, endControl, t),
              cd = lerp(endControl, end, t),
              abbc = lerp(ab, bc, t),
              bccd = lerp(bc, cd, t),
              dest = lerp(abbc, bccd, t);
              return [bezierCurve(start, ab, abbc, dest), bezierCurve(dest, bccd, cd, end)];
            },
            curveTo: function(borderArgs) {
              borderArgs.push(["bezierCurve", startControl.x, startControl.y, endControl.x, endControl.y, end.x, end.y]);
            },
            curveToReversed: function(borderArgs) {
              borderArgs.push(["bezierCurve", endControl.x, endControl.y, startControl.x, startControl.y, start.x, start.y]);
            }
          };
        }
      
        function parseCorner(borderArgs, radius1, radius2, corner1, corner2, x, y) {
          if (radius1[0] > 0 || radius1[1] > 0) {
            borderArgs.push(["line", corner1[0].start.x, corner1[0].start.y]);
            corner1[0].curveTo(borderArgs);
            corner1[1].curveTo(borderArgs);
          } else {
            borderArgs.push(["line", x, y]);
          }
      
          if (radius2[0] > 0 || radius2[1] > 0) {
            borderArgs.push(["line", corner2[0].start.x, corner2[0].start.y]);
          }
        }
      
        function drawSide(borderData, radius1, radius2, outer1, inner1, outer2, inner2) {
          var borderArgs = [];
      
          if (radius1[0] > 0 || radius1[1] > 0) {
            borderArgs.push(["line", outer1[1].start.x, outer1[1].start.y]);
            outer1[1].curveTo(borderArgs);
          } else {
            borderArgs.push([ "line", borderData.c1[0], borderData.c1[1]]);
          }
      
          if (radius2[0] > 0 || radius2[1] > 0) {
            borderArgs.push(["line", outer2[0].start.x, outer2[0].start.y]);
            outer2[0].curveTo(borderArgs);
            borderArgs.push(["line", inner2[0].end.x, inner2[0].end.y]);
            inner2[0].curveToReversed(borderArgs);
          } else {
            borderArgs.push([ "line", borderData.c2[0], borderData.c2[1]]);
            borderArgs.push([ "line", borderData.c3[0], borderData.c3[1]]);
          }
      
          if (radius1[0] > 0 || radius1[1] > 0) {
            borderArgs.push(["line", inner1[1].end.x, inner1[1].end.y]);
            inner1[1].curveToReversed(borderArgs);
          } else {
            borderArgs.push([ "line", borderData.c4[0], borderData.c4[1]]);
          }
      
          return borderArgs;
        }
      
        function calculateCurvePoints(bounds, borderRadius, borders) {
      
          var x = bounds.left,
          y = bounds.top,
          width = bounds.width,
          height = bounds.height,
      
          tlh = borderRadius[0][0],
          tlv = borderRadius[0][1],
          trh = borderRadius[1][0],
          trv = borderRadius[1][1],
          brh = borderRadius[2][0],
          brv = borderRadius[2][1],
          blh = borderRadius[3][0],
          blv = borderRadius[3][1],
      
          topWidth = width - trh,
          rightHeight = height - brv,
          bottomWidth = width - brh,
          leftHeight = height - blv;
      
          return {
            topLeftOuter: getCurvePoints(
              x,
              y,
              tlh,
              tlv
              ).topLeft.subdivide(0.5),
      
            topLeftInner: getCurvePoints(
              x + borders[3].width,
              y + borders[0].width,
              Math.max(0, tlh - borders[3].width),
              Math.max(0, tlv - borders[0].width)
              ).topLeft.subdivide(0.5),
      
            topRightOuter: getCurvePoints(
              x + topWidth,
              y,
              trh,
              trv
              ).topRight.subdivide(0.5),
      
            topRightInner: getCurvePoints(
              x + Math.min(topWidth, width + borders[3].width),
              y + borders[0].width,
              (topWidth > width + borders[3].width) ? 0 :trh - borders[3].width,
              trv - borders[0].width
              ).topRight.subdivide(0.5),
      
            bottomRightOuter: getCurvePoints(
              x + bottomWidth,
              y + rightHeight,
              brh,
              brv
              ).bottomRight.subdivide(0.5),
      
            bottomRightInner: getCurvePoints(
              x + Math.min(bottomWidth, width + borders[3].width),
              y + Math.min(rightHeight, height + borders[0].width),
              Math.max(0, brh - borders[1].width),
              Math.max(0, brv - borders[2].width)
              ).bottomRight.subdivide(0.5),
      
            bottomLeftOuter: getCurvePoints(
              x,
              y + leftHeight,
              blh,
              blv
              ).bottomLeft.subdivide(0.5),
      
            bottomLeftInner: getCurvePoints(
              x + borders[3].width,
              y + leftHeight,
              Math.max(0, blh - borders[3].width),
              Math.max(0, blv - borders[2].width)
              ).bottomLeft.subdivide(0.5)
          };
        }
      
        function getBorderClip(element, borderPoints, borders, radius, bounds) {
          var backgroundClip = getCSS(element, 'backgroundClip'),
          borderArgs = [];
      
          switch(backgroundClip) {
            case "content-box":
            case "padding-box":
              parseCorner(borderArgs, radius[0], radius[1], borderPoints.topLeftInner, borderPoints.topRightInner, bounds.left + borders[3].width, bounds.top + borders[0].width);
              parseCorner(borderArgs, radius[1], radius[2], borderPoints.topRightInner, borderPoints.bottomRightInner, bounds.left + bounds.width - borders[1].width, bounds.top + borders[0].width);
              parseCorner(borderArgs, radius[2], radius[3], borderPoints.bottomRightInner, borderPoints.bottomLeftInner, bounds.left + bounds.width - borders[1].width, bounds.top + bounds.height - borders[2].width);
              parseCorner(borderArgs, radius[3], radius[0], borderPoints.bottomLeftInner, borderPoints.topLeftInner, bounds.left + borders[3].width, bounds.top + bounds.height - borders[2].width);
              break;
      
            default:
              parseCorner(borderArgs, radius[0], radius[1], borderPoints.topLeftOuter, borderPoints.topRightOuter, bounds.left, bounds.top);
              parseCorner(borderArgs, radius[1], radius[2], borderPoints.topRightOuter, borderPoints.bottomRightOuter, bounds.left + bounds.width, bounds.top);
              parseCorner(borderArgs, radius[2], radius[3], borderPoints.bottomRightOuter, borderPoints.bottomLeftOuter, bounds.left + bounds.width, bounds.top + bounds.height);
              parseCorner(borderArgs, radius[3], radius[0], borderPoints.bottomLeftOuter, borderPoints.topLeftOuter, bounds.left, bounds.top + bounds.height);
              break;
          }
      
          return borderArgs;
        }
      
        function parseBorders(element, bounds, borders){
          var x = bounds.left,
          y = bounds.top,
          width = bounds.width,
          height = bounds.height,
          borderSide,
          bx,
          by,
          bw,
          bh,
          borderArgs,
          // http://www.w3.org/TR/css3-background/#the-border-radius
          borderRadius = getBorderRadiusData(element),
          borderPoints = calculateCurvePoints(bounds, borderRadius, borders),
          borderData = {
            clip: getBorderClip(element, borderPoints, borders, borderRadius, bounds),
            borders: []
          };
      
          for (borderSide = 0; borderSide < 4; borderSide++) {
      
            if (borders[borderSide].width > 0) {
              bx = x;
              by = y;
              bw = width;
              bh = height - (borders[2].width);
      
              switch(borderSide) {
                case 0:
                  // top border
                  bh = borders[0].width;
      
                  borderArgs = drawSide({
                    c1: [bx, by],
                    c2: [bx + bw, by],
                    c3: [bx + bw - borders[1].width, by + bh],
                    c4: [bx + borders[3].width, by + bh]
                  }, borderRadius[0], borderRadius[1],
                  borderPoints.topLeftOuter, borderPoints.topLeftInner, borderPoints.topRightOuter, borderPoints.topRightInner);
                  break;
                case 1:
                  // right border
                  bx = x + width - (borders[1].width);
                  bw = borders[1].width;
      
                  borderArgs = drawSide({
                    c1: [bx + bw, by],
                    c2: [bx + bw, by + bh + borders[2].width],
                    c3: [bx, by + bh],
                    c4: [bx, by + borders[0].width]
                  }, borderRadius[1], borderRadius[2],
                  borderPoints.topRightOuter, borderPoints.topRightInner, borderPoints.bottomRightOuter, borderPoints.bottomRightInner);
                  break;
                case 2:
                  // bottom border
                  by = (by + height) - (borders[2].width);
                  bh = borders[2].width;
      
                  borderArgs = drawSide({
                    c1: [bx + bw, by + bh],
                    c2: [bx, by + bh],
                    c3: [bx + borders[3].width, by],
                    c4: [bx + bw - borders[3].width, by]
                  }, borderRadius[2], borderRadius[3],
                  borderPoints.bottomRightOuter, borderPoints.bottomRightInner, borderPoints.bottomLeftOuter, borderPoints.bottomLeftInner);
                  break;
                case 3:
                  // left border
                  bw = borders[3].width;
      
                  borderArgs = drawSide({
                    c1: [bx, by + bh + borders[2].width],
                    c2: [bx, by],
                    c3: [bx + bw, by + borders[0].width],
                    c4: [bx + bw, by + bh]
                  }, borderRadius[3], borderRadius[0],
                  borderPoints.bottomLeftOuter, borderPoints.bottomLeftInner, borderPoints.topLeftOuter, borderPoints.topLeftInner);
                  break;
              }
      
              borderData.borders.push({
                args: borderArgs,
                color: borders[borderSide].color
              });
      
            }
          }
      
          return borderData;
        }
      
        function createShape(ctx, args) {
          var shape = ctx.drawShape();
          args.forEach(function(border, index) {
            shape[(index === 0) ? "moveTo" : border[0] + "To" ].apply(null, border.slice(1));
          });
          return shape;
        }
      
        function renderBorders(ctx, borderArgs, color) {
          if (color !== "transparent") {
            ctx.setVariable( "fillStyle", color);
            createShape(ctx, borderArgs);
            ctx.fill();
            numDraws+=1;
          }
        }
      
        function renderFormValue (el, bounds, stack){
      
          var valueWrap = doc.createElement('valuewrap'),
          cssPropertyArray = ['lineHeight','textAlign','fontFamily','color','fontSize','paddingLeft','paddingTop','width','height','border','borderLeftWidth','borderTopWidth'],
          textValue,
          textNode;
      
          cssPropertyArray.forEach(function(property) {
            try {
              valueWrap.style[property] = getCSS(el, property);
            } catch(e) {
              // Older IE has issues with "border"
              Util.log("html2canvas: Parse: Exception caught in renderFormValue: " + e.message);
            }
          });
      
          valueWrap.style.borderColor = "black";
          valueWrap.style.borderStyle = "solid";
          valueWrap.style.display = "block";
          valueWrap.style.position = "absolute";
      
          if (/^(submit|reset|button|text|password)$/.test(el.type) || el.nodeName === "SELECT"){
            valueWrap.style.lineHeight = getCSS(el, "height");
          }
      
          valueWrap.style.top = bounds.top + "px";
          valueWrap.style.left = bounds.left + "px";
      
          textValue = (el.nodeName === "SELECT") ? (el.options[el.selectedIndex] || 0).text : el.value;
          if(!textValue) {
            textValue = el.placeholder;
          }
      
          textNode = doc.createTextNode(textValue);
      
          valueWrap.appendChild(textNode);
          body.appendChild(valueWrap);
      
          renderText(el, textNode, stack);
          body.removeChild(valueWrap);
        }
      
        function drawImage (ctx) {
          ctx.drawImage.apply(ctx, Array.prototype.slice.call(arguments, 1));
          numDraws+=1;
        }
      
        function getPseudoElement(el, which) {
          var elStyle = window.getComputedStyle(el, which);
          if(!elStyle || !elStyle.content || elStyle.content === "none" || elStyle.content === "-moz-alt-content" || elStyle.display === "none") {
            return;
          }
          var content = elStyle.content + '',
          first = content.substr( 0, 1 );
          //strips quotes
          if(first === content.substr( content.length - 1 ) && first.match(/'|"/)) {
            content = content.substr( 1, content.length - 2 );
          }
      
          var isImage = content.substr( 0, 3 ) === 'url',
          elps = document.createElement( isImage ? 'img' : 'span' );
      
          elps.className = pseudoHide + "-before " + pseudoHide + "-after";
      
          Object.keys(elStyle).filter(indexedProperty).forEach(function(prop) {
            // Prevent assigning of read only CSS Rules, ex. length, parentRule
            try {
              elps.style[prop] = elStyle[prop];
            } catch (e) {
              Util.log(['Tried to assign readonly property ', prop, 'Error:', e]);
            }
          });
      
          if(isImage) {
            elps.src = Util.parseBackgroundImage(content)[0].args[0];
          } else {
            elps.innerHTML = content;
          }
          return elps;
        }
      
        function indexedProperty(property) {
          return (isNaN(window.parseInt(property, 10)));
        }
      
        function injectPseudoElements(el, stack) {
          var before = getPseudoElement(el, ':before'),
          after = getPseudoElement(el, ':after');
          if(!before && !after) {
            return;
          }
      
          if(before) {
            el.className += " " + pseudoHide + "-before";
            el.parentNode.insertBefore(before, el);
            parseElement(before, stack, true);
            el.parentNode.removeChild(before);
            el.className = el.className.replace(pseudoHide + "-before", "").trim();
          }
      
          if (after) {
            el.className += " " + pseudoHide + "-after";
            el.appendChild(after);
            parseElement(after, stack, true);
            el.removeChild(after);
            el.className = el.className.replace(pseudoHide + "-after", "").trim();
          }
      
        }
      
        function renderBackgroundRepeat(ctx, image, backgroundPosition, bounds) {
          var offsetX = Math.round(bounds.left + backgroundPosition.left),
          offsetY = Math.round(bounds.top + backgroundPosition.top);
      
          ctx.createPattern(image);
          ctx.translate(offsetX, offsetY);
          ctx.fill();
          ctx.translate(-offsetX, -offsetY);
        }
      
        function backgroundRepeatShape(ctx, image, backgroundPosition, bounds, left, top, width, height) {
          var args = [];
          args.push(["line", Math.round(left), Math.round(top)]);
          args.push(["line", Math.round(left + width), Math.round(top)]);
          args.push(["line", Math.round(left + width), Math.round(height + top)]);
          args.push(["line", Math.round(left), Math.round(height + top)]);
          createShape(ctx, args);
          ctx.save();
          ctx.clip();
          renderBackgroundRepeat(ctx, image, backgroundPosition, bounds);
          ctx.restore();
        }
      
        function renderBackgroundColor(ctx, backgroundBounds, bgcolor) {
          renderRect(
            ctx,
            backgroundBounds.left,
            backgroundBounds.top,
            backgroundBounds.width,
            backgroundBounds.height,
            bgcolor
            );
        }
      
        function renderBackgroundRepeating(el, bounds, ctx, image, imageIndex) {
          var backgroundSize = Util.BackgroundSize(el, bounds, image, imageIndex),
          backgroundPosition = Util.BackgroundPosition(el, bounds, image, imageIndex, backgroundSize),
          backgroundRepeat = getCSS(el, "backgroundRepeat").split(",").map(Util.trimText);
      
          image = resizeImage(image, backgroundSize);
      
          backgroundRepeat = backgroundRepeat[imageIndex] || backgroundRepeat[0];
      
          switch (backgroundRepeat) {
            case "repeat-x":
              backgroundRepeatShape(ctx, image, backgroundPosition, bounds,
                bounds.left, bounds.top + backgroundPosition.top, 99999, image.height);
              break;
      
            case "repeat-y":
              backgroundRepeatShape(ctx, image, backgroundPosition, bounds,
                bounds.left + backgroundPosition.left, bounds.top, image.width, 99999);
              break;
      
            case "no-repeat":
              backgroundRepeatShape(ctx, image, backgroundPosition, bounds,
                bounds.left + backgroundPosition.left, bounds.top + backgroundPosition.top, image.width, image.height);
              break;
      
            default:
              renderBackgroundRepeat(ctx, image, backgroundPosition, {
                top: bounds.top,
                left: bounds.left,
                width: image.width,
                height: image.height
              });
              break;
          }
        }
      
        function renderBackgroundImage(element, bounds, ctx) {
          var backgroundImage = getCSS(element, "backgroundImage"),
          backgroundImages = Util.parseBackgroundImage(backgroundImage),
          image,
          imageIndex = backgroundImages.length;
      
          while(imageIndex--) {
            backgroundImage = backgroundImages[imageIndex];
      
            if (!backgroundImage.args || backgroundImage.args.length === 0) {
              continue;
            }
      
            var key = backgroundImage.method === 'url' ?
            backgroundImage.args[0] :
            backgroundImage.value;
      
            image = loadImage(key);
      
            // TODO add support for background-origin
            if (image) {
              renderBackgroundRepeating(element, bounds, ctx, image, imageIndex);
            } else {
              Util.log("html2canvas: Error loading background:", backgroundImage);
            }
          }
        }
      
        function resizeImage(image, bounds) {
          if(image.width === bounds.width && image.height === bounds.height) {
            return image;
          }
      
          var ctx, canvas = doc.createElement('canvas');
          canvas.width = bounds.width;
          canvas.height = bounds.height;
          ctx = canvas.getContext("2d");
          drawImage(ctx, image, 0, 0, image.width, image.height, 0, 0, bounds.width, bounds.height );
          return canvas;
        }
      
        function setOpacity(ctx, element, parentStack) {
          return ctx.setVariable("globalAlpha", getCSS(element, "opacity") * ((parentStack) ? parentStack.opacity : 1));
        }
      
        function removePx(str) {
          return str.replace("px", "");
        }
      
        var transformRegExp = /(matrix)\((.+)\)/;
      
        function getTransform(element, parentStack) {
          var transform = getCSS(element, "transform") || getCSS(element, "-webkit-transform") || getCSS(element, "-moz-transform") || getCSS(element, "-ms-transform") || getCSS(element, "-o-transform");
          var transformOrigin = getCSS(element, "transform-origin") || getCSS(element, "-webkit-transform-origin") || getCSS(element, "-moz-transform-origin") || getCSS(element, "-ms-transform-origin") || getCSS(element, "-o-transform-origin") || "0px 0px";
      
          transformOrigin = transformOrigin.split(" ").map(removePx).map(Util.asFloat);
      
          var matrix;
          if (transform && transform !== "none") {
            var match = transform.match(transformRegExp);
            if (match) {
              switch(match[1]) {
                case "matrix":
                  matrix = match[2].split(",").map(Util.trimText).map(Util.asFloat);
                  break;
              }
            }
          }
      
          return {
            origin: transformOrigin,
            matrix: matrix
          };
        }
      
        function createStack(element, parentStack, bounds, transform) {
          var ctx = h2cRenderContext((!parentStack) ? documentWidth() : bounds.width , (!parentStack) ? documentHeight() : bounds.height),
          stack = {
            ctx: ctx,
            opacity: setOpacity(ctx, element, parentStack),
            cssPosition: getCSS(element, "position"),
            borders: getBorderData(element),
            transform: transform,
            clip: (parentStack && parentStack.clip) ? Util.Extend( {}, parentStack.clip ) : null
          };
      
          setZ(element, stack, parentStack);
      
          // TODO correct overflow for absolute content residing under a static position
          if (options.useOverflow === true && /(hidden|scroll|auto)/.test(getCSS(element, "overflow")) === true && /(BODY)/i.test(element.nodeName) === false){
            stack.clip = (stack.clip) ? clipBounds(stack.clip, bounds) : bounds;
          }
      
          return stack;
        }
      
        function getBackgroundBounds(borders, bounds, clip) {
          var backgroundBounds = {
            left: bounds.left + borders[3].width,
            top: bounds.top + borders[0].width,
            width: bounds.width - (borders[1].width + borders[3].width),
            height: bounds.height - (borders[0].width + borders[2].width)
          };
      
          if (clip) {
            backgroundBounds = clipBounds(backgroundBounds, clip);
          }
      
          return backgroundBounds;
        }
      
        function getBounds(element, transform) {
          var bounds = (transform.matrix) ? Util.OffsetBounds(element) : Util.Bounds(element);
          transform.origin[0] += bounds.left;
          transform.origin[1] += bounds.top;
          return bounds;
        }
      
        function renderElement(element, parentStack, pseudoElement, ignoreBackground) {
          var transform = getTransform(element, parentStack),
          bounds = getBounds(element, transform),
          image,
          stack = createStack(element, parentStack, bounds, transform),
          borders = stack.borders,
          ctx = stack.ctx,
          backgroundBounds = getBackgroundBounds(borders, bounds, stack.clip),
          borderData = parseBorders(element, bounds, borders),
          backgroundColor = (ignoreElementsRegExp.test(element.nodeName)) ? "#efefef" : getCSS(element, "backgroundColor");
      
      
          createShape(ctx, borderData.clip);
      
          ctx.save();
          ctx.clip();
      
          if (backgroundBounds.height > 0 && backgroundBounds.width > 0 && !ignoreBackground) {
            renderBackgroundColor(ctx, bounds, backgroundColor);
            renderBackgroundImage(element, backgroundBounds, ctx);
          } else if (ignoreBackground) {
            stack.backgroundColor =  backgroundColor;
          }
      
          ctx.restore();
      
          borderData.borders.forEach(function(border) {
            renderBorders(ctx, border.args, border.color);
          });
      
          if (!pseudoElement) {
            injectPseudoElements(element, stack);
          }
      
          switch(element.nodeName){
            case "IMG":
              if ((image = loadImage(element.getAttribute('src')))) {
                renderImage(ctx, element, image, bounds, borders);
              } else {
                Util.log("html2canvas: Error loading <img>:" + element.getAttribute('src'));
              }
              break;
            case "INPUT":
              // TODO add all relevant type's, i.e. HTML5 new stuff
              // todo add support for placeholder attribute for browsers which support it
              if (/^(text|url|email|submit|button|reset)$/.test(element.type) && (element.value || element.placeholder || "").length > 0){
                renderFormValue(element, bounds, stack);
              }
              break;
            case "TEXTAREA":
              if ((element.value || element.placeholder || "").length > 0){
                renderFormValue(element, bounds, stack);
              }
              break;
            case "SELECT":
              if ((element.options||element.placeholder || "").length > 0){
                renderFormValue(element, bounds, stack);
              }
              break;
            case "LI":
              renderListItem(element, stack, backgroundBounds);
              break;
            case "CANVAS":
              renderImage(ctx, element, element, bounds, borders);
              break;
          }
      
          return stack;
        }
      
        function isElementVisible(element) {
          return (getCSS(element, 'display') !== "none" && getCSS(element, 'visibility') !== "hidden" && !element.hasAttribute("data-html2canvas-ignore"));
        }
      
        function parseElement (element, stack, pseudoElement) {
          if (isElementVisible(element)) {
            stack = renderElement(element, stack, pseudoElement, false) || stack;
            if (!ignoreElementsRegExp.test(element.nodeName)) {
              parseChildren(element, stack, pseudoElement);
            }
          }
        }
      
        function parseChildren(element, stack, pseudoElement) {
          Util.Children(element).forEach(function(node) {
            if (node.nodeType === node.ELEMENT_NODE) {
              parseElement(node, stack, pseudoElement);
            } else if (node.nodeType === node.TEXT_NODE) {
              renderText(element, node, stack);
            }
          });
        }
      
        function init() {
          var background = getCSS(document.documentElement, "backgroundColor"),
            transparentBackground = (Util.isTransparent(background) && element === document.body),
            stack = renderElement(element, null, false, transparentBackground);
          parseChildren(element, stack);
      
          if (transparentBackground) {
            background = stack.backgroundColor;
          }
      
          body.removeChild(hidePseudoElements);
          return {
            backgroundColor: background,
            stack: stack
          };
        }
      
        return init();
      };
      
      function h2czContext(zindex) {
        return {
          zindex: zindex,
          children: []
        };
      }
      
      _html2canvas.Preload = function( options ) {
      
        var images = {
          numLoaded: 0,   // also failed are counted here
          numFailed: 0,
          numTotal: 0,
          cleanupDone: false
        },
        pageOrigin,
        Util = _html2canvas.Util,
        methods,
        i,
        count = 0,
        element = options.elements[0] || document.body,
        doc = element.ownerDocument,
        domImages = element.getElementsByTagName('img'), // Fetch images of the present element only
        imgLen = domImages.length,
        link = doc.createElement("a"),
        supportCORS = (function( img ){
          return (img.crossOrigin !== undefined);
        })(new Image()),
        timeoutTimer;
      
        link.href = window.location.href;
        pageOrigin  = link.protocol + link.host;
      
        function isSameOrigin(url){
          link.href = url;
          link.href = link.href; // YES, BELIEVE IT OR NOT, that is required for IE9 - http://jsfiddle.net/niklasvh/2e48b/
          var origin = link.protocol + link.host;
          return (origin === pageOrigin);
        }
      
        function start(){
          Util.log("html2canvas: start: images: " + images.numLoaded + " / " + images.numTotal + " (failed: " + images.numFailed + ")");
          if (!images.firstRun && images.numLoaded >= images.numTotal){
            Util.log("Finished loading images: # " + images.numTotal + " (failed: " + images.numFailed + ")");
      
            if (typeof options.complete === "function"){
              options.complete(images);
            }
      
          }
        }
      
        // TODO modify proxy to serve images with CORS enabled, where available
        function proxyGetImage(url, img, imageObj){
          var callback_name,
          scriptUrl = options.proxy,
          script;
      
          link.href = url;
          url = link.href; // work around for pages with base href="" set - WARNING: this may change the url
      
          callback_name = 'html2canvas_' + (count++);
          imageObj.callbackname = callback_name;
      
          if (scriptUrl.indexOf("?") > -1) {
            scriptUrl += "&";
          } else {
            scriptUrl += "?";
          }
          scriptUrl += 'url=' + encodeURIComponent(url) + '&callback=' + callback_name;
          script = doc.createElement("script");
      
          window[callback_name] = function(a){
            if (a.substring(0,6) === "error:"){
              imageObj.succeeded = false;
              images.numLoaded++;
              images.numFailed++;
              start();
            } else {
              setImageLoadHandlers(img, imageObj);
              img.src = a;
            }
            window[callback_name] = undefined; // to work with IE<9  // NOTE: that the undefined callback property-name still exists on the window object (for IE<9)
            try {
              delete window[callback_name];  // for all browser that support this
            } catch(ex) {}
            script.parentNode.removeChild(script);
            script = null;
            delete imageObj.script;
            delete imageObj.callbackname;
          };
      
          script.setAttribute("type", "text/javascript");
          script.setAttribute("src", scriptUrl);
          imageObj.script = script;
          window.document.body.appendChild(script);
      
        }
      
        function loadPseudoElement(element, type) {
          var style = window.getComputedStyle(element, type),
          content = style.content;
          if (content.substr(0, 3) === 'url') {
            methods.loadImage(_html2canvas.Util.parseBackgroundImage(content)[0].args[0]);
          }
          loadBackgroundImages(style.backgroundImage, element);
        }
      
        function loadPseudoElementImages(element) {
          loadPseudoElement(element, ":before");
          loadPseudoElement(element, ":after");
        }
      
        function loadGradientImage(backgroundImage, bounds) {
          var img = _html2canvas.Generate.Gradient(backgroundImage, bounds);
      
          if (img !== undefined){
            images[backgroundImage] = {
              img: img,
              succeeded: true
            };
            images.numTotal++;
            images.numLoaded++;
            start();
          }
        }
      
        function invalidBackgrounds(background_image) {
          return (background_image && background_image.method && background_image.args && background_image.args.length > 0 );
        }
      
        function loadBackgroundImages(background_image, el) {
          var bounds;
      
          _html2canvas.Util.parseBackgroundImage(background_image).filter(invalidBackgrounds).forEach(function(background_image) {
            if (background_image.method === 'url') {
              methods.loadImage(background_image.args[0]);
            } else if(background_image.method.match(/\-?gradient$/)) {
              if(bounds === undefined) {
                bounds = _html2canvas.Util.Bounds(el);
              }
              loadGradientImage(background_image.value, bounds);
            }
          });
        }
      
        function getImages (el) {
          var elNodeType = false;
      
          // Firefox fails with permission denied on pages with iframes
          try {
            Util.Children(el).forEach(getImages);
          }
          catch( e ) {}
      
          try {
            elNodeType = el.nodeType;
          } catch (ex) {
            elNodeType = false;
            Util.log("html2canvas: failed to access some element's nodeType - Exception: " + ex.message);
          }
      
          if (elNodeType === 1 || elNodeType === undefined) {
            loadPseudoElementImages(el);
            try {
              loadBackgroundImages(Util.getCSS(el, 'backgroundImage'), el);
            } catch(e) {
              Util.log("html2canvas: failed to get background-image - Exception: " + e.message);
            }
            loadBackgroundImages(el);
          }
        }
      
        function setImageLoadHandlers(img, imageObj) {
          img.onload = function() {
            if ( imageObj.timer !== undefined ) {
              // CORS succeeded
              window.clearTimeout( imageObj.timer );
            }
      
            images.numLoaded++;
            imageObj.succeeded = true;
            img.onerror = img.onload = null;
            start();
          };
          img.onerror = function() {
            if (img.crossOrigin === "anonymous") {
              // CORS failed
              window.clearTimeout( imageObj.timer );
      
              // let's try with proxy instead
              if ( options.proxy ) {
                var src = img.src;
                img = new Image();
                imageObj.img = img;
                img.src = src;
      
                proxyGetImage( img.src, img, imageObj );
                return;
              }
            }
      
            images.numLoaded++;
            images.numFailed++;
            imageObj.succeeded = false;
            img.onerror = img.onload = null;
            start();
          };
        }
      
        methods = {
          loadImage: function( src ) {
            var img, imageObj;
            if ( src && images[src] === undefined ) {
              img = new Image();
              if ( src.match(/data:image\/.*;base64,/i) ) {
                img.src = src.replace(/url\(['"]{0,}|['"]{0,}\)$/ig, '');
                imageObj = images[src] = {
                  img: img
                };
                images.numTotal++;
                setImageLoadHandlers(img, imageObj);
              } else if ( isSameOrigin( src ) || options.allowTaint ===  true ) {
                imageObj = images[src] = {
                  img: img
                };
                images.numTotal++;
                setImageLoadHandlers(img, imageObj);
                img.src = src;
              } else if ( supportCORS && !options.allowTaint && options.useCORS ) {
                // attempt to load with CORS
      
                img.crossOrigin = "anonymous";
                imageObj = images[src] = {
                  img: img
                };
                images.numTotal++;
                setImageLoadHandlers(img, imageObj);
                img.src = src;
              } else if ( options.proxy ) {
                imageObj = images[src] = {
                  img: img
                };
                images.numTotal++;
                proxyGetImage( src, img, imageObj );
              }
            }
      
          },
          cleanupDOM: function(cause) {
            var img, src;
            if (!images.cleanupDone) {
              if (cause && typeof cause === "string") {
                Util.log("html2canvas: Cleanup because: " + cause);
              } else {
                Util.log("html2canvas: Cleanup after timeout: " + options.timeout + " ms.");
              }
      
              for (src in images) {
                if (images.hasOwnProperty(src)) {
                  img = images[src];
                  if (typeof img === "object" && img.callbackname && img.succeeded === undefined) {
                    // cancel proxy image request
                    window[img.callbackname] = undefined; // to work with IE<9  // NOTE: that the undefined callback property-name still exists on the window object (for IE<9)
                    try {
                      delete window[img.callbackname];  // for all browser that support this
                    } catch(ex) {}
                    if (img.script && img.script.parentNode) {
                      img.script.setAttribute("src", "about:blank");  // try to cancel running request
                      img.script.parentNode.removeChild(img.script);
                    }
                    images.numLoaded++;
                    images.numFailed++;
                    Util.log("html2canvas: Cleaned up failed img: '" + src + "' Steps: " + images.numLoaded + " / " + images.numTotal);
                  }
                }
              }
      
              // cancel any pending requests
              if(window.stop !== undefined) {
                window.stop();
              } else if(document.execCommand !== undefined) {
                document.execCommand("Stop", false);
              }
              if (document.close !== undefined) {
                document.close();
              }
              images.cleanupDone = true;
              if (!(cause && typeof cause === "string")) {
                start();
              }
            }
          },
      
          renderingDone: function() {
            if (timeoutTimer) {
              window.clearTimeout(timeoutTimer);
            }
          }
        };
      
        if (options.timeout > 0) {
          timeoutTimer = window.setTimeout(methods.cleanupDOM, options.timeout);
        }
      
        Util.log('html2canvas: Preload starts: finding background-images');
        images.firstRun = true;
      
        getImages(element);
      
        Util.log('html2canvas: Preload: Finding images');
        // load <img> images
        for (i = 0; i < imgLen; i+=1){
          methods.loadImage( domImages[i].getAttribute( "src" ) );
        }
      
        images.firstRun = false;
        Util.log('html2canvas: Preload: Done.');
        if (images.numTotal === images.numLoaded) {
          start();
        }
      
        return methods;
      };
      
      _html2canvas.Renderer = function(parseQueue, options){
      
        // http://www.w3.org/TR/CSS21/zindex.html
        function createRenderQueue(parseQueue) {
          var queue = [],
          rootContext;
      
          rootContext = (function buildStackingContext(rootNode) {
            var rootContext = {};
            function insert(context, node, specialParent) {
              var zi = (node.zIndex.zindex === 'auto') ? 0 : Number(node.zIndex.zindex),
              contextForChildren = context, // the stacking context for children
              isPositioned = node.zIndex.isPositioned,
              isFloated = node.zIndex.isFloated,
              stub = {node: node},
              childrenDest = specialParent; // where children without z-index should be pushed into
      
              if (node.zIndex.ownStacking) {
                // '!' comes before numbers in sorted array
                contextForChildren = stub.context = { '!': [{node:node, children: []}]};
                childrenDest = undefined;
              } else if (isPositioned || isFloated) {
                childrenDest = stub.children = [];
              }
      
              if (zi === 0 && specialParent) {
                specialParent.push(stub);
              } else {
                if (!context[zi]) { context[zi] = []; }
                context[zi].push(stub);
              }
      
              node.zIndex.children.forEach(function(childNode) {
                insert(contextForChildren, childNode, childrenDest);
              });
            }
            insert(rootContext, rootNode);
            return rootContext;
          })(parseQueue);
      
          function sortZ(context) {
            Object.keys(context).sort().forEach(function(zi) {
              var nonPositioned = [],
              floated = [],
              positioned = [],
              list = [];
      
              // positioned after static
              context[zi].forEach(function(v) {
                if (v.node.zIndex.isPositioned || v.node.zIndex.opacity < 1) {
                  // http://www.w3.org/TR/css3-color/#transparency
                  // non-positioned element with opactiy < 1 should be stacked as if it were a positioned element with â€˜z-index: 0â€™ and â€˜opacity: 1â€™.
                  positioned.push(v);
                } else if (v.node.zIndex.isFloated) {
                  floated.push(v);
                } else {
                  nonPositioned.push(v);
                }
              });
      
              (function walk(arr) {
                arr.forEach(function(v) {
                  list.push(v);
                  if (v.children) { walk(v.children); }
                });
              })(nonPositioned.concat(floated, positioned));
      
              list.forEach(function(v) {
                if (v.context) {
                  sortZ(v.context);
                } else {
                  queue.push(v.node);
                }
              });
            });
          }
      
          sortZ(rootContext);
      
          return queue;
        }
      
        function getRenderer(rendererName) {
          var renderer;
      
          if (typeof options.renderer === "string" && _html2canvas.Renderer[rendererName] !== undefined) {
            renderer = _html2canvas.Renderer[rendererName](options);
          } else if (typeof rendererName === "function") {
            renderer = rendererName(options);
          } else {
            throw new Error("Unknown renderer");
          }
      
          if ( typeof renderer !== "function" ) {
            throw new Error("Invalid renderer defined");
          }
          return renderer;
        }
      
        return getRenderer(options.renderer)(parseQueue, options, document, createRenderQueue(parseQueue.stack), _html2canvas);
      };
      
      _html2canvas.Util.Support = function (options, doc) {
      
        function supportSVGRendering() {
          var img = new Image(),
          canvas = doc.createElement("canvas"),
          ctx = (canvas.getContext === undefined) ? false : canvas.getContext("2d");
          if (ctx === false) {
            return false;
          }
          canvas.width = canvas.height = 10;
          img.src = [
          "data:image/svg+xml,",
          "<svg xmlns='http://www.w3.org/2000/svg' width='10' height='10'>",
          "<foreignObject width='10' height='10'>",
          "<div xmlns='http://www.w3.org/1999/xhtml' style='width:10;height:10;'>",
          "sup",
          "</div>",
          "</foreignObject>",
          "</svg>"
          ].join("");
          try {
            ctx.drawImage(img, 0, 0);
            canvas.toDataURL();
          } catch(e) {
            return false;
          }
          _html2canvas.Util.log('html2canvas: Parse: SVG powered rendering available');
          return true;
        }
      
        // Test whether we can use ranges to measure bounding boxes
        // Opera doesn't provide valid bounds.height/bottom even though it supports the method.
      
        function supportRangeBounds() {
          var r, testElement, rangeBounds, rangeHeight, support = false;
      
          if (doc.createRange) {
            r = doc.createRange();
            if (r.getBoundingClientRect) {
              testElement = doc.createElement('boundtest');
              testElement.style.height = "123px";
              testElement.style.display = "block";
              doc.body.appendChild(testElement);
      
              r.selectNode(testElement);
              rangeBounds = r.getBoundingClientRect();
              rangeHeight = rangeBounds.height;
      
              if (rangeHeight === 123) {
                support = true;
              }
              doc.body.removeChild(testElement);
            }
          }
      
          return support;
        }
      
        return {
          rangeBounds: supportRangeBounds(),
          svgRendering: options.svgRendering && supportSVGRendering()
        };
      };
      window.html2canvas = function(elements, opts) {
        elements = (elements.length) ? elements : [elements];
        var queue,
        canvas,
        options = {
          // general
          logging: false,
          elements: elements,
          background: "#fff",
      
          // preload options
          proxy: null,
          timeout: 0,    // no timeout
          useCORS: false, // try to load images as CORS (where available), before falling back to proxy
          allowTaint: false, // whether to allow images to taint the canvas, won't need proxy if set to true
      
          // parse options
          svgRendering: false, // use svg powered rendering where available (FF11+)
          ignoreElements: "IFRAME|OBJECT|PARAM",
          useOverflow: true,
          letterRendering: false,
          chinese: false,
      
          // render options
      
          width: null,
          height: null,
          taintTest: true, // do a taint test with all images before applying to canvas
          renderer: "Canvas"
        };
      
        options = _html2canvas.Util.Extend(opts, options);
      
        _html2canvas.logging = options.logging;
        options.complete = function( images ) {
      
          if (typeof options.onpreloaded === "function") {
            if ( options.onpreloaded( images ) === false ) {
              return;
            }
          }
          queue = _html2canvas.Parse( images, options );
      
          if (typeof options.onparsed === "function") {
            if ( options.onparsed( queue ) === false ) {
              return;
            }
          }
      
          canvas = _html2canvas.Renderer( queue, options );
      
          if (typeof options.onrendered === "function") {
            options.onrendered( canvas );
          }
      
      
        };
      
        // for pages without images, we still want this to be async, i.e. return methods before executing
        window.setTimeout( function(){
          _html2canvas.Preload( options );
        }, 0 );
      
        return {
          render: function( queue, opts ) {
            return _html2canvas.Renderer( queue, _html2canvas.Util.Extend(opts, options) );
          },
          parse: function( images, opts ) {
            return _html2canvas.Parse( images, _html2canvas.Util.Extend(opts, options) );
          },
          preload: function( opts ) {
            return _html2canvas.Preload( _html2canvas.Util.Extend(opts, options) );
          },
          log: _html2canvas.Util.log
        };
      };
      
      window.html2canvas.log = _html2canvas.Util.log; // for renderers
      window.html2canvas.Renderer = {
        Canvas: undefined // We are assuming this will be used
      };
      _html2canvas.Renderer.Canvas = function(options) {
        options = options || {};
      
        var doc = document,
        safeImages = [],
        testCanvas = document.createElement("canvas"),
        testctx = testCanvas.getContext("2d"),
        Util = _html2canvas.Util,
        canvas = options.canvas || doc.createElement('canvas');
      
        function createShape(ctx, args) {
          ctx.beginPath();
          args.forEach(function(arg) {
            ctx[arg.name].apply(ctx, arg['arguments']);
          });
          ctx.closePath();
        }
      
        function safeImage(item) {
          if (safeImages.indexOf(item['arguments'][0].src ) === -1) {
            testctx.drawImage(item['arguments'][0], 0, 0);
            try {
              testctx.getImageData(0, 0, 1, 1);
            } catch(e) {
              testCanvas = doc.createElement("canvas");
              testctx = testCanvas.getContext("2d");
              return false;
            }
            safeImages.push(item['arguments'][0].src);
          }
          return true;
        }
      
        function renderItem(ctx, item) {
          switch(item.type){
            case "variable":
              ctx[item.name] = item['arguments'];
              break;
            case "function":
              switch(item.name) {
                case "createPattern":
                  if (item['arguments'][0].width > 0 && item['arguments'][0].height > 0) {
                    try {
                      ctx.fillStyle = ctx.createPattern(item['arguments'][0], "repeat");
                    }
                    catch(e) {
                      Util.log("html2canvas: Renderer: Error creating pattern", e.message);
                    }
                  }
                  break;
                case "drawShape":
                  createShape(ctx, item['arguments']);
                  break;
                case "drawImage":
                  if (item['arguments'][8] > 0 && item['arguments'][7] > 0) {
                    if (!options.taintTest || (options.taintTest && safeImage(item))) {
                      ctx.drawImage.apply( ctx, item['arguments'] );
                    }
                  }
                  break;
                default:
                  ctx[item.name].apply(ctx, item['arguments']);
              }
              break;
          }
        }
      
        return function(parsedData, options, document, queue, _html2canvas) {
          var ctx = canvas.getContext("2d"),
          newCanvas,
          bounds,
          fstyle,
          zStack = parsedData.stack;
      
          canvas.width = canvas.style.width =  options.width || zStack.ctx.width;
          canvas.height = canvas.style.height = options.height || zStack.ctx.height;
      
          fstyle = ctx.fillStyle;
          ctx.fillStyle = (Util.isTransparent(zStack.backgroundColor) && options.background !== undefined) ? options.background : parsedData.backgroundColor;
          ctx.fillRect(0, 0, canvas.width, canvas.height);
          ctx.fillStyle = fstyle;
      
          queue.forEach(function(storageContext) {
            // set common settings for canvas
            ctx.textBaseline = "bottom";
            ctx.save();
      
            if (storageContext.transform.matrix) {
              ctx.translate(storageContext.transform.origin[0], storageContext.transform.origin[1]);
              ctx.transform.apply(ctx, storageContext.transform.matrix);
              ctx.translate(-storageContext.transform.origin[0], -storageContext.transform.origin[1]);
            }
      
            if (storageContext.clip){
              ctx.beginPath();
              ctx.rect(storageContext.clip.left, storageContext.clip.top, storageContext.clip.width, storageContext.clip.height);
              ctx.clip();
            }
      
            if (storageContext.ctx.storage) {
              storageContext.ctx.storage.forEach(function(item) {
                renderItem(ctx, item);
              });
            }
      
            ctx.restore();
          });
      
          Util.log("html2canvas: Renderer: Canvas renderer done - returning canvas obj");
      
          if (options.elements.length === 1) {
            if (typeof options.elements[0] === "object" && options.elements[0].nodeName !== "BODY") {
              // crop image to the bounds of selected (single) element
              bounds = _html2canvas.Util.Bounds(options.elements[0]);
              newCanvas = document.createElement('canvas');
              newCanvas.width = Math.ceil(bounds.width);
              newCanvas.height = Math.ceil(bounds.height);
              ctx = newCanvas.getContext("2d");
      
              ctx.drawImage(canvas, bounds.left, bounds.top, bounds.width, bounds.height, 0, 0, bounds.width, bounds.height);
              canvas = null;
              return newCanvas;
            }
          }
      
          return canvas;
        };
      };
      })(window,document);