Snippets

Zaid Bin Khalid Blurry image fix

Created by Zaid Bin Khalid
View revision

File html2canvas.js Added

  • Ignore whitespace
  • Hide word diff 
+(function(window, document, exports, global, define, undefined) {
+    /*!
+     * @overview es6-promise - a tiny implementation of Promises/A+.
+     * @copyright Copyright (c) 2014 Yehuda Katz, Tom Dale, Stefan Penner and contributors (Conversion to ES6 API by Jake Archibald)
+     * @license Licensed under MIT license
+     * See https://raw.githubusercontent.com/jakearchibald/es6-promise/master/LICENSE
+     * @version 2.0.1
+     */
+    (function() {
+        function r(a, b) {
+            n[l] = a;
+            n[l + 1] = b;
+            l += 2;
+            2 === l && A()
+        }
+
+        function s(a) {
+            return "function" === typeof a
+        }
+
+        function F() {
+            return function() {
+                process.nextTick(t)
+            }
+        }
+
+        function G() {
+            var a = 0,
+                b = new B(t),
+                c = document.createTextNode("");
+            b.observe(c, {
+                characterData: !0
+            });
+            return function() {
+                c.data = a = ++a % 2
+            }
+        }
+
+        function H() {
+            var a = new MessageChannel;
+            a.port1.onmessage = t;
+            return function() {
+                a.port2.postMessage(0)
+            }
+        }
+
+        function I() {
+            return function() {
+                setTimeout(t, 1)
+            }
+        }
+
+        function t() {
+            for (var a = 0; a < l; a += 2)(0, n[a])(n[a + 1]), n[a] = void 0, n[a + 1] = void 0;
+            l = 0
+        }
+
+        function p() {}
+
+        function J(a, b, c, d) {
+            try {
+                a.call(b, c, d)
+            } catch (e) {
+                return e
+            }
+        }
+
+        function K(a, b, c) {
+            r(function(a) {
+                var e = !1,
+                    f = J(c, b, function(c) {
+                        e || (e = !0, b !== c ? q(a, c) : m(a, c))
+                    }, function(b) {
+                        e || (e = !0, g(a, b))
+                    });
+                !e && f && (e = !0, g(a, f))
+            }, a)
+        }
+
+        function L(a, b) {
+            1 === b.a ? m(a, b.b) : 2 === a.a ? g(a, b.b) : u(b, void 0, function(b) {
+                q(a, b)
+            }, function(b) {
+                g(a, b)
+            })
+        }
+
+        function q(a, b) {
+            if (a === b) g(a, new TypeError("You cannot resolve a promise with itself"));
+            else if ("function" === typeof b || "object" === typeof b && null !== b)
+                if (b.constructor === a.constructor) L(a, b);
+                else {
+                    var c;
+                    try {
+                        c = b.then
+                    } catch (d) {
+                        v.error = d, c = v
+                    }
+                    c === v ? g(a, v.error) : void 0 === c ? m(a, b) : s(c) ? K(a, b, c) : m(a, b)
+                } else m(a, b)
+        }
+
+        function M(a) {
+            a.f && a.f(a.b);
+            x(a)
+        }
+
+        function m(a, b) {
+            void 0 === a.a && (a.b = b, a.a = 1, 0 !== a.e.length && r(x, a))
+        }
+
+        function g(a, b) {
+            void 0 === a.a && (a.a = 2, a.b = b, r(M, a))
+        }
+
+        function u(a, b, c, d) {
+            var e = a.e,
+                f = e.length;
+            a.f = null;
+            e[f] = b;
+            e[f + 1] = c;
+            e[f + 2] = d;
+            0 === f && a.a && r(x, a)
+        }
+
+        function x(a) {
+            var b = a.e,
+                c = a.a;
+            if (0 !== b.length) {
+                for (var d, e, f = a.b, g = 0; g < b.length; g += 3) d = b[g], e = b[g + c], d ? C(c, d, e, f) : e(f);
+                a.e.length = 0
+            }
+        }
+
+        function D() {
+            this.error = null
+        }
+
+        function C(a, b, c, d) {
+            var e = s(c),
+                f, k, h, l;
+            if (e) {
+                try {
+                    f = c(d)
+                } catch (n) {
+                    y.error = n, f = y
+                }
+                f === y ? (l = !0, k = f.error, f = null) : h = !0;
+                if (b === f) {
+                    g(b, new TypeError("A promises callback cannot return that same promise."));
+                    return
+                }
+            } else f = d, h = !0;
+            void 0 === b.a && (e && h ? q(b, f) : l ? g(b, k) : 1 === a ? m(b, f) : 2 === a && g(b, f))
+        }
+
+        function N(a, b) {
+            try {
+                b(function(b) {
+                    q(a, b)
+                }, function(b) {
+                    g(a, b)
+                })
+            } catch (c) {
+                g(a, c)
+            }
+        }
+
+        function k(a, b, c, d) {
+            this.n = a;
+            this.c = new a(p, d);
+            this.i = c;
+            this.o(b) ? (this.m = b, this.d = this.length = b.length, this.l(), 0 === this.length ? m(this.c, this.b) : (this.length = this.length || 0, this.k(), 0 === this.d && m(this.c, this.b))) : g(this.c, this.p())
+        }
+
+        function h(a) {
+            O++;
+            this.b = this.a = void 0;
+            this.e = [];
+            if (p !== a) {
+                if (!s(a)) throw new TypeError("You must pass a resolver function as the first argument to the promise constructor");
+                if (!(this instanceof h)) throw new TypeError("Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function.");
+                N(this, a)
+            }
+        }
+        var E = Array.isArray ? Array.isArray : function(a) {
+                return "[object Array]" === Object.prototype.toString.call(a)
+            },
+            l = 0,
+            w = "undefined" !== typeof window ? window : {},
+            B = w.MutationObserver || w.WebKitMutationObserver,
+            w = "undefined" !== typeof Uint8ClampedArray && "undefined" !== typeof importScripts && "undefined" !== typeof MessageChannel,
+            n = Array(1E3),
+            A;
+        A = "undefined" !== typeof process && "[object process]" === {}.toString.call(process) ? F() : B ? G() : w ? H() : I();
+        var v = new D,
+            y = new D;
+        k.prototype.o = function(a) {
+            return E(a)
+        };
+        k.prototype.p = function() {
+            return Error("Array Methods must be provided an Array")
+        };
+        k.prototype.l = function() {
+            this.b = Array(this.length)
+        };
+        k.prototype.k = function() {
+            for (var a = this.length, b = this.c, c = this.m, d = 0; void 0 === b.a && d < a; d++) this.j(c[d], d)
+        };
+        k.prototype.j = function(a, b) {
+            var c = this.n;
+            "object" === typeof a && null !== a ? a.constructor === c && void 0 !== a.a ? (a.f = null, this.g(a.a, b, a.b)) : this.q(c.resolve(a), b) : (this.d--, this.b[b] = this.h(a))
+        };
+        k.prototype.g = function(a, b, c) {
+            var d = this.c;
+            void 0 === d.a && (this.d--, this.i && 2 === a ? g(d, c) : this.b[b] = this.h(c));
+            0 === this.d && m(d, this.b)
+        };
+        k.prototype.h = function(a) {
+            return a
+        };
+        k.prototype.q = function(a, b) {
+            var c = this;
+            u(a, void 0, function(a) {
+                c.g(1, b, a)
+            }, function(a) {
+                c.g(2, b, a)
+            })
+        };
+        var O = 0;
+        h.all = function(a, b) {
+            return (new k(this, a, !0, b)).c
+        };
+        h.race = function(a, b) {
+            function c(a) {
+                q(e, a)
+            }
+
+            function d(a) {
+                g(e, a)
+            }
+            var e = new this(p, b);
+            if (!E(a)) return (g(e, new TypeError("You must pass an array to race.")), e);
+            for (var f = a.length, h = 0; void 0 === e.a && h < f; h++) u(this.resolve(a[h]), void 0, c, d);
+            return e
+
+        };
+        h.resolve = function(a, b) {
+            if (a && "object" === typeof a && a.constructor === this) return a;
+            var c = new this(p, b);
+            q(c, a);
+            return c
+        };
+        h.reject = function(a, b) {
+            var c = new this(p, b);
+            g(c, a);
+            return c
+        };
+        h.prototype = {
+            constructor: h,
+            then: function(a, b) {
+                var c = this.a;
+                if (1 === c && !a || 2 === c && !b) return this;
+                var d = new this.constructor(p),
+                    e = this.b;
+                if (c) {
+                    var f = arguments[c - 1];
+                    r(function() {
+                        C(c, d, f, e)
+                    })
+                } else u(this, d, a, b);
+                return d
+            },
+            "catch": function(a) {
+                return this.then(null, a)
+            }
+        };
+        var z = {
+            Promise: h,
+            polyfill: function() {
+                var a;
+                a = "undefined" !== typeof global ? global : "undefined" !== typeof window && window.document ? window : self;
+                "Promise" in a && "resolve" in
+                    a.Promise && "reject" in a.Promise && "all" in a.Promise && "race" in a.Promise && function() {
+                        var b;
+                        new a.Promise(function(a) {
+                            b = a
+                        });
+                        return s(b)
+                    }() || (a.Promise = h)
+            }
+        };
+        "function" === typeof define && define.amd ? define(function() {
+            return z
+        }) : "undefined" !== typeof module && module.exports ? module.exports = z : "undefined" !== typeof this && (this.ES6Promise = z);
+    }).call(window);
+    if (window) {
+        window.ES6Promise.polyfill();
+    }
+    if (typeof(document) === "undefined" || typeof(Object.create) !== "function" || typeof(document.createElement("canvas").getContext) !== "function") {
+        (window || module.exports).html2canvas = function() {
+            return Promise.reject("No canvas support");
+        };
+        return;
+    } /*!https://mths.be/punycode v1.3.1 by @mathias*/ ;
+    (function(root) {
+        var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;
+        var freeModule = typeof module == 'object' && module && !module.nodeType && module;
+        var freeGlobal = typeof global == 'object' && global;
+        if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal || freeGlobal.self === freeGlobal) {
+            root = freeGlobal;
+        }
+        var punycode, 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];
+            }
+            var labels = string.split(regexSeparators);
+            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 * (digit < 26) - ((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 = {
+            'version': '1.3.1',
+            'ucs2': {
+                'decode': ucs2decode,
+                'encode': ucs2encode
+            },
+            'decode': decode,
+            'encode': encode,
+            'toASCII': toASCII,
+            'toUnicode': toUnicode
+        };
+        if (typeof define == 'function' && typeof define.amd == 'object' && define.amd) {
+            define('punycode', function() {
+                return punycode;
+            });
+        } else if (freeExports && freeModule) {
+            if (module.exports == freeExports) {
+                freeModule.exports = punycode;
+            } else {
+                for (key in punycode) {
+                    punycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);
+
+                }
+            }
+        } else {
+            root.punycode = punycode;
+        }
+    }(this));
+    var html2canvasNodeAttribute = "data-html2canvas-node";
+    var html2canvasCanvasCloneAttribute = "data-html2canvas-canvas-clone";
+    var html2canvasCanvasCloneIndex = 0;
+    var html2canvasCloneIndex = 0;
+    window.html2canvas = function(nodeList, options) {
+        var index = html2canvasCloneIndex++;
+        options = options || {};
+        if (options.logging) {
+            window.html2canvas.logging = true;
+            window.html2canvas.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 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.punycode = this.punycode;
+    window.html2canvas.proxy = {};
+
+    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") ? Promise.resolve(options.onclone(clonedWindow.document)) : 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: clonedWindow.pageXOffset,
+                    y: clonedWindow.pageYOffset
+                });
+            }
+            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;
+        log("Cropping canvas at:", "left:", bounds.left, "top:", bounds.top, "width:", (x2 - x1), "height:", (y2 - y1));
+        log("Resulting crop with width", bounds.width, "and height", bounds.height, " with x", x1, "and y", y1);
+        croppedCanvas.getContext("2d").drawImage(canvas, x1, y1, x2 - x1, y2 - y1, bounds.x, bounds.y, x2 - x1, y2 - y1);
+        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 smallImage() {
+        return "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7";
+    }
+
+    function isIE9() {
+        return document.documentMode && document.documentMode <= 9;
+    }
+
+    function cloneNodeIE9(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(cloneNodeIE9(child, javascriptEnabled));
+            }
+            child = child.nextSibling;
+        }
+        return clone;
+    }
+
+    function createWindowClone(ownerDocument, containerDocument, width, height, options, x, y) {
+        labelCanvasElements(ownerDocument);
+        var documentElement = isIE9() ? cloneNodeIE9(ownerDocument.documentElement, options.javascriptEnabled) : ownerDocument.documentElement.cloneNode(true);
+        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 Promise(function(resolve) {
+            var documentClone = container.contentWindow.document;
+            cloneNodeValues(ownerDocument.documentElement, documentElement, "textarea");
+            cloneNodeValues(ownerDocument.documentElement, documentElement, "select");
+            container.contentWindow.onload = container.onload = function() {
+                var interval = setInterval(function() {
+                    if (documentClone.body.childNodes.length > 0) {
+                        cloneCanvasContents(ownerDocument, documentClone);
+                        clearInterval(interval);
+                        if (options.type === "view") {
+                            container.contentWindow.scrollTo(x, y);
+                        }
+                        resolve(container);
+                    }
+                }, 50);
+            };
+            documentClone.open();
+            documentClone.write("<!DOCTYPE html><html></html>");
+            restoreOwnerScroll(ownerDocument, x, y);
+            documentClone.replaceChild(options.javascriptEnabled === true ? documentClone.adoptNode(documentElement) : removeScriptNodes(documentClone.adoptNode(documentElement)), documentClone.documentElement);
+            documentClone.close();
+        });
+    }
+
+    function cloneNodeValues(document, clone, nodeName) {
+        var originalNodes = document.getElementsByTagName(nodeName);
+        var clonedNodes = clone.getElementsByTagName(nodeName);
+        var count = originalNodes.length;
+        for (var i = 0; i < count; i++) {
+            clonedNodes[i].value = originalNodes[i].value;
+        }
+    }
+
+    function restoreOwnerScroll(ownerDocument, x, y) {
+        if (ownerDocument.defaultView && (x !== ownerDocument.defaultView.pageXOffset || y !== ownerDocument.defaultView.pageYOffset)) {
+            ownerDocument.defaultView.scrollTo(x, y);
+        }
+    }
+
+    function loadUrlDocument(src, proxy, document, width, height, options) {
+        return new Proxy(src, proxy, window.document).then(documentFromHTML(src)).then(function(doc) {
+            return createWindowClone(doc, document, width, height, options, 0, 0);
+        });
+    }
+
+    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;
+        };
+    }
+
+    function labelCanvasElements(ownerDocument) {
+        [].slice.call(ownerDocument.querySelectorAll("canvas"), 0).forEach(function(canvas) {
+            canvas.setAttribute(html2canvasCanvasCloneAttribute, "canvas-" + html2canvasCanvasCloneIndex++);
+        });
+    }
+
+    function cloneCanvasContents(ownerDocument, documentClone) {
+        [].slice.call(ownerDocument.querySelectorAll("[" + html2canvasCanvasCloneAttribute + "]"), 0).forEach(function(canvas) {
+            try {
+                var clonedCanvas = documentClone.querySelector('[' + html2canvasCanvasCloneAttribute + '="' + canvas.getAttribute(html2canvasCanvasCloneAttribute) + '"]');
+                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);
+            }
+            canvas.removeAttribute(html2canvasCanvasCloneAttribute);
+        });
+    }
+
+    function removeScriptNodes(parent) {
+        [].slice.call(parent.childNodes, 0).filter(isElementNode).forEach(function(node) {
+            if (node.tagName === "SCRIPT") {
+                parent.removeChild(node);
+            } else {
+                removeScriptNodes(node);
+            }
+        });
+        return parent;
+    }
+
+    function isElementNode(node) {
+        return node.nodeType === Node.ELEMENT_NODE;
+    }
+
+    function absoluteUrl(url) {
+        var link = document.createElement("a");
+        link.href = url;
+        link.href = link.href;
+        return link;
+    }
+
+    function Color(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);
+    }
+    Color.prototype.darken = function(amount) {
+        var a = 1 - amount;
+        return new Color([Math.round(this.r * a), Math.round(this.g * a), Math.round(this.b * a), this.a]);
+    };
+    Color.prototype.isTransparent = function() {
+        return this.a === 0;
+    };
+    Color.prototype.isBlack = function() {
+        return this.r === 0 && this.g === 0 && this.b === 0;
+    };
+    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;
+    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;
+    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\((\d{1,3}) *, *(\d{1,3}) *, *(\d{1,3})\)$/;
+    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\((\d{1,3}) *, *(\d{1,3}) *, *(\d{1,3}) *, *(\d+\.?\d*)\)$/;
+    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;
+    };
+    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(",") + ")";
+    };
+    Color.prototype.namedColor = function(value) {
+        var color = colors[value.toLowerCase()];
+        if (color) {
+            this.r = color[0];
+            this.g = color[1];
+            this.b = color[2];
+        } else if (value.toLowerCase() === "transparent") {
+            this.r = this.g = this.b = this.a = 0;
+            return true;
+        }
+        return !!color;
+    };
+    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]
+    };
+
+    function DummyImageContainer(src) {
+        this.src = src;
+        log("DummyImageContainer for", src);
+        if (!this.promise || !this.image) {
+            log("Initiating DummyImageContainer");
+            DummyImageContainer.prototype.image = new Image();
+            var image = this.image;
+            DummyImageContainer.prototype.promise = new Promise(function(resolve, reject) {
+                image.onload = resolve;
+                image.onerror = reject;
+                image.src = smallImage();
+                if (image.complete === true) {
+                    resolve(image);
+                }
+            });
+        }
+    }
+
+    function Font(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;
+    }
+
+    function FontMetrics() {
+        this.data = {};
+    }
+    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];
+    };
+
+    function FrameContainer(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 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) {
+            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;
+        });
+    }
+    FrameContainer.prototype.proxyLoad = function(proxy, bounds, options) {
+        var container = this.src;
+        return loadUrlDocument(container.src, proxy, container.ownerDocument, bounds.width, bounds.height, options);
+    };
+
+    function GradientContainer(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 = Promise.resolve(true);
+    }
+    GradientContainer.prototype.TYPES = {
+        LINEAR: 1,
+        RADIAL: 2
+    };
+
+    function ImageContainer(src, cors) {
+        this.src = src;
+        this.image = new Image();
+        var self = this;
+        this.tainted = null;
+        this.promise = new 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);
+            }
+        });
+    }
+
+    function ImageLoader(options, support) {
+        this.link = null;
+        this.options = options;
+        this.support = support;
+        this.origin = this.getOrigin(window.location.href);
+    }
+    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
+                    }]);
+            }
+            return imageNodes;
+        }, []).forEach(this.addImage(images, this.loadImage), this);
+        return images;
+    };
+    ImageLoader.prototype.findBackgroundImage = function(images, container) {
+        container.parseBackgroundImages().filter(this.hasImageBackground).forEach(this.addImage(images, this.loadImage), this);
+        return images;
+    };
+    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);
+        };
+    };
+    ImageLoader.prototype.hasImageBackground = function(imageData) {
+        return imageData.method !== "none";
+    };
+    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);
+        }
+    };
+    ImageLoader.prototype.isSVG = function(src) {
+        return src.substring(src.length - 3).toLowerCase() === "svg" || SVGContainer.prototype.isInline(src);
+    };
+    ImageLoader.prototype.imageExists = function(images, src) {
+        return images.some(function(image) {
+            return image.src === src;
+        });
+    };
+    ImageLoader.prototype.isSameOrigin = function(url) {
+        return (this.getOrigin(url) === this.origin);
+    };
+    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;
+    };
+    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;
+            });
+        });
+    };
+    ImageLoader.prototype.get = function(src) {
+        var found = null;
+        return this.images.some(function(img) {
+            return (found = img).src === src;
+        }) ? found : null;
+    };
+    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 = Promise.all(this.images.map(this.getPromise, this));
+        log("Finished searching images");
+        return this;
+    };
+    ImageLoader.prototype.timeout = function(container, timeout) {
+        var timer;
+        var promise = Promise.race([container.promise, new 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;
+    };
+
+    function LinearGradientContainer(imageData) {
+        GradientContainer.apply(this, arguments);
+        this.type = this.TYPES.LINEAR;
+        var hasDirection = imageData.args[0].match(this.stepRegExp) === null;
+        if (hasDirection) {
+            imageData.args[0].split(" ").reverse().forEach(function(position) {
+                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;
+                }
+            }, this);
+        } else {
+            this.y0 = 0;
+            this.y1 = 1;
+        }
+        this.colorStops = imageData.args.slice(hasDirection ? 1 : 0).map(function(colorStop) {
+            var colorStopMatch = colorStop.match(this.stepRegExp);
+            return {
+                color: new Color(colorStopMatch[1]),
+                stop: colorStopMatch[3] === "%" ? colorStopMatch[2] / 100 : null
+            };
+        }, this);
+        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);
+    }
+    LinearGradientContainer.prototype = Object.create(GradientContainer.prototype);
+    LinearGradientContainer.prototype.stepRegExp = /((?:rgb|rgba)\(\d{1,3},\s\d{1,3},\s\d{1,3}(?:,\s[0-9\.]+)?\))\s*(\d{1,3})?(%|px)?/;
+
+    function log() {
+        if (window.html2canvas.logging && window.console && window.console.log) {
+            Function.prototype.bind.call(window.console.log, (window.console)).apply(window.console, [(Date.now() - window.html2canvas.start) + "ms", "html2canvas:"].concat([].slice.call(arguments, 0)));
+        }
+    }
+
+    function NodeContainer(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;
+    }
+    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;
+    };
+    NodeContainer.prototype.getOpacity = function() {
+        return this.opacity === null ? (this.opacity = this.cssFloat('opacity')) : this.opacity;
+    };
+    NodeContainer.prototype.assignStack = function(stack) {
+        this.stack = stack;
+        stack.children.push(this);
+    };
+    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"));
+    };
+    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]);
+    };
+    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;
+    };
+    NodeContainer.prototype.computedStyle = function(type) {
+        return this.node.ownerDocument.defaultView.getComputedStyle(this.node, type);
+    };
+    NodeContainer.prototype.cssInt = function(attribute) {
+        var value = parseInt(this.css(attribute), 10);
+        return (isNaN(value)) ? 0 : value;
+    };
+    NodeContainer.prototype.color = function(attribute) {
+        return this.colors[attribute] || (this.colors[attribute] = new Color(this.css(attribute)));
+    };
+    NodeContainer.prototype.cssFloat = function(attribute) {
+        var value = parseFloat(this.css(attribute));
+        return (isNaN(value)) ? 0 : value;
+    };
+    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;
+    };
+    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;
+    };
+    NodeContainer.prototype.parseBackgroundImages = function() {
+        return this.backgroundImages || (this.backgroundImages = parseBackgrounds(this.css("backgroundImage")));
+    };
+    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], value[0]];
+        }
+        return value;
+    };
+    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 (targetRatio < currentRatio ^ 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
+        };
+    };
+    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
+        };
+    };
+    NodeContainer.prototype.parseBackgroundRepeat = function(index) {
+        return this.cssList("backgroundRepeat", index)[0];
+    };
+    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;
+    };
+    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;
+    };
+    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;
+    };
+    NodeContainer.prototype.parseBounds = function() {
+        return this.bounds || (this.bounds = this.hasTransform() ? offsetBounds(this.node) : getBounds(this.node));
+    };
+    NodeContainer.prototype.hasTransform = function() {
+        return this.parseTransformMatrix().join(",") !== "1,0,0,1,0,0" || (this.parent && this.parent.hasTransform());
+    };
+    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;
+    };
+    NodeContainer.prototype.MATRIX_PROPERTY = /(matrix)\((.+)\)/;
+    NodeContainer.prototype.TEXT_SHADOW_PROPERTY = /((rgba|rgb)\([^\)]+\)(\s-?\d+px){0,})/g;
+    NodeContainer.prototype.TEXT_SHADOW_VALUES = /(-?\d+px)|(#.+)|(rgb\(.+\))|(rgba\(.+\))/g;
+    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());
+            });
+        }
+    }
+
+    function isPercentage(value) {
+        return value.toString().indexOf("%") !== -1;
+    }
+
+    function parseBackgrounds(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;
+    }
+
+    function removePx(str) {
+        return str.replace("px", "");
+    }
+
+    function asFloat(str) {
+        return parseFloat(str);
+    }
+
+    function getBounds (node) {
+        if (node.getBoundingClientRect) {
+            var clientRect = node.getBoundingClientRect();
+            var width = node.offsetWidth == null ? clientRect.width : node.offsetWidth;
+            return {
+                top   : Math.floor(clientRect.top),
+                bottom: Math.floor(clientRect.bottom || (clientRect.top + clientRect.height)),
+                right : Math.floor(clientRect.left + width),
+                left  : Math.floor(clientRect.left),
+                width : width,
+                height: node.offsetHeight == null ? clientRect.height : node.offsetHeight
+            };
+        }
+        return {};
+    }
+
+    function offsetBounds(node) {
+        var parent = node.offsetParent ? 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
+        };
+    }
+
+    function NodeParser(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.visibile = 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 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));
+    }
+    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;
+    }
+    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);
+        }
+    };
+    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; }');
+    };
+    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;}');
+    };
+    NodeParser.prototype.createStyles = function(document, styles) {
+        var hidePseudoElements = document.createElement('style');
+        hidePseudoElements.innerHTML = styles;
+        document.body.appendChild(hidePseudoElements);
+    };
+    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('-', '');
+        });
+    }
+    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)];
+        }
+    };
+    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));
+    };
+    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;
+    };
+    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);
+    };
+    NodeParser.prototype.isBodyWithTransparentRoot = function(container) {
+        return container.node.nodeName === "BODY" && container.parent.color('backgroundColor').isTransparent();
+    };
+    NodeParser.prototype.isRootElement = function(container) {
+        return container.parent === null;
+    };
+    NodeParser.prototype.sortStackingContexts = function(stack) {
+        stack.contexts.sort(zIndexSort(stack.contexts.slice(0)));
+        stack.contexts.forEach(this.sortStackingContexts, this);
+    };
+    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 {};
+        };
+    };
+    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;
+    };
+    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() {}
+    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);
+    };
+    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;
+            }
+        }
+    };
+    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);
+        }
+    };
+    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":
+                    this.paintFormValue(container);
+                    break;
+            }
+        }, this);
+    };
+    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);
+    };
+    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);
+    };
+    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);
+        }
+    };
+    NodeParser.prototype.paintText = function(container) {
+        container.applyTextTransform();
+        var characters = window.html2canvas.punycode.ucs2.decode(container.node.data);
+        var textList = (!this.options.letterRendering || noLetterSpacing(container)) && !hasUnicode(container.node.data) ? getWords(characters) : characters.map(function(character) {
+            return window.html2canvas.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);
+    };
+    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]
+        ]
+    };
+    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;
+        });
+    }
+    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],
+            tlv = borderRadius[0][1],
+            trh = borderRadius[1][0],
+            trv = borderRadius[1][1],
+            brh = borderRadius[2][0],
+            brv = borderRadius[2][1],
+            blh = borderRadius[3][0],
+            blv = borderRadius[3][1];
+        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 bind(callback, context) {
+        return function() {
+            return callback.apply(context, arguments);
+        };
+    }
+
+    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(window.html2canvas.punycode.ucs2.encode(word));
+                }
+                onWordBoundary = !onWordBoundary;
+                i = 0;
+            } else {
+                i++;
+            }
+            if (i >= characters.length) {
+                word = characters.splice(0, i);
+                if (word.length) {
+                    words.push(window.html2canvas.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);
+    }
+
+    function Proxy(src, proxyUrl, document) {
+        if (!proxyUrl) {
+            return 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;
+    var supportsCORS = ('withCredentials' in new XMLHttpRequest());
+    var supportsCORSImage = ('crossOrigin' in new Image());
+
+    function ProxyURL(src, proxyUrl, document) {
+        var callback = createCallback(supportsCORSImage);
+        var url = createProxyUrl(proxyUrl, src, callback);
+        return (supportsCORSImage ? Promise.resolve(url) : jsonp(document, url, callback).then(function(response) {
+            return "data:" + response.type + ";base64," + response.content;
+        }));
+    }
+
+    function jsonp(document, url, callback) {
+        return new 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 ProxyImageContainer(src, proxy) {
+        var script = document.createElement("script");
+        var link = document.createElement("a");
+        link.href = src;
+        src = link.href;
+        this.src = src;
+        this.image = new Image();
+        var self = this;
+        this.promise = new 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);
+        });
+    }
+
+    function PseudoElementContainer(node, parent, type) {
+        NodeContainer.call(this, node, parent);
+        this.isPseudoElement = true;
+        this.before = type === ":before";
+    }
+    PseudoElementContainer.prototype.cloneTo = function(stack) {
+        PseudoElementContainer.prototype.cloneTo.call(this, stack);
+        stack.isPseudoElement = true;
+        stack.before = this.before;
+    };
+    PseudoElementContainer.prototype = Object.create(NodeContainer.prototype);
+    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();
+    };
+    PseudoElementContainer.prototype.cleanDOM = function() {
+        this.node.parentNode.removeChild(this.node);
+        this.parent.node.className = this.parent.node.className.replace(this.getHideClass(), "");
+    };
+    PseudoElementContainer.prototype.getHideClass = function() {
+        return this["PSEUDO_HIDE_ELEMENT_CLASS_" + (this.before ? "BEFORE" : "AFTER")];
+    };
+    PseudoElementContainer.prototype.PSEUDO_HIDE_ELEMENT_CLASS_BEFORE = "___html2canvas___pseudoelement_before";
+    PseudoElementContainer.prototype.PSEUDO_HIDE_ELEMENT_CLASS_AFTER = "___html2canvas___pseudoelement_after";
+
+    function Renderer(width, height, images, options, document) {
+        this.width = width;
+        this.height = height;
+        this.images = images;
+        this.options = options;
+        this.document = document;
+    }
+    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);
+    };
+    Renderer.prototype.renderBackground = function(container, bounds, borderData) {
+        if (bounds.height > 0 && bounds.width > 0) {
+            this.renderBackgroundColor(container, bounds);
+            this.renderBackgroundImage(container, bounds, borderData);
+        }
+    };
+    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);
+        }
+    };
+    Renderer.prototype.renderBorders = function(borders) {
+        borders.forEach(this.renderBorder, this);
+    };
+    Renderer.prototype.renderBorder = function(data) {
+        if (!data.color.isTransparent() && data.args !== null) {
+            this.drawShape(data.args, data.color);
+        }
+    };
+    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);
+    };
+    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;
+        }
+    };
+
+    function StackingContext(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;
+    }
+    StackingContext.prototype = Object.create(NodeContainer.prototype);
+    StackingContext.prototype.getParentStack = function(context) {
+        var parentStack = (this.parent) ? this.parent.stack : null;
+        return parentStack ? (parentStack.ownStacking ? parentStack : parentStack.getParentStack(context)) : context.stack;
+    };
+
+    function Support(document) {
+        this.rangeBounds = this.testRangeBounds(document);
+        this.cors = this.testCORS();
+        this.svg = this.testSVG();
+    }
+    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;
+    };
+    Support.prototype.testCORS = function() {
+        return typeof((new Image()).crossOrigin) !== "undefined";
+    };
+    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;
+    };
+
+    function SVGContainer(src) {
+        this.src = src;
+        this.image = null;
+        var self = this;
+        this.promise = this.hasFabric().then(function() {
+            return (self.isInline(src) ? Promise.resolve(self.inlineFormatting(src)) : XHR(src));
+        }).then(function(svg) {
+            return new Promise(function(resolve) {
+                html2canvas.fabric.loadSVGFromString(svg, self.createCanvas.call(self, resolve));
+            });
+        });
+    }
+    SVGContainer.prototype.hasFabric = function() {
+        return !html2canvas.fabric ? Promise.reject(new Error("html2canvas.svg.js is not loaded, cannot render svg")) : Promise.resolve();
+    };
+    SVGContainer.prototype.inlineFormatting = function(src) {
+        return (/^data:image\/svg\+xml;base64,/.test(src)) ? this.decode64(this.removeContentType(src)) : this.removeContentType(src);
+    };
+    SVGContainer.prototype.removeContentType = function(src) {
+        return src.replace(/^data:image\/svg\+xml(;base64)?,/, '');
+    };
+    SVGContainer.prototype.isInline = function(src) {
+        return (/^data:image\/svg\+xml/i.test(src));
+    };
+    SVGContainer.prototype.createCanvas = function(resolve) {
+        var self = this;
+        return function(objects, options) {
+            var canvas = new html2canvas.fabric.StaticCanvas('c');
+            self.image = canvas.lowerCanvasEl;
+            canvas.setWidth(options.width).setHeight(options.height).add(html2canvas.fabric.util.groupSVGElements(objects, options)).renderAll();
+            resolve(canvas.lowerCanvasEl);
+        };
+    };
+    SVGContainer.prototype.decode64 = function(str) {
+        return (typeof(window.atob) === "function") ? window.atob(str) : decode64(str);
+    };
+
+    function decode64(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;
+    }
+
+    function SVGNodeContainer(node, native) {
+        this.src = node;
+        this.image = null;
+        var self = this;
+        this.promise = native ? new Promise(function(resolve, reject) {
+            self.image = new Image();
+            self.image.onload = resolve;
+            self.image.onerror = reject;
+            self.image.src = "data:image/svg+xml," + (new XMLSerializer()).serializeToString(node);
+            if (self.image.complete === true) {
+                resolve(self.image);
+            }
+        }) : this.hasFabric().then(function() {
+            return new Promise(function(resolve) {
+                html2canvas.fabric.parseSVGDocument(node, self.createCanvas.call(self, resolve));
+            });
+        });
+    }
+    SVGNodeContainer.prototype = Object.create(SVGContainer.prototype);
+
+    function TextContainer(node, parent) {
+        NodeContainer.call(this, node, parent);
+    }
+    TextContainer.prototype = Object.create(NodeContainer.prototype);
+    TextContainer.prototype.applyTextTransform = function() {
+        this.node.data = this.transform(this.parent.css("textTransform"));
+    };
+    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();
+        }
+    }
+
+    function WebkitGradientContainer(imageData) {
+        GradientContainer.apply(this, arguments);
+        this.type = (imageData.args[0] === "linear") ? this.TYPES.LINEAR : this.TYPES.RADIAL;
+    }
+    WebkitGradientContainer.prototype = Object.create(GradientContainer.prototype);
+
+    function XHR(url) {
+        return new 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();
+        });
+    }
+
+    function CanvasRenderer(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);
+    }
+    CanvasRenderer.prototype = Object.create(Renderer.prototype);
+    CanvasRenderer.prototype.setFillStyle = function(fillStyle) {
+        this.ctx.fillStyle = typeof(fillStyle) === "object" && !!fillStyle.isColor ? fillStyle.toString() : fillStyle;
+        return this.ctx;
+    };
+    CanvasRenderer.prototype.rectangle = function(left, top, width, height, color) {
+        this.setFillStyle(color).fillRect(left, top, width, height);
+    };
+    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();
+    };
+    CanvasRenderer.prototype.circleStroke = function(left, top, size, color, stroke, strokeColor) {
+        this.circle(left, top, size, color);
+        this.ctx.strokeStyle = strokeColor.toString();
+        this.ctx.stroke();
+    };
+    CanvasRenderer.prototype.drawShape = function(shape, color) {
+        this.shape(shape);
+        this.setFillStyle(color).fill();
+    };
+    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;
+    };
+    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);
+        }
+    };
+    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();
+    };
+    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;
+    };
+    CanvasRenderer.prototype.font = function(color, style, variant, weight, size, family) {
+        this.setFillStyle(color).font = [style, variant, weight, size, family].join(" ").split(",")[0];
+    };
+    CanvasRenderer.prototype.fontShadow = function(color, offsetX, offsetY, blur) {
+        this.setVariable("shadowColor", color.toString()).setVariable("shadowOffsetY", offsetX).setVariable("shadowOffsetX", offsetY).setVariable("shadowBlur", blur);
+    };
+    CanvasRenderer.prototype.clearShadow = function() {
+        this.setVariable("shadowColor", "rgba(0,0,0,0)");
+    };
+    CanvasRenderer.prototype.setOpacity = function(opacity) {
+        this.ctx.globalAlpha = opacity;
+    };
+    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]);
+    };
+    CanvasRenderer.prototype.setVariable = function(property, value) {
+        if (this.variables[property] !== value) {
+            this.variables[property] = this.ctx[property] = value;
+        }
+        return this;
+    };
+    CanvasRenderer.prototype.text = function(text, left, bottom) {
+        this.ctx.fillText(text, left, bottom);
+    };
+    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);
+    };
+    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);
+    };
+    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);
+        }
+    };
+    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;
+    }
+}).call({}, typeof(window) !== "undefined" ? window : undefined, typeof(document) !== "undefined" ? document : undefined);
HTTPS SSH

You can clone a snippet to your computer for local editing. Learn more.