/*!
  html2canvas  <http://html2canvas.hertzen.com>
  Copyright (c) 2016 Niklas von Hertzen
*/

/*! Copyright Mathias Bynens <https://mathiasbynens.be/> */
var PunyCode;
(function (PunyCode_1) {
	var maxInt = 2147483647, base = 36, tMin = 1, tMax = 26, skew = 38, damp = 700, initialBias = 72, initialN = 128, delimiter = '-', regexPunycode = /^xn--/, regexNonASCII = /[^\x20-\x7E]/, regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g, errors = {
		'overflow': 'Overflow: input needs wider integers to process',
		'not-basic': 'Illegal input >= 0x80 (not a basic code point)',
		'invalid-input': 'Invalid input'
	}, baseMinusTMin = base - tMin, floor = Math.floor, stringFromCharCode = String.fromCharCode, key;
	function error(type) {
		throw RangeError(errors[type]);
	}
	function map(array, fn) {
		var length = array.length;
		var result = [];
		while (length--) {
			result[length] = fn(array[length]);
		}
		return result;
	}
	function mapDomain(string, fn) {
		var parts = string.split('@');
		var result = '';
		if (parts.length > 1) {
			result = parts[0] + '@';
			string = parts[1];
		}
		string = string.replace(regexSeparators, '\x2E');
		var labels = string.split('.');
		var encoded = map(labels, fn).join('.');
		return result + encoded;
	}
	function ucs2decode(string) {
		var output = [], counter = 0, length = string.length, value, extra;
		while (counter < length) {
			value = string.charCodeAt(counter++);
			if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
				extra = string.charCodeAt(counter++);
				if ((extra & 0xFC00) == 0xDC00) {
					output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
				}
				else {
					output.push(value);
					counter--;
				}
			}
			else {
				output.push(value);
			}
		}
		return output;
	}
	function ucs2encode(array) {
		return map(array, function (value) {
			var output = '';
			if (value > 0xFFFF) {
				value -= 0x10000;
				output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);
				value = 0xDC00 | value & 0x3FF;
			}
			output += stringFromCharCode(value);
			return output;
		}).join('');
	}
	function basicToDigit(codePoint) {
		if (codePoint - 48 < 10) {
			return codePoint - 22;
		}
		if (codePoint - 65 < 26) {
			return codePoint - 65;
		}
		if (codePoint - 97 < 26) {
			return codePoint - 97;
		}
		return base;
	}
	function digitToBasic(digit, flag) {
		return digit + 22 + 75 * (Number)(digit < 26) - ((Number)(flag != 0) << 5);
	}
	function adapt(delta, numPoints, firstTime) {
		var k = 0;
		delta = firstTime ? floor(delta / damp) : delta >> 1;
		delta += floor(delta / numPoints);
		for (; delta > baseMinusTMin * tMax >> 1; k += base) {
			delta = floor(delta / baseMinusTMin);
		}
		return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
	}
	function decode(input) {
		var output = [], inputLength = input.length, out, i = 0, n = initialN, bias = initialBias, basic, j, index, oldi, w, k, digit, t, baseMinusT;
		basic = input.lastIndexOf(delimiter);
		if (basic < 0) {
			basic = 0;
		}
		for (j = 0; j < basic; ++j) {
			if (input.charCodeAt(j) >= 0x80) {
				error('not-basic');
			}
			output.push(input.charCodeAt(j));
		}
		for (index = basic > 0 ? basic + 1 : 0; index < inputLength;) {
			for (oldi = i, w = 1, k = base; ; k += base) {
				if (index >= inputLength) {
					error('invalid-input');
				}
				digit = basicToDigit(input.charCodeAt(index++));
				if (digit >= base || digit > floor((maxInt - i) / w)) {
					error('overflow');
				}
				i += digit * w;
				t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
				if (digit < t) {
					break;
				}
				baseMinusT = base - t;
				if (w > floor(maxInt / baseMinusT)) {
					error('overflow');
				}
				w *= baseMinusT;
			}
			out = output.length + 1;
			bias = adapt(i - oldi, out, oldi == 0);
			if (floor(i / out) > maxInt - n) {
				error('overflow');
			}
			n += floor(i / out);
			i %= out;
			output.splice(i++, 0, n);
		}
		return ucs2encode(output);
	}
	function encode(input) {
		var n, delta, handledCPCount, basicLength, bias, j, m, q, k, t, currentValue, output = [], inputLength, handledCPCountPlusOne, baseMinusT, qMinusT;
		input = ucs2decode(input);
		inputLength = input.length;
		n = initialN;
		delta = 0;
		bias = initialBias;
		for (j = 0; j < inputLength; ++j) {
			currentValue = input[j];
			if (currentValue < 0x80) {
				output.push(stringFromCharCode(currentValue));
			}
		}
		handledCPCount = basicLength = output.length;
		if (basicLength) {
			output.push(delimiter);
		}
		while (handledCPCount < inputLength) {
			for (m = maxInt, j = 0; j < inputLength; ++j) {
				currentValue = input[j];
				if (currentValue >= n && currentValue < m) {
					m = currentValue;
				}
			}
			handledCPCountPlusOne = handledCPCount + 1;
			if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
				error('overflow');
			}
			delta += (m - n) * handledCPCountPlusOne;
			n = m;
			for (j = 0; j < inputLength; ++j) {
				currentValue = input[j];
				if (currentValue < n && ++delta > maxInt) {
					error('overflow');
				}
				if (currentValue == n) {
					for (q = delta, k = base; ; k += base) {
						t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
						if (q < t) {
							break;
						}
						qMinusT = q - t;
						baseMinusT = base - t;
						output.push(stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0)));
						q = floor(qMinusT / baseMinusT);
					}
					output.push(stringFromCharCode(digitToBasic(q, 0)));
					bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);
					delta = 0;
					++handledCPCount;
				}
			}
			++delta;
			++n;
		}
		return output.join('');
	}
	function toUnicode(input) {
		return mapDomain(input, function (string) {
			return regexPunycode.test(string)
                ? decode(string.slice(4).toLowerCase())
                : string;
		});
	}
	function toASCII(input) {
		return mapDomain(input, function (string) {
			return regexNonASCII.test(string)
                ? 'xn--' + encode(string)
                : string;
		});
	}
	PunyCode_1.PunyCode = {
		'version': '1.3.2',
		'ucs2': {
			'decode': ucs2decode,
			'encode': ucs2encode
		},
		'decode': decode,
		'encode': encode,
		'toASCII': toASCII,
		'toUnicode': toUnicode
	};
})(PunyCode || (PunyCode = {}));
var Html2canvas;
(function (Html2canvas) {
	Html2canvas.Color = function (value) {
		this.r = 0;
		this.g = 0;
		this.b = 0;
		this.a = null;
		var result = this.fromArray(value) ||
            this.namedColor(value) ||
            this.rgb(value) ||
            this.rgba(value) ||
            this.hex6(value) ||
            this.hex3(value);
	};
	Html2canvas.Color.prototype.darken = function (amount) {
		var a = 1 - amount;
		return new Html2canvas.Color([
            Math.round(this.r * a),
            Math.round(this.g * a),
            Math.round(this.b * a),
            this.a
		]);
	};
	Html2canvas.Color.prototype.isTransparent = function () {
		return this.a === 0;
	};
	Html2canvas.Color.prototype.isBlack = function () {
		return this.r === 0 && this.g === 0 && this.b === 0;
	};
	Html2canvas.Color.prototype.fromArray = function (array) {
		if (Array.isArray(array)) {
			this.r = Math.min(array[0], 255);
			this.g = Math.min(array[1], 255);
			this.b = Math.min(array[2], 255);
			if (array.length > 3) {
				this.a = array[3];
			}
		}
		return (Array.isArray(array));
	};
	var _hex3 = /^#([a-f0-9]{3})$/i;
	Html2canvas.Color.prototype.hex3 = function (value) {
		var match = null;
		if ((match = value.match(_hex3)) !== null) {
			this.r = parseInt(match[1][0] + match[1][0], 16);
			this.g = parseInt(match[1][1] + match[1][1], 16);
			this.b = parseInt(match[1][2] + match[1][2], 16);
		}
		return match !== null;
	};
	var _hex6 = /^#([a-f0-9]{6})$/i;
	Html2canvas.Color.prototype.hex6 = function (value) {
		var match = null;
		if ((match = value.match(_hex6)) !== null) {
			this.r = parseInt(match[1].substring(0, 2), 16);
			this.g = parseInt(match[1].substring(2, 4), 16);
			this.b = parseInt(match[1].substring(4, 6), 16);
		}
		return match !== null;
	};
	var _rgb = /^rgb\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*\)$/;
	Html2canvas.Color.prototype.rgb = function (value) {
		var match = null;
		if ((match = value.match(_rgb)) !== null) {
			this.r = Number(match[1]);
			this.g = Number(match[2]);
			this.b = Number(match[3]);
		}
		return match !== null;
	};
	var _rgba = /^rgba\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d?\.?\d+)\s*\)$/;
	Html2canvas.Color.prototype.rgba = function (value) {
		var match = null;
		if ((match = value.match(_rgba)) !== null) {
			this.r = Number(match[1]);
			this.g = Number(match[2]);
			this.b = Number(match[3]);
			this.a = Number(match[4]);
		}
		return match !== null;
	};
	Html2canvas.Color.prototype.toString = function () {
		return this.a !== null && this.a !== 1 ?
            "rgba(" + [this.r, this.g, this.b, this.a].join(",") + ")" :
            "rgb(" + [this.r, this.g, this.b].join(",") + ")";
	};
	Html2canvas.Color.prototype.namedColor = function (value) {
		value = value.toLowerCase();
		var color = colors[value];
		if (color) {
			this.r = color[0];
			this.g = color[1];
			this.b = color[2];
		}
		else if (value === "transparent") {
			this.r = this.g = this.b = this.a = 0;
			return true;
		}
		return !!color;
	};
	Html2canvas.Color.prototype.isColor = true;
	var colors = {
		"aliceblue": [240, 248, 255],
		"antiquewhite": [250, 235, 215],
		"aqua": [0, 255, 255],
		"aquamarine": [127, 255, 212],
		"azure": [240, 255, 255],
		"beige": [245, 245, 220],
		"bisque": [255, 228, 196],
		"black": [0, 0, 0],
		"blanchedalmond": [255, 235, 205],
		"blue": [0, 0, 255],
		"blueviolet": [138, 43, 226],
		"brown": [165, 42, 42],
		"burlywood": [222, 184, 135],
		"cadetblue": [95, 158, 160],
		"chartreuse": [127, 255, 0],
		"chocolate": [210, 105, 30],
		"coral": [255, 127, 80],
		"cornflowerblue": [100, 149, 237],
		"cornsilk": [255, 248, 220],
		"crimson": [220, 20, 60],
		"cyan": [0, 255, 255],
		"darkblue": [0, 0, 139],
		"darkcyan": [0, 139, 139],
		"darkgoldenrod": [184, 134, 11],
		"darkgray": [169, 169, 169],
		"darkgreen": [0, 100, 0],
		"darkgrey": [169, 169, 169],
		"darkkhaki": [189, 183, 107],
		"darkmagenta": [139, 0, 139],
		"darkolivegreen": [85, 107, 47],
		"darkorange": [255, 140, 0],
		"darkorchid": [153, 50, 204],
		"darkred": [139, 0, 0],
		"darksalmon": [233, 150, 122],
		"darkseagreen": [143, 188, 143],
		"darkslateblue": [72, 61, 139],
		"darkslategray": [47, 79, 79],
		"darkslategrey": [47, 79, 79],
		"darkturquoise": [0, 206, 209],
		"darkviolet": [148, 0, 211],
		"deeppink": [255, 20, 147],
		"deepskyblue": [0, 191, 255],
		"dimgray": [105, 105, 105],
		"dimgrey": [105, 105, 105],
		"dodgerblue": [30, 144, 255],
		"firebrick": [178, 34, 34],
		"floralwhite": [255, 250, 240],
		"forestgreen": [34, 139, 34],
		"fuchsia": [255, 0, 255],
		"gainsboro": [220, 220, 220],
		"ghostwhite": [248, 248, 255],
		"gold": [255, 215, 0],
		"goldenrod": [218, 165, 32],
		"gray": [128, 128, 128],
		"green": [0, 128, 0],
		"greenyellow": [173, 255, 47],
		"grey": [128, 128, 128],
		"honeydew": [240, 255, 240],
		"hotpink": [255, 105, 180],
		"indianred": [205, 92, 92],
		"indigo": [75, 0, 130],
		"ivory": [255, 255, 240],
		"khaki": [240, 230, 140],
		"lavender": [230, 230, 250],
		"lavenderblush": [255, 240, 245],
		"lawngreen": [124, 252, 0],
		"lemonchiffon": [255, 250, 205],
		"lightblue": [173, 216, 230],
		"lightcoral": [240, 128, 128],
		"lightcyan": [224, 255, 255],
		"lightgoldenrodyellow": [250, 250, 210],
		"lightgray": [211, 211, 211],
		"lightgreen": [144, 238, 144],
		"lightgrey": [211, 211, 211],
		"lightpink": [255, 182, 193],
		"lightsalmon": [255, 160, 122],
		"lightseagreen": [32, 178, 170],
		"lightskyblue": [135, 206, 250],
		"lightslategray": [119, 136, 153],
		"lightslategrey": [119, 136, 153],
		"lightsteelblue": [176, 196, 222],
		"lightyellow": [255, 255, 224],
		"lime": [0, 255, 0],
		"limegreen": [50, 205, 50],
		"linen": [250, 240, 230],
		"magenta": [255, 0, 255],
		"maroon": [128, 0, 0],
		"mediumaquamarine": [102, 205, 170],
		"mediumblue": [0, 0, 205],
		"mediumorchid": [186, 85, 211],
		"mediumpurple": [147, 112, 219],
		"mediumseagreen": [60, 179, 113],
		"mediumslateblue": [123, 104, 238],
		"mediumspringgreen": [0, 250, 154],
		"mediumturquoise": [72, 209, 204],
		"mediumvioletred": [199, 21, 133],
		"midnightblue": [25, 25, 112],
		"mintcream": [245, 255, 250],
		"mistyrose": [255, 228, 225],
		"moccasin": [255, 228, 181],
		"navajowhite": [255, 222, 173],
		"navy": [0, 0, 128],
		"oldlace": [253, 245, 230],
		"olive": [128, 128, 0],
		"olivedrab": [107, 142, 35],
		"orange": [255, 165, 0],
		"orangered": [255, 69, 0],
		"orchid": [218, 112, 214],
		"palegoldenrod": [238, 232, 170],
		"palegreen": [152, 251, 152],
		"paleturquoise": [175, 238, 238],
		"palevioletred": [219, 112, 147],
		"papayawhip": [255, 239, 213],
		"peachpuff": [255, 218, 185],
		"peru": [205, 133, 63],
		"pink": [255, 192, 203],
		"plum": [221, 160, 221],
		"powderblue": [176, 224, 230],
		"purple": [128, 0, 128],
		"rebeccapurple": [102, 51, 153],
		"red": [255, 0, 0],
		"rosybrown": [188, 143, 143],
		"royalblue": [65, 105, 225],
		"saddlebrown": [139, 69, 19],
		"salmon": [250, 128, 114],
		"sandybrown": [244, 164, 96],
		"seagreen": [46, 139, 87],
		"seashell": [255, 245, 238],
		"sienna": [160, 82, 45],
		"silver": [192, 192, 192],
		"skyblue": [135, 206, 235],
		"slateblue": [106, 90, 205],
		"slategray": [112, 128, 144],
		"slategrey": [112, 128, 144],
		"snow": [255, 250, 250],
		"springgreen": [0, 255, 127],
		"steelblue": [70, 130, 180],
		"tan": [210, 180, 140],
		"teal": [0, 128, 128],
		"thistle": [216, 191, 216],
		"tomato": [255, 99, 71],
		"turquoise": [64, 224, 208],
		"violet": [238, 130, 238],
		"wheat": [245, 222, 179],
		"white": [255, 255, 255],
		"whitesmoke": [245, 245, 245],
		"yellow": [255, 255, 0],
		"yellowgreen": [154, 205, 50]
	};
})(Html2canvas || (Html2canvas = {}));
var Html2canvas;
(function (Html2canvas) {
	Html2canvas.Log = function () {
		if (Html2canvas.Log.options.logging && window.console && window.console.log) {
			Function.prototype.bind.call(window.console.log, (window.console)).apply(window.console, [(Date.now() - Html2canvas.Log.options.start) + "ms", "html2canvas:"].concat([].slice.call(arguments, 0)));
		}
	};
	Html2canvas.Log.options = { logging: false };
})(Html2canvas || (Html2canvas = {}));
var Html2canvas;
(function (Html2canvas) {
	Html2canvas.Support = function (document) {
		this.rangeBounds = this.testRangeBounds(document);
		this.cors = this.testCORS();
		this.svg = this.testSVG();
	};
	Html2canvas.Support.prototype.testRangeBounds = function (document) {
		var range, testElement, rangeBounds, rangeHeight, support = false;
		if (document.createRange) {
			range = document.createRange();
			if (range.getBoundingClientRect) {
				testElement = document.createElement('boundtest');
				testElement.style.height = "123px";
				testElement.style.display = "block";
				document.body.appendChild(testElement);
				range.selectNode(testElement);
				rangeBounds = range.getBoundingClientRect();
				rangeHeight = rangeBounds.height;
				if (rangeHeight === 123) {
					support = true;
				}
				document.body.removeChild(testElement);
			}
		}
		return support;
	};
	Html2canvas.Support.prototype.testCORS = function () {
		return typeof ((new Image()).crossOrigin) !== "undefined";
	};
	Html2canvas.Support.prototype.testSVG = function () {
		var img = new Image();
		var canvas = document.createElement("canvas");
		var ctx = canvas.getContext("2d");
		img.src = "data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg'></svg>";
		try {
			ctx.drawImage(img, 0, 0);
			canvas.toDataURL();
		}
		catch (e) {
			return false;
		}
		return true;
	};
})(Html2canvas || (Html2canvas = {}));
var Html2canvas;
(function (Html2canvas) {
	Html2canvas.Utils = {};
	Html2canvas.Promise = (typeof (window.Promise) !== "undefined") ? window.Promise : OfficeExtension.Promise;
	Html2canvas.Utils.smallImage = function () {
		return "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7";
	};
	Html2canvas.Utils.bind = function (callback, context) {
		return function () {
			return callback.apply(context, arguments);
		};
	};
	Html2canvas.Utils.decode64 = function (base64) {
		var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
		var len = base64.length, i, encoded1, encoded2, encoded3, encoded4, byte1, byte2, byte3;
		var output = "";
		for (i = 0; i < len; i += 4) {
			encoded1 = chars.indexOf(base64[i]);
			encoded2 = chars.indexOf(base64[i + 1]);
			encoded3 = chars.indexOf(base64[i + 2]);
			encoded4 = chars.indexOf(base64[i + 3]);
			byte1 = (encoded1 << 2) | (encoded2 >> 4);
			byte2 = ((encoded2 & 15) << 4) | (encoded3 >> 2);
			byte3 = ((encoded3 & 3) << 6) | encoded4;
			if (encoded3 === 64) {
				output += String.fromCharCode(byte1);
			}
			else if (encoded4 === 64 || encoded4 === -1) {
				output += String.fromCharCode(byte1, byte2);
			}
			else {
				output += String.fromCharCode(byte1, byte2, byte3);
			}
		}
		return output;
	};
	Html2canvas.Utils.getBounds = function (node) {
		if (node.getBoundingClientRect) {
			var clientRect = node.getBoundingClientRect();
			var width = node.offsetWidth == null ? clientRect.width : node.offsetWidth;
			return {
				top: clientRect.top,
				bottom: clientRect.bottom || (clientRect.top + clientRect.height),
				right: clientRect.left + width,
				left: clientRect.left,
				width: width,
				height: node.offsetHeight == null ? clientRect.height : node.offsetHeight
			};
		}
		return {};
	};
	Html2canvas.Utils.offsetBounds = function (node) {
		var parent = node.offsetParent ? Html2canvas.Utils.offsetBounds(node.offsetParent) : { top: 0, left: 0 };
		return {
			top: node.offsetTop + parent.top,
			bottom: node.offsetTop + node.offsetHeight + parent.top,
			right: node.offsetLeft + parent.left + node.offsetWidth,
			left: node.offsetLeft + parent.left,
			width: node.offsetWidth,
			height: node.offsetHeight
		};
	};
	Html2canvas.Utils.parseBackgrounds = function (backgroundImage) {
		var whitespace = ' \r\n\t', method, definition, prefix, prefix_i, block, results = [], 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,
					image: null
				});
			}
			args = [];
			method = prefix = definition = block = '';
		};
		args = [];
		method = prefix = definition = block = '';
		backgroundImage.split("").forEach(function (c) {
			if (mode === 0 && whitespace.indexOf(c) > -1) {
				return;
			}
			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;
						return;
					}
					else {
						numParen++;
					}
					break;
				case ')':
					if (quote) {
						break;
					}
					else if (mode === 1) {
						if (numParen === 0) {
							mode = 0;
							block += c;
							appendResult();
							return;
						}
						else {
							numParen--;
						}
					}
					break;
				case ',':
					if (quote) {
						break;
					}
					else if (mode === 0) {
						appendResult();
						return;
					}
					else if (mode === 1) {
						if (numParen === 0 && !method.match(/^url$/i)) {
							args.push(definition);
							definition = '';
							block += c;
							return;
						}
					}
					break;
			}
			block += c;
			if (mode === 0) {
				method += c;
			}
			else {
				definition += c;
			}
		});
		appendResult();
		return results;
	};
})(Html2canvas || (Html2canvas = {}));
var Html2canvas;
(function (Html2canvas) {
	Html2canvas.XHR = function (url) {
		return new Html2canvas.Promise(function (resolve, reject) {
			var xhr = new XMLHttpRequest();
			xhr.open('GET', url);
			xhr.onload = function () {
				if (xhr.status === 200) {
					resolve(xhr.responseText);
				}
				else {
					reject(new Error(xhr.statusText));
				}
			};
			xhr.onerror = function () {
				reject(new Error("Network Error"));
			};
			xhr.send();
		});
	};
})(Html2canvas || (Html2canvas = {}));
var Html2canvas;
(function (Html2canvas) {
	var log = Html2canvas.Log;
	function restoreOwnerScroll(ownerDocument, x, y) {
		if (ownerDocument.defaultView && (x !== ownerDocument.defaultView.pageXOffset || y !== ownerDocument.defaultView.pageYOffset)) {
			ownerDocument.defaultView.scrollTo(x, y);
		}
	}
	function cloneCanvasContents(canvas, clonedCanvas) {
		try {
			if (clonedCanvas) {
				clonedCanvas.width = canvas.width;
				clonedCanvas.height = canvas.height;
				clonedCanvas.getContext("2d").putImageData(canvas.getContext("2d").getImageData(0, 0, canvas.width, canvas.height), 0, 0);
			}
		}
		catch (e) {
			log("Unable to copy canvas content from", canvas, e);
		}
	}
	function cloneNode(node, javascriptEnabled) {
		var clone = node.nodeType === 3 ? document.createTextNode(node.nodeValue) : node.cloneNode(false);
		var child = node.firstChild;
		while (child) {
			if (javascriptEnabled === true || child.nodeType !== 1 || child.nodeName !== 'SCRIPT') {
				clone.appendChild(cloneNode(child, javascriptEnabled));
			}
			child = child.nextSibling;
		}
		if (node.nodeType === 1) {
			clone._scrollTop = node.scrollTop;
			clone._scrollLeft = node.scrollLeft;
			if (node.nodeName === "CANVAS") {
				cloneCanvasContents(node, clone);
			}
			else if (node.nodeName === "TEXTAREA" || node.nodeName === "SELECT") {
				clone.value = node.value;
			}
		}
		return clone;
	}
	function initNode(node) {
		if (node.nodeType === 1) {
			node.scrollTop = node._scrollTop;
			node.scrollLeft = node._scrollLeft;
			var child = node.firstChild;
			while (child) {
				initNode(child);
				child = child.nextSibling;
			}
		}
	}
	Html2canvas.CreateWindowClone = function (ownerDocument, containerDocument, width, height, options, x, y) {
		var documentElement = cloneNode(ownerDocument.documentElement, options.javascriptEnabled);
		var container = containerDocument.createElement("iframe");
		container.className = "html2canvas-container";
		container.style.visibility = "hidden";
		container.style.position = "fixed";
		container.style.left = "-10000px";
		container.style.top = "0px";
		container.style.border = "0";
		container.width = width;
		container.height = height;
		container.scrolling = "no";
		containerDocument.body.appendChild(container);
		return new Html2canvas.Promise(function (resolve) {
			var documentClone = container.contentWindow.document;
			container.contentWindow.onload = container.onload = function () {
				var interval = setInterval(function () {
					if (documentClone.body.childNodes.length > 0) {
						initNode(documentClone.documentElement);
						clearInterval(interval);
						if (options.type === "view") {
							container.contentWindow.scrollTo(x, y);
							if ((/(iPad|iPhone|iPod)/g).test(navigator.userAgent) && (container.contentWindow.scrollY !== y || container.contentWindow.scrollX !== x)) {
								documentClone.documentElement.style.top = (-y) + "px";
								documentClone.documentElement.style.left = (-x) + "px";
								documentClone.documentElement.style.position = 'absolute';
							}
						}
						resolve(container);
					}
				}, 50);
			};
			documentClone.open();
			documentClone.write("<!DOCTYPE html><html></html>");
			restoreOwnerScroll(ownerDocument, x, y);
			documentClone.replaceChild(documentClone.adoptNode(documentElement), documentClone.documentElement);
			documentClone.close();
		});
	};
})(Html2canvas || (Html2canvas = {}));
var Html2canvas;
(function (Html2canvas) {
	var log = Html2canvas.Log;
	var smallImage = Html2canvas.Utils.smallImage;
	Html2canvas.DummyImageContainer = function (src) {
		this.src = src;
		log("DummyImageContainer for", src);
		if (!this.promise || !this.image) {
			log("Initiating DummyImageContainer");
			Html2canvas.DummyImageContainer.prototype.image = new Image();
			var image = this.image;
			Html2canvas.DummyImageContainer.prototype.promise = new Html2canvas.Promise(function (resolve, reject) {
				image.onload = resolve;
				image.onerror = reject;
				image.src = smallImage();
				if (image.complete === true) {
					resolve(image);
				}
			});
		}
	};
})(Html2canvas || (Html2canvas = {}));
var Html2canvas;
(function (Html2canvas) {
	var smallImage = Html2canvas.Utils.smallImage;
	Html2canvas.Font = function (family, size) {
		var container = document.createElement('div'), img = document.createElement('img'), span = document.createElement('span'), sampleText = 'Hidden Text', baseline, middle;
		container.style.visibility = "hidden";
		container.style.fontFamily = family;
		container.style.fontSize = size;
		container.style.margin = '0';
		container.style.padding = '0';
		document.body.appendChild(container);
		img.src = smallImage();
		img.width = 1;
		img.height = 1;
		img.style.margin = '0';
		img.style.padding = '0';
		img.style.verticalAlign = "baseline";
		span.style.fontFamily = family;
		span.style.fontSize = size;
		span.style.margin = '0';
		span.style.padding = '0';
		span.appendChild(document.createTextNode(sampleText));
		container.appendChild(span);
		container.appendChild(img);
		baseline = (img.offsetTop - span.offsetTop) + 1;
		container.removeChild(span);
		container.appendChild(document.createTextNode(sampleText));
		container.style.lineHeight = "normal";
		img.style.verticalAlign = "super";
		middle = (img.offsetTop - container.offsetTop) + 1;
		document.body.removeChild(container);
		this.baseline = baseline;
		this.lineWidth = 1;
		this.middle = middle;
	};
})(Html2canvas || (Html2canvas = {}));
var Html2canvas;
(function (Html2canvas) {
	var Font = Html2canvas.Font;
	Html2canvas.FontMetrics = function () {
		this.data = {};
	};
	Html2canvas.FontMetrics.prototype.getMetrics = function (family, size) {
		if (this.data[family + "-" + size] === undefined) {
			this.data[family + "-" + size] = new Font(family, size);
		}
		return this.data[family + "-" + size];
	};
})(Html2canvas || (Html2canvas = {}));
var Html2canvas;
(function (Html2canvas) {
	Html2canvas.GradientContainer = function (imageData) {
		this.src = imageData.value;
		this.colorStops = [];
		this.type = null;
		this.x0 = 0.5;
		this.y0 = 0.5;
		this.x1 = 0.5;
		this.y1 = 0.5;
		this.promise = Html2canvas.Promise.resolve(true);
	};
	Html2canvas.GradientContainer.TYPES = {
		LINEAR: 1,
		RADIAL: 2
	};
	Html2canvas.GradientContainer.REGEXP_COLORSTOP = /^\s*(rgba?\(\s*\d{1,3},\s*\d{1,3},\s*\d{1,3}(?:,\s*[0-9\.]+)?\s*\)|[a-z]{3,20}|#[a-f0-9]{3,6})(?:\s+(\d{1,3}(?:\.\d+)?)(%|px)?)?(?:\s|$)/i;
})(Html2canvas || (Html2canvas = {}));
var Html2canvas;
(function (Html2canvas) {
	Html2canvas.ImageContainer = function (src, cors) {
		this.src = src;
		this.image = new Image();
		var self = this;
		this.tainted = null;
		this.promise = new Html2canvas.Promise(function (resolve, reject) {
			self.image.onload = resolve;
			self.image.onerror = reject;
			if (cors) {
				self.image.crossOrigin = "anonymous";
			}
			self.image.src = src;
			if (self.image.complete === true) {
				resolve(self.image);
			}
		});
	};
})(Html2canvas || (Html2canvas = {}));
var Html2canvas;
(function (Html2canvas) {
	var GradientContainer = Html2canvas.GradientContainer;
	var Color = Html2canvas.Color;
	Html2canvas.LinearGradientContainer = function (imageData) {
		GradientContainer.apply(this, arguments);
		this.type = GradientContainer.TYPES.LINEAR;
		var hasDirection = Html2canvas.LinearGradientContainer.REGEXP_DIRECTION.test(imageData.args[0]) ||
            !GradientContainer.REGEXP_COLORSTOP.test(imageData.args[0]);
		if (hasDirection) {
			imageData.args[0].split(/\s+/).reverse().forEach(function (position, index) {
				switch (position) {
					case "left":
						this.x0 = 0;
						this.x1 = 1;
						break;
					case "top":
						this.y0 = 0;
						this.y1 = 1;
						break;
					case "right":
						this.x0 = 1;
						this.x1 = 0;
						break;
					case "bottom":
						this.y0 = 1;
						this.y1 = 0;
						break;
					case "to":
						var y0 = this.y0;
						var x0 = this.x0;
						this.y0 = this.y1;
						this.x0 = this.x1;
						this.x1 = x0;
						this.y1 = y0;
						break;
					case "center":
						break;
					default:
						var ratio = parseFloat(position) * 1e-2;
						if (isNaN(ratio)) {
							break;
						}
						if (index === 0) {
							this.y0 = ratio;
							this.y1 = 1 - this.y0;
						}
						else {
							this.x0 = ratio;
							this.x1 = 1 - this.x0;
						}
						break;
				}
			}, this);
		}
		else {
			this.y0 = 0;
			this.y1 = 1;
		}
		this.colorStops = imageData.args.slice(hasDirection ? 1 : 0).map(function (colorStop) {
			var colorStopMatch = colorStop.match(GradientContainer.REGEXP_COLORSTOP);
			var value = +colorStopMatch[2];
			var unit = value === 0 ? "%" : colorStopMatch[3];
			return {
				color: new Color(colorStopMatch[1]),
				stop: unit === "%" ? value / 100 : null
			};
		});
		if (this.colorStops[0].stop === null) {
			this.colorStops[0].stop = 0;
		}
		if (this.colorStops[this.colorStops.length - 1].stop === null) {
			this.colorStops[this.colorStops.length - 1].stop = 1;
		}
		this.colorStops.forEach(function (colorStop, index) {
			if (colorStop.stop === null) {
				this.colorStops.slice(index).some(function (find, count) {
					if (find.stop !== null) {
						colorStop.stop = ((find.stop - this.colorStops[index - 1].stop) / (count + 1)) + this.colorStops[index - 1].stop;
						return true;
					}
					else {
						return false;
					}
				}, this);
			}
		}, this);
	};
	Html2canvas.LinearGradientContainer.prototype = Object.create(GradientContainer.prototype);
	Html2canvas.LinearGradientContainer.REGEXP_DIRECTION = /^\s*(?:to|left|right|top|bottom|center|\d{1,3}(?:\.\d+)?%?)(?:\s|$)/i;
})(Html2canvas || (Html2canvas = {}));
var Html2canvas;
(function (Html2canvas) {
	var Color = Html2canvas.Color;
	var utils = Html2canvas.Utils;
	var getBounds = utils.getBounds;
	var parseBackgrounds = utils.parseBackgrounds;
	var offsetBounds = utils.offsetBounds;
	Html2canvas.NodeContainer = function (node, parent) {
		this.node = node;
		this.parent = parent;
		this.stack = null;
		this.bounds = null;
		this.borders = null;
		this.clip = [];
		this.backgroundClip = [];
		this.offsetBounds = null;
		this.visible = null;
		this.computedStyles = null;
		this.colors = {};
		this.styles = {};
		this.backgroundImages = null;
		this.transformData = null;
		this.transformMatrix = null;
		this.isPseudoElement = false;
		this.opacity = null;
	};
	Html2canvas.NodeContainer.prototype.cloneTo = function (stack) {
		stack.visible = this.visible;
		stack.borders = this.borders;
		stack.bounds = this.bounds;
		stack.clip = this.clip;
		stack.backgroundClip = this.backgroundClip;
		stack.computedStyles = this.computedStyles;
		stack.styles = this.styles;
		stack.backgroundImages = this.backgroundImages;
		stack.opacity = this.opacity;
	};
	Html2canvas.NodeContainer.prototype.getOpacity = function () {
		return this.opacity === null ? (this.opacity = this.cssFloat('opacity')) : this.opacity;
	};
	Html2canvas.NodeContainer.prototype.assignStack = function (stack) {
		this.stack = stack;
		stack.children.push(this);
	};
	Html2canvas.NodeContainer.prototype.isElementVisible = function () {
		return this.node.nodeType === Node.TEXT_NODE ? this.parent.visible : (this.css('display') !== "none" &&
            this.css('visibility') !== "hidden" &&
            !this.node.hasAttribute("data-html2canvas-ignore") &&
            (this.node.nodeName !== "INPUT" || this.node.getAttribute("type") !== "hidden"));
	};
	Html2canvas.NodeContainer.prototype.css = function (attribute) {
		if (!this.computedStyles) {
			this.computedStyles = this.isPseudoElement ? this.parent.computedStyle(this.before ? ":before" : ":after") : this.computedStyle(null);
		}
		return this.styles[attribute] || (this.styles[attribute] = this.computedStyles[attribute]);
	};
	Html2canvas.NodeContainer.prototype.prefixedCss = function (attribute) {
		var prefixes = ["webkit", "moz", "ms", "o"];
		var value = this.css(attribute);
		if (value === undefined) {
			prefixes.some(function (prefix) {
				value = this.css(prefix + attribute.substr(0, 1).toUpperCase() + attribute.substr(1));
				return value !== undefined;
			}, this);
		}
		return value === undefined ? null : value;
	};
	Html2canvas.NodeContainer.prototype.computedStyle = function (type) {
		return this.node.ownerDocument.defaultView.getComputedStyle(this.node, type);
	};
	Html2canvas.NodeContainer.prototype.cssInt = function (attribute) {
		var value = parseInt(this.css(attribute), 10);
		return (isNaN(value)) ? 0 : value;
	};
	Html2canvas.NodeContainer.prototype.color = function (attribute) {
		return this.colors[attribute] || (this.colors[attribute] = new Color(this.css(attribute)));
	};
	Html2canvas.NodeContainer.prototype.cssFloat = function (attribute) {
		var value = parseFloat(this.css(attribute));
		return (isNaN(value)) ? 0 : value;
	};
	Html2canvas.NodeContainer.prototype.fontWeight = function () {
		var weight = this.css("fontWeight");
		switch (parseInt(weight, 10)) {
			case 401:
				weight = "bold";
				break;
			case 400:
				weight = "normal";
				break;
		}
		return weight;
	};
	Html2canvas.NodeContainer.prototype.parseClip = function () {
		var matches = this.css('clip').match(this.CLIP);
		if (matches) {
			return {
				top: parseInt(matches[1], 10),
				right: parseInt(matches[2], 10),
				bottom: parseInt(matches[3], 10),
				left: parseInt(matches[4], 10)
			};
		}
		return null;
	};
	Html2canvas.NodeContainer.prototype.parseBackgroundImages = function () {
		return this.backgroundImages || (this.backgroundImages = parseBackgrounds(this.css("backgroundImage")));
	};
	Html2canvas.NodeContainer.prototype.cssList = function (property, index) {
		var value = (this.css(property) || '').split(',');
		value = value[index || 0] || value[0] || 'auto';
		value = value.trim().split(' ');
		if (value.length === 1) {
			value = [value[0], isPercentage(value[0]) ? 'auto' : value[0]];
		}
		return value;
	};
	Html2canvas.NodeContainer.prototype.parseBackgroundSize = function (bounds, image, index) {
		var size = this.cssList("backgroundSize", index);
		var width, height;
		if (isPercentage(size[0])) {
			width = bounds.width * parseFloat(size[0]) / 100;
		}
		else if (/contain|cover/.test(size[0])) {
			var targetRatio = bounds.width / bounds.height, currentRatio = image.width / image.height;
			return ((Number)(targetRatio < currentRatio) ^ (Number)(size[0] === 'contain')) ?
                { width: bounds.height * currentRatio, height: bounds.height } :
                { width: bounds.width, height: bounds.width / currentRatio };
		}
		else {
			width = parseInt(size[0], 10);
		}
		if (size[0] === 'auto' && size[1] === 'auto') {
			height = image.height;
		}
		else if (size[1] === 'auto') {
			height = width / image.width * image.height;
		}
		else if (isPercentage(size[1])) {
			height = bounds.height * parseFloat(size[1]) / 100;
		}
		else {
			height = parseInt(size[1], 10);
		}
		if (size[0] === 'auto') {
			width = height / image.height * image.width;
		}
		return { width: width, height: height };
	};
	Html2canvas.NodeContainer.prototype.parseBackgroundPosition = function (bounds, image, index, backgroundSize) {
		var position = this.cssList('backgroundPosition', index);
		var left, top;
		if (isPercentage(position[0])) {
			left = (bounds.width - (backgroundSize || image).width) * (parseFloat(position[0]) / 100);
		}
		else {
			left = parseInt(position[0], 10);
		}
		if (position[1] === 'auto') {
			top = left / image.width * image.height;
		}
		else if (isPercentage(position[1])) {
			top = (bounds.height - (backgroundSize || image).height) * parseFloat(position[1]) / 100;
		}
		else {
			top = parseInt(position[1], 10);
		}
		if (position[0] === 'auto') {
			left = top / image.height * image.width;
		}
		return { left: left, top: top };
	};
	Html2canvas.NodeContainer.prototype.parseBackgroundRepeat = function (index) {
		return this.cssList("backgroundRepeat", index)[0];
	};
	Html2canvas.NodeContainer.prototype.parseTextShadows = function () {
		var textShadow = this.css("textShadow");
		var results = [];
		if (textShadow && textShadow !== 'none') {
			var shadows = textShadow.match(this.TEXT_SHADOW_PROPERTY);
			for (var i = 0; shadows && (i < shadows.length) ; i++) {
				var s = shadows[i].match(this.TEXT_SHADOW_VALUES);
				results.push({
					color: new Color(s[0]),
					offsetX: s[1] ? parseFloat(s[1].replace('px', '')) : 0,
					offsetY: s[2] ? parseFloat(s[2].replace('px', '')) : 0,
					blur: s[3] ? s[3].replace('px', '') : 0
				});
			}
		}
		return results;
	};
	Html2canvas.NodeContainer.prototype.parseTransform = function () {
		if (!this.transformData) {
			if (this.hasTransform()) {
				var offset = this.parseBounds();
				var origin = this.prefixedCss("transformOrigin").split(" ").map(removePx).map(asFloat);
				origin[0] += offset.left;
				origin[1] += offset.top;
				this.transformData = {
					origin: origin,
					matrix: this.parseTransformMatrix()
				};
			}
			else {
				this.transformData = {
					origin: [0, 0],
					matrix: [1, 0, 0, 1, 0, 0]
				};
			}
		}
		return this.transformData;
	};
	Html2canvas.NodeContainer.prototype.parseTransformMatrix = function () {
		if (!this.transformMatrix) {
			var transform = this.prefixedCss("transform");
			var matrix = transform ? parseMatrix(transform.match(this.MATRIX_PROPERTY)) : null;
			this.transformMatrix = matrix ? matrix : [1, 0, 0, 1, 0, 0];
		}
		return this.transformMatrix;
	};
	Html2canvas.NodeContainer.prototype.parseBounds = function () {
		return this.bounds || (this.bounds = this.hasTransform() ? offsetBounds(this.node) : getBounds(this.node));
	};
	Html2canvas.NodeContainer.prototype.hasTransform = function () {
		return this.parseTransformMatrix().join(",") !== "1,0,0,1,0,0" || (this.parent && this.parent.hasTransform());
	};
	Html2canvas.NodeContainer.prototype.getValue = function () {
		var value = this.node.value || "";
		if (this.node.tagName === "SELECT") {
			value = selectionValue(this.node);
		}
		else if (this.node.type === "password") {
			value = Array(value.length + 1).join('\u2022');
		}
		return value.length === 0 ? (this.node.placeholder || "") : value;
	};
	Html2canvas.NodeContainer.prototype.MATRIX_PROPERTY = /(matrix|matrix3d)\((.+)\)/;
	Html2canvas.NodeContainer.prototype.TEXT_SHADOW_PROPERTY = /((rgba|rgb)\([^\)]+\)(\s-?\d+px){0,})/g;
	Html2canvas.NodeContainer.prototype.TEXT_SHADOW_VALUES = /(-?\d+px)|(#.+)|(rgb\(.+\))|(rgba\(.+\))/g;
	Html2canvas.NodeContainer.prototype.CLIP = /^rect\((\d+)px,? (\d+)px,? (\d+)px,? (\d+)px\)$/;
	function selectionValue(node) {
		var option = node.options[node.selectedIndex || 0];
		return option ? (option.text || "") : "";
	}
	function parseMatrix(match) {
		if (match && match[1] === "matrix") {
			return match[2].split(",").map(function (s) {
				return parseFloat(s.trim());
			});
		}
		else if (match && match[1] === "matrix3d") {
			var matrix3d = match[2].split(",").map(function (s) {
				return parseFloat(s.trim());
			});
			return [matrix3d[0], matrix3d[1], matrix3d[4], matrix3d[5], matrix3d[12], matrix3d[13]];
		}
	}
	function isPercentage(value) {
		return value.toString().indexOf("%") !== -1;
	}
	function removePx(str) {
		return str.replace("px", "");
	}
	function asFloat(str) {
		return parseFloat(str);
	}
})(Html2canvas || (Html2canvas = {}));
var Html2canvas;
(function (Html2canvas) {
	var XHR = Html2canvas.XHR;
	var utils = Html2canvas.Utils;
	var log = Html2canvas.Log;
	var createWindowClone = Html2canvas.CreateWindowClone;
	var decode64 = utils.decode64;
	Html2canvas.Proxy = function (src, proxyUrl, document) {
		var supportsCORS = ('withCredentials' in new XMLHttpRequest());
		if (!proxyUrl) {
			return Html2canvas.Promise.reject("No proxy configured");
		}
		var callback = createCallback(supportsCORS);
		var url = createProxyUrl(proxyUrl, src, callback);
		return supportsCORS ? XHR(url) : (jsonp(document, url, callback).then(function (response) {
			return decode64(response.content);
		}));
	};
	var proxyCount = 0;
	Html2canvas.ProxyURL = function (src, proxyUrl, document) {
		var supportsCORSImage = ('crossOrigin' in new Image());
		var callback = createCallback(supportsCORSImage);
		var url = createProxyUrl(proxyUrl, src, callback);
		return (supportsCORSImage ? Html2canvas.Promise.resolve(url) : jsonp(document, url, callback).then(function (response) {
			return "data:" + response.type + ";base64," + response.content;
		}));
	};
	function jsonp(document, url, callback) {
		return new Html2canvas.Promise(function (resolve, reject) {
			var s = document.createElement("script");
			var cleanup = function () {
				delete window.html2canvas.proxy[callback];
				document.body.removeChild(s);
			};
			window.html2canvas.proxy[callback] = function (response) {
				cleanup();
				resolve(response);
			};
			s.src = url;
			s.onerror = function (e) {
				cleanup();
				reject(e);
			};
			document.body.appendChild(s);
		});
	}
	function createCallback(useCORS) {
		return !useCORS ? "html2canvas_" + Date.now() + "_" + (++proxyCount) + "_" + Math.round(Math.random() * 100000) : "";
	}
	function createProxyUrl(proxyUrl, src, callback) {
		return proxyUrl + "?url=" + encodeURIComponent(src) + (callback.length ? "&callback=html2canvas.proxy." + callback : "");
	}
	function documentFromHTML(src) {
		return function (html) {
			var parser = new DOMParser(), doc;
			try {
				doc = parser.parseFromString(html, "text/html");
			}
			catch (e) {
				log("DOMParser not supported, falling back to createHTMLDocument");
				doc = document.implementation.createHTMLDocument("");
				try {
					doc.open();
					doc.write(html);
					doc.close();
				}
				catch (ee) {
					log("createHTMLDocument write not supported, falling back to document.body.innerHTML");
					doc.body.innerHTML = html;
				}
			}
			var b = doc.querySelector("base");
			if (!b || !b.href.host) {
				var base = doc.createElement("base");
				base.href = src;
				doc.head.insertBefore(base, doc.head.firstChild);
			}
			return doc;
		};
	}
	Html2canvas.loadUrlDocument = function (src, proxy, document, width, height, options) {
		return new Html2canvas.Proxy(src, proxy, window.document).then(documentFromHTML(src)).then(function (doc) {
			return createWindowClone(doc, document, width, height, options, 0, 0);
		});
	};
})(Html2canvas || (Html2canvas = {}));
var Html2canvas;
(function (Html2canvas) {
	var ProxyURL = Html2canvas.ProxyURL;
	Html2canvas.ProxyImageContainer = function (src, proxy) {
		var link = document.createElement("a");
		link.href = src;
		src = link.href;
		this.src = src;
		this.image = new Image();
		var self = this;
		this.promise = new Html2canvas.Promise(function (resolve, reject) {
			self.image.crossOrigin = "Anonymous";
			self.image.onload = resolve;
			self.image.onerror = reject;
			new ProxyURL(src, proxy, document).then(function (url) {
				self.image.src = url;
			})['catch'](reject);
		});
	};
})(Html2canvas || (Html2canvas = {}));
var Html2canvas;
(function (Html2canvas) {
	var NodeContainer = Html2canvas.NodeContainer;
	Html2canvas.PseudoElementContainer = function (node, parent, type) {
		NodeContainer.call(this, node, parent);
		this.isPseudoElement = true;
		this.before = type === ":before";
	};
	Html2canvas.PseudoElementContainer.prototype.cloneTo = function (stack) {
		Html2canvas.PseudoElementContainer.prototype.cloneTo.call(this, stack);
		stack.isPseudoElement = true;
		stack.before = this.before;
	};
	Html2canvas.PseudoElementContainer.prototype = Object.create(NodeContainer.prototype);
	Html2canvas.PseudoElementContainer.prototype.appendToDOM = function () {
		if (this.before) {
			this.parent.node.insertBefore(this.node, this.parent.node.firstChild);
		}
		else {
			this.parent.node.appendChild(this.node);
		}
		this.parent.node.className += " " + this.getHideClass();
	};
	Html2canvas.PseudoElementContainer.prototype.cleanDOM = function () {
		this.node.parentNode.removeChild(this.node);
		this.parent.node.className = this.parent.node.className.replace(this.getHideClass(), "");
	};
	Html2canvas.PseudoElementContainer.prototype.getHideClass = function () {
		return this["PSEUDO_HIDE_ELEMENT_CLASS_" + (this.before ? "BEFORE" : "AFTER")];
	};
	Html2canvas.PseudoElementContainer.prototype.PSEUDO_HIDE_ELEMENT_CLASS_BEFORE = "___html2canvas___pseudoelement_before";
	Html2canvas.PseudoElementContainer.prototype.PSEUDO_HIDE_ELEMENT_CLASS_AFTER = "___html2canvas___pseudoelement_after";
})(Html2canvas || (Html2canvas = {}));
var Html2canvas;
(function (Html2canvas) {
	var log = Html2canvas.Log;
	Html2canvas.Renderer = function (width, height, images, options, document) {
		this.width = width;
		this.height = height;
		this.images = images;
		this.options = options;
		this.document = document;
	};
	Html2canvas.Renderer.prototype.renderImage = function (container, bounds, borderData, imageContainer) {
		var paddingLeft = container.cssInt('paddingLeft'), paddingTop = container.cssInt('paddingTop'), paddingRight = container.cssInt('paddingRight'), paddingBottom = container.cssInt('paddingBottom'), borders = borderData.borders;
		var width = bounds.width - (borders[1].width + borders[3].width + paddingLeft + paddingRight);
		var height = bounds.height - (borders[0].width + borders[2].width + paddingTop + paddingBottom);
		this.drawImage(imageContainer, 0, 0, imageContainer.image.width || width, imageContainer.image.height || height, bounds.left + paddingLeft + borders[3].width, bounds.top + paddingTop + borders[0].width, width, height);
	};
	Html2canvas.Renderer.prototype.renderBackground = function (container, bounds, borderData) {
		if (bounds.height > 0 && bounds.width > 0) {
			this.renderBackgroundColor(container, bounds);
			this.renderBackgroundImage(container, bounds, borderData);
		}
	};
	Html2canvas.Renderer.prototype.renderBackgroundColor = function (container, bounds) {
		var color = container.color("backgroundColor");
		if (!color.isTransparent()) {
			this.rectangle(bounds.left, bounds.top, bounds.width, bounds.height, color);
		}
	};
	Html2canvas.Renderer.prototype.renderBorders = function (borders) {
		borders.forEach(this.renderBorder, this);
	};
	Html2canvas.Renderer.prototype.renderBorder = function (data) {
		if (!data.color.isTransparent() && data.args !== null) {
			this.drawShape(data.args, data.color);
		}
	};
	Html2canvas.Renderer.prototype.renderBackgroundImage = function (container, bounds, borderData) {
		var backgroundImages = container.parseBackgroundImages();
		backgroundImages.reverse().forEach(function (backgroundImage, index, arr) {
			switch (backgroundImage.method) {
				case "url":
					var image = this.images.get(backgroundImage.args[0]);
					if (image) {
						this.renderBackgroundRepeating(container, bounds, image, arr.length - (index + 1), borderData);
					}
					else {
						log("Error loading background-image", backgroundImage.args[0]);
					}
					break;
				case "linear-gradient":
				case "gradient":
					var gradientImage = this.images.get(backgroundImage.value);
					if (gradientImage) {
						this.renderBackgroundGradient(gradientImage, bounds, borderData);
					}
					else {
						log("Error loading background-image", backgroundImage.args[0]);
					}
					break;
				case "none":
					break;
				default:
					log("Unknown background-image type", backgroundImage.args[0]);
			}
		}, this);
	};
	Html2canvas.Renderer.prototype.renderBackgroundRepeating = function (container, bounds, imageContainer, index, borderData) {
		var size = container.parseBackgroundSize(bounds, imageContainer.image, index);
		var position = container.parseBackgroundPosition(bounds, imageContainer.image, index, size);
		var repeat = container.parseBackgroundRepeat(index);
		switch (repeat) {
			case "repeat-x":
			case "repeat no-repeat":
				this.backgroundRepeatShape(imageContainer, position, size, bounds, bounds.left + borderData[3], bounds.top + position.top + borderData[0], 99999, size.height, borderData);
				break;
			case "repeat-y":
			case "no-repeat repeat":
				this.backgroundRepeatShape(imageContainer, position, size, bounds, bounds.left + position.left + borderData[3], bounds.top + borderData[0], size.width, 99999, borderData);
				break;
			case "no-repeat":
				this.backgroundRepeatShape(imageContainer, position, size, bounds, bounds.left + position.left + borderData[3], bounds.top + position.top + borderData[0], size.width, size.height, borderData);
				break;
			default:
				this.renderBackgroundRepeat(imageContainer, position, size, { top: bounds.top, left: bounds.left }, borderData[3], borderData[0]);
				break;
		}
	};
})(Html2canvas || (Html2canvas = {}));
var Html2canvas;
(function (Html2canvas) {
	var Renderer = Html2canvas.Renderer;
	var LinearGradientContainer = Html2canvas.LinearGradientContainer;
	var log = Html2canvas.Log;
	Html2canvas.CanvasRenderer = function (width, height) {
		Renderer.apply(this, arguments);
		this.canvas = this.options.canvas || this.document.createElement("canvas");
		if (!this.options.canvas) {
			this.canvas.width = width;
			this.canvas.height = height;
		}
		this.ctx = this.canvas.getContext("2d");
		this.taintCtx = this.document.createElement("canvas").getContext("2d");
		this.ctx.textBaseline = "bottom";
		this.variables = {};
		log("Initialized CanvasRenderer with size", width, "x", height);
	};
	Html2canvas.CanvasRenderer.prototype = Object.create(Renderer.prototype);
	Html2canvas.CanvasRenderer.prototype.setFillStyle = function (fillStyle) {
		this.ctx.fillStyle = typeof (fillStyle) === "object" && !!fillStyle.isColor ? fillStyle.toString() : fillStyle;
		return this.ctx;
	};
	Html2canvas.CanvasRenderer.prototype.rectangle = function (left, top, width, height, color) {
		this.setFillStyle(color).fillRect(left, top, width, height);
	};
	Html2canvas.CanvasRenderer.prototype.circle = function (left, top, size, color) {
		this.setFillStyle(color);
		this.ctx.beginPath();
		this.ctx.arc(left + size / 2, top + size / 2, size / 2, 0, Math.PI * 2, true);
		this.ctx.closePath();
		this.ctx.fill();
	};
	Html2canvas.CanvasRenderer.prototype.circleStroke = function (left, top, size, color, stroke, strokeColor) {
		this.circle(left, top, size, color);
		this.ctx.strokeStyle = strokeColor.toString();
		this.ctx.stroke();
	};
	Html2canvas.CanvasRenderer.prototype.drawShape = function (shape, color) {
		this.shape(shape);
		this.setFillStyle(color).fill();
	};
	Html2canvas.CanvasRenderer.prototype.taints = function (imageContainer) {
		if (imageContainer.tainted === null) {
			this.taintCtx.drawImage(imageContainer.image, 0, 0);
			try {
				this.taintCtx.getImageData(0, 0, 1, 1);
				imageContainer.tainted = false;
			}
			catch (e) {
				this.taintCtx = document.createElement("canvas").getContext("2d");
				imageContainer.tainted = true;
			}
		}
		return imageContainer.tainted;
	};
	Html2canvas.CanvasRenderer.prototype.drawImage = function (imageContainer, sx, sy, sw, sh, dx, dy, dw, dh) {
		if (!this.taints(imageContainer) || this.options.allowTaint) {
			this.ctx.drawImage(imageContainer.image, sx, sy, sw, sh, dx, dy, dw, dh);
		}
	};
	Html2canvas.CanvasRenderer.prototype.clip = function (shapes, callback, context) {
		this.ctx.save();
		shapes.filter(hasEntries).forEach(function (shape) {
			this.shape(shape).clip();
		}, this);
		callback.call(context);
		this.ctx.restore();
	};
	Html2canvas.CanvasRenderer.prototype.shape = function (shape) {
		this.ctx.beginPath();
		shape.forEach(function (point, index) {
			if (point[0] === "rect") {
				this.ctx.rect.apply(this.ctx, point.slice(1));
			}
			else {
				this.ctx[(index === 0) ? "moveTo" : point[0] + "To"].apply(this.ctx, point.slice(1));
			}
		}, this);
		this.ctx.closePath();
		return this.ctx;
	};
	Html2canvas.CanvasRenderer.prototype.font = function (color, style, variant, weight, size, family) {
		this.setFillStyle(color).font = [style, variant, weight, size, family].join(" ").split(",")[0];
	};
	Html2canvas.CanvasRenderer.prototype.fontShadow = function (color, offsetX, offsetY, blur) {
		this.setVariable("shadowColor", color.toString())
            .setVariable("shadowOffsetY", offsetX)
            .setVariable("shadowOffsetX", offsetY)
            .setVariable("shadowBlur", blur);
	};
	Html2canvas.CanvasRenderer.prototype.clearShadow = function () {
		this.setVariable("shadowColor", "rgba(0,0,0,0)");
	};
	Html2canvas.CanvasRenderer.prototype.setOpacity = function (opacity) {
		this.ctx.globalAlpha = opacity;
	};
	Html2canvas.CanvasRenderer.prototype.setTransform = function (transform) {
		this.ctx.translate(transform.origin[0], transform.origin[1]);
		this.ctx.transform.apply(this.ctx, transform.matrix);
		this.ctx.translate(-transform.origin[0], -transform.origin[1]);
	};
	Html2canvas.CanvasRenderer.prototype.setVariable = function (property, value) {
		if (this.variables[property] !== value) {
			this.variables[property] = this.ctx[property] = value;
		}
		return this;
	};
	Html2canvas.CanvasRenderer.prototype.text = function (text, left, bottom) {
		this.ctx.fillText(text, left, bottom);
	};
	Html2canvas.CanvasRenderer.prototype.backgroundRepeatShape = function (imageContainer, backgroundPosition, size, bounds, left, top, width, height, borderData) {
		var shape = [
            ["line", Math.round(left), Math.round(top)],
            ["line", Math.round(left + width), Math.round(top)],
            ["line", Math.round(left + width), Math.round(height + top)],
            ["line", Math.round(left), Math.round(height + top)]
		];
		this.clip([shape], function () {
			this.renderBackgroundRepeat(imageContainer, backgroundPosition, size, bounds, borderData[3], borderData[0]);
		}, this);
	};
	Html2canvas.CanvasRenderer.prototype.renderBackgroundRepeat = function (imageContainer, backgroundPosition, size, bounds, borderLeft, borderTop) {
		var offsetX = Math.round(bounds.left + backgroundPosition.left + borderLeft), offsetY = Math.round(bounds.top + backgroundPosition.top + borderTop);
		this.setFillStyle(this.ctx.createPattern(this.resizeImage(imageContainer, size), "repeat"));
		this.ctx.translate(offsetX, offsetY);
		this.ctx.fill();
		this.ctx.translate(-offsetX, -offsetY);
	};
	Html2canvas.CanvasRenderer.prototype.renderBackgroundGradient = function (gradientImage, bounds) {
		if (gradientImage instanceof LinearGradientContainer) {
			var gradient = this.ctx.createLinearGradient(bounds.left + bounds.width * gradientImage.x0, bounds.top + bounds.height * gradientImage.y0, bounds.left + bounds.width * gradientImage.x1, bounds.top + bounds.height * gradientImage.y1);
			gradientImage.colorStops.forEach(function (colorStop) {
				gradient.addColorStop(colorStop.stop, colorStop.color.toString());
			});
			this.rectangle(bounds.left, bounds.top, bounds.width, bounds.height, gradient);
		}
	};
	Html2canvas.CanvasRenderer.prototype.resizeImage = function (imageContainer, size) {
		var image = imageContainer.image;
		if (image.width === size.width && image.height === size.height) {
			return image;
		}
		var ctx, canvas = document.createElement('canvas');
		canvas.width = size.width;
		canvas.height = size.height;
		ctx = canvas.getContext("2d");
		ctx.drawImage(image, 0, 0, image.width, image.height, 0, 0, size.width, size.height);
		return canvas;
	};
	function hasEntries(array) {
		return array.length > 0;
	}
})(Html2canvas || (Html2canvas = {}));
var Html2canvas;
(function (Html2canvas) {
	var NodeContainer = Html2canvas.NodeContainer;
	Html2canvas.StackingContext = function (hasOwnStacking, opacity, element, parent) {
		NodeContainer.call(this, element, parent);
		this.ownStacking = hasOwnStacking;
		this.contexts = [];
		this.children = [];
		this.opacity = (this.parent ? this.parent.stack.opacity : 1) * opacity;
	};
	Html2canvas.StackingContext.prototype = Object.create(NodeContainer.prototype);
	Html2canvas.StackingContext.prototype.getParentStack = function (context) {
		var parentStack = (this.parent) ? this.parent.stack : null;
		return parentStack ? (parentStack.ownStacking ? parentStack : parentStack.getParentStack(context)) : context.stack;
	};
})(Html2canvas || (Html2canvas = {}));
var Html2canvas;
(function (Html2canvas) {
	var XHR = Html2canvas.XHR;
	var decode64 = Html2canvas.Utils.decode64;
	Html2canvas.SVGContainer = function (src) {
		this.src = src;
		this.image = null;
		var self = this;
		this.promise = this.hasFabric().then(function () {
			return (self.isInline(src) ? Html2canvas.Promise.resolve(self.inlineFormatting(src)) : XHR(src));
		}).then(function (svg) {
			return new Html2canvas.Promise(function (resolve) {
				window.html2canvas.svg.fabric.loadSVGFromString(svg, self.createCanvas.call(self, resolve));
			});
		});
	};
	Html2canvas.SVGContainer.prototype.hasFabric = function () {
		return !window.html2canvas.svg || !window.html2canvas.svg.fabric ? Html2canvas.Promise.reject(new Error("html2canvas.svg.js is not loaded, cannot render svg")) : Html2canvas.Promise.resolve();
	};
	Html2canvas.SVGContainer.prototype.inlineFormatting = function (src) {
		return (/^data:image\/svg\+xml;base64,/.test(src)) ? this.decode64(this.removeContentType(src)) : this.removeContentType(src);
	};
	Html2canvas.SVGContainer.prototype.removeContentType = function (src) {
		return src.replace(/^data:image\/svg\+xml(;base64)?,/, '');
	};
	Html2canvas.SVGContainer.prototype.isInline = function (src) {
		return (/^data:image\/svg\+xml/i.test(src));
	};
	Html2canvas.SVGContainer.prototype.createCanvas = function (resolve) {
		var self = this;
		return function (objects, options) {
			var canvas = new window.html2canvas.svg.fabric.StaticCanvas('c');
			self.image = canvas.lowerCanvasEl;
			canvas
                .setWidth(options.width)
                .setHeight(options.height)
                .add(window.html2canvas.svg.fabric.util.groupSVGElements(objects, options))
                .renderAll();
			resolve(canvas.lowerCanvasEl);
		};
	};
	Html2canvas.SVGContainer.prototype.decode64 = function (str) {
		return (typeof (window.atob) === "function") ? window.atob(str) : decode64(str);
	};
})(Html2canvas || (Html2canvas = {}));
var Html2canvas;
(function (Html2canvas) {
	Html2canvas.SVGNodeContainer = function (node, _native) {
		this.src = node;
		this.image = null;
		var self = this;
		this.promise = _native ? new Html2canvas.Promise(function (resolve, reject) {
			self.image = new Image();
			self.image.onload = resolve;
			self.image.onerror = reject;
			self.image.src = "data:image/svg+xml," + encodeURIComponent((new XMLSerializer()).serializeToString(node));
			if (self.image.complete === true) {
				resolve(self.image);
			}
		}) : this.hasFabric().then(function () {
			return new Html2canvas.Promise(function (resolve) {
				window.html2canvas.svg.fabric.parseSVGDocument(node, self.createCanvas.call(self, resolve));
			});
		});
	};
	Html2canvas.SVGNodeContainer.prototype = Object.create(Html2canvas.SVGContainer.prototype);
})(Html2canvas || (Html2canvas = {}));
var Html2canvas;
(function (Html2canvas) {
	var NodeContainer = Html2canvas.NodeContainer;
	Html2canvas.TextContainer = function (node, parent) {
		NodeContainer.call(this, node, parent);
	};
	Html2canvas.TextContainer.prototype = Object.create(NodeContainer.prototype);
	Html2canvas.TextContainer.prototype.applyTextTransform = function () {
		this.node.data = this.transform(this.parent.css("textTransform"));
	};
	Html2canvas.TextContainer.prototype.transform = function (transform) {
		var text = this.node.data;
		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 capitalize(m, p1, p2) {
		if (m.length > 0) {
			return p1 + p2.toUpperCase();
		}
	}
})(Html2canvas || (Html2canvas = {}));
var Html2canvas;
(function (Html2canvas) {
	var GradientContainer = Html2canvas.GradientContainer;
	Html2canvas.WebkitGradientContainer = function (imageData) {
		GradientContainer.apply(this, arguments);
		this.type = imageData.args[0] === "linear" ? GradientContainer.TYPES.LINEAR : GradientContainer.TYPES.RADIAL;
	};
	Html2canvas.WebkitGradientContainer.prototype = Object.create(GradientContainer.prototype);
})(Html2canvas || (Html2canvas = {}));
var Html2canvas;
(function (Html2canvas) {
	var log = Html2canvas.Log;
	var punycode = PunyCode.PunyCode;
	var NodeContainer = Html2canvas.NodeContainer;
	var TextContainer = Html2canvas.TextContainer;
	var PseudoElementContainer = Html2canvas.PseudoElementContainer;
	var FontMetrics = Html2canvas.FontMetrics;
	var Color = Html2canvas.Color;
	var StackingContext = Html2canvas.StackingContext;
	var utils = Html2canvas.Utils;
	var bind = utils.bind;
	var getBounds = utils.getBounds;
	var parseBackgrounds = utils.parseBackgrounds;
	var offsetBounds = utils.offsetBounds;
	Html2canvas.NodeParser = function (element, renderer, support, imageLoader, options) {
		log("Starting NodeParser");
		this.renderer = renderer;
		this.options = options;
		this.range = null;
		this.support = support;
		this.renderQueue = [];
		this.stack = new StackingContext(true, 1, element.ownerDocument, null);
		var parent = new NodeContainer(element, null);
		if (options.background) {
			renderer.rectangle(0, 0, renderer.width, renderer.height, new Color(options.background));
		}
		if (element === element.ownerDocument.documentElement) {
			var canvasBackground = new NodeContainer(parent.color('backgroundColor').isTransparent() ? element.ownerDocument.body : element.ownerDocument.documentElement, null);
			renderer.rectangle(0, 0, renderer.width, renderer.height, canvasBackground.color('backgroundColor'));
		}
		parent.visible = parent.isElementVisible();
		this.createPseudoHideStyles(element.ownerDocument);
		this.disableAnimations(element.ownerDocument);
		this.nodes = flatten([parent].concat(this.getChildren(parent)).filter(function (container) {
			return container.visible = container.isElementVisible();
		}).map(this.getPseudoElements, this));
		this.fontMetrics = new FontMetrics();
		log("Fetched nodes, total:", this.nodes.length);
		log("Calculate overflow clips");
		this.calculateOverflowClips();
		log("Start fetching images");
		this.images = imageLoader.fetch(this.nodes.filter(isElement));
		this.ready = this.images.ready.then(bind(function () {
			log("Images loaded, starting parsing");
			log("Creating stacking contexts");
			this.createStackingContexts();
			log("Sorting stacking contexts");
			this.sortStackingContexts(this.stack);
			this.parse(this.stack);
			log("Render queue created with " + this.renderQueue.length + " items");
			return new Html2canvas.Promise(bind(function (resolve) {
				if (!options.async) {
					this.renderQueue.forEach(this.paint, this);
					resolve();
				}
				else if (typeof (options.async) === "function") {
					options.async.call(this, this.renderQueue, resolve);
				}
				else if (this.renderQueue.length > 0) {
					this.renderIndex = 0;
					this.asyncRenderer(this.renderQueue, resolve);
				}
				else {
					resolve();
				}
			}, this));
		}, this));
	};
	Html2canvas.NodeParser.prototype.calculateOverflowClips = function () {
		this.nodes.forEach(function (container) {
			if (isElement(container)) {
				if (isPseudoElement(container)) {
					container.appendToDOM();
				}
				container.borders = this.parseBorders(container);
				var clip = (container.css('overflow') === "hidden") ? [container.borders.clip] : [];
				var cssClip = container.parseClip();
				if (cssClip && ["absolute", "fixed"].indexOf(container.css('position')) !== -1) {
					clip.push([["rect",
                            container.bounds.left + cssClip.left,
                            container.bounds.top + cssClip.top,
                            cssClip.right - cssClip.left,
                            cssClip.bottom - cssClip.top
					]]);
				}
				container.clip = hasParentClip(container) ? container.parent.clip.concat(clip) : clip;
				container.backgroundClip = (container.css('overflow') !== "hidden") ? container.clip.concat([container.borders.clip]) : container.clip;
				if (isPseudoElement(container)) {
					container.cleanDOM();
				}
			}
			else if (isTextNode(container)) {
				container.clip = hasParentClip(container) ? container.parent.clip : [];
			}
			if (!isPseudoElement(container)) {
				container.bounds = null;
			}
		}, this);
	};
	function hasParentClip(container) {
		return container.parent && container.parent.clip.length;
	}
	Html2canvas.NodeParser.prototype.asyncRenderer = function (queue, resolve, asyncTimer) {
		asyncTimer = asyncTimer || Date.now();
		this.paint(queue[this.renderIndex++]);
		if (queue.length === this.renderIndex) {
			resolve();
		}
		else if (asyncTimer + 20 > Date.now()) {
			this.asyncRenderer(queue, resolve, asyncTimer);
		}
		else {
			setTimeout(bind(function () {
				this.asyncRenderer(queue, resolve);
			}, this), 0);
		}
	};
	Html2canvas.NodeParser.prototype.createPseudoHideStyles = function (document) {
		this.createStyles(document, '.' + PseudoElementContainer.prototype.PSEUDO_HIDE_ELEMENT_CLASS_BEFORE + ':before { content: "" !important; display: none !important; }' +
            '.' + PseudoElementContainer.prototype.PSEUDO_HIDE_ELEMENT_CLASS_AFTER + ':after { content: "" !important; display: none !important; }');
	};
	Html2canvas.NodeParser.prototype.disableAnimations = function (document) {
		this.createStyles(document, '* { -webkit-animation: none !important; -moz-animation: none !important; -o-animation: none !important; animation: none !important; ' +
            '-webkit-transition: none !important; -moz-transition: none !important; -o-transition: none !important; transition: none !important;}');
	};
	Html2canvas.NodeParser.prototype.createStyles = function (document, styles) {
		var hidePseudoElements = document.createElement('style');
		hidePseudoElements.innerHTML = styles;
		document.body.appendChild(hidePseudoElements);
	};
	Html2canvas.NodeParser.prototype.getPseudoElements = function (container) {
		var nodes = [[container]];
		if (container.node.nodeType === Node.ELEMENT_NODE) {
			var before = this.getPseudoElement(container, ":before");
			var after = this.getPseudoElement(container, ":after");
			if (before) {
				nodes.push(before);
			}
			if (after) {
				nodes.push(after);
			}
		}
		return flatten(nodes);
	};
	function toCamelCase(str) {
		return str.replace(/(\-[a-z])/g, function (match) {
			return match.toUpperCase().replace('-', '');
		});
	}
	Html2canvas.NodeParser.prototype.getPseudoElement = function (container, type) {
		var style = container.computedStyle(type);
		if (!style || !style.content || style.content === "none" || style.content === "-moz-alt-content" || style.display === "none") {
			return null;
		}
		var content = stripQuotes(style.content);
		var isImage = content.substr(0, 3) === 'url';
		var pseudoNode = document.createElement(isImage ? 'img' : 'html2canvaspseudoelement');
		var pseudoContainer = new PseudoElementContainer(pseudoNode, container, type);
		for (var i = style.length - 1; i >= 0; i--) {
			var property = toCamelCase(style.item(i));
			pseudoNode.style[property] = style[property];
		}
		pseudoNode.className = PseudoElementContainer.prototype.PSEUDO_HIDE_ELEMENT_CLASS_BEFORE + " " + PseudoElementContainer.prototype.PSEUDO_HIDE_ELEMENT_CLASS_AFTER;
		if (isImage) {
			pseudoNode.src = parseBackgrounds(content)[0].args[0];
			return [pseudoContainer];
		}
		else {
			var text = document.createTextNode(content);
			pseudoNode.appendChild(text);
			return [pseudoContainer, new TextContainer(text, pseudoContainer)];
		}
	};
	Html2canvas.NodeParser.prototype.getChildren = function (parentContainer) {
		return flatten([].filter.call(parentContainer.node.childNodes, renderableNode).map(function (node) {
			var container = [node.nodeType === Node.TEXT_NODE ? new TextContainer(node, parentContainer) : new NodeContainer(node, parentContainer)].filter(nonIgnoredElement);
			return node.nodeType === Node.ELEMENT_NODE && container.length && node.tagName !== "TEXTAREA" ? (container[0].isElementVisible() ? container.concat(this.getChildren(container[0])) : []) : container;
		}, this));
	};
	Html2canvas.NodeParser.prototype.newStackingContext = function (container, hasOwnStacking) {
		var stack = new StackingContext(hasOwnStacking, container.getOpacity(), container.node, container.parent);
		container.cloneTo(stack);
		var parentStack = hasOwnStacking ? stack.getParentStack(this) : stack.parent.stack;
		parentStack.contexts.push(stack);
		container.stack = stack;
	};
	Html2canvas.NodeParser.prototype.createStackingContexts = function () {
		this.nodes.forEach(function (container) {
			if (isElement(container) && (this.isRootElement(container) || hasOpacity(container) || isPositionedForStacking(container) || this.isBodyWithTransparentRoot(container) || container.hasTransform())) {
				this.newStackingContext(container, true);
			}
			else if (isElement(container) && ((isPositioned(container) && zIndex0(container)) || isInlineBlock(container) || isFloating(container))) {
				this.newStackingContext(container, false);
			}
			else {
				container.assignStack(container.parent.stack);
			}
		}, this);
	};
	Html2canvas.NodeParser.prototype.isBodyWithTransparentRoot = function (container) {
		return container.node.nodeName === "BODY" && container.parent.color('backgroundColor').isTransparent();
	};
	Html2canvas.NodeParser.prototype.isRootElement = function (container) {
		return container.parent === null;
	};
	Html2canvas.NodeParser.prototype.sortStackingContexts = function (stack) {
		stack.contexts.sort(zIndexSort(stack.contexts.slice(0)));
		stack.contexts.forEach(this.sortStackingContexts, this);
	};
	Html2canvas.NodeParser.prototype.parseTextBounds = function (container) {
		return function (text, index, textList) {
			if (container.parent.css("textDecoration").substr(0, 4) !== "none" || text.trim().length !== 0) {
				if (this.support.rangeBounds && !container.parent.hasTransform()) {
					var offset = textList.slice(0, index).join("").length;
					return this.getRangeBounds(container.node, offset, text.length);
				}
				else if (container.node && typeof (container.node.data) === "string") {
					var replacementNode = container.node.splitText(text.length);
					var bounds = this.getWrapperBounds(container.node, container.parent.hasTransform());
					container.node = replacementNode;
					return bounds;
				}
			}
			else if (!this.support.rangeBounds || container.parent.hasTransform()) {
				container.node = container.node.splitText(text.length);
			}
			return {};
		};
	};
	Html2canvas.NodeParser.prototype.getWrapperBounds = function (node, transform) {
		var wrapper = node.ownerDocument.createElement('html2canvaswrapper');
		var parent = node.parentNode, backupText = node.cloneNode(true);
		wrapper.appendChild(node.cloneNode(true));
		parent.replaceChild(wrapper, node);
		var bounds = transform ? offsetBounds(wrapper) : getBounds(wrapper);
		parent.replaceChild(backupText, wrapper);
		return bounds;
	};
	Html2canvas.NodeParser.prototype.getRangeBounds = function (node, offset, length) {
		var range = this.range || (this.range = node.ownerDocument.createRange());
		range.setStart(node, offset);
		range.setEnd(node, offset + length);
		return range.getBoundingClientRect();
	};
	function ClearTransform() { }
	Html2canvas.NodeParser.prototype.parse = function (stack) {
		var negativeZindex = stack.contexts.filter(negativeZIndex);
		var descendantElements = stack.children.filter(isElement);
		var descendantNonFloats = descendantElements.filter(not(isFloating));
		var nonInlineNonPositionedDescendants = descendantNonFloats.filter(not(isPositioned)).filter(not(inlineLevel));
		var nonPositionedFloats = descendantElements.filter(not(isPositioned)).filter(isFloating);
		var inFlow = descendantNonFloats.filter(not(isPositioned)).filter(inlineLevel);
		var stackLevel0 = stack.contexts.concat(descendantNonFloats.filter(isPositioned)).filter(zIndex0);
		var text = stack.children.filter(isTextNode).filter(hasText);
		var positiveZindex = stack.contexts.filter(positiveZIndex);
		negativeZindex.concat(nonInlineNonPositionedDescendants).concat(nonPositionedFloats)
            .concat(inFlow).concat(stackLevel0).concat(text).concat(positiveZindex).forEach(function (container) {
            	this.renderQueue.push(container);
            	if (isStackingContext(container)) {
            		this.parse(container);
            		this.renderQueue.push(new ClearTransform());
            	}
            }, this);
	};
	Html2canvas.NodeParser.prototype.paint = function (container) {
		try {
			if (container instanceof ClearTransform) {
				this.renderer.ctx.restore();
			}
			else if (isTextNode(container)) {
				if (isPseudoElement(container.parent)) {
					container.parent.appendToDOM();
				}
				this.paintText(container);
				if (isPseudoElement(container.parent)) {
					container.parent.cleanDOM();
				}
			}
			else {
				this.paintNode(container);
			}
		}
		catch (e) {
			log(e);
			if (this.options.strict) {
				throw e;
			}
		}
	};
	Html2canvas.NodeParser.prototype.paintNode = function (container) {
		if (isStackingContext(container)) {
			this.renderer.setOpacity(container.opacity);
			this.renderer.ctx.save();
			if (container.hasTransform()) {
				this.renderer.setTransform(container.parseTransform());
			}
		}
		if (container.node.nodeName === "INPUT" && container.node.type === "checkbox") {
			this.paintCheckbox(container);
		}
		else if (container.node.nodeName === "INPUT" && container.node.type === "radio") {
			this.paintRadio(container);
		}
		else {
			this.paintElement(container);
		}
	};
	Html2canvas.NodeParser.prototype.paintElement = function (container) {
		var bounds = container.parseBounds();
		this.renderer.clip(container.backgroundClip, function () {
			this.renderer.renderBackground(container, bounds, container.borders.borders.map(getWidth));
		}, this);
		this.renderer.clip(container.clip, function () {
			this.renderer.renderBorders(container.borders.borders);
		}, this);
		this.renderer.clip(container.backgroundClip, function () {
			switch (container.node.nodeName) {
				case "svg":
				case "IFRAME":
					var imgContainer = this.images.get(container.node);
					if (imgContainer) {
						this.renderer.renderImage(container, bounds, container.borders, imgContainer);
					}
					else {
						log("Error loading <" + container.node.nodeName + ">", container.node);
					}
					break;
				case "IMG":
					var imageContainer = this.images.get(container.node.src);
					if (imageContainer) {
						this.renderer.renderImage(container, bounds, container.borders, imageContainer);
					}
					else {
						log("Error loading <img>", container.node.src);
					}
					break;
				case "CANVAS":
					this.renderer.renderImage(container, bounds, container.borders, { image: container.node });
					break;
				case "SELECT":
				case "INPUT":
				case "TEXTAREA":
					if (container.node.nodeName === 'INPUT' && container.node.type === 'image') {
						var imgContainer = this.images.get(container.node);
						if (imgContainer) {
							this.renderer.renderImage(container, bounds, container.borders, imgContainer);
						}
						else {
							log("Error loading <" + container.node.nodeName + ">", container.node);
						}
					}
					else {
						this.paintFormValue(container);
					}
					break;
			}
		}, this);
	};
	Html2canvas.NodeParser.prototype.paintCheckbox = function (container) {
		var b = container.parseBounds();
		var size = Math.min(b.width, b.height);
		var bounds = { width: size - 1, height: size - 1, top: b.top, left: b.left };
		var r = [3, 3];
		var radius = [r, r, r, r];
		var borders = [1, 1, 1, 1].map(function (w) {
			return { color: new Color('#A5A5A5'), width: w };
		});
		var borderPoints = calculateCurvePoints(bounds, radius, borders);
		this.renderer.clip(container.backgroundClip, function () {
			this.renderer.rectangle(bounds.left + 1, bounds.top + 1, bounds.width - 2, bounds.height - 2, new Color("#DEDEDE"));
			this.renderer.renderBorders(calculateBorders(borders, bounds, borderPoints, radius));
			if (container.node.checked) {
				this.renderer.font(new Color('#424242'), 'normal', 'normal', 'bold', (size - 3) + "px", 'arial');
				this.renderer.text("\u2714", bounds.left + size / 6, bounds.top + size - 1);
			}
		}, this);
	};
	Html2canvas.NodeParser.prototype.paintRadio = function (container) {
		var bounds = container.parseBounds();
		var size = Math.min(bounds.width, bounds.height) - 2;
		this.renderer.clip(container.backgroundClip, function () {
			this.renderer.circleStroke(bounds.left + 1, bounds.top + 1, size, new Color('#DEDEDE'), 1, new Color('#A5A5A5'));
			if (container.node.checked) {
				this.renderer.circle(Math.ceil(bounds.left + size / 4) + 1, Math.ceil(bounds.top + size / 4) + 1, Math.floor(size / 2), new Color('#424242'));
			}
		}, this);
	};
	Html2canvas.NodeParser.prototype.paintFormValue = function (container) {
		var value = container.getValue();
		if (value.length > 0) {
			var document = container.node.ownerDocument;
			var wrapper = document.createElement('html2canvaswrapper');
			var properties = ['lineHeight', 'textAlign', 'fontFamily', 'fontWeight', 'fontSize', 'color',
                'paddingLeft', 'paddingTop', 'paddingRight', 'paddingBottom',
                'width', 'height', 'borderLeftStyle', 'borderTopStyle', 'borderLeftWidth', 'borderTopWidth',
                'boxSizing', 'whiteSpace', 'wordWrap'];
			properties.forEach(function (property) {
				try {
					wrapper.style[property] = container.css(property);
				}
				catch (e) {
					log("html2canvas: Parse: Exception caught in renderFormValue: " + e.message);
				}
			});
			var bounds = container.parseBounds();
			wrapper.style.position = "fixed";
			wrapper.style.left = bounds.left + "px";
			wrapper.style.top = bounds.top + "px";
			wrapper.textContent = value;
			document.body.appendChild(wrapper);
			this.paintText(new TextContainer(wrapper.firstChild, container));
			document.body.removeChild(wrapper);
		}
	};
	Html2canvas.NodeParser.prototype.paintText = function (container) {
		container.applyTextTransform();
		var characters = punycode.ucs2.decode(container.node.data);
		var textList = (!this.options.letterRendering || noLetterSpacing(container)) && !hasUnicode(container.node.data) ? getWords(characters) : characters.map(function (character) {
			return punycode.ucs2.encode([character]);
		});
		var weight = container.parent.fontWeight();
		var size = container.parent.css('fontSize');
		var family = container.parent.css('fontFamily');
		var shadows = container.parent.parseTextShadows();
		this.renderer.font(container.parent.color('color'), container.parent.css('fontStyle'), container.parent.css('fontVariant'), weight, size, family);
		if (shadows.length) {
			this.renderer.fontShadow(shadows[0].color, shadows[0].offsetX, shadows[0].offsetY, shadows[0].blur);
		}
		else {
			this.renderer.clearShadow();
		}
		this.renderer.clip(container.parent.clip, function () {
			textList.map(this.parseTextBounds(container), this).forEach(function (bounds, index) {
				if (bounds) {
					this.renderer.text(textList[index], bounds.left, bounds.bottom);
					this.renderTextDecoration(container.parent, bounds, this.fontMetrics.getMetrics(family, size));
				}
			}, this);
		}, this);
	};
	Html2canvas.NodeParser.prototype.renderTextDecoration = function (container, bounds, metrics) {
		switch (container.css("textDecoration").split(" ")[0]) {
			case "underline":
				this.renderer.rectangle(bounds.left, Math.round(bounds.top + metrics.baseline + metrics.lineWidth), bounds.width, 1, container.color("color"));
				break;
			case "overline":
				this.renderer.rectangle(bounds.left, Math.round(bounds.top), bounds.width, 1, container.color("color"));
				break;
			case "line-through":
				this.renderer.rectangle(bounds.left, Math.ceil(bounds.top + metrics.middle + metrics.lineWidth), bounds.width, 1, container.color("color"));
				break;
		}
	};
	var borderColorTransforms = {
		inset: [
            ["darken", 0.60],
            ["darken", 0.10],
            ["darken", 0.10],
            ["darken", 0.60]
		]
	};
	Html2canvas.NodeParser.prototype.parseBorders = function (container) {
		var nodeBounds = container.parseBounds();
		var radius = getBorderRadiusData(container);
		var borders = ["Top", "Right", "Bottom", "Left"].map(function (side, index) {
			var style = container.css('border' + side + 'Style');
			var color = container.color('border' + side + 'Color');
			if (style === "inset" && color.isBlack()) {
				color = new Color([255, 255, 255, color.a]);
			}
			var colorTransform = borderColorTransforms[style] ? borderColorTransforms[style][index] : null;
			return {
				width: container.cssInt('border' + side + 'Width'),
				color: colorTransform ? color[colorTransform[0]](colorTransform[1]) : color,
				args: null
			};
		});
		var borderPoints = calculateCurvePoints(nodeBounds, radius, borders);
		return {
			clip: this.parseBackgroundClip(container, borderPoints, borders, radius, nodeBounds),
			borders: calculateBorders(borders, nodeBounds, borderPoints, radius)
		};
	};
	function calculateBorders(borders, nodeBounds, borderPoints, radius) {
		return borders.map(function (border, borderSide) {
			if (border.width > 0) {
				var bx = nodeBounds.left;
				var by = nodeBounds.top;
				var bw = nodeBounds.width;
				var bh = nodeBounds.height - (borders[2].width);
				switch (borderSide) {
					case 0:
						bh = borders[0].width;
						border.args = drawSide({
							c1: [bx, by],
							c2: [bx + bw, by],
							c3: [bx + bw - borders[1].width, by + bh],
							c4: [bx + borders[3].width, by + bh]
						}, radius[0], radius[1], borderPoints.topLeftOuter, borderPoints.topLeftInner, borderPoints.topRightOuter, borderPoints.topRightInner);
						break;
					case 1:
						bx = nodeBounds.left + nodeBounds.width - (borders[1].width);
						bw = borders[1].width;
						border.args = drawSide({
							c1: [bx + bw, by],
							c2: [bx + bw, by + bh + borders[2].width],
							c3: [bx, by + bh],
							c4: [bx, by + borders[0].width]
						}, radius[1], radius[2], borderPoints.topRightOuter, borderPoints.topRightInner, borderPoints.bottomRightOuter, borderPoints.bottomRightInner);
						break;
					case 2:
						by = (by + nodeBounds.height) - (borders[2].width);
						bh = borders[2].width;
						border.args = drawSide({
							c1: [bx + bw, by + bh],
							c2: [bx, by + bh],
							c3: [bx + borders[3].width, by],
							c4: [bx + bw - borders[3].width, by]
						}, radius[2], radius[3], borderPoints.bottomRightOuter, borderPoints.bottomRightInner, borderPoints.bottomLeftOuter, borderPoints.bottomLeftInner);
						break;
					case 3:
						bw = borders[3].width;
						border.args = drawSide({
							c1: [bx, by + bh + borders[2].width],
							c2: [bx, by],
							c3: [bx + bw, by + borders[0].width],
							c4: [bx + bw, by + bh]
						}, radius[3], radius[0], borderPoints.bottomLeftOuter, borderPoints.bottomLeftInner, borderPoints.topLeftOuter, borderPoints.topLeftInner);
						break;
				}
			}
			return border;
		});
	}
	Html2canvas.NodeParser.prototype.parseBackgroundClip = function (container, borderPoints, borders, radius, bounds) {
		var backgroundClip = container.css('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 getCurvePoints(x, y, r1, r2) {
		var kappa = 4 * ((Math.sqrt(2) - 1) / 3);
		var ox = (r1) * kappa, oy = (r2) * kappa, xm = x + r1, ym = y + r2;
		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 })
		};
	}
	function calculateCurvePoints(bounds, borderRadius, borders) {
		var x = bounds.left, y = bounds.top, width = bounds.width, height = bounds.height, tlh = borderRadius[0][0] < width / 2 ? borderRadius[0][0] : width / 2, tlv = borderRadius[0][1] < height / 2 ? borderRadius[0][1] : height / 2, trh = borderRadius[1][0] < width / 2 ? borderRadius[1][0] : width / 2, trv = borderRadius[1][1] < height / 2 ? borderRadius[1][1] : height / 2, brh = borderRadius[2][0] < width / 2 ? borderRadius[2][0] : width / 2, brv = borderRadius[2][1] < height / 2 ? borderRadius[2][1] : height / 2, blh = borderRadius[3][0] < width / 2 ? borderRadius[3][0] : width / 2, blv = borderRadius[3][1] < height / 2 ? borderRadius[3][1] : height / 2;
		var 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), 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), blv - borders[2].width).bottomLeft.subdivide(0.5)
		};
	}
	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 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 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 negativeZIndex(container) {
		return container.cssInt("zIndex") < 0;
	}
	function positiveZIndex(container) {
		return container.cssInt("zIndex") > 0;
	}
	function zIndex0(container) {
		return container.cssInt("zIndex") === 0;
	}
	function inlineLevel(container) {
		return ["inline", "inline-block", "inline-table"].indexOf(container.css("display")) !== -1;
	}
	function isStackingContext(container) {
		return (container instanceof StackingContext);
	}
	function hasText(container) {
		return container.node.data.trim().length > 0;
	}
	function noLetterSpacing(container) {
		return (/^(normal|none|0px)$/.test(container.parent.css("letterSpacing")));
	}
	function getBorderRadiusData(container) {
		return ["TopLeft", "TopRight", "BottomRight", "BottomLeft"].map(function (side) {
			var value = container.css('border' + side + 'Radius');
			var arr = value.split(" ");
			if (arr.length <= 1) {
				arr[1] = arr[0];
			}
			return arr.map(asInt);
		});
	}
	function renderableNode(node) {
		return (node.nodeType === Node.TEXT_NODE || node.nodeType === Node.ELEMENT_NODE);
	}
	function isPositionedForStacking(container) {
		var position = container.css("position");
		var zIndex = (["absolute", "relative", "fixed"].indexOf(position) !== -1) ? container.css("zIndex") : "auto";
		return zIndex !== "auto";
	}
	function isPositioned(container) {
		return container.css("position") !== "static";
	}
	function isFloating(container) {
		return container.css("float") !== "none";
	}
	function isInlineBlock(container) {
		return ["inline-block", "inline-table"].indexOf(container.css("display")) !== -1;
	}
	function not(callback) {
		var context = this;
		return function () {
			return !callback.apply(context, arguments);
		};
	}
	function isElement(container) {
		return container.node.nodeType === Node.ELEMENT_NODE;
	}
	function isPseudoElement(container) {
		return container.isPseudoElement === true;
	}
	function isTextNode(container) {
		return container.node.nodeType === Node.TEXT_NODE;
	}
	function zIndexSort(contexts) {
		return function (a, b) {
			return (a.cssInt("zIndex") + (contexts.indexOf(a) / contexts.length)) - (b.cssInt("zIndex") + (contexts.indexOf(b) / contexts.length));
		};
	}
	function hasOpacity(container) {
		return container.getOpacity() < 1;
	}
	function asInt(value) {
		return parseInt(value, 10);
	}
	function getWidth(border) {
		return border.width;
	}
	function nonIgnoredElement(nodeContainer) {
		return (nodeContainer.node.nodeType !== Node.ELEMENT_NODE || ["SCRIPT", "HEAD", "TITLE", "OBJECT", "BR", "OPTION"].indexOf(nodeContainer.node.nodeName) === -1);
	}
	function flatten(arrays) {
		return [].concat.apply([], arrays);
	}
	function stripQuotes(content) {
		var first = content.substr(0, 1);
		return (first === content.substr(content.length - 1) && first.match(/'|"/)) ? content.substr(1, content.length - 2) : content;
	}
	function getWords(characters) {
		var words = [], i = 0, onWordBoundary = false, word;
		while (characters.length) {
			if (isWordBoundary(characters[i]) === onWordBoundary) {
				word = characters.splice(0, i);
				if (word.length) {
					words.push(punycode.ucs2.encode(word));
				}
				onWordBoundary = !onWordBoundary;
				i = 0;
			}
			else {
				i++;
			}
			if (i >= characters.length) {
				word = characters.splice(0, i);
				if (word.length) {
					words.push(punycode.ucs2.encode(word));
				}
			}
		}
		return words;
	}
	function isWordBoundary(characterCode) {
		return [
            32,
            13,
            10,
            9,
            45
		].indexOf(characterCode) !== -1;
	}
	function hasUnicode(string) {
		return (/[^\u0000-\u00ff]/).test(string);
	}
})(Html2canvas || (Html2canvas = {}));
var Html2canvas;
(function (Html2canvas) {
	var utils = Html2canvas.Utils;
	var getBounds = utils.getBounds;
	var loadUrlDocument = Html2canvas.loadUrlDocument;
	Html2canvas.FrameContainer = function (container, sameOrigin, options) {
		this.image = null;
		this.src = container;
		var self = this;
		var bounds = getBounds(container);
		this.promise = (!sameOrigin ? this.proxyLoad(options.proxy, bounds, options) : new Html2canvas.Promise(function (resolve) {
			if (container.contentWindow.document.URL === "about:blank" || container.contentWindow.document.documentElement == null) {
				container.contentWindow.onload = container.onload = function () {
					resolve(container);
				};
			}
			else {
				resolve(container);
			}
		})).then(function (container) {
			var html2canvas = Html2canvas.html2canvasExport;
			return html2canvas(container.contentWindow.document.documentElement, { type: 'view', width: container.width, height: container.height, proxy: options.proxy, javascriptEnabled: options.javascriptEnabled, removeContainer: options.removeContainer, allowTaint: options.allowTaint, imageTimeout: options.imageTimeout / 2 });
		}).then(function (canvas) {
			return self.image = canvas;
		});
	};
	Html2canvas.FrameContainer.prototype.proxyLoad = function (proxy, bounds, options) {
		var container = this.src;
		return loadUrlDocument(container.src, proxy, container.ownerDocument, bounds.width, bounds.height, options);
	};
})(Html2canvas || (Html2canvas = {}));
var Html2canvas;
(function (Html2canvas) {
	var log = Html2canvas.Log;
	var ImageContainer = Html2canvas.ImageContainer;
	var DummyImageContainer = Html2canvas.DummyImageContainer;
	var ProxyImageContainer = Html2canvas.ProxyImageContainer;
	var FrameContainer = Html2canvas.FrameContainer;
	var SVGContainer = Html2canvas.SVGContainer;
	var SVGNodeContainer = Html2canvas.SVGNodeContainer;
	var LinearGradientContainer = Html2canvas.LinearGradientContainer;
	var WebkitGradientContainer = Html2canvas.WebkitGradientContainer;
	var bind = Html2canvas.Utils.bind;
	Html2canvas.ImageLoader = function (options, support) {
		this.link = null;
		this.options = options;
		this.support = support;
		this.origin = this.getOrigin(window.location.href);
	};
	Html2canvas.ImageLoader.prototype.findImages = function (nodes) {
		var images = [];
		nodes.reduce(function (imageNodes, container) {
			switch (container.node.nodeName) {
				case "IMG":
					return imageNodes.concat([{
						args: [container.node.src],
						method: "url"
					}]);
				case "svg":
				case "IFRAME":
					return imageNodes.concat([{
						args: [container.node],
						method: container.node.nodeName
					}]);
			}
			if (container.node.nodeName === 'INPUT' && container.node.type === 'image') {
				return imageNodes.concat([{
					args: [container.node.src],
					method: "url"
				}]);
			}
			return imageNodes;
		}, []).forEach(this.addImage(images, this.loadImage), this);
		return images;
	};
	Html2canvas.ImageLoader.prototype.findBackgroundImage = function (images, container) {
		container.parseBackgroundImages().filter(this.hasImageBackground).forEach(this.addImage(images, this.loadImage), this);
		return images;
	};
	Html2canvas.ImageLoader.prototype.addImage = function (images, callback) {
		return function (newImage) {
			newImage.args.forEach(function (image) {
				if (!this.imageExists(images, image)) {
					images.splice(0, 0, callback.call(this, newImage));
					log('Added image #' + (images.length), typeof (image) === "string" ? image.substring(0, 100) : image);
				}
			}, this);
		};
	};
	Html2canvas.ImageLoader.prototype.hasImageBackground = function (imageData) {
		return imageData.method !== "none";
	};
	Html2canvas.ImageLoader.prototype.loadImage = function (imageData) {
		if (imageData.method === "url") {
			var src = imageData.args[0];
			if (this.isSVG(src) && !this.support.svg && !this.options.allowTaint) {
				return new SVGContainer(src);
			}
			else if (src.match(/data:image\/.*;base64,/i)) {
				return new ImageContainer(src.replace(/url\(['"]{0,}|['"]{0,}\)$/ig, ''), false);
			}
			else if (this.isSameOrigin(src) || this.options.allowTaint === true || this.isSVG(src)) {
				return new ImageContainer(src, false);
			}
			else if (this.support.cors && !this.options.allowTaint && this.options.useCORS) {
				return new ImageContainer(src, true);
			}
			else if (this.options.proxy) {
				return new ProxyImageContainer(src, this.options.proxy);
			}
			else {
				return new DummyImageContainer(src);
			}
		}
		else if (imageData.method === "linear-gradient") {
			return new LinearGradientContainer(imageData);
		}
		else if (imageData.method === "gradient") {
			return new WebkitGradientContainer(imageData);
		}
		else if (imageData.method === "svg") {
			return new SVGNodeContainer(imageData.args[0], this.support.svg);
		}
		else if (imageData.method === "IFRAME") {
			return new FrameContainer(imageData.args[0], this.isSameOrigin(imageData.args[0].src), this.options);
		}
		else {
			return new DummyImageContainer(imageData);
		}
	};
	Html2canvas.ImageLoader.prototype.isSVG = function (src) {
		return src.substring(src.length - 3).toLowerCase() === "svg" || SVGContainer.prototype.isInline(src);
	};
	Html2canvas.ImageLoader.prototype.imageExists = function (images, src) {
		return images.some(function (image) {
			return image.src === src;
		});
	};
	Html2canvas.ImageLoader.prototype.isSameOrigin = function (url) {
		return (this.getOrigin(url) === this.origin);
	};
	Html2canvas.ImageLoader.prototype.getOrigin = function (url) {
		var link = this.link || (this.link = document.createElement("a"));
		link.href = url;
		link.href = link.href;
		return link.protocol + link.hostname + link.port;
	};
	Html2canvas.ImageLoader.prototype.getPromise = function (container) {
		return this.timeout(container, this.options.imageTimeout)['catch'](function () {
			var dummy = new DummyImageContainer(container.src);
			return dummy.promise.then(function (image) {
				container.image = image;
			});
		});
	};
	Html2canvas.ImageLoader.prototype.get = function (src) {
		var found = null;
		return this.images.some(function (img) {
			return (found = img).src === src;
		}) ? found : null;
	};
	Html2canvas.ImageLoader.prototype.fetch = function (nodes) {
		this.images = nodes.reduce(bind(this.findBackgroundImage, this), this.findImages(nodes));
		this.images.forEach(function (image, index) {
			image.promise.then(function () {
				log("Succesfully loaded image #" + (index + 1), image);
			}, function (e) {
				log("Failed loading image #" + (index + 1), image, e);
			});
		});
		this.ready = Html2canvas.Promise.all(this.images.map(this.getPromise, this));
		log("Finished searching images");
		return this;
	};
	Html2canvas.ImageLoader.prototype.timeout = function (container, timeout) {
		var timer;
		var promise = Html2canvas.Promise.race([container.promise, new Html2canvas.Promise(function (res, reject) {
			timer = setTimeout(function () {
				log("Timed out loading image", container);
				reject(container);
			}, timeout);
		})]).then(function (container) {
			clearTimeout(timer);
			return container;
		});
		promise['catch'](function () {
			clearTimeout(timer);
		});
		return promise;
	};
})(Html2canvas || (Html2canvas = {}));
var Html2canvas;
(function (Html2canvas) {
	var Support = Html2canvas.Support;
	var CanvasRenderer = Html2canvas.CanvasRenderer;
	var ImageLoader = Html2canvas.ImageLoader;
	var NodeParser = Html2canvas.NodeParser;
	var NodeContainer = Html2canvas.NodeContainer;
	var log = Html2canvas.Log;
	var utils = Html2canvas.Utils;
	var createWindowClone = Html2canvas.CreateWindowClone;
	var loadUrlDocument = Html2canvas.loadUrlDocument;
	var getBounds = utils.getBounds;
	var html2canvasNodeAttribute = "data-html2canvas-node";
	var html2canvasCloneIndex = 0;
	Html2canvas.html2canvas = function (nodeList, options) {
		var index = html2canvasCloneIndex++;
		options = options || {};
		if (options.logging) {
			log.options.logging = true;
			log.options.start = Date.now();
		}
		options.async = typeof (options.async) === "undefined" ? true : options.async;
		options.allowTaint = typeof (options.allowTaint) === "undefined" ? false : options.allowTaint;
		options.removeContainer = typeof (options.removeContainer) === "undefined" ? true : options.removeContainer;
		options.javascriptEnabled = typeof (options.javascriptEnabled) === "undefined" ? false : options.javascriptEnabled;
		options.imageTimeout = typeof (options.imageTimeout) === "undefined" ? 10000 : options.imageTimeout;
		options.renderer = typeof (options.renderer) === "function" ? options.renderer : CanvasRenderer;
		options.strict = !!options.strict;
		if (typeof (nodeList) === "string") {
			if (typeof (options.proxy) !== "string") {
				return Html2canvas.Promise.reject("Proxy must be used when rendering url");
			}
			var width = options.width != null ? options.width : window.innerWidth;
			var height = options.height != null ? options.height : window.innerHeight;
			return loadUrlDocument(absoluteUrl(nodeList), options.proxy, document, width, height, options).then(function (container) {
				return renderWindow(container.contentWindow.document.documentElement, container, options, width, height);
			});
		}
		var node = ((nodeList === undefined) ? [document.documentElement] : ((nodeList.length) ? nodeList : [nodeList]))[0];
		node.setAttribute(html2canvasNodeAttribute + index, index);
		return renderDocument(node.ownerDocument, options, node.ownerDocument.defaultView.innerWidth, node.ownerDocument.defaultView.innerHeight, index).then(function (canvas) {
			if (typeof (options.onrendered) === "function") {
				log("options.onrendered is deprecated, html2canvas returns a Promise containing the canvas");
				options.onrendered(canvas);
			}
			return canvas;
		});
	};
	window.html2canvas = Html2canvas.html2canvas;
	Html2canvas.html2canvas.CanvasRenderer = CanvasRenderer;
	Html2canvas.html2canvas.NodeContainer = NodeContainer;
	Html2canvas.html2canvas.log = log;
	Html2canvas.html2canvas.utils = utils;
	Html2canvas.html2canvasExport = (typeof (document) === "undefined" || typeof (Object.create) !== "function" || typeof (document.createElement("canvas").getContext) !== "function") ? function () {
		return Html2canvas.Promise.reject("No canvas support");
	} : Html2canvas.html2canvas;
	function renderDocument(document, options, windowWidth, windowHeight, html2canvasIndex) {
		return createWindowClone(document, document, windowWidth, windowHeight, options, document.defaultView.pageXOffset, document.defaultView.pageYOffset).then(function (container) {
			log("Document cloned");
			var attributeName = html2canvasNodeAttribute + html2canvasIndex;
			var selector = "[" + attributeName + "='" + html2canvasIndex + "']";
			document.querySelector(selector).removeAttribute(attributeName);
			var clonedWindow = container.contentWindow;
			var node = clonedWindow.document.querySelector(selector);
			var oncloneHandler = (typeof (options.onclone) === "function") ? Html2canvas.Promise.resolve(options.onclone(clonedWindow.document)) : Html2canvas.Promise.resolve(true);
			return oncloneHandler.then(function () {
				return renderWindow(node, container, options, windowWidth, windowHeight);
			});
		});
	}
	function renderWindow(node, container, options, windowWidth, windowHeight) {
		var clonedWindow = container.contentWindow;
		var support = new Support(clonedWindow.document);
		var imageLoader = new ImageLoader(options, support);
		var bounds = getBounds(node);
		var width = options.type === "view" ? windowWidth : documentWidth(clonedWindow.document);
		var height = options.type === "view" ? windowHeight : documentHeight(clonedWindow.document);
		var renderer = new options.renderer(width, height, imageLoader, options, document);
		var parser = new NodeParser(node, renderer, support, imageLoader, options);
		return parser.ready.then(function () {
			log("Finished rendering");
			var canvas;
			if (options.type === "view") {
				canvas = crop(renderer.canvas, { width: renderer.canvas.width, height: renderer.canvas.height, top: 0, left: 0, x: 0, y: 0 });
			}
			else if (node === clonedWindow.document.body || node === clonedWindow.document.documentElement || options.canvas != null) {
				canvas = renderer.canvas;
			}
			else {
				canvas = crop(renderer.canvas, { width: options.width != null ? options.width : bounds.width, height: options.height != null ? options.height : bounds.height, top: bounds.top, left: bounds.left, x: 0, y: 0 });
			}
			cleanupContainer(container, options);
			return canvas;
		});
	}
	function cleanupContainer(container, options) {
		if (options.removeContainer) {
			container.parentNode.removeChild(container);
			log("Cleaned up container");
		}
	}
	function crop(canvas, bounds) {
		var croppedCanvas = document.createElement("canvas");
		var x1 = Math.min(canvas.width - 1, Math.max(0, bounds.left));
		var x2 = Math.min(canvas.width, Math.max(1, bounds.left + bounds.width));
		var y1 = Math.min(canvas.height - 1, Math.max(0, bounds.top));
		var y2 = Math.min(canvas.height, Math.max(1, bounds.top + bounds.height));
		croppedCanvas.width = bounds.width;
		croppedCanvas.height = bounds.height;
		var width = x2 - x1;
		var height = y2 - y1;
		log("Cropping canvas at:", "left:", bounds.left, "top:", bounds.top, "width:", width, "height:", height);
		log("Resulting crop with width", bounds.width, "and height", bounds.height, "with x", x1, "and y", y1);
		croppedCanvas.getContext("2d").drawImage(canvas, x1, y1, width, height, bounds.x, bounds.y, width, height);
		return croppedCanvas;
	}
	function documentWidth(doc) {
		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(doc) {
		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 absoluteUrl(url) {
		var link = document.createElement("a");
		link.href = url;
		link.href = link.href;
		return link;
	}
})(Html2canvas || (Html2canvas = {}));
