pushfeedback 0.1.53 → 0.1.54

package/dist/esm/feedback-button_2.entry.js

@@ -136,15 +136,15 @@ function commonjsRequire () {
 	throw new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs');
 }
 
-var html2canvas = createCommonjsModule(function (module, exports) {
+var html2canvasPro = createCommonjsModule(function (module, exports) {
 /*!
- * html2canvas 1.4.1 <https://html2canvas.hertzen.com>
- * Copyright (c) 2022 Niklas von Hertzen <https://hertzen.com>
+ * html2canvas-pro 1.5.8 <https://yorickshan.github.io/html2canvas-pro/>
+ * Copyright (c) 2024 yorickshan <https://github.com/yorickshan>
  * Released under MIT License
  */
 (function (global, factory) {
     module.exports = factory() ;
-}(commonjsGlobal, (function () {
+})(commonjsGlobal, (function () {
     /*! *****************************************************************************
     Copyright (c) Microsoft Corporation.
 
@@ -1128,38 +1128,38 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         return sign * (int + frac * Math.pow(10, -fracd)) * Math.pow(10, expsign * exp);
     };
     var LEFT_PARENTHESIS_TOKEN = {
-        type: 2 /* LEFT_PARENTHESIS_TOKEN */
+        type: 2 /* TokenType.LEFT_PARENTHESIS_TOKEN */
     };
     var RIGHT_PARENTHESIS_TOKEN = {
-        type: 3 /* RIGHT_PARENTHESIS_TOKEN */
-    };
-    var COMMA_TOKEN = { type: 4 /* COMMA_TOKEN */ };
-    var SUFFIX_MATCH_TOKEN = { type: 13 /* SUFFIX_MATCH_TOKEN */ };
-    var PREFIX_MATCH_TOKEN = { type: 8 /* PREFIX_MATCH_TOKEN */ };
-    var COLUMN_TOKEN = { type: 21 /* COLUMN_TOKEN */ };
-    var DASH_MATCH_TOKEN = { type: 9 /* DASH_MATCH_TOKEN */ };
-    var INCLUDE_MATCH_TOKEN = { type: 10 /* INCLUDE_MATCH_TOKEN */ };
+        type: 3 /* TokenType.RIGHT_PARENTHESIS_TOKEN */
+    };
+    var COMMA_TOKEN = { type: 4 /* TokenType.COMMA_TOKEN */ };
+    var SUFFIX_MATCH_TOKEN = { type: 13 /* TokenType.SUFFIX_MATCH_TOKEN */ };
+    var PREFIX_MATCH_TOKEN = { type: 8 /* TokenType.PREFIX_MATCH_TOKEN */ };
+    var COLUMN_TOKEN = { type: 21 /* TokenType.COLUMN_TOKEN */ };
+    var DASH_MATCH_TOKEN = { type: 9 /* TokenType.DASH_MATCH_TOKEN */ };
+    var INCLUDE_MATCH_TOKEN = { type: 10 /* TokenType.INCLUDE_MATCH_TOKEN */ };
     var LEFT_CURLY_BRACKET_TOKEN = {
-        type: 11 /* LEFT_CURLY_BRACKET_TOKEN */
+        type: 11 /* TokenType.LEFT_CURLY_BRACKET_TOKEN */
     };
     var RIGHT_CURLY_BRACKET_TOKEN = {
-        type: 12 /* RIGHT_CURLY_BRACKET_TOKEN */
-    };
-    var SUBSTRING_MATCH_TOKEN = { type: 14 /* SUBSTRING_MATCH_TOKEN */ };
-    var BAD_URL_TOKEN = { type: 23 /* BAD_URL_TOKEN */ };
-    var BAD_STRING_TOKEN = { type: 1 /* BAD_STRING_TOKEN */ };
-    var CDO_TOKEN = { type: 25 /* CDO_TOKEN */ };
-    var CDC_TOKEN = { type: 24 /* CDC_TOKEN */ };
-    var COLON_TOKEN = { type: 26 /* COLON_TOKEN */ };
-    var SEMICOLON_TOKEN = { type: 27 /* SEMICOLON_TOKEN */ };
+        type: 12 /* TokenType.RIGHT_CURLY_BRACKET_TOKEN */
+    };
+    var SUBSTRING_MATCH_TOKEN = { type: 14 /* TokenType.SUBSTRING_MATCH_TOKEN */ };
+    var BAD_URL_TOKEN = { type: 23 /* TokenType.BAD_URL_TOKEN */ };
+    var BAD_STRING_TOKEN = { type: 1 /* TokenType.BAD_STRING_TOKEN */ };
+    var CDO_TOKEN = { type: 25 /* TokenType.CDO_TOKEN */ };
+    var CDC_TOKEN = { type: 24 /* TokenType.CDC_TOKEN */ };
+    var COLON_TOKEN = { type: 26 /* TokenType.COLON_TOKEN */ };
+    var SEMICOLON_TOKEN = { type: 27 /* TokenType.SEMICOLON_TOKEN */ };
     var LEFT_SQUARE_BRACKET_TOKEN = {
-        type: 28 /* LEFT_SQUARE_BRACKET_TOKEN */
+        type: 28 /* TokenType.LEFT_SQUARE_BRACKET_TOKEN */
     };
     var RIGHT_SQUARE_BRACKET_TOKEN = {
-        type: 29 /* RIGHT_SQUARE_BRACKET_TOKEN */
+        type: 29 /* TokenType.RIGHT_SQUARE_BRACKET_TOKEN */
     };
-    var WHITESPACE_TOKEN = { type: 31 /* WHITESPACE_TOKEN */ };
-    var EOF_TOKEN = { type: 32 /* EOF_TOKEN */ };
+    var WHITESPACE_TOKEN = { type: 31 /* TokenType.WHITESPACE_TOKEN */ };
+    var EOF_TOKEN = { type: 32 /* TokenType.EOF_TOKEN */ };
     var Tokenizer = /** @class */ (function () {
         function Tokenizer() {
             this._value = [];
@@ -1188,7 +1188,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                     if (isNameCodePoint(c1) || isValidEscape(c2, c3)) {
                         var flags = isIdentifierStart(c1, c2, c3) ? FLAG_ID : FLAG_UNRESTRICTED;
                         var value = this.consumeName();
-                        return { type: 5 /* HASH_TOKEN */, value: value, flags: flags };
+                        return { type: 5 /* TokenType.HASH_TOKEN */, value: value, flags: flags };
                     }
                     break;
                 case DOLLAR_SIGN:
@@ -1277,7 +1277,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                     var a3 = this.peekCodePoint(2);
                     if (isIdentifierStart(a1, a2, a3)) {
                         var value = this.consumeName();
-                        return { type: 7 /* AT_KEYWORD_TOKEN */, value: value };
+                        return { type: 7 /* TokenType.AT_KEYWORD_TOKEN */, value: value };
                     }
                     break;
                 case LEFT_SQUARE_BRACKET:
@@ -1341,7 +1341,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                 this.reconsumeCodePoint(codePoint);
                 return this.consumeIdentLikeToken();
             }
-            return { type: 6 /* DELIM_TOKEN */, value: fromCodePoint$1(codePoint) };
+            return { type: 6 /* TokenType.DELIM_TOKEN */, value: fromCodePoint$1(codePoint) };
         };
         Tokenizer.prototype.consumeCodePoint = function () {
             var value = this._value.shift();
@@ -1372,7 +1372,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
             if (questionMarks) {
                 var start_1 = parseInt(fromCodePoint$1.apply(void 0, digits.map(function (digit) { return (digit === QUESTION_MARK ? ZERO : digit); })), 16);
                 var end = parseInt(fromCodePoint$1.apply(void 0, digits.map(function (digit) { return (digit === QUESTION_MARK ? F : digit); })), 16);
-                return { type: 30 /* UNICODE_RANGE_TOKEN */, start: start_1, end: end };
+                return { type: 30 /* TokenType.UNICODE_RANGE_TOKEN */, start: start_1, end: end };
             }
             var start = parseInt(fromCodePoint$1.apply(void 0, digits), 16);
             if (this.peekCodePoint(0) === HYPHEN_MINUS && isHex(this.peekCodePoint(1))) {
@@ -1384,10 +1384,10 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                     codePoint = this.consumeCodePoint();
                 }
                 var end = parseInt(fromCodePoint$1.apply(void 0, endDigits), 16);
-                return { type: 30 /* UNICODE_RANGE_TOKEN */, start: start, end: end };
+                return { type: 30 /* TokenType.UNICODE_RANGE_TOKEN */, start: start, end: end };
             }
             else {
-                return { type: 30 /* UNICODE_RANGE_TOKEN */, start: start, end: start };
+                return { type: 30 /* TokenType.UNICODE_RANGE_TOKEN */, start: start, end: start };
             }
         };
         Tokenizer.prototype.consumeIdentLikeToken = function () {
@@ -1398,24 +1398,24 @@ var html2canvas = createCommonjsModule(function (module, exports) {
             }
             else if (this.peekCodePoint(0) === LEFT_PARENTHESIS) {
                 this.consumeCodePoint();
-                return { type: 19 /* FUNCTION_TOKEN */, value: value };
+                return { type: 19 /* TokenType.FUNCTION_TOKEN */, value: value };
             }
-            return { type: 20 /* IDENT_TOKEN */, value: value };
+            return { type: 20 /* TokenType.IDENT_TOKEN */, value: value };
         };
         Tokenizer.prototype.consumeUrlToken = function () {
             var value = [];
             this.consumeWhiteSpace();
             if (this.peekCodePoint(0) === EOF) {
-                return { type: 22 /* URL_TOKEN */, value: '' };
+                return { type: 22 /* TokenType.URL_TOKEN */, value: '' };
             }
             var next = this.peekCodePoint(0);
             if (next === APOSTROPHE || next === QUOTATION_MARK) {
                 var stringToken = this.consumeStringToken(this.consumeCodePoint());
-                if (stringToken.type === 0 /* STRING_TOKEN */) {
+                if (stringToken.type === 0 /* TokenType.STRING_TOKEN */) {
                     this.consumeWhiteSpace();
                     if (this.peekCodePoint(0) === EOF || this.peekCodePoint(0) === RIGHT_PARENTHESIS) {
                         this.consumeCodePoint();
-                        return { type: 22 /* URL_TOKEN */, value: stringToken.value };
+                        return { type: 22 /* TokenType.URL_TOKEN */, value: stringToken.value };
                     }
                 }
                 this.consumeBadUrlRemnants();
@@ -1424,13 +1424,13 @@ var html2canvas = createCommonjsModule(function (module, exports) {
             while (true) {
                 var codePoint = this.consumeCodePoint();
                 if (codePoint === EOF || codePoint === RIGHT_PARENTHESIS) {
-                    return { type: 22 /* URL_TOKEN */, value: fromCodePoint$1.apply(void 0, value) };
+                    return { type: 22 /* TokenType.URL_TOKEN */, value: fromCodePoint$1.apply(void 0, value) };
                 }
                 else if (isWhiteSpace(codePoint)) {
                     this.consumeWhiteSpace();
                     if (this.peekCodePoint(0) === EOF || this.peekCodePoint(0) === RIGHT_PARENTHESIS) {
                         this.consumeCodePoint();
-                        return { type: 22 /* URL_TOKEN */, value: fromCodePoint$1.apply(void 0, value) };
+                        return { type: 22 /* TokenType.URL_TOKEN */, value: fromCodePoint$1.apply(void 0, value) };
                     }
                     this.consumeBadUrlRemnants();
                     return BAD_URL_TOKEN;
@@ -1490,7 +1490,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                 var codePoint = this._value[i];
                 if (codePoint === EOF || codePoint === undefined || codePoint === endingCodePoint) {
                     value += this.consumeStringSlice(i);
-                    return { type: 0 /* STRING_TOKEN */, value: value };
+                    return { type: 0 /* TokenType.STRING_TOKEN */, value: value };
                 }
                 if (codePoint === LINE_FEED) {
                     this._value.splice(0, i);
@@ -1552,13 +1552,13 @@ var html2canvas = createCommonjsModule(function (module, exports) {
             var c3 = this.peekCodePoint(2);
             if (isIdentifierStart(c1, c2, c3)) {
                 var unit = this.consumeName();
-                return { type: 15 /* DIMENSION_TOKEN */, number: number, flags: flags, unit: unit };
+                return { type: 15 /* TokenType.DIMENSION_TOKEN */, number: number, flags: flags, unit: unit };
             }
             if (c1 === PERCENTAGE_SIGN) {
                 this.consumeCodePoint();
-                return { type: 16 /* PERCENTAGE_TOKEN */, number: number, flags: flags };
+                return { type: 16 /* TokenType.PERCENTAGE_TOKEN */, number: number, flags: flags };
             }
-            return { type: 17 /* NUMBER_TOKEN */, number: number, flags: flags };
+            return { type: 17 /* TokenType.NUMBER_TOKEN */, number: number, flags: flags };
         };
         Tokenizer.prototype.consumeEscapedCodePoint = function () {
             var codePoint = this.consumeCodePoint();
@@ -1617,18 +1617,18 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         };
         Parser.prototype.parseComponentValue = function () {
             var token = this.consumeToken();
-            while (token.type === 31 /* WHITESPACE_TOKEN */) {
+            while (token.type === 31 /* TokenType.WHITESPACE_TOKEN */) {
                 token = this.consumeToken();
             }
-            if (token.type === 32 /* EOF_TOKEN */) {
+            if (token.type === 32 /* TokenType.EOF_TOKEN */) {
                 throw new SyntaxError("Error parsing CSS component value, unexpected EOF");
             }
             this.reconsumeToken(token);
             var value = this.consumeComponentValue();
             do {
                 token = this.consumeToken();
-            } while (token.type === 31 /* WHITESPACE_TOKEN */);
-            if (token.type === 32 /* EOF_TOKEN */) {
+            } while (token.type === 31 /* TokenType.WHITESPACE_TOKEN */);
+            if (token.type === 32 /* TokenType.EOF_TOKEN */) {
                 return value;
             }
             throw new SyntaxError("Error parsing CSS component value, multiple values found when expecting only one");
@@ -1637,7 +1637,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
             var values = [];
             while (true) {
                 var value = this.consumeComponentValue();
-                if (value.type === 32 /* EOF_TOKEN */) {
+                if (value.type === 32 /* TokenType.EOF_TOKEN */) {
                     return values;
                 }
                 values.push(value);
@@ -1647,11 +1647,11 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         Parser.prototype.consumeComponentValue = function () {
             var token = this.consumeToken();
             switch (token.type) {
-                case 11 /* LEFT_CURLY_BRACKET_TOKEN */:
-                case 28 /* LEFT_SQUARE_BRACKET_TOKEN */:
-                case 2 /* LEFT_PARENTHESIS_TOKEN */:
+                case 11 /* TokenType.LEFT_CURLY_BRACKET_TOKEN */:
+                case 28 /* TokenType.LEFT_SQUARE_BRACKET_TOKEN */:
+                case 2 /* TokenType.LEFT_PARENTHESIS_TOKEN */:
                     return this.consumeSimpleBlock(token.type);
-                case 19 /* FUNCTION_TOKEN */:
+                case 19 /* TokenType.FUNCTION_TOKEN */:
                     return this.consumeFunction(token);
             }
             return token;
@@ -1660,7 +1660,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
             var block = { type: type, values: [] };
             var token = this.consumeToken();
             while (true) {
-                if (token.type === 32 /* EOF_TOKEN */ || isEndingTokenFor(token, type)) {
+                if (token.type === 32 /* TokenType.EOF_TOKEN */ || isEndingTokenFor(token, type)) {
                     return block;
                 }
                 this.reconsumeToken(token);
@@ -1672,11 +1672,11 @@ var html2canvas = createCommonjsModule(function (module, exports) {
             var cssFunction = {
                 name: functionToken.value,
                 values: [],
-                type: 18 /* FUNCTION */
+                type: 18 /* TokenType.FUNCTION */
             };
             while (true) {
                 var token = this.consumeToken();
-                if (token.type === 32 /* EOF_TOKEN */ || token.type === 3 /* RIGHT_PARENTHESIS_TOKEN */) {
+                if (token.type === 32 /* TokenType.EOF_TOKEN */ || token.type === 3 /* TokenType.RIGHT_PARENTHESIS_TOKEN */) {
                     return cssFunction;
                 }
                 this.reconsumeToken(token);
@@ -1692,22 +1692,22 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         };
         return Parser;
     }());
-    var isDimensionToken = function (token) { return token.type === 15 /* DIMENSION_TOKEN */; };
-    var isNumberToken = function (token) { return token.type === 17 /* NUMBER_TOKEN */; };
-    var isIdentToken = function (token) { return token.type === 20 /* IDENT_TOKEN */; };
-    var isStringToken = function (token) { return token.type === 0 /* STRING_TOKEN */; };
+    var isDimensionToken = function (token) { return token.type === 15 /* TokenType.DIMENSION_TOKEN */; };
+    var isNumberToken = function (token) { return token.type === 17 /* TokenType.NUMBER_TOKEN */; };
+    var isIdentToken = function (token) { return token.type === 20 /* TokenType.IDENT_TOKEN */; };
+    var isStringToken = function (token) { return token.type === 0 /* TokenType.STRING_TOKEN */; };
     var isIdentWithValue = function (token, value) {
         return isIdentToken(token) && token.value === value;
     };
-    var nonWhiteSpace = function (token) { return token.type !== 31 /* WHITESPACE_TOKEN */; };
+    var nonWhiteSpace = function (token) { return token.type !== 31 /* TokenType.WHITESPACE_TOKEN */; };
     var nonFunctionArgSeparator = function (token) {
-        return token.type !== 31 /* WHITESPACE_TOKEN */ && token.type !== 4 /* COMMA_TOKEN */;
+        return token.type !== 31 /* TokenType.WHITESPACE_TOKEN */ && token.type !== 4 /* TokenType.COMMA_TOKEN */;
     };
     var parseFunctionArgs = function (tokens) {
         var args = [];
         var arg = [];
         tokens.forEach(function (token) {
-            if (token.type === 4 /* COMMA_TOKEN */) {
+            if (token.type === 4 /* TokenType.COMMA_TOKEN */) {
                 if (arg.length === 0) {
                     throw new Error("Error parsing function args, zero tokens for arg");
                 }
@@ -1715,7 +1715,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                 arg = [];
                 return;
             }
-            if (token.type !== 31 /* WHITESPACE_TOKEN */) {
+            if (token.type !== 31 /* TokenType.WHITESPACE_TOKEN */) {
                 arg.push(token);
             }
         });
@@ -1725,37 +1725,37 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         return args;
     };
     var isEndingTokenFor = function (token, type) {
-        if (type === 11 /* LEFT_CURLY_BRACKET_TOKEN */ && token.type === 12 /* RIGHT_CURLY_BRACKET_TOKEN */) {
+        if (type === 11 /* TokenType.LEFT_CURLY_BRACKET_TOKEN */ && token.type === 12 /* TokenType.RIGHT_CURLY_BRACKET_TOKEN */) {
             return true;
         }
-        if (type === 28 /* LEFT_SQUARE_BRACKET_TOKEN */ && token.type === 29 /* RIGHT_SQUARE_BRACKET_TOKEN */) {
+        if (type === 28 /* TokenType.LEFT_SQUARE_BRACKET_TOKEN */ && token.type === 29 /* TokenType.RIGHT_SQUARE_BRACKET_TOKEN */) {
             return true;
         }
-        return type === 2 /* LEFT_PARENTHESIS_TOKEN */ && token.type === 3 /* RIGHT_PARENTHESIS_TOKEN */;
+        return type === 2 /* TokenType.LEFT_PARENTHESIS_TOKEN */ && token.type === 3 /* TokenType.RIGHT_PARENTHESIS_TOKEN */;
     };
 
     var isLength = function (token) {
-        return token.type === 17 /* NUMBER_TOKEN */ || token.type === 15 /* DIMENSION_TOKEN */;
+        return token.type === 17 /* TokenType.NUMBER_TOKEN */ || token.type === 15 /* TokenType.DIMENSION_TOKEN */;
     };
 
     var isLengthPercentage = function (token) {
-        return token.type === 16 /* PERCENTAGE_TOKEN */ || isLength(token);
+        return token.type === 16 /* TokenType.PERCENTAGE_TOKEN */ || isLength(token);
     };
     var parseLengthPercentageTuple = function (tokens) {
         return tokens.length > 1 ? [tokens[0], tokens[1]] : [tokens[0]];
     };
     var ZERO_LENGTH = {
-        type: 17 /* NUMBER_TOKEN */,
+        type: 17 /* TokenType.NUMBER_TOKEN */,
         number: 0,
         flags: FLAG_INTEGER
     };
     var FIFTY_PERCENT = {
-        type: 16 /* PERCENTAGE_TOKEN */,
+        type: 16 /* TokenType.PERCENTAGE_TOKEN */,
         number: 50,
         flags: FLAG_INTEGER
     };
     var HUNDRED_PERCENT = {
-        type: 16 /* PERCENTAGE_TOKEN */,
+        type: 16 /* TokenType.PERCENTAGE_TOKEN */,
         number: 100,
         flags: FLAG_INTEGER
     };
@@ -1764,7 +1764,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         return [getAbsoluteValue(x, width), getAbsoluteValue(typeof y !== 'undefined' ? y : x, height)];
     };
     var getAbsoluteValue = function (token, parent) {
-        if (token.type === 16 /* PERCENTAGE_TOKEN */) {
+        if (token.type === 16 /* TokenType.PERCENTAGE_TOKEN */) {
             return (token.number / 100) * parent;
         }
         if (isDimensionToken(token)) {
@@ -1787,7 +1787,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
     var angle = {
         name: 'angle',
         parse: function (_context, value) {
-            if (value.type === 15 /* DIMENSION_TOKEN */) {
+            if (value.type === 15 /* TokenType.DIMENSION_TOKEN */) {
                 switch (value.unit) {
                     case DEG:
                         return (Math.PI * value.number) / 180;
@@ -1803,7 +1803,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         }
     };
     var isAngle = function (value) {
-        if (value.type === 15 /* DIMENSION_TOKEN */) {
+        if (value.type === 15 /* TokenType.DIMENSION_TOKEN */) {
             if (value.unit === DEG || value.unit === GRAD || value.unit === RAD || value.unit === TURN) {
                 return true;
             }
@@ -1853,87 +1853,154 @@ var html2canvas = createCommonjsModule(function (module, exports) {
     };
     var deg = function (deg) { return (Math.PI * deg) / 180; };
 
-    var color$1 = {
-        name: 'color',
-        parse: function (context, value) {
-            if (value.type === 18 /* FUNCTION */) {
-                var colorFunction = SUPPORTED_COLOR_FUNCTIONS[value.name];
-                if (typeof colorFunction === 'undefined') {
-                    throw new Error("Attempting to parse an unsupported color function \"" + value.name + "\"");
-                }
-                return colorFunction(context, value.values);
-            }
-            if (value.type === 5 /* HASH_TOKEN */) {
-                if (value.value.length === 3) {
-                    var r = value.value.substring(0, 1);
-                    var g = value.value.substring(1, 2);
-                    var b = value.value.substring(2, 3);
-                    return pack(parseInt(r + r, 16), parseInt(g + g, 16), parseInt(b + b, 16), 1);
-                }
-                if (value.value.length === 4) {
-                    var r = value.value.substring(0, 1);
-                    var g = value.value.substring(1, 2);
-                    var b = value.value.substring(2, 3);
-                    var a = value.value.substring(3, 4);
-                    return pack(parseInt(r + r, 16), parseInt(g + g, 16), parseInt(b + b, 16), parseInt(a + a, 16) / 255);
-                }
-                if (value.value.length === 6) {
-                    var r = value.value.substring(0, 2);
-                    var g = value.value.substring(2, 4);
-                    var b = value.value.substring(4, 6);
-                    return pack(parseInt(r, 16), parseInt(g, 16), parseInt(b, 16), 1);
-                }
-                if (value.value.length === 8) {
-                    var r = value.value.substring(0, 2);
-                    var g = value.value.substring(2, 4);
-                    var b = value.value.substring(4, 6);
-                    var a = value.value.substring(6, 8);
-                    return pack(parseInt(r, 16), parseInt(g, 16), parseInt(b, 16), parseInt(a, 16) / 255);
-                }
-            }
-            if (value.type === 20 /* IDENT_TOKEN */) {
-                var namedColor = COLORS[value.value.toUpperCase()];
-                if (typeof namedColor !== 'undefined') {
-                    return namedColor;
-                }
-            }
-            return COLORS.TRANSPARENT;
-        }
-    };
     var isTransparent = function (color) { return (0xff & color) === 0; };
     var asString = function (color) {
         var alpha = 0xff & color;
         var blue = 0xff & (color >> 8);
         var green = 0xff & (color >> 16);
         var red = 0xff & (color >> 24);
-        return alpha < 255 ? "rgba(" + red + "," + green + "," + blue + "," + alpha / 255 + ")" : "rgb(" + red + "," + green + "," + blue + ")";
+        return alpha < 255 ? "rgba(".concat(red, ",").concat(green, ",").concat(blue, ",").concat(alpha / 255, ")") : "rgb(".concat(red, ",").concat(green, ",").concat(blue, ")");
     };
     var pack = function (r, g, b, a) {
         return ((r << 24) | (g << 16) | (b << 8) | (Math.round(a * 255) << 0)) >>> 0;
     };
     var getTokenColorValue = function (token, i) {
-        if (token.type === 17 /* NUMBER_TOKEN */) {
+        if (token.type === 17 /* TokenType.NUMBER_TOKEN */) {
             return token.number;
         }
-        if (token.type === 16 /* PERCENTAGE_TOKEN */) {
+        if (token.type === 16 /* TokenType.PERCENTAGE_TOKEN */) {
             var max = i === 3 ? 1 : 255;
             return i === 3 ? (token.number / 100) * max : Math.round((token.number / 100) * max);
         }
         return 0;
     };
-    var rgb = function (_context, args) {
-        var tokens = args.filter(nonFunctionArgSeparator);
-        if (tokens.length === 3) {
-            var _a = tokens.map(getTokenColorValue), r = _a[0], g = _a[1], b = _a[2];
-            return pack(r, g, b, 1);
-        }
-        if (tokens.length === 4) {
-            var _b = tokens.map(getTokenColorValue), r = _b[0], g = _b[1], b = _b[2], a = _b[3];
-            return pack(r, g, b, a);
-        }
-        return 0;
+    var isRelativeTransform = function (tokens) {
+        return (tokens[0].type === 20 /* TokenType.IDENT_TOKEN */ ? tokens[0].value : 'unknown') === 'from';
+    };
+    var clamp = function (value, min, max) {
+        return Math.min(Math.max(value, min), max);
+    };
+    var multiplyMatrices = function (A, B) {
+        return [
+            A[0] * B[0] + A[1] * B[1] + A[2] * B[2],
+            A[3] * B[0] + A[4] * B[1] + A[5] * B[2],
+            A[6] * B[0] + A[7] * B[1] + A[8] * B[2]
+        ];
+    };
+    var packSrgb = function (args) {
+        return pack(clamp(Math.round(args[0] * 255), 0, 255), clamp(Math.round(args[1] * 255), 0, 255), clamp(Math.round(args[2] * 255), 0, 255), clamp(args[3], 0, 1));
+    };
+    var packSrgbLinear = function (_a) {
+        var r = _a[0], g = _a[1], b = _a[2], a = _a[3];
+        var rgb = srgbLinear2rgb([r, g, b]);
+        return pack(clamp(Math.round(rgb[0] * 255), 0, 255), clamp(Math.round(rgb[1] * 255), 0, 255), clamp(Math.round(rgb[2] * 255), 0, 255), a);
+    };
+    var packXYZ = function (args) {
+        var srgb_linear = xyz2rgbLinear([args[0], args[1], args[2]]);
+        return packSrgbLinear([srgb_linear[0], srgb_linear[1], srgb_linear[2], args[3]]);
+    };
+    var packLab = function (_context, args) {
+        if (isRelativeTransform(args.filter(nonFunctionArgSeparator))) {
+            throw new Error('Relative color not supported for lab()');
+        }
+        var _a = extractLabComponents(args), l = _a[0], a = _a[1], b = _a[2], alpha = _a[3], rgb = srgbLinear2rgb(xyz2rgbLinear(lab2xyz([l, a, b])));
+        return pack(clamp(Math.round(rgb[0] * 255), 0, 255), clamp(Math.round(rgb[1] * 255), 0, 255), clamp(Math.round(rgb[2] * 255), 0, 255), alpha);
+    };
+    var packOkLab = function (_context, args) {
+        if (isRelativeTransform(args.filter(nonFunctionArgSeparator))) {
+            throw new Error('Relative color not supported for oklab()');
+        }
+        var _a = extractLabComponents(args), l = _a[0], a = _a[1], b = _a[2], alpha = _a[3], rgb = srgbLinear2rgb(xyz2rgbLinear(oklab2xyz([l, a, b])));
+        return pack(clamp(Math.round(rgb[0] * 255), 0, 255), clamp(Math.round(rgb[1] * 255), 0, 255), clamp(Math.round(rgb[2] * 255), 0, 255), alpha);
+    };
+    var packOkLch = function (_context, args) {
+        if (isRelativeTransform(args.filter(nonFunctionArgSeparator))) {
+            throw new Error('Relative color not supported for oklch()');
+        }
+        var _a = extractOkLchComponents(args), l = _a[0], c = _a[1], h = _a[2], alpha = _a[3], rgb = srgbLinear2rgb(xyz2rgbLinear(oklab2xyz(lch2lab([l, c, h]))));
+        return pack(clamp(Math.round(rgb[0] * 255), 0, 255), clamp(Math.round(rgb[1] * 255), 0, 255), clamp(Math.round(rgb[2] * 255), 0, 255), alpha);
+    };
+    var packLch = function (_context, args) {
+        if (isRelativeTransform(args.filter(nonFunctionArgSeparator))) {
+            throw new Error('Relative color not supported for lch()');
+        }
+        var _a = extractLchComponents(args), l = _a[0], c = _a[1], h = _a[2], a = _a[3], rgb = srgbLinear2rgb(xyz2rgbLinear(lab2xyz(lch2lab([l, c, h]))));
+        return pack(clamp(Math.round(rgb[0] * 255), 0, 255), clamp(Math.round(rgb[1] * 255), 0, 255), clamp(Math.round(rgb[2] * 255), 0, 255), a);
+    };
+    var extractHslComponents = function (context, args) {
+        var tokens = args.filter(nonFunctionArgSeparator), hue = tokens[0], saturation = tokens[1], lightness = tokens[2], alpha = tokens[3], h = (hue.type === 17 /* TokenType.NUMBER_TOKEN */ ? deg(hue.number) : angle.parse(context, hue)) / (Math.PI * 2), s = isLengthPercentage(saturation) ? saturation.number / 100 : 0, l = isLengthPercentage(lightness) ? lightness.number / 100 : 0, a = typeof alpha !== 'undefined' && isLengthPercentage(alpha) ? getAbsoluteValue(alpha, 1) : 1;
+        return [h, s, l, a];
+    };
+    var packHSL = function (context, args) {
+        if (isRelativeTransform(args)) {
+            throw new Error('Relative color not supported for hsl()');
+        }
+        var _a = extractHslComponents(context, args), h = _a[0], s = _a[1], l = _a[2], a = _a[3], rgb = hsl2rgb([h, s, l]);
+        return pack(rgb[0] * 255, rgb[1] * 255, rgb[2] * 255, s === 0 ? 1 : a);
+    };
+    var extractLchComponents = function (args) {
+        var tokens = args.filter(nonFunctionArgSeparator), l = isLengthPercentage(tokens[0]) ? tokens[0].number : 0, c = isLengthPercentage(tokens[1]) ? tokens[1].number : 0, h = isNumberToken(tokens[2]) || isDimensionToken(tokens[2]) ? tokens[2].number : 0, a = typeof tokens[4] !== 'undefined' && isLengthPercentage(tokens[4]) ? getAbsoluteValue(tokens[4], 1) : 1;
+        return [l, c, h, a];
+    };
+    var extractLabComponents = function (args) {
+        var tokens = args.filter(nonFunctionArgSeparator), 
+        // eslint-disable-next-line prettier/prettier
+        l = tokens[0].type === 16 /* TokenType.PERCENTAGE_TOKEN */
+            ? tokens[0].number / 100
+            : isNumberToken(tokens[0])
+                ? tokens[0].number
+                : 0, 
+        // eslint-disable-next-line prettier/prettier
+        a = tokens[1].type === 16 /* TokenType.PERCENTAGE_TOKEN */
+            ? tokens[1].number / 100
+            : isNumberToken(tokens[1])
+                ? tokens[1].number
+                : 0, b = isNumberToken(tokens[2]) || isDimensionToken(tokens[2]) ? tokens[2].number : 0, alpha = typeof tokens[4] !== 'undefined' && isLengthPercentage(tokens[4]) ? getAbsoluteValue(tokens[4], 1) : 1;
+        return [l, a, b, alpha];
+    };
+    var extractOkLchComponents = function (args) {
+        var tokens = args.filter(nonFunctionArgSeparator), 
+        // eslint-disable-next-line prettier/prettier
+        l = tokens[0].type === 16 /* TokenType.PERCENTAGE_TOKEN */
+            ? tokens[0].number / 100
+            : isNumberToken(tokens[0])
+                ? tokens[0].number
+                : 0, 
+        // eslint-disable-next-line prettier/prettier
+        c = tokens[1].type === 16 /* TokenType.PERCENTAGE_TOKEN */
+            ? tokens[1].number / 100
+            : isNumberToken(tokens[1])
+                ? tokens[1].number
+                : 0, h = isNumberToken(tokens[2]) || isDimensionToken(tokens[2]) ? tokens[2].number : 0, a = typeof tokens[4] !== 'undefined' && isLengthPercentage(tokens[4]) ? getAbsoluteValue(tokens[4], 1) : 1;
+        return [l, c, h, a];
+    };
+    /**
+     * Convert D65 to D50
+     *
+     * @param xyz
+     */
+    var d65toD50 = function (xyz) {
+        return multiplyMatrices(
+        // eslint-disable-next-line prettier/prettier
+        [
+            1.0479297925449969, 0.022946870601609652, -0.05019226628920524, 0.02962780877005599, 0.9904344267538799,
+            -0.017073799063418826, -0.009243040646204504, 0.015055191490298152, 0.7518742814281371
+        ], xyz);
     };
-    function hue2rgb(t1, t2, hue) {
+    /**
+     * Convert D50 to D65
+     *
+     * @param xyz
+     */
+    var d50toD65 = function (xyz) {
+        return multiplyMatrices(
+        // eslint-disable-next-line prettier/prettier
+        [
+            0.955473421488075, -0.02309845494876471, 0.06325924320057072, -0.0283697093338637, 1.0099953980813041,
+            0.021041441191917323, 0.012314014864481998, -0.020507649298898964, 1.330365926242124
+        ], xyz);
+    };
+    var hue2rgb = function (t1, t2, hue) {
         if (hue < 0) {
             hue += 1;
         }
@@ -1952,29 +2019,783 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         else {
             return t1;
         }
-    }
-    var hsl = function (context, args) {
-        var tokens = args.filter(nonFunctionArgSeparator);
-        var hue = tokens[0], saturation = tokens[1], lightness = tokens[2], alpha = tokens[3];
-        var h = (hue.type === 17 /* NUMBER_TOKEN */ ? deg(hue.number) : angle.parse(context, hue)) / (Math.PI * 2);
-        var s = isLengthPercentage(saturation) ? saturation.number / 100 : 0;
-        var l = isLengthPercentage(lightness) ? lightness.number / 100 : 0;
-        var a = typeof alpha !== 'undefined' && isLengthPercentage(alpha) ? getAbsoluteValue(alpha, 1) : 1;
+    };
+    var hsl2rgb = function (_a) {
+        var h = _a[0], s = _a[1], l = _a[2];
         if (s === 0) {
-            return pack(l * 255, l * 255, l * 255, 1);
+            return [l * 255, l * 255, l * 255];
+        }
+        var t2 = l <= 0.5 ? l * (s + 1) : l + s - l * s, t1 = l * 2 - t2, r = hue2rgb(t1, t2, h + 1 / 3), g = hue2rgb(t1, t2, h), b = hue2rgb(t1, t2, h - 1 / 3);
+        return [r, g, b];
+    };
+    /**
+     * Convert lch to OKLab
+     *
+     * @param l
+     * @param c
+     * @param h
+     */
+    var lch2lab = function (_a) {
+        var l = _a[0], c = _a[1], h = _a[2];
+        if (c < 0) {
+            c = 0;
+        }
+        if (isNaN(h)) {
+            h = 0;
+        }
+        return [l, c * Math.cos((h * Math.PI) / 180), c * Math.sin((h * Math.PI) / 180)];
+    };
+    /**
+     * Convert OKLab to XYZ relative to D65
+     *
+     * @param lab
+     */
+    var oklab2xyz = function (lab) {
+        var LMSg = multiplyMatrices(
+        // eslint-disable-next-line prettier/prettier
+        [
+            1, 0.3963377773761749, 0.2158037573099136, 1, -0.1055613458156586, -0.0638541728258133, 1,
+            -0.0894841775298119, -1.2914855480194092
+        ], lab), LMS = LMSg.map(function (val) { return Math.pow(val, 3); });
+        return multiplyMatrices(
+        // eslint-disable-next-line prettier/prettier
+        [
+            1.2268798758459243, -0.5578149944602171, 0.2813910456659647, -0.0405757452148008, 1.112286803280317,
+            -0.0717110580655164, -0.0763729366746601, -0.4214933324022432, 1.5869240198367816
+        ], LMS);
+    };
+    /**
+     * Convert Lab to D50-adapted XYZ
+     *
+     * @param lab
+     */
+    var lab2xyz = function (lab) {
+        var fy = (lab[0] + 16) / 116, fx = lab[1] / 500 + fy, fz = fy - lab[2] / 200, k = 24389 / 27, e = 24 / 116, xyz = [
+            ((fx > e ? Math.pow(fx, 3) : (116 * fx - 16) / k) * 0.3457) / 0.3585,
+            lab[0] > 8 ? Math.pow(fy, 3) : lab[0] / k,
+            ((fz > e ? Math.pow(fz, 3) : (116 * fz - 16) / k) * (1.0 - 0.3457 - 0.3585)) / 0.3585
+        ];
+        return d50toD65([xyz[0], xyz[1], xyz[2]]);
+    };
+    /**
+     * Convert RGB to XYZ
+     *
+     * @param _context
+     * @param args
+     */
+    var rgbToXyz = function (_context, args) {
+        var tokens = args.filter(nonFunctionArgSeparator);
+        if (tokens.length === 3) {
+            var _a = tokens.map(getTokenColorValue), r = _a[0], g = _a[1], b = _a[2], rgb_linear = rgb2rgbLinear([r / 255, g / 255, b / 255]), _b = rgbLinear2xyz([rgb_linear[0], rgb_linear[1], rgb_linear[2]]), x = _b[0], y = _b[1], z = _b[2];
+            return [x, y, z, 1];
+        }
+        if (tokens.length === 4) {
+            var _c = tokens.map(getTokenColorValue), r = _c[0], g = _c[1], b = _c[2], a = _c[3], rgb_linear = rgb2rgbLinear([r / 255, g / 255, b / 255]), _d = rgbLinear2xyz([rgb_linear[0], rgb_linear[1], rgb_linear[2]]), x = _d[0], y = _d[1], z = _d[2];
+            return [x, y, z, a];
+        }
+        return [0, 0, 0, 1];
+    };
+    /**
+     * HSL to XYZ
+     *
+     * @param context
+     * @param args
+     */
+    var hslToXyz = function (context, args) {
+        var _a = extractHslComponents(context, args), h = _a[0], s = _a[1], l = _a[2], a = _a[3], rgb_linear = rgb2rgbLinear(hsl2rgb([h, s, l])), _b = rgbLinear2xyz([rgb_linear[0], rgb_linear[1], rgb_linear[2]]), x = _b[0], y = _b[1], z = _b[2];
+        return [x, y, z, a];
+    };
+    /**
+     * LAB to XYZ
+     *
+     * @param _context
+     * @param args
+     */
+    var labToXyz = function (_context, args) {
+        var _a = extractLabComponents(args), l = _a[0], a = _a[1], b = _a[2], alpha = _a[3], _b = lab2xyz([l, a, b]), x = _b[0], y = _b[1], z = _b[2];
+        return [x, y, z, alpha];
+    };
+    /**
+     * LCH to XYZ
+     *
+     * @param _context
+     * @param args
+     */
+    var lchToXyz = function (_context, args) {
+        var _a = extractLchComponents(args), l = _a[0], c = _a[1], h = _a[2], alpha = _a[3], _b = lab2xyz(lch2lab([l, c, h])), x = _b[0], y = _b[1], z = _b[2];
+        return [x, y, z, alpha];
+    };
+    /**
+     * OKLch to XYZ
+     *
+     * @param _context
+     * @param args
+     */
+    var oklchToXyz = function (_context, args) {
+        var _a = extractOkLchComponents(args), l = _a[0], c = _a[1], h = _a[2], alpha = _a[3], _b = oklab2xyz(lch2lab([l, c, h])), x = _b[0], y = _b[1], z = _b[2];
+        return [x, y, z, alpha];
+    };
+    /**
+     * OKLab to XYZ
+     *
+     * @param _context
+     * @param args
+     */
+    var oklabToXyz = function (_context, args) {
+        var _a = extractLabComponents(args), l = _a[0], c = _a[1], h = _a[2], alpha = _a[3], _b = oklab2xyz([l, c, h]), x = _b[0], y = _b[1], z = _b[2];
+        return [x, y, z, alpha];
+    };
+    /**
+     * XYZ-50 to XYZ
+     *
+     * @param args
+     */
+    var xyz50ToXYZ = function (args) {
+        return d50toD65([args[0], args[1], args[2]]);
+    };
+    /**
+     * Does nothing, required for SUPPORTED_COLOR_SPACES_FROM_XYZ in the _color() function
+     *
+     * @param args
+     */
+    var xyzFromXYZ = function (args) {
+        return args;
+    };
+    /**
+     * XYZ-65 to XYZ-50
+     *
+     * @param args
+     */
+    var xyz50FromXYZ = function (args) {
+        var _a = d65toD50([args[0], args[2], args[3]]), x = _a[0], y = _a[1], z = _a[2];
+        return [x, y, z, args[3]];
+    };
+    /**
+     * Convert XYZ to SRGB and Pack
+     *
+     * @param args
+     */
+    var convertXyz = function (args) {
+        return packXYZ([args[0], args[1], args[2], args[3]]);
+    };
+    /**
+     * Convert XYZ-50 to SRGB and Pack
+     *
+     * @param args
+     */
+    var convertXyz50 = function (args) {
+        var xyz = xyz50ToXYZ([args[0], args[1], args[2]]);
+        return packXYZ([xyz[0], xyz[1], xyz[2], args[3]]);
+    };
+
+    /**
+     * SRGB related functions
+     */
+    /**
+     * Convert XYZ to linear-light sRGB
+     *
+     * @param xyz
+     */
+    var xyz2rgbLinear = function (xyz) {
+        return multiplyMatrices(
+        // eslint-disable-next-line prettier/prettier
+        [
+            3.2409699419045226, -1.537383177570094, -0.4986107602930034, -0.9692436362808796, 1.8759675015077202,
+            0.04155505740717559, 0.05563007969699366, -0.20397695888897652, 1.0569715142428786
+        ], xyz);
+    };
+    /**
+     * Convert XYZ to linear-light sRGB
+     *
+     * @param xyz
+     */
+    var rgbLinear2xyz = function (xyz) {
+        return multiplyMatrices(
+        // eslint-disable-next-line prettier/prettier
+        [
+            0.41239079926595934, 0.357584339383878, 0.1804807884018343, 0.21263900587151027, 0.715168678767756,
+            0.07219231536073371, 0.01933081871559182, 0.11919477979462598, 0.9505321522496607
+        ], xyz);
+    };
+    /**
+     * Convert sRGB to RGB
+     *
+     * @param rgb
+     */
+    var srgbLinear2rgb = function (rgb) {
+        return rgb.map(function (c) {
+            var sign = c < 0 ? -1 : 1, abs = Math.abs(c);
+            // eslint-disable-next-line prettier/prettier
+            return abs > 0.0031308 ? sign * (1.055 * Math.pow(abs, (1 / 2.4)) - 0.055) : 12.92 * c;
+        });
+    };
+    /**
+     * Convert RGB to sRGB
+     *
+     * @param rgb
+     */
+    var rgb2rgbLinear = function (rgb) {
+        return rgb.map(function (c) {
+            var sign = c < 0 ? -1 : 1, abs = Math.abs(c);
+            // eslint-disable-next-line prettier/prettier
+            return abs <= 0.04045 ? c / 12.92 : sign * Math.pow(((abs + 0.055) / 1.055), 2.4);
+        });
+    };
+    /**
+     * XYZ to SRGB
+     *
+     * @param args
+     */
+    var srgbFromXYZ = function (args) {
+        var _a = srgbLinear2rgb(xyz2rgbLinear([args[0], args[1], args[2]])), r = _a[0], g = _a[1], b = _a[2];
+        return [r, g, b, args[3]];
+    };
+    /**
+     * XYZ to SRGB-Linear
+     * @param args
+     */
+    var srgbLinearFromXYZ = function (args) {
+        var _a = xyz2rgbLinear([args[0], args[1], args[2]]), r = _a[0], g = _a[1], b = _a[2];
+        return [
+            clamp(Math.round(r * 255), 0, 255),
+            clamp(Math.round(g * 255), 0, 255),
+            clamp(Math.round(b * 255), 0, 255),
+            args[3]
+        ];
+    };
+
+    /**
+     * Display-P3 related functions
+     */
+    /**
+     * Convert P3 Linear to xyz
+     *
+     * @param p3l
+     */
+    var p3LinearToXyz = function (p3l) {
+        return multiplyMatrices(
+        // eslint-disable-next-line prettier/prettier
+        [
+            0.4865709486482162, 0.26566769316909306, 0.1982172852343625, 0.2289745640697488, 0.6917385218365064,
+            0.079286914093745, 0.0, 0.04511338185890264, 1.043944368900976
+        ], p3l);
+    };
+    /**
+     * Convert XYZ to P3 Linear
+     *
+     * @param xyz
+     */
+    var xyzToP3Linear = function (xyz) {
+        return multiplyMatrices(
+        // eslint-disable-next-line prettier/prettier
+        [
+            2.493496911941425, -0.9313836179191239, -0.40271078445071684, -0.8294889695615747, 1.7626640603183463,
+            0.023624685841943577, 0.03584583024378447, -0.07617238926804182, 0.9568845240076872
+        ], xyz);
+    };
+    /**
+     * Convert P3 to P3 linear
+     *
+     * @param p3
+     */
+    var p32p3Linear = function (p3) {
+        return p3.map(function (c) {
+            var sign = c < 0 ? -1 : 1, abs = c * sign;
+            if (abs <= 0.04045) {
+                return c / 12.92;
+            }
+            // eslint-disable-next-line prettier/prettier
+            return sign * Math.pow(((c + 0.055) / 1.055), 2.4) || 0;
+        });
+    };
+    /**
+     * Convert P3 Linear to P3
+     *
+     * @param p3l
+     */
+    var p3Linear2p3 = function (p3l) {
+        return srgbLinear2rgb(p3l);
+    };
+    /**
+     * Convert P3 to XYZ
+     *
+     * @param args
+     */
+    var p3ToXYZ = function (args) {
+        var p3_linear = p32p3Linear([args[0], args[1], args[2]]);
+        return p3LinearToXyz([p3_linear[0], p3_linear[1], p3_linear[2]]);
+    };
+    /**
+     * Convert XYZ to P3
+     *
+     * @param args
+     */
+    var p3FromXYZ = function (args) {
+        var _a = p3Linear2p3(xyzToP3Linear([args[0], args[1], args[2]])), r = _a[0], g = _a[1], b = _a[2];
+        return [r, g, b, args[3]];
+    };
+    /**
+     * Convert P3 to SRGB and Pack
+     *
+     * @param args
+     */
+    var convertP3 = function (args) {
+        var xyz = p3ToXYZ([args[0], args[1], args[2]]);
+        return packXYZ([xyz[0], xyz[1], xyz[2], args[3]]);
+    };
+
+    /**
+     * A98-RGB related functions
+     */
+    /**
+     * Convert XYZ to a98 linear
+     *
+     * @param xyz
+     */
+    var xyz2a98Linear = function (xyz) {
+        return multiplyMatrices(
+        // eslint-disable-next-line prettier/prettier
+        [
+            2.0415879038107465, -0.5650069742788596, -0.34473135077832956, -0.9692436362808795, 1.8759675015077202,
+            0.04155505740717557, 0.013444280632031142, -0.11836239223101838, 1.0151749943912054
+        ], xyz);
+    };
+    /**
+     * Convert XYZ to a98 linear
+     *
+     * @param a98
+     */
+    var a98Linear2xyz = function (a98) {
+        return multiplyMatrices(
+        // eslint-disable-next-line prettier/prettier
+        [
+            0.5766690429101305, 0.1855582379065463, 0.1882286462349947, 0.29734497525053605, 0.6273635662554661,
+            0.0752914584939978, 0.02703136138641234, 0.07068885253582723, 0.9913375368376388
+        ], a98);
+    };
+    /**
+     * Convert A98 RGB to rgb linear
+     *
+     * @param rgb
+     */
+    var a982a98Linear = function (rgb) {
+        var mapped = rgb.map(function (c) {
+            var sign = c < 0 ? -1 : 1, abs = Math.abs(c);
+            return sign * Math.pow(abs, (563 / 256));
+        });
+        return [mapped[0], mapped[1], mapped[2]];
+    };
+    /**
+     * Convert A98 RGB Linear to A98
+     *
+     * @param rgb
+     */
+    var a98Linear2a98 = function (rgb) {
+        var mapped = rgb.map(function (c) {
+            var sign = c < 0 ? -1 : 1, abs = Math.abs(c);
+            return sign * Math.pow(abs, (256 / 563));
+        });
+        return [mapped[0], mapped[1], mapped[2]];
+    };
+    /**
+     * Convert XYZ to A98
+     *
+     * @param args
+     */
+    var a98FromXYZ = function (args) {
+        var _a = a98Linear2a98(xyz2a98Linear([args[0], args[1], args[2]])), r = _a[0], g = _a[1], b = _a[2];
+        return [r, g, b, args[3]];
+    };
+    /**
+     * Convert A98 to XYZ and Pack
+     *
+     * @param args
+     */
+    var convertA98rgb = function (args) {
+        var srgb_linear = xyz2rgbLinear(a98Linear2xyz(a982a98Linear([args[0], args[1], args[2]])));
+        return packSrgbLinear([srgb_linear[0], srgb_linear[1], srgb_linear[2], args[3]]);
+    };
+
+    /**
+     * Pro Photo related functions
+     */
+    /**
+     * Convert linear-light display-p3 to XYZ D65
+     *
+     * @param p3
+     */
+    var proPhotoLinearToXyz = function (p3) {
+        return multiplyMatrices(
+        // eslint-disable-next-line prettier/prettier
+        [
+            0.7977666449006423, 0.13518129740053308, 0.0313477341283922, 0.2880748288194013, 0.711835234241873,
+            0.00008993693872564, 0.0, 0.0, 0.8251046025104602
+        ], p3);
+    };
+    /**
+     * Convert XYZ D65 to linear-light display-p3
+     *
+     * @param xyz
+     */
+    var xyzToProPhotoLinear = function (xyz) {
+        return multiplyMatrices(
+        // eslint-disable-next-line prettier/prettier
+        [
+            1.3457868816471583, -0.25557208737979464, -0.05110186497554526, -0.5446307051249019, 1.5082477428451468,
+            0.02052744743642139, 0.0, 0.0, 1.2119675456389452
+        ], xyz);
+    };
+    /**
+     * Convert Pro-Photo to Pro-Photo Linear
+     *
+     * @param p3
+     */
+    var proPhotoToProPhotoLinear = function (p3) {
+        return p3.map(function (c) {
+            return c < 16 / 512 ? c / 16 : Math.pow(c, 1.8);
+        });
+    };
+    /**
+     * Convert Pro-Photo Linear to Pro-Photo
+     *
+     * @param p3
+     */
+    var proPhotoLinearToProPhoto = function (p3) {
+        return p3.map(function (c) {
+            return c > 1 / 512 ? Math.pow(c, (1 / 1.8)) : c * 16;
+        });
+    };
+    /**
+     * Convert Pro-Photo to XYZ
+     *
+     * @param args
+     */
+    var proPhotoToXYZ = function (args) {
+        var prophoto_linear = proPhotoToProPhotoLinear([args[0], args[1], args[2]]);
+        return d50toD65(proPhotoLinearToXyz([prophoto_linear[0], prophoto_linear[1], prophoto_linear[2]]));
+    };
+    /**
+     * Convert XYZ to Pro-Photo
+     *
+     * @param args
+     */
+    var proPhotoFromXYZ = function (args) {
+        var _a = proPhotoLinearToProPhoto(xyzToProPhotoLinear(d65toD50([args[0], args[1], args[2]]))), r = _a[0], g = _a[1], b = _a[2];
+        return [r, g, b, args[3]];
+    };
+    /**
+     * Convert Pro-Photo to XYZ and Pack
+     *
+     * @param args
+     */
+    var convertProPhoto = function (args) {
+        var xyz = proPhotoToXYZ([args[0], args[1], args[2]]);
+        return packXYZ([xyz[0], xyz[1], xyz[2], args[3]]);
+    };
+
+    /**
+     * REC2020 related functions
+     */
+    var _a = 1.09929682680944;
+    var _b = 0.018053968510807;
+    /**
+     * Convert rec2020 to rec2020 linear
+     *
+     * @param rgb
+     */
+    var rec20202rec2020Linear = function (rgb) {
+        return rgb.map(function (c) {
+            return c < _b * 4.5 ? c / 4.5 : Math.pow((c + _a - 1) / _a, 1 / 0.45);
+        });
+    };
+    /**
+     * Convert rec2020 linear to rec2020
+     *
+     * @param rgb
+     */
+    var rec2020Linear2rec2020 = function (rgb) {
+        return rgb.map(function (c) {
+            return c >= _b ? _a * Math.pow(c, 0.45) - (_a - 1) : 4.5 * c;
+        });
+    };
+    /**
+     * Convert rec2020 linear to XYZ D65
+     *
+     * @param rec
+     */
+    var rec2020LinearToXyz = function (rec) {
+        return multiplyMatrices(
+        // eslint-disable-next-line prettier/prettier
+        [
+            0.6369580483012914, 0.14461690358620832, 0.1688809751641721, 0.2627002120112671, 0.6779980715188708,
+            0.05930171646986196, 0.0, 0.028072693049087428, 1.060985057710791
+        ], rec);
+    };
+    /**
+     * Convert XYZ D65 to rec2020 linear
+     *
+     * @param xyz
+     */
+    var xyzToRec2020Linear = function (xyz) {
+        return multiplyMatrices(
+        // eslint-disable-next-line prettier/prettier
+        [
+            1.716651187971268, -0.355670783776392, -0.25336628137366, -0.666684351832489, 1.616481236634939,
+            0.0157685458139111, 0.017639857445311, -0.042770613257809, 0.942103121235474
+        ], xyz);
+    };
+    /**
+     * Convert Rec2020 to XYZ
+     *
+     * @param args
+     */
+    var rec2020ToXYZ = function (args) {
+        var rec2020_linear = rec20202rec2020Linear([args[0], args[1], args[2]]);
+        return rec2020LinearToXyz([rec2020_linear[0], rec2020_linear[1], rec2020_linear[2]]);
+    };
+    /**
+     * Convert XYZ to Rec2020
+     *
+     * @param args
+     */
+    var rec2020FromXYZ = function (args) {
+        var _c = rec2020Linear2rec2020(xyzToRec2020Linear([args[0], args[1], args[2]])), r = _c[0], g = _c[1], b = _c[2];
+        return [r, g, b, args[3]];
+    };
+    /**
+     * Convert Rec2020 to SRGB and Pack
+     *
+     * @param args
+     */
+    var convertRec2020 = function (args) {
+        var xyz = rec2020ToXYZ([args[0], args[1], args[2]]);
+        return packXYZ([xyz[0], xyz[1], xyz[2], args[3]]);
+    };
+
+    var color$1 = {
+        name: 'color',
+        parse: function (context, value) {
+            if (value.type === 18 /* TokenType.FUNCTION */) {
+                var colorFunction = SUPPORTED_COLOR_FUNCTIONS[value.name];
+                if (typeof colorFunction === 'undefined') {
+                    throw new Error("Attempting to parse an unsupported color function \"".concat(value.name, "\""));
+                }
+                return colorFunction(context, value.values);
+            }
+            if (value.type === 5 /* TokenType.HASH_TOKEN */) {
+                var _a = hash2rgb(value), r = _a[0], g = _a[1], b = _a[2], a = _a[3];
+                return pack(r, g, b, a);
+            }
+            if (value.type === 20 /* TokenType.IDENT_TOKEN */) {
+                var namedColor = COLORS[value.value.toUpperCase()];
+                if (typeof namedColor !== 'undefined') {
+                    return namedColor;
+                }
+            }
+            return COLORS.TRANSPARENT;
+        }
+    };
+    var hash2rgb = function (token) {
+        if (token.value.length === 3) {
+            var r = token.value.substring(0, 1);
+            var g = token.value.substring(1, 2);
+            var b = token.value.substring(2, 3);
+            return [parseInt(r + r, 16), parseInt(g + g, 16), parseInt(b + b, 16), 1];
+        }
+        if (token.value.length === 4) {
+            var r = token.value.substring(0, 1);
+            var g = token.value.substring(1, 2);
+            var b = token.value.substring(2, 3);
+            var a = token.value.substring(3, 4);
+            return [parseInt(r + r, 16), parseInt(g + g, 16), parseInt(b + b, 16), parseInt(a + a, 16) / 255];
+        }
+        if (token.value.length === 6) {
+            var r = token.value.substring(0, 2);
+            var g = token.value.substring(2, 4);
+            var b = token.value.substring(4, 6);
+            return [parseInt(r, 16), parseInt(g, 16), parseInt(b, 16), 1];
+        }
+        if (token.value.length === 8) {
+            var r = token.value.substring(0, 2);
+            var g = token.value.substring(2, 4);
+            var b = token.value.substring(4, 6);
+            var a = token.value.substring(6, 8);
+            return [parseInt(r, 16), parseInt(g, 16), parseInt(b, 16), parseInt(a, 16) / 255];
+        }
+        return [0, 0, 0, 1];
+    };
+    var rgb = function (_context, args) {
+        var tokens = args.filter(nonFunctionArgSeparator);
+        if (isRelativeTransform(tokens)) {
+            throw new Error('Relative color not supported for rgb()');
+        }
+        if (tokens.length === 3) {
+            var _a = tokens.map(getTokenColorValue), r = _a[0], g = _a[1], b = _a[2];
+            return pack(r, g, b, 1);
+        }
+        if (tokens.length === 4) {
+            var _b = tokens.map(getTokenColorValue), r = _b[0], g = _b[1], b = _b[2], a = _b[3];
+            return pack(r, g, b, a);
+        }
+        return 0;
+    };
+    /**
+     * Handle the CSS color() function
+     *
+     * @param context
+     * @param args
+     */
+    var _color = function (context, args) {
+        var tokens = args.filter(nonFunctionArgSeparator), token_1_value = tokens[0].type === 20 /* TokenType.IDENT_TOKEN */ ? tokens[0].value : 'unknown', is_absolute = !isRelativeTransform(tokens);
+        if (is_absolute) {
+            var color_space = token_1_value, colorSpaceFunction = SUPPORTED_COLOR_SPACES_ABSOLUTE[color_space];
+            if (typeof colorSpaceFunction === 'undefined') {
+                throw new Error("Attempting to parse an unsupported color space \"".concat(color_space, "\" for color() function"));
+            }
+            var c1 = isNumberToken(tokens[1]) ? tokens[1].number : 0, c2 = isNumberToken(tokens[2]) ? tokens[2].number : 0, c3 = isNumberToken(tokens[3]) ? tokens[3].number : 0, a = tokens.length > 4 &&
+                tokens[4].type === 6 /* TokenType.DELIM_TOKEN */ &&
+                tokens[4].value === '/' &&
+                isNumberToken(tokens[5])
+                ? tokens[5].number
+                : 1;
+            return colorSpaceFunction([c1, c2, c3, a]);
         }
-        var t2 = l <= 0.5 ? l * (s + 1) : l + s - l * s;
-        var t1 = l * 2 - t2;
-        var r = hue2rgb(t1, t2, h + 1 / 3);
-        var g = hue2rgb(t1, t2, h);
-        var b = hue2rgb(t1, t2, h - 1 / 3);
-        return pack(r * 255, g * 255, b * 255, a);
+        else {
+            var extractComponent = function (color, token) {
+                if (isNumberToken(token)) {
+                    return token.number;
+                }
+                var posFromVal = function (value) {
+                    return value === 'r' || value === 'x' ? 0 : value === 'g' || value === 'y' ? 1 : 2;
+                };
+                if (isIdentToken(token)) {
+                    var position = posFromVal(token.value);
+                    return color[position];
+                }
+                var parseCalc = function (args) {
+                    var parts = args.filter(nonFunctionArgSeparator);
+                    var expression = '(';
+                    for (var _i = 0, parts_1 = parts; _i < parts_1.length; _i++) {
+                        var part = parts_1[_i];
+                        expression +=
+                            part.type === 18 /* TokenType.FUNCTION */ && part.name === 'calc'
+                                ? parseCalc(part.values)
+                                : isNumberToken(part)
+                                    ? part.number
+                                    : part.type === 6 /* TokenType.DELIM_TOKEN */ || isIdentToken(part)
+                                        ? part.value
+                                        : '';
+                    }
+                    expression += ')';
+                    return expression;
+                };
+                if (token.type === 18 /* TokenType.FUNCTION */) {
+                    var args_1 = token.values.filter(nonFunctionArgSeparator);
+                    if (token.name === 'calc') {
+                        var expression = parseCalc(args_1)
+                            .replace(/r|x/, color[0].toString())
+                            .replace(/g|y/, color[1].toString())
+                            .replace(/b|z/, color[2].toString());
+                        return new Function('return ' + expression)();
+                    }
+                }
+                return null;
+            };
+            var from_colorspace = tokens[1].type === 18 /* TokenType.FUNCTION */
+                ? tokens[1].name
+                : isIdentToken(tokens[1]) || tokens[1].type === 5 /* TokenType.HASH_TOKEN */
+                    ? 'rgb'
+                    : 'unknown', to_colorspace = isIdentToken(tokens[2]) ? tokens[2].value : 'unknown';
+            var from = tokens[1].type === 18 /* TokenType.FUNCTION */ ? tokens[1].values : isIdentToken(tokens[1]) ? [tokens[1]] : [];
+            if (isIdentToken(tokens[1])) {
+                var named_color = COLORS[tokens[1].value.toUpperCase()];
+                if (typeof named_color === 'undefined') {
+                    throw new Error("Attempting to use unknown color in relative color 'from'");
+                }
+                else {
+                    var _c = parseColor(context, tokens[1].value), alpha = 0xff & _c, blue = 0xff & (_c >> 8), green = 0xff & (_c >> 16), red = 0xff & (_c >> 24);
+                    from = [
+                        { type: 17 /* TokenType.NUMBER_TOKEN */, number: red, flags: 1 },
+                        { type: 17 /* TokenType.NUMBER_TOKEN */, number: green, flags: 1 },
+                        { type: 17 /* TokenType.NUMBER_TOKEN */, number: blue, flags: 1 },
+                        { type: 17 /* TokenType.NUMBER_TOKEN */, number: alpha > 1 ? alpha / 255 : alpha, flags: 1 }
+                    ];
+                }
+            }
+            else if (tokens[1].type === 5 /* TokenType.HASH_TOKEN */) {
+                var _a = hash2rgb(tokens[1]), red = _a[0], green = _a[1], blue = _a[2], alpha = _a[3];
+                from = [
+                    { type: 17 /* TokenType.NUMBER_TOKEN */, number: red, flags: 1 },
+                    { type: 17 /* TokenType.NUMBER_TOKEN */, number: green, flags: 1 },
+                    { type: 17 /* TokenType.NUMBER_TOKEN */, number: blue, flags: 1 },
+                    { type: 17 /* TokenType.NUMBER_TOKEN */, number: alpha > 1 ? alpha / 255 : alpha, flags: 1 }
+                ];
+            }
+            if (from.length === 0) {
+                throw new Error("Attempting to use unknown color in relative color 'from'");
+            }
+            if (to_colorspace === 'unknown') {
+                throw new Error("Attempting to use unknown colorspace in relative color 'to'");
+            }
+            var fromColorToXyz = SUPPORTED_COLOR_SPACES_TO_XYZ[from_colorspace], toColorFromXyz = SUPPORTED_COLOR_SPACES_FROM_XYZ[to_colorspace], toColorPack = SUPPORTED_COLOR_SPACES_ABSOLUTE[to_colorspace];
+            if (typeof fromColorToXyz === 'undefined') {
+                throw new Error("Attempting to parse an unsupported color space \"".concat(from_colorspace, "\" for color() function"));
+            }
+            if (typeof toColorFromXyz === 'undefined') {
+                throw new Error("Attempting to parse an unsupported color space \"".concat(to_colorspace, "\" for color() function"));
+            }
+            var from_color = fromColorToXyz(context, from), from_final_colorspace = toColorFromXyz(from_color), c1 = extractComponent(from_final_colorspace, tokens[3]), c2 = extractComponent(from_final_colorspace, tokens[4]), c3 = extractComponent(from_final_colorspace, tokens[5]), a = tokens.length > 6 &&
+                tokens[6].type === 6 /* TokenType.DELIM_TOKEN */ &&
+                tokens[6].value === '/' &&
+                isNumberToken(tokens[7])
+                ? tokens[7].number
+                : 1;
+            if (c1 === null || c2 === null || c3 === null) {
+                throw new Error("Invalid relative color in color() function");
+            }
+            return toColorPack([c1, c2, c3, a]);
+        }
+    };
+    var SUPPORTED_COLOR_SPACES_ABSOLUTE = {
+        srgb: packSrgb,
+        'srgb-linear': packSrgbLinear,
+        'display-p3': convertP3,
+        'a98-rgb': convertA98rgb,
+        'prophoto-rgb': convertProPhoto,
+        xyz: convertXyz,
+        'xyz-d50': convertXyz50,
+        'xyz-d65': convertXyz,
+        rec2020: convertRec2020
+    };
+    var SUPPORTED_COLOR_SPACES_TO_XYZ = {
+        rgb: rgbToXyz,
+        hsl: hslToXyz,
+        lab: labToXyz,
+        lch: lchToXyz,
+        oklab: oklabToXyz,
+        oklch: oklchToXyz
+    };
+    var SUPPORTED_COLOR_SPACES_FROM_XYZ = {
+        srgb: srgbFromXYZ,
+        'srgb-linear': srgbLinearFromXYZ,
+        'display-p3': p3FromXYZ,
+        'a98-rgb': a98FromXYZ,
+        'prophoto-rgb': proPhotoFromXYZ,
+        xyz: xyzFromXYZ,
+        'xyz-d50': xyz50FromXYZ,
+        'xyz-d65': xyzFromXYZ,
+        rec2020: rec2020FromXYZ
     };
     var SUPPORTED_COLOR_FUNCTIONS = {
-        hsl: hsl,
-        hsla: hsl,
+        hsl: packHSL,
+        hsla: packHSL,
         rgb: rgb,
-        rgba: rgb
+        rgba: rgb,
+        lch: packLch,
+        oklch: packOkLch,
+        oklab: packOkLab,
+        lab: packLab,
+        color: _color
     };
     var parseColor = function (context, value) {
         return color$1.parse(context, Parser.create(value).parseComponentValue());
@@ -2135,18 +2956,18 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         name: 'background-clip',
         initialValue: 'border-box',
         prefix: false,
-        type: 1 /* LIST */,
+        type: 1 /* PropertyDescriptorParsingType.LIST */,
         parse: function (_context, tokens) {
             return tokens.map(function (token) {
                 if (isIdentToken(token)) {
                     switch (token.value) {
                         case 'padding-box':
-                            return 1 /* PADDING_BOX */;
+                            return 1 /* BACKGROUND_CLIP.PADDING_BOX */;
                         case 'content-box':
-                            return 2 /* CONTENT_BOX */;
+                            return 2 /* BACKGROUND_CLIP.CONTENT_BOX */;
                     }
                 }
-                return 0 /* BORDER_BOX */;
+                return 0 /* BACKGROUND_CLIP.BORDER_BOX */;
             });
         }
     };
@@ -2155,7 +2976,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         name: "background-color",
         initialValue: 'transparent',
         prefix: false,
-        type: 3 /* TYPE_VALUE */,
+        type: 3 /* PropertyDescriptorParsingType.TYPE_VALUE */,
         format: 'color'
     };
 
@@ -2258,24 +3079,24 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         var rx = 0;
         var ry = 0;
         switch (gradient.size) {
-            case 0 /* CLOSEST_SIDE */:
+            case 0 /* CSSRadialExtent.CLOSEST_SIDE */:
                 // The ending shape is sized so that that it exactly meets the side of the gradient box closest to the gradient’s center.
                 // If the shape is an ellipse, it exactly meets the closest side in each dimension.
-                if (gradient.shape === 0 /* CIRCLE */) {
+                if (gradient.shape === 0 /* CSSRadialShape.CIRCLE */) {
                     rx = ry = Math.min(Math.abs(x), Math.abs(x - width), Math.abs(y), Math.abs(y - height));
                 }
-                else if (gradient.shape === 1 /* ELLIPSE */) {
+                else if (gradient.shape === 1 /* CSSRadialShape.ELLIPSE */) {
                     rx = Math.min(Math.abs(x), Math.abs(x - width));
                     ry = Math.min(Math.abs(y), Math.abs(y - height));
                 }
                 break;
-            case 2 /* CLOSEST_CORNER */:
+            case 2 /* CSSRadialExtent.CLOSEST_CORNER */:
                 // The ending shape is sized so that that it passes through the corner of the gradient box closest to the gradient’s center.
                 // If the shape is an ellipse, the ending shape is given the same aspect-ratio it would have if closest-side were specified.
-                if (gradient.shape === 0 /* CIRCLE */) {
+                if (gradient.shape === 0 /* CSSRadialShape.CIRCLE */) {
                     rx = ry = Math.min(distance(x, y), distance(x, y - height), distance(x - width, y), distance(x - width, y - height));
                 }
-                else if (gradient.shape === 1 /* ELLIPSE */) {
+                else if (gradient.shape === 1 /* CSSRadialShape.ELLIPSE */) {
                     // Compute the ratio ry/rx (which is to be the same as for "closest-side")
                     var c = Math.min(Math.abs(y), Math.abs(y - height)) / Math.min(Math.abs(x), Math.abs(x - width));
                     var _a = findCorner(width, height, x, y, true), cx = _a[0], cy = _a[1];
@@ -2283,23 +3104,23 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                     ry = c * rx;
                 }
                 break;
-            case 1 /* FARTHEST_SIDE */:
+            case 1 /* CSSRadialExtent.FARTHEST_SIDE */:
                 // Same as closest-side, except the ending shape is sized based on the farthest side(s)
-                if (gradient.shape === 0 /* CIRCLE */) {
+                if (gradient.shape === 0 /* CSSRadialShape.CIRCLE */) {
                     rx = ry = Math.max(Math.abs(x), Math.abs(x - width), Math.abs(y), Math.abs(y - height));
                 }
-                else if (gradient.shape === 1 /* ELLIPSE */) {
+                else if (gradient.shape === 1 /* CSSRadialShape.ELLIPSE */) {
                     rx = Math.max(Math.abs(x), Math.abs(x - width));
                     ry = Math.max(Math.abs(y), Math.abs(y - height));
                 }
                 break;
-            case 3 /* FARTHEST_CORNER */:
+            case 3 /* CSSRadialExtent.FARTHEST_CORNER */:
                 // Same as closest-corner, except the ending shape is sized based on the farthest corner.
                 // If the shape is an ellipse, the ending shape is given the same aspect ratio it would have if farthest-side were specified.
-                if (gradient.shape === 0 /* CIRCLE */) {
+                if (gradient.shape === 0 /* CSSRadialShape.CIRCLE */) {
                     rx = ry = Math.max(distance(x, y), distance(x, y - height), distance(x - width, y), distance(x - width, y - height));
                 }
-                else if (gradient.shape === 1 /* ELLIPSE */) {
+                else if (gradient.shape === 1 /* CSSRadialShape.ELLIPSE */) {
                     // Compute the ratio ry/rx (which is to be the same as for "farthest-side")
                     var c = Math.max(Math.abs(y), Math.abs(y - height)) / Math.max(Math.abs(x), Math.abs(x - width));
                     var _b = findCorner(width, height, x, y, false), cx = _b[0], cy = _b[1];
@@ -2321,7 +3142,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         parseFunctionArgs(tokens).forEach(function (arg, i) {
             if (i === 0) {
                 var firstToken = arg[0];
-                if (firstToken.type === 20 /* IDENT_TOKEN */ && firstToken.value === 'to') {
+                if (firstToken.type === 20 /* TokenType.IDENT_TOKEN */ && firstToken.value === 'to') {
                     angle$1 = parseNamedSide(arg);
                     return;
                 }
@@ -2333,7 +3154,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
             var colorStop = parseColorStop(context, arg);
             stops.push(colorStop);
         });
-        return { angle: angle$1, stops: stops, type: 1 /* LINEAR_GRADIENT */ };
+        return { angle: angle$1, stops: stops, type: 1 /* CSSImageType.LINEAR_GRADIENT */ };
     };
 
     var prefixLinearGradient = function (context, tokens) {
@@ -2342,7 +3163,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         parseFunctionArgs(tokens).forEach(function (arg, i) {
             if (i === 0) {
                 var firstToken = arg[0];
-                if (firstToken.type === 20 /* IDENT_TOKEN */ &&
+                if (firstToken.type === 20 /* TokenType.IDENT_TOKEN */ &&
                     ['top', 'left', 'right', 'bottom'].indexOf(firstToken.value) !== -1) {
                     angle$1 = parseNamedSide(arg);
                     return;
@@ -2358,30 +3179,30 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         return {
             angle: angle$1,
             stops: stops,
-            type: 1 /* LINEAR_GRADIENT */
+            type: 1 /* CSSImageType.LINEAR_GRADIENT */
         };
     };
 
     var webkitGradient = function (context, tokens) {
         var angle = deg(180);
         var stops = [];
-        var type = 1 /* LINEAR_GRADIENT */;
-        var shape = 0 /* CIRCLE */;
-        var size = 3 /* FARTHEST_CORNER */;
+        var type = 1 /* CSSImageType.LINEAR_GRADIENT */;
+        var shape = 0 /* CSSRadialShape.CIRCLE */;
+        var size = 3 /* CSSRadialExtent.FARTHEST_CORNER */;
         var position = [];
         parseFunctionArgs(tokens).forEach(function (arg, i) {
             var firstToken = arg[0];
             if (i === 0) {
                 if (isIdentToken(firstToken) && firstToken.value === 'linear') {
-                    type = 1 /* LINEAR_GRADIENT */;
+                    type = 1 /* CSSImageType.LINEAR_GRADIENT */;
                     return;
                 }
                 else if (isIdentToken(firstToken) && firstToken.value === 'radial') {
-                    type = 2 /* RADIAL_GRADIENT */;
+                    type = 2 /* CSSImageType.RADIAL_GRADIENT */;
                     return;
                 }
             }
-            if (firstToken.type === 18 /* FUNCTION */) {
+            if (firstToken.type === 18 /* TokenType.FUNCTION */) {
                 if (firstToken.name === 'from') {
                     var color = color$1.parse(context, firstToken.values[0]);
                     stops.push({ stop: ZERO_LENGTH, color: color });
@@ -2397,7 +3218,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                         var stop_1 = values[0];
                         if (isNumberToken(stop_1)) {
                             stops.push({
-                                stop: { type: 16 /* PERCENTAGE_TOKEN */, number: stop_1.number * 100, flags: stop_1.flags },
+                                stop: { type: 16 /* TokenType.PERCENTAGE_TOKEN */, number: stop_1.number * 100, flags: stop_1.flags },
                                 color: color
                             });
                         }
@@ -2405,7 +3226,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                 }
             }
         });
-        return type === 1 /* LINEAR_GRADIENT */
+        return type === 1 /* CSSImageType.LINEAR_GRADIENT */
             ? {
                 angle: (angle + deg(180)) % deg(360),
                 stops: stops,
@@ -2423,8 +3244,8 @@ var html2canvas = createCommonjsModule(function (module, exports) {
     var COVER = 'cover';
     var CONTAIN = 'contain';
     var radialGradient = function (context, tokens) {
-        var shape = 0 /* CIRCLE */;
-        var size = 3 /* FARTHEST_CORNER */;
+        var shape = 0 /* CSSRadialShape.CIRCLE */;
+        var size = 3 /* CSSRadialExtent.FARTHEST_CORNER */;
         var stops = [];
         var position = [];
         parseFunctionArgs(tokens).forEach(function (arg, i) {
@@ -2455,27 +3276,27 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                     else if (isIdentToken(token)) {
                         switch (token.value) {
                             case CIRCLE:
-                                shape = 0 /* CIRCLE */;
+                                shape = 0 /* CSSRadialShape.CIRCLE */;
                                 return false;
                             case ELLIPSE:
-                                shape = 1 /* ELLIPSE */;
+                                shape = 1 /* CSSRadialShape.ELLIPSE */;
                                 return false;
                             case 'at':
                                 isAtPosition_1 = true;
                                 return false;
                             case CLOSEST_SIDE:
-                                size = 0 /* CLOSEST_SIDE */;
+                                size = 0 /* CSSRadialExtent.CLOSEST_SIDE */;
                                 return false;
                             case COVER:
                             case FARTHEST_SIDE:
-                                size = 1 /* FARTHEST_SIDE */;
+                                size = 1 /* CSSRadialExtent.FARTHEST_SIDE */;
                                 return false;
                             case CONTAIN:
                             case CLOSEST_CORNER:
-                                size = 2 /* CLOSEST_CORNER */;
+                                size = 2 /* CSSRadialExtent.CLOSEST_CORNER */;
                                 return false;
                             case FARTHEST_CORNER:
-                                size = 3 /* FARTHEST_CORNER */;
+                                size = 3 /* CSSRadialExtent.FARTHEST_CORNER */;
                                 return false;
                         }
                     }
@@ -2494,12 +3315,12 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                 stops.push(colorStop);
             }
         });
-        return { size: size, shape: shape, stops: stops, position: position, type: 2 /* RADIAL_GRADIENT */ };
+        return { size: size, shape: shape, stops: stops, position: position, type: 2 /* CSSImageType.RADIAL_GRADIENT */ };
     };
 
     var prefixRadialGradient = function (context, tokens) {
-        var shape = 0 /* CIRCLE */;
-        var size = 3 /* FARTHEST_CORNER */;
+        var shape = 0 /* CSSRadialShape.CIRCLE */;
+        var size = 3 /* CSSRadialExtent.FARTHEST_CORNER */;
         var stops = [];
         var position = [];
         parseFunctionArgs(tokens).forEach(function (arg, i) {
@@ -2533,24 +3354,24 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                     if (isIdentToken(token)) {
                         switch (token.value) {
                             case CIRCLE:
-                                shape = 0 /* CIRCLE */;
+                                shape = 0 /* CSSRadialShape.CIRCLE */;
                                 return false;
                             case ELLIPSE:
-                                shape = 1 /* ELLIPSE */;
+                                shape = 1 /* CSSRadialShape.ELLIPSE */;
                                 return false;
                             case CONTAIN:
                             case CLOSEST_SIDE:
-                                size = 0 /* CLOSEST_SIDE */;
+                                size = 0 /* CSSRadialExtent.CLOSEST_SIDE */;
                                 return false;
                             case FARTHEST_SIDE:
-                                size = 1 /* FARTHEST_SIDE */;
+                                size = 1 /* CSSRadialExtent.FARTHEST_SIDE */;
                                 return false;
                             case CLOSEST_CORNER:
-                                size = 2 /* CLOSEST_CORNER */;
+                                size = 2 /* CSSRadialExtent.CLOSEST_CORNER */;
                                 return false;
                             case COVER:
                             case FARTHEST_CORNER:
-                                size = 3 /* FARTHEST_CORNER */;
+                                size = 3 /* CSSRadialExtent.FARTHEST_CORNER */;
                                 return false;
                         }
                     }
@@ -2569,36 +3390,36 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                 stops.push(colorStop);
             }
         });
-        return { size: size, shape: shape, stops: stops, position: position, type: 2 /* RADIAL_GRADIENT */ };
+        return { size: size, shape: shape, stops: stops, position: position, type: 2 /* CSSImageType.RADIAL_GRADIENT */ };
     };
 
     var isLinearGradient = function (background) {
-        return background.type === 1 /* LINEAR_GRADIENT */;
+        return background.type === 1 /* CSSImageType.LINEAR_GRADIENT */;
     };
     var isRadialGradient = function (background) {
-        return background.type === 2 /* RADIAL_GRADIENT */;
+        return background.type === 2 /* CSSImageType.RADIAL_GRADIENT */;
     };
     var image = {
         name: 'image',
         parse: function (context, value) {
-            if (value.type === 22 /* URL_TOKEN */) {
-                var image_1 = { url: value.value, type: 0 /* URL */ };
+            if (value.type === 22 /* TokenType.URL_TOKEN */) {
+                var image_1 = { url: value.value, type: 0 /* CSSImageType.URL */ };
                 context.cache.addImage(value.value);
                 return image_1;
             }
-            if (value.type === 18 /* FUNCTION */) {
+            if (value.type === 18 /* TokenType.FUNCTION */) {
                 var imageFunction = SUPPORTED_IMAGE_FUNCTIONS[value.name];
                 if (typeof imageFunction === 'undefined') {
-                    throw new Error("Attempting to parse an unsupported image function \"" + value.name + "\"");
+                    throw new Error("Attempting to parse an unsupported image function \"".concat(value.name, "\""));
                 }
                 return imageFunction(context, value.values);
             }
-            throw new Error("Unsupported image type " + value.type);
+            throw new Error("Unsupported image type ".concat(value.type));
         }
     };
     function isSupportedImage(value) {
-        return (!(value.type === 20 /* IDENT_TOKEN */ && value.value === 'none') &&
-            (value.type !== 18 /* FUNCTION */ || !!SUPPORTED_IMAGE_FUNCTIONS[value.name]));
+        return (!(value.type === 20 /* TokenType.IDENT_TOKEN */ && value.value === 'none') &&
+            (value.type !== 18 /* TokenType.FUNCTION */ || !!SUPPORTED_IMAGE_FUNCTIONS[value.name]));
     }
     var SUPPORTED_IMAGE_FUNCTIONS = {
         'linear-gradient': linearGradient,
@@ -2617,14 +3438,14 @@ var html2canvas = createCommonjsModule(function (module, exports) {
     var backgroundImage = {
         name: 'background-image',
         initialValue: 'none',
-        type: 1 /* LIST */,
+        type: 1 /* PropertyDescriptorParsingType.LIST */,
         prefix: false,
         parse: function (context, tokens) {
             if (tokens.length === 0) {
                 return [];
             }
             var first = tokens[0];
-            if (first.type === 20 /* IDENT_TOKEN */ && first.value === 'none') {
+            if (first.type === 20 /* TokenType.IDENT_TOKEN */ && first.value === 'none') {
                 return [];
             }
             return tokens
@@ -2637,18 +3458,18 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         name: 'background-origin',
         initialValue: 'border-box',
         prefix: false,
-        type: 1 /* LIST */,
+        type: 1 /* PropertyDescriptorParsingType.LIST */,
         parse: function (_context, tokens) {
             return tokens.map(function (token) {
                 if (isIdentToken(token)) {
                     switch (token.value) {
                         case 'padding-box':
-                            return 1 /* PADDING_BOX */;
+                            return 1 /* BACKGROUND_ORIGIN.PADDING_BOX */;
                         case 'content-box':
-                            return 2 /* CONTENT_BOX */;
+                            return 2 /* BACKGROUND_ORIGIN.CONTENT_BOX */;
                     }
                 }
-                return 0 /* BORDER_BOX */;
+                return 0 /* BACKGROUND_ORIGIN.BORDER_BOX */;
             });
         }
     };
@@ -2656,7 +3477,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
     var backgroundPosition = {
         name: 'background-position',
         initialValue: '0% 0%',
-        type: 1 /* LIST */,
+        type: 1 /* PropertyDescriptorParsingType.LIST */,
         prefix: false,
         parse: function (_context, tokens) {
             return parseFunctionArgs(tokens)
@@ -2669,7 +3490,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         name: 'background-repeat',
         initialValue: 'repeat',
         prefix: false,
-        type: 1 /* LIST */,
+        type: 1 /* PropertyDescriptorParsingType.LIST */,
         parse: function (_context, tokens) {
             return parseFunctionArgs(tokens)
                 .map(function (values) {
@@ -2684,16 +3505,16 @@ var html2canvas = createCommonjsModule(function (module, exports) {
     var parseBackgroundRepeat = function (value) {
         switch (value) {
             case 'no-repeat':
-                return 1 /* NO_REPEAT */;
+                return 1 /* BACKGROUND_REPEAT.NO_REPEAT */;
             case 'repeat-x':
             case 'repeat no-repeat':
-                return 2 /* REPEAT_X */;
+                return 2 /* BACKGROUND_REPEAT.REPEAT_X */;
             case 'repeat-y':
             case 'no-repeat repeat':
-                return 3 /* REPEAT_Y */;
+                return 3 /* BACKGROUND_REPEAT.REPEAT_Y */;
             case 'repeat':
             default:
-                return 0 /* REPEAT */;
+                return 0 /* BACKGROUND_REPEAT.REPEAT */;
         }
     };
 
@@ -2707,7 +3528,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         name: 'background-size',
         initialValue: '0',
         prefix: false,
-        type: 1 /* LIST */,
+        type: 1 /* PropertyDescriptorParsingType.LIST */,
         parse: function (_context, tokens) {
             return parseFunctionArgs(tokens).map(function (values) { return values.filter(isBackgroundSizeInfoToken); });
         }
@@ -2717,10 +3538,10 @@ var html2canvas = createCommonjsModule(function (module, exports) {
     };
 
     var borderColorForSide = function (side) { return ({
-        name: "border-" + side + "-color",
+        name: "border-".concat(side, "-color"),
         initialValue: 'transparent',
         prefix: false,
-        type: 3 /* TYPE_VALUE */,
+        type: 3 /* PropertyDescriptorParsingType.TYPE_VALUE */,
         format: 'color'
     }); };
     var borderTopColor = borderColorForSide('top');
@@ -2729,10 +3550,10 @@ var html2canvas = createCommonjsModule(function (module, exports) {
     var borderLeftColor = borderColorForSide('left');
 
     var borderRadiusForSide = function (side) { return ({
-        name: "border-radius-" + side,
+        name: "border-radius-".concat(side),
         initialValue: '0 0',
         prefix: false,
-        type: 1 /* LIST */,
+        type: 1 /* PropertyDescriptorParsingType.LIST */,
         parse: function (_context, tokens) {
             return parseLengthPercentageTuple(tokens.filter(isLengthPercentage));
         }
@@ -2743,22 +3564,22 @@ var html2canvas = createCommonjsModule(function (module, exports) {
     var borderBottomLeftRadius = borderRadiusForSide('bottom-left');
 
     var borderStyleForSide = function (side) { return ({
-        name: "border-" + side + "-style",
+        name: "border-".concat(side, "-style"),
         initialValue: 'solid',
         prefix: false,
-        type: 2 /* IDENT_VALUE */,
+        type: 2 /* PropertyDescriptorParsingType.IDENT_VALUE */,
         parse: function (_context, style) {
             switch (style) {
                 case 'none':
-                    return 0 /* NONE */;
+                    return 0 /* BORDER_STYLE.NONE */;
                 case 'dashed':
-                    return 2 /* DASHED */;
+                    return 2 /* BORDER_STYLE.DASHED */;
                 case 'dotted':
-                    return 3 /* DOTTED */;
+                    return 3 /* BORDER_STYLE.DOTTED */;
                 case 'double':
-                    return 4 /* DOUBLE */;
+                    return 4 /* BORDER_STYLE.DOUBLE */;
             }
-            return 1 /* SOLID */;
+            return 1 /* BORDER_STYLE.SOLID */;
         }
     }); };
     var borderTopStyle = borderStyleForSide('top');
@@ -2767,9 +3588,9 @@ var html2canvas = createCommonjsModule(function (module, exports) {
     var borderLeftStyle = borderStyleForSide('left');
 
     var borderWidthForSide = function (side) { return ({
-        name: "border-" + side + "-width",
+        name: "border-".concat(side, "-width"),
         initialValue: '0',
-        type: 0 /* VALUE */,
+        type: 0 /* PropertyDescriptorParsingType.VALUE */,
         prefix: false,
         parse: function (_context, token) {
             if (isDimensionToken(token)) {
@@ -2787,7 +3608,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         name: "color",
         initialValue: 'transparent',
         prefix: false,
-        type: 3 /* TYPE_VALUE */,
+        type: 3 /* PropertyDescriptorParsingType.TYPE_VALUE */,
         format: 'color'
     };
 
@@ -2795,14 +3616,14 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         name: 'direction',
         initialValue: 'ltr',
         prefix: false,
-        type: 2 /* IDENT_VALUE */,
+        type: 2 /* PropertyDescriptorParsingType.IDENT_VALUE */,
         parse: function (_context, direction) {
             switch (direction) {
                 case 'rtl':
-                    return 1 /* RTL */;
+                    return 1 /* DIRECTION.RTL */;
                 case 'ltr':
                 default:
-                    return 0 /* LTR */;
+                    return 0 /* DIRECTION.LTR */;
             }
         }
     };
@@ -2811,97 +3632,97 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         name: 'display',
         initialValue: 'inline-block',
         prefix: false,
-        type: 1 /* LIST */,
+        type: 1 /* PropertyDescriptorParsingType.LIST */,
         parse: function (_context, tokens) {
             return tokens.filter(isIdentToken).reduce(function (bit, token) {
-                return bit | parseDisplayValue(token.value);
-            }, 0 /* NONE */);
+                return bit | parseDisplayValue$1(token.value);
+            }, 0 /* DISPLAY.NONE */);
         }
     };
-    var parseDisplayValue = function (display) {
+    var parseDisplayValue$1 = function (display) {
         switch (display) {
             case 'block':
             case '-webkit-box':
-                return 2 /* BLOCK */;
+                return 2 /* DISPLAY.BLOCK */;
             case 'inline':
-                return 4 /* INLINE */;
+                return 4 /* DISPLAY.INLINE */;
             case 'run-in':
-                return 8 /* RUN_IN */;
+                return 8 /* DISPLAY.RUN_IN */;
             case 'flow':
-                return 16 /* FLOW */;
+                return 16 /* DISPLAY.FLOW */;
             case 'flow-root':
-                return 32 /* FLOW_ROOT */;
+                return 32 /* DISPLAY.FLOW_ROOT */;
             case 'table':
-                return 64 /* TABLE */;
+                return 64 /* DISPLAY.TABLE */;
             case 'flex':
             case '-webkit-flex':
-                return 128 /* FLEX */;
+                return 128 /* DISPLAY.FLEX */;
             case 'grid':
             case '-ms-grid':
-                return 256 /* GRID */;
+                return 256 /* DISPLAY.GRID */;
             case 'ruby':
-                return 512 /* RUBY */;
+                return 512 /* DISPLAY.RUBY */;
             case 'subgrid':
-                return 1024 /* SUBGRID */;
+                return 1024 /* DISPLAY.SUBGRID */;
             case 'list-item':
-                return 2048 /* LIST_ITEM */;
+                return 2048 /* DISPLAY.LIST_ITEM */;
             case 'table-row-group':
-                return 4096 /* TABLE_ROW_GROUP */;
+                return 4096 /* DISPLAY.TABLE_ROW_GROUP */;
             case 'table-header-group':
-                return 8192 /* TABLE_HEADER_GROUP */;
+                return 8192 /* DISPLAY.TABLE_HEADER_GROUP */;
             case 'table-footer-group':
-                return 16384 /* TABLE_FOOTER_GROUP */;
+                return 16384 /* DISPLAY.TABLE_FOOTER_GROUP */;
             case 'table-row':
-                return 32768 /* TABLE_ROW */;
+                return 32768 /* DISPLAY.TABLE_ROW */;
             case 'table-cell':
-                return 65536 /* TABLE_CELL */;
+                return 65536 /* DISPLAY.TABLE_CELL */;
             case 'table-column-group':
-                return 131072 /* TABLE_COLUMN_GROUP */;
+                return 131072 /* DISPLAY.TABLE_COLUMN_GROUP */;
             case 'table-column':
-                return 262144 /* TABLE_COLUMN */;
+                return 262144 /* DISPLAY.TABLE_COLUMN */;
             case 'table-caption':
-                return 524288 /* TABLE_CAPTION */;
+                return 524288 /* DISPLAY.TABLE_CAPTION */;
             case 'ruby-base':
-                return 1048576 /* RUBY_BASE */;
+                return 1048576 /* DISPLAY.RUBY_BASE */;
             case 'ruby-text':
-                return 2097152 /* RUBY_TEXT */;
+                return 2097152 /* DISPLAY.RUBY_TEXT */;
             case 'ruby-base-container':
-                return 4194304 /* RUBY_BASE_CONTAINER */;
+                return 4194304 /* DISPLAY.RUBY_BASE_CONTAINER */;
             case 'ruby-text-container':
-                return 8388608 /* RUBY_TEXT_CONTAINER */;
+                return 8388608 /* DISPLAY.RUBY_TEXT_CONTAINER */;
             case 'contents':
-                return 16777216 /* CONTENTS */;
+                return 16777216 /* DISPLAY.CONTENTS */;
             case 'inline-block':
-                return 33554432 /* INLINE_BLOCK */;
+                return 33554432 /* DISPLAY.INLINE_BLOCK */;
             case 'inline-list-item':
-                return 67108864 /* INLINE_LIST_ITEM */;
+                return 67108864 /* DISPLAY.INLINE_LIST_ITEM */;
             case 'inline-table':
-                return 134217728 /* INLINE_TABLE */;
+                return 134217728 /* DISPLAY.INLINE_TABLE */;
             case 'inline-flex':
-                return 268435456 /* INLINE_FLEX */;
+                return 268435456 /* DISPLAY.INLINE_FLEX */;
             case 'inline-grid':
-                return 536870912 /* INLINE_GRID */;
+                return 536870912 /* DISPLAY.INLINE_GRID */;
         }
-        return 0 /* NONE */;
+        return 0 /* DISPLAY.NONE */;
     };
 
     var float = {
         name: 'float',
         initialValue: 'none',
         prefix: false,
-        type: 2 /* IDENT_VALUE */,
+        type: 2 /* PropertyDescriptorParsingType.IDENT_VALUE */,
         parse: function (_context, float) {
             switch (float) {
                 case 'left':
-                    return 1 /* LEFT */;
+                    return 1 /* FLOAT.LEFT */;
                 case 'right':
-                    return 2 /* RIGHT */;
+                    return 2 /* FLOAT.RIGHT */;
                 case 'inline-start':
-                    return 3 /* INLINE_START */;
+                    return 3 /* FLOAT.INLINE_START */;
                 case 'inline-end':
-                    return 4 /* INLINE_END */;
+                    return 4 /* FLOAT.INLINE_END */;
             }
-            return 0 /* NONE */;
+            return 0 /* FLOAT.NONE */;
         }
     };
 
@@ -2909,15 +3730,15 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         name: 'letter-spacing',
         initialValue: '0',
         prefix: false,
-        type: 0 /* VALUE */,
+        type: 0 /* PropertyDescriptorParsingType.VALUE */,
         parse: function (_context, token) {
-            if (token.type === 20 /* IDENT_TOKEN */ && token.value === 'normal') {
+            if (token.type === 20 /* TokenType.IDENT_TOKEN */ && token.value === 'normal') {
                 return 0;
             }
-            if (token.type === 17 /* NUMBER_TOKEN */) {
+            if (token.type === 17 /* TokenType.NUMBER_TOKEN */) {
                 return token.number;
             }
-            if (token.type === 15 /* DIMENSION_TOKEN */) {
+            if (token.type === 15 /* TokenType.DIMENSION_TOKEN */) {
                 return token.number;
             }
             return 0;
@@ -2933,7 +3754,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         name: 'line-break',
         initialValue: 'normal',
         prefix: false,
-        type: 2 /* IDENT_VALUE */,
+        type: 2 /* PropertyDescriptorParsingType.IDENT_VALUE */,
         parse: function (_context, lineBreak) {
             switch (lineBreak) {
                 case 'strict':
@@ -2949,13 +3770,13 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         name: 'line-height',
         initialValue: 'normal',
         prefix: false,
-        type: 4 /* TOKEN_VALUE */
+        type: 4 /* PropertyDescriptorParsingType.TOKEN_VALUE */
     };
     var computeLineHeight = function (token, fontSize) {
         if (isIdentToken(token) && token.value === 'normal') {
             return 1.2 * fontSize;
         }
-        else if (token.type === 17 /* NUMBER_TOKEN */) {
+        else if (token.type === 17 /* TokenType.NUMBER_TOKEN */) {
             return fontSize * token.number;
         }
         else if (isLengthPercentage(token)) {
@@ -2967,10 +3788,10 @@ var html2canvas = createCommonjsModule(function (module, exports) {
     var listStyleImage = {
         name: 'list-style-image',
         initialValue: 'none',
-        type: 0 /* VALUE */,
+        type: 0 /* PropertyDescriptorParsingType.VALUE */,
         prefix: false,
         parse: function (context, token) {
-            if (token.type === 20 /* IDENT_TOKEN */ && token.value === 'none') {
+            if (token.type === 20 /* TokenType.IDENT_TOKEN */ && token.value === 'none') {
                 return null;
             }
             return image.parse(context, token);
@@ -2981,14 +3802,14 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         name: 'list-style-position',
         initialValue: 'outside',
         prefix: false,
-        type: 2 /* IDENT_VALUE */,
+        type: 2 /* PropertyDescriptorParsingType.IDENT_VALUE */,
         parse: function (_context, position) {
             switch (position) {
                 case 'inside':
-                    return 0 /* INSIDE */;
+                    return 0 /* LIST_STYLE_POSITION.INSIDE */;
                 case 'outside':
                 default:
-                    return 1 /* OUTSIDE */;
+                    return 1 /* LIST_STYLE_POSITION.OUTSIDE */;
             }
         }
     };
@@ -2997,127 +3818,127 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         name: 'list-style-type',
         initialValue: 'none',
         prefix: false,
-        type: 2 /* IDENT_VALUE */,
+        type: 2 /* PropertyDescriptorParsingType.IDENT_VALUE */,
         parse: function (_context, type) {
             switch (type) {
                 case 'disc':
-                    return 0 /* DISC */;
+                    return 0 /* LIST_STYLE_TYPE.DISC */;
                 case 'circle':
-                    return 1 /* CIRCLE */;
+                    return 1 /* LIST_STYLE_TYPE.CIRCLE */;
                 case 'square':
-                    return 2 /* SQUARE */;
+                    return 2 /* LIST_STYLE_TYPE.SQUARE */;
                 case 'decimal':
-                    return 3 /* DECIMAL */;
+                    return 3 /* LIST_STYLE_TYPE.DECIMAL */;
                 case 'cjk-decimal':
-                    return 4 /* CJK_DECIMAL */;
+                    return 4 /* LIST_STYLE_TYPE.CJK_DECIMAL */;
                 case 'decimal-leading-zero':
-                    return 5 /* DECIMAL_LEADING_ZERO */;
+                    return 5 /* LIST_STYLE_TYPE.DECIMAL_LEADING_ZERO */;
                 case 'lower-roman':
-                    return 6 /* LOWER_ROMAN */;
+                    return 6 /* LIST_STYLE_TYPE.LOWER_ROMAN */;
                 case 'upper-roman':
-                    return 7 /* UPPER_ROMAN */;
+                    return 7 /* LIST_STYLE_TYPE.UPPER_ROMAN */;
                 case 'lower-greek':
-                    return 8 /* LOWER_GREEK */;
+                    return 8 /* LIST_STYLE_TYPE.LOWER_GREEK */;
                 case 'lower-alpha':
-                    return 9 /* LOWER_ALPHA */;
+                    return 9 /* LIST_STYLE_TYPE.LOWER_ALPHA */;
                 case 'upper-alpha':
-                    return 10 /* UPPER_ALPHA */;
+                    return 10 /* LIST_STYLE_TYPE.UPPER_ALPHA */;
                 case 'arabic-indic':
-                    return 11 /* ARABIC_INDIC */;
+                    return 11 /* LIST_STYLE_TYPE.ARABIC_INDIC */;
                 case 'armenian':
-                    return 12 /* ARMENIAN */;
+                    return 12 /* LIST_STYLE_TYPE.ARMENIAN */;
                 case 'bengali':
-                    return 13 /* BENGALI */;
+                    return 13 /* LIST_STYLE_TYPE.BENGALI */;
                 case 'cambodian':
-                    return 14 /* CAMBODIAN */;
+                    return 14 /* LIST_STYLE_TYPE.CAMBODIAN */;
                 case 'cjk-earthly-branch':
-                    return 15 /* CJK_EARTHLY_BRANCH */;
+                    return 15 /* LIST_STYLE_TYPE.CJK_EARTHLY_BRANCH */;
                 case 'cjk-heavenly-stem':
-                    return 16 /* CJK_HEAVENLY_STEM */;
+                    return 16 /* LIST_STYLE_TYPE.CJK_HEAVENLY_STEM */;
                 case 'cjk-ideographic':
-                    return 17 /* CJK_IDEOGRAPHIC */;
+                    return 17 /* LIST_STYLE_TYPE.CJK_IDEOGRAPHIC */;
                 case 'devanagari':
-                    return 18 /* DEVANAGARI */;
+                    return 18 /* LIST_STYLE_TYPE.DEVANAGARI */;
                 case 'ethiopic-numeric':
-                    return 19 /* ETHIOPIC_NUMERIC */;
+                    return 19 /* LIST_STYLE_TYPE.ETHIOPIC_NUMERIC */;
                 case 'georgian':
-                    return 20 /* GEORGIAN */;
+                    return 20 /* LIST_STYLE_TYPE.GEORGIAN */;
                 case 'gujarati':
-                    return 21 /* GUJARATI */;
+                    return 21 /* LIST_STYLE_TYPE.GUJARATI */;
                 case 'gurmukhi':
-                    return 22 /* GURMUKHI */;
+                    return 22 /* LIST_STYLE_TYPE.GURMUKHI */;
                 case 'hebrew':
-                    return 22 /* HEBREW */;
+                    return 22 /* LIST_STYLE_TYPE.HEBREW */;
                 case 'hiragana':
-                    return 23 /* HIRAGANA */;
+                    return 23 /* LIST_STYLE_TYPE.HIRAGANA */;
                 case 'hiragana-iroha':
-                    return 24 /* HIRAGANA_IROHA */;
+                    return 24 /* LIST_STYLE_TYPE.HIRAGANA_IROHA */;
                 case 'japanese-formal':
-                    return 25 /* JAPANESE_FORMAL */;
+                    return 25 /* LIST_STYLE_TYPE.JAPANESE_FORMAL */;
                 case 'japanese-informal':
-                    return 26 /* JAPANESE_INFORMAL */;
+                    return 26 /* LIST_STYLE_TYPE.JAPANESE_INFORMAL */;
                 case 'kannada':
-                    return 27 /* KANNADA */;
+                    return 27 /* LIST_STYLE_TYPE.KANNADA */;
                 case 'katakana':
-                    return 28 /* KATAKANA */;
+                    return 28 /* LIST_STYLE_TYPE.KATAKANA */;
                 case 'katakana-iroha':
-                    return 29 /* KATAKANA_IROHA */;
+                    return 29 /* LIST_STYLE_TYPE.KATAKANA_IROHA */;
                 case 'khmer':
-                    return 30 /* KHMER */;
+                    return 30 /* LIST_STYLE_TYPE.KHMER */;
                 case 'korean-hangul-formal':
-                    return 31 /* KOREAN_HANGUL_FORMAL */;
+                    return 31 /* LIST_STYLE_TYPE.KOREAN_HANGUL_FORMAL */;
                 case 'korean-hanja-formal':
-                    return 32 /* KOREAN_HANJA_FORMAL */;
+                    return 32 /* LIST_STYLE_TYPE.KOREAN_HANJA_FORMAL */;
                 case 'korean-hanja-informal':
-                    return 33 /* KOREAN_HANJA_INFORMAL */;
+                    return 33 /* LIST_STYLE_TYPE.KOREAN_HANJA_INFORMAL */;
                 case 'lao':
-                    return 34 /* LAO */;
+                    return 34 /* LIST_STYLE_TYPE.LAO */;
                 case 'lower-armenian':
-                    return 35 /* LOWER_ARMENIAN */;
+                    return 35 /* LIST_STYLE_TYPE.LOWER_ARMENIAN */;
                 case 'malayalam':
-                    return 36 /* MALAYALAM */;
+                    return 36 /* LIST_STYLE_TYPE.MALAYALAM */;
                 case 'mongolian':
-                    return 37 /* MONGOLIAN */;
+                    return 37 /* LIST_STYLE_TYPE.MONGOLIAN */;
                 case 'myanmar':
-                    return 38 /* MYANMAR */;
+                    return 38 /* LIST_STYLE_TYPE.MYANMAR */;
                 case 'oriya':
-                    return 39 /* ORIYA */;
+                    return 39 /* LIST_STYLE_TYPE.ORIYA */;
                 case 'persian':
-                    return 40 /* PERSIAN */;
+                    return 40 /* LIST_STYLE_TYPE.PERSIAN */;
                 case 'simp-chinese-formal':
-                    return 41 /* SIMP_CHINESE_FORMAL */;
+                    return 41 /* LIST_STYLE_TYPE.SIMP_CHINESE_FORMAL */;
                 case 'simp-chinese-informal':
-                    return 42 /* SIMP_CHINESE_INFORMAL */;
+                    return 42 /* LIST_STYLE_TYPE.SIMP_CHINESE_INFORMAL */;
                 case 'tamil':
-                    return 43 /* TAMIL */;
+                    return 43 /* LIST_STYLE_TYPE.TAMIL */;
                 case 'telugu':
-                    return 44 /* TELUGU */;
+                    return 44 /* LIST_STYLE_TYPE.TELUGU */;
                 case 'thai':
-                    return 45 /* THAI */;
+                    return 45 /* LIST_STYLE_TYPE.THAI */;
                 case 'tibetan':
-                    return 46 /* TIBETAN */;
+                    return 46 /* LIST_STYLE_TYPE.TIBETAN */;
                 case 'trad-chinese-formal':
-                    return 47 /* TRAD_CHINESE_FORMAL */;
+                    return 47 /* LIST_STYLE_TYPE.TRAD_CHINESE_FORMAL */;
                 case 'trad-chinese-informal':
-                    return 48 /* TRAD_CHINESE_INFORMAL */;
+                    return 48 /* LIST_STYLE_TYPE.TRAD_CHINESE_INFORMAL */;
                 case 'upper-armenian':
-                    return 49 /* UPPER_ARMENIAN */;
+                    return 49 /* LIST_STYLE_TYPE.UPPER_ARMENIAN */;
                 case 'disclosure-open':
-                    return 50 /* DISCLOSURE_OPEN */;
+                    return 50 /* LIST_STYLE_TYPE.DISCLOSURE_OPEN */;
                 case 'disclosure-closed':
-                    return 51 /* DISCLOSURE_CLOSED */;
+                    return 51 /* LIST_STYLE_TYPE.DISCLOSURE_CLOSED */;
                 case 'none':
                 default:
-                    return -1 /* NONE */;
+                    return -1 /* LIST_STYLE_TYPE.NONE */;
             }
         }
     };
 
     var marginForSide = function (side) { return ({
-        name: "margin-" + side,
+        name: "margin-".concat(side),
         initialValue: '0',
         prefix: false,
-        type: 4 /* TOKEN_VALUE */
+        type: 4 /* PropertyDescriptorParsingType.TOKEN_VALUE */
     }); };
     var marginTop = marginForSide('top');
     var marginRight = marginForSide('right');
@@ -3128,21 +3949,21 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         name: 'overflow',
         initialValue: 'visible',
         prefix: false,
-        type: 1 /* LIST */,
+        type: 1 /* PropertyDescriptorParsingType.LIST */,
         parse: function (_context, tokens) {
             return tokens.filter(isIdentToken).map(function (overflow) {
                 switch (overflow.value) {
                     case 'hidden':
-                        return 1 /* HIDDEN */;
+                        return 1 /* OVERFLOW.HIDDEN */;
                     case 'scroll':
-                        return 2 /* SCROLL */;
+                        return 2 /* OVERFLOW.SCROLL */;
                     case 'clip':
-                        return 3 /* CLIP */;
+                        return 3 /* OVERFLOW.CLIP */;
                     case 'auto':
-                        return 4 /* AUTO */;
+                        return 4 /* OVERFLOW.AUTO */;
                     case 'visible':
                     default:
-                        return 0 /* VISIBLE */;
+                        return 0 /* OVERFLOW.VISIBLE */;
                 }
             });
         }
@@ -3152,23 +3973,23 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         name: 'overflow-wrap',
         initialValue: 'normal',
         prefix: false,
-        type: 2 /* IDENT_VALUE */,
+        type: 2 /* PropertyDescriptorParsingType.IDENT_VALUE */,
         parse: function (_context, overflow) {
             switch (overflow) {
                 case 'break-word':
-                    return "break-word" /* BREAK_WORD */;
+                    return "break-word" /* OVERFLOW_WRAP.BREAK_WORD */;
                 case 'normal':
                 default:
-                    return "normal" /* NORMAL */;
+                    return "normal" /* OVERFLOW_WRAP.NORMAL */;
             }
         }
     };
 
     var paddingForSide = function (side) { return ({
-        name: "padding-" + side,
+        name: "padding-".concat(side),
         initialValue: '0',
         prefix: false,
-        type: 3 /* TYPE_VALUE */,
+        type: 3 /* PropertyDescriptorParsingType.TYPE_VALUE */,
         format: 'length-percentage'
     }); };
     var paddingTop = paddingForSide('top');
@@ -3180,17 +4001,17 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         name: 'text-align',
         initialValue: 'left',
         prefix: false,
-        type: 2 /* IDENT_VALUE */,
+        type: 2 /* PropertyDescriptorParsingType.IDENT_VALUE */,
         parse: function (_context, textAlign) {
             switch (textAlign) {
                 case 'right':
-                    return 2 /* RIGHT */;
+                    return 2 /* TEXT_ALIGN.RIGHT */;
                 case 'center':
                 case 'justify':
-                    return 1 /* CENTER */;
+                    return 1 /* TEXT_ALIGN.CENTER */;
                 case 'left':
                 default:
-                    return 0 /* LEFT */;
+                    return 0 /* TEXT_ALIGN.LEFT */;
             }
         }
     };
@@ -3199,26 +4020,26 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         name: 'position',
         initialValue: 'static',
         prefix: false,
-        type: 2 /* IDENT_VALUE */,
+        type: 2 /* PropertyDescriptorParsingType.IDENT_VALUE */,
         parse: function (_context, position) {
             switch (position) {
                 case 'relative':
-                    return 1 /* RELATIVE */;
+                    return 1 /* POSITION.RELATIVE */;
                 case 'absolute':
-                    return 2 /* ABSOLUTE */;
+                    return 2 /* POSITION.ABSOLUTE */;
                 case 'fixed':
-                    return 3 /* FIXED */;
+                    return 3 /* POSITION.FIXED */;
                 case 'sticky':
-                    return 4 /* STICKY */;
+                    return 4 /* POSITION.STICKY */;
             }
-            return 0 /* STATIC */;
+            return 0 /* POSITION.STATIC */;
         }
     };
 
     var textShadow = {
         name: 'text-shadow',
         initialValue: 'none',
-        type: 1 /* LIST */,
+        type: 1 /* PropertyDescriptorParsingType.LIST */,
         prefix: false,
         parse: function (context, tokens) {
             if (tokens.length === 1 && isIdentWithValue(tokens[0], 'none')) {
@@ -3259,17 +4080,17 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         name: 'text-transform',
         initialValue: 'none',
         prefix: false,
-        type: 2 /* IDENT_VALUE */,
+        type: 2 /* PropertyDescriptorParsingType.IDENT_VALUE */,
         parse: function (_context, textTransform) {
             switch (textTransform) {
                 case 'uppercase':
-                    return 2 /* UPPERCASE */;
+                    return 2 /* TEXT_TRANSFORM.UPPERCASE */;
                 case 'lowercase':
-                    return 1 /* LOWERCASE */;
+                    return 1 /* TEXT_TRANSFORM.LOWERCASE */;
                 case 'capitalize':
-                    return 3 /* CAPITALIZE */;
+                    return 3 /* TEXT_TRANSFORM.CAPITALIZE */;
             }
-            return 0 /* NONE */;
+            return 0 /* TEXT_TRANSFORM.NONE */;
         }
     };
 
@@ -3277,15 +4098,15 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         name: 'transform',
         initialValue: 'none',
         prefix: true,
-        type: 0 /* VALUE */,
+        type: 0 /* PropertyDescriptorParsingType.VALUE */,
         parse: function (_context, token) {
-            if (token.type === 20 /* IDENT_TOKEN */ && token.value === 'none') {
+            if (token.type === 20 /* TokenType.IDENT_TOKEN */ && token.value === 'none') {
                 return null;
             }
-            if (token.type === 18 /* FUNCTION */) {
+            if (token.type === 18 /* TokenType.FUNCTION */) {
                 var transformFunction = SUPPORTED_TRANSFORM_FUNCTIONS[token.name];
                 if (typeof transformFunction === 'undefined') {
-                    throw new Error("Attempting to parse an unsupported transform function \"" + token.name + "\"");
+                    throw new Error("Attempting to parse an unsupported transform function \"".concat(token.name, "\""));
                 }
                 return transformFunction(token.values);
             }
@@ -3293,12 +4114,12 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         }
     };
     var matrix = function (args) {
-        var values = args.filter(function (arg) { return arg.type === 17 /* NUMBER_TOKEN */; }).map(function (arg) { return arg.number; });
+        var values = args.filter(function (arg) { return arg.type === 17 /* TokenType.NUMBER_TOKEN */; }).map(function (arg) { return arg.number; });
         return values.length === 6 ? values : null;
     };
     // doesn't support 3D transforms at the moment
     var matrix3d = function (args) {
-        var values = args.filter(function (arg) { return arg.type === 17 /* NUMBER_TOKEN */; }).map(function (arg) { return arg.number; });
+        var values = args.filter(function (arg) { return arg.type === 17 /* TokenType.NUMBER_TOKEN */; }).map(function (arg) { return arg.number; });
         var a1 = values[0], b1 = values[1]; var a2 = values[4], b2 = values[5]; var a4 = values[12], b4 = values[13];        return values.length === 16 ? [a1, b1, a2, b2, a4, b4] : null;
     };
     var SUPPORTED_TRANSFORM_FUNCTIONS = {
@@ -3307,7 +4128,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
     };
 
     var DEFAULT_VALUE = {
-        type: 16 /* PERCENTAGE_TOKEN */,
+        type: 16 /* TokenType.PERCENTAGE_TOKEN */,
         number: 50,
         flags: FLAG_INTEGER
     };
@@ -3316,7 +4137,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         name: 'transform-origin',
         initialValue: '50% 50%',
         prefix: true,
-        type: 1 /* LIST */,
+        type: 1 /* PropertyDescriptorParsingType.LIST */,
         parse: function (_context, tokens) {
             var origins = tokens.filter(isLengthPercentage);
             if (origins.length !== 2) {
@@ -3330,16 +4151,16 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         name: 'visible',
         initialValue: 'none',
         prefix: false,
-        type: 2 /* IDENT_VALUE */,
+        type: 2 /* PropertyDescriptorParsingType.IDENT_VALUE */,
         parse: function (_context, visibility) {
             switch (visibility) {
                 case 'hidden':
-                    return 1 /* HIDDEN */;
+                    return 1 /* VISIBILITY.HIDDEN */;
                 case 'collapse':
-                    return 2 /* COLLAPSE */;
+                    return 2 /* VISIBILITY.COLLAPSE */;
                 case 'visible':
                 default:
-                    return 0 /* VISIBLE */;
+                    return 0 /* VISIBILITY.VISIBLE */;
             }
         }
     };
@@ -3354,7 +4175,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         name: 'word-break',
         initialValue: 'normal',
         prefix: false,
-        type: 2 /* IDENT_VALUE */,
+        type: 2 /* PropertyDescriptorParsingType.IDENT_VALUE */,
         parse: function (_context, wordBreak) {
             switch (wordBreak) {
                 case 'break-all':
@@ -3372,9 +4193,9 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         name: 'z-index',
         initialValue: 'auto',
         prefix: false,
-        type: 0 /* VALUE */,
+        type: 0 /* PropertyDescriptorParsingType.VALUE */,
         parse: function (_context, token) {
-            if (token.type === 20 /* IDENT_TOKEN */) {
+            if (token.type === 20 /* TokenType.IDENT_TOKEN */) {
                 return { auto: true, order: 0 };
             }
             if (isNumberToken(token)) {
@@ -3387,7 +4208,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
     var time = {
         name: 'time',
         parse: function (_context, value) {
-            if (value.type === 15 /* DIMENSION_TOKEN */) {
+            if (value.type === 15 /* TokenType.DIMENSION_TOKEN */) {
                 switch (value.unit.toLowerCase()) {
                     case 's':
                         return 1000 * value.number;
@@ -3402,7 +4223,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
     var opacity = {
         name: 'opacity',
         initialValue: '1',
-        type: 0 /* VALUE */,
+        type: 0 /* PropertyDescriptorParsingType.VALUE */,
         prefix: false,
         parse: function (_context, token) {
             if (isNumberToken(token)) {
@@ -3416,7 +4237,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         name: "text-decoration-color",
         initialValue: 'transparent',
         prefix: false,
-        type: 3 /* TYPE_VALUE */,
+        type: 3 /* PropertyDescriptorParsingType.TYPE_VALUE */,
         format: 'color'
     };
 
@@ -3424,24 +4245,24 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         name: 'text-decoration-line',
         initialValue: 'none',
         prefix: false,
-        type: 1 /* LIST */,
+        type: 1 /* PropertyDescriptorParsingType.LIST */,
         parse: function (_context, tokens) {
             return tokens
                 .filter(isIdentToken)
                 .map(function (token) {
                 switch (token.value) {
                     case 'underline':
-                        return 1 /* UNDERLINE */;
+                        return 1 /* TEXT_DECORATION_LINE.UNDERLINE */;
                     case 'overline':
-                        return 2 /* OVERLINE */;
+                        return 2 /* TEXT_DECORATION_LINE.OVERLINE */;
                     case 'line-through':
-                        return 3 /* LINE_THROUGH */;
+                        return 3 /* TEXT_DECORATION_LINE.LINE_THROUGH */;
                     case 'none':
-                        return 4 /* BLINK */;
+                        return 4 /* TEXT_DECORATION_LINE.BLINK */;
                 }
-                return 0 /* NONE */;
+                return 0 /* TEXT_DECORATION_LINE.NONE */;
             })
-                .filter(function (line) { return line !== 0 /* NONE */; });
+                .filter(function (line) { return line !== 0 /* TEXT_DECORATION_LINE.NONE */; });
         }
     };
 
@@ -3449,20 +4270,20 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         name: "font-family",
         initialValue: '',
         prefix: false,
-        type: 1 /* LIST */,
+        type: 1 /* PropertyDescriptorParsingType.LIST */,
         parse: function (_context, tokens) {
             var accumulator = [];
             var results = [];
             tokens.forEach(function (token) {
                 switch (token.type) {
-                    case 20 /* IDENT_TOKEN */:
-                    case 0 /* STRING_TOKEN */:
+                    case 20 /* TokenType.IDENT_TOKEN */:
+                    case 0 /* TokenType.STRING_TOKEN */:
                         accumulator.push(token.value);
                         break;
-                    case 17 /* NUMBER_TOKEN */:
+                    case 17 /* TokenType.NUMBER_TOKEN */:
                         accumulator.push(token.number.toString());
                         break;
-                    case 4 /* COMMA_TOKEN */:
+                    case 4 /* TokenType.COMMA_TOKEN */:
                         results.push(accumulator.join(' '));
                         accumulator.length = 0;
                         break;
@@ -3471,7 +4292,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
             if (accumulator.length) {
                 results.push(accumulator.join(' '));
             }
-            return results.map(function (result) { return (result.indexOf(' ') === -1 ? result : "'" + result + "'"); });
+            return results.map(function (result) { return (result.indexOf(' ') === -1 ? result : "'".concat(result, "'")); });
         }
     };
 
@@ -3479,14 +4300,14 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         name: "font-size",
         initialValue: '0',
         prefix: false,
-        type: 3 /* TYPE_VALUE */,
+        type: 3 /* PropertyDescriptorParsingType.TYPE_VALUE */,
         format: 'length'
     };
 
     var fontWeight = {
         name: 'font-weight',
         initialValue: 'normal',
-        type: 0 /* VALUE */,
+        type: 0 /* PropertyDescriptorParsingType.VALUE */,
         prefix: false,
         parse: function (_context, token) {
             if (isNumberToken(token)) {
@@ -3508,7 +4329,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
     var fontVariant = {
         name: 'font-variant',
         initialValue: 'none',
-        type: 1 /* LIST */,
+        type: 1 /* PropertyDescriptorParsingType.LIST */,
         prefix: false,
         parse: function (_context, tokens) {
             return tokens.filter(isIdentToken).map(function (token) { return token.value; });
@@ -3519,16 +4340,16 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         name: 'font-style',
         initialValue: 'normal',
         prefix: false,
-        type: 2 /* IDENT_VALUE */,
+        type: 2 /* PropertyDescriptorParsingType.IDENT_VALUE */,
         parse: function (_context, overflow) {
             switch (overflow) {
                 case 'oblique':
-                    return "oblique" /* OBLIQUE */;
+                    return "oblique" /* FONT_STYLE.OBLIQUE */;
                 case 'italic':
-                    return "italic" /* ITALIC */;
+                    return "italic" /* FONT_STYLE.ITALIC */;
                 case 'normal':
                 default:
-                    return "normal" /* NORMAL */;
+                    return "normal" /* FONT_STYLE.NORMAL */;
             }
         }
     };
@@ -3538,14 +4359,14 @@ var html2canvas = createCommonjsModule(function (module, exports) {
     var content = {
         name: 'content',
         initialValue: 'none',
-        type: 1 /* LIST */,
+        type: 1 /* PropertyDescriptorParsingType.LIST */,
         prefix: false,
         parse: function (_context, tokens) {
             if (tokens.length === 0) {
                 return [];
             }
             var first = tokens[0];
-            if (first.type === 20 /* IDENT_TOKEN */ && first.value === 'none') {
+            if (first.type === 20 /* TokenType.IDENT_TOKEN */ && first.value === 'none') {
                 return [];
             }
             return tokens;
@@ -3556,13 +4377,13 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         name: 'counter-increment',
         initialValue: 'none',
         prefix: true,
-        type: 1 /* LIST */,
+        type: 1 /* PropertyDescriptorParsingType.LIST */,
         parse: function (_context, tokens) {
             if (tokens.length === 0) {
                 return null;
             }
             var first = tokens[0];
-            if (first.type === 20 /* IDENT_TOKEN */ && first.value === 'none') {
+            if (first.type === 20 /* TokenType.IDENT_TOKEN */ && first.value === 'none') {
                 return null;
             }
             var increments = [];
@@ -3570,7 +4391,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
             for (var i = 0; i < filtered.length; i++) {
                 var counter = filtered[i];
                 var next = filtered[i + 1];
-                if (counter.type === 20 /* IDENT_TOKEN */) {
+                if (counter.type === 20 /* TokenType.IDENT_TOKEN */) {
                     var increment = next && isNumberToken(next) ? next.number : 1;
                     increments.push({ counter: counter.value, increment: increment });
                 }
@@ -3583,7 +4404,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         name: 'counter-reset',
         initialValue: 'none',
         prefix: true,
-        type: 1 /* LIST */,
+        type: 1 /* PropertyDescriptorParsingType.LIST */,
         parse: function (_context, tokens) {
             if (tokens.length === 0) {
                 return [];
@@ -3606,7 +4427,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         name: 'duration',
         initialValue: '0s',
         prefix: false,
-        type: 1 /* LIST */,
+        type: 1 /* PropertyDescriptorParsingType.LIST */,
         parse: function (context, tokens) {
             return tokens.filter(isDimensionToken).map(function (token) { return time.parse(context, token); });
         }
@@ -3616,13 +4437,13 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         name: 'quotes',
         initialValue: 'none',
         prefix: true,
-        type: 1 /* LIST */,
+        type: 1 /* PropertyDescriptorParsingType.LIST */,
         parse: function (_context, tokens) {
             if (tokens.length === 0) {
                 return null;
             }
             var first = tokens[0];
-            if (first.type === 20 /* IDENT_TOKEN */ && first.value === 'none') {
+            if (first.type === 20 /* TokenType.IDENT_TOKEN */ && first.value === 'none') {
                 return null;
             }
             var quotes = [];
@@ -3652,7 +4473,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
     var boxShadow = {
         name: 'box-shadow',
         initialValue: 'none',
-        type: 1 /* LIST */,
+        type: 1 /* PropertyDescriptorParsingType.LIST */,
         prefix: false,
         parse: function (context, tokens) {
             if (tokens.length === 1 && isIdentWithValue(tokens[0], 'none')) {
@@ -3701,20 +4522,20 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         name: 'paint-order',
         initialValue: 'normal',
         prefix: false,
-        type: 1 /* LIST */,
+        type: 1 /* PropertyDescriptorParsingType.LIST */,
         parse: function (_context, tokens) {
-            var DEFAULT_VALUE = [0 /* FILL */, 1 /* STROKE */, 2 /* MARKERS */];
+            var DEFAULT_VALUE = [0 /* PAINT_ORDER_LAYER.FILL */, 1 /* PAINT_ORDER_LAYER.STROKE */, 2 /* PAINT_ORDER_LAYER.MARKERS */];
             var layers = [];
             tokens.filter(isIdentToken).forEach(function (token) {
                 switch (token.value) {
                     case 'stroke':
-                        layers.push(1 /* STROKE */);
+                        layers.push(1 /* PAINT_ORDER_LAYER.STROKE */);
                         break;
                     case 'fill':
-                        layers.push(0 /* FILL */);
+                        layers.push(0 /* PAINT_ORDER_LAYER.FILL */);
                         break;
                     case 'markers':
-                        layers.push(2 /* MARKERS */);
+                        layers.push(2 /* PAINT_ORDER_LAYER.MARKERS */);
                         break;
                 }
             });
@@ -3731,14 +4552,14 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         name: "-webkit-text-stroke-color",
         initialValue: 'currentcolor',
         prefix: false,
-        type: 3 /* TYPE_VALUE */,
+        type: 3 /* PropertyDescriptorParsingType.TYPE_VALUE */,
         format: 'color'
     };
 
     var webkitTextStrokeWidth = {
         name: "-webkit-text-stroke-width",
         initialValue: '0',
-        type: 0 /* VALUE */,
+        type: 0 /* PropertyDescriptorParsingType.VALUE */,
         prefix: false,
         parse: function (_context, token) {
             if (isDimensionToken(token)) {
@@ -3748,6 +4569,31 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         }
     };
 
+    var objectFit = {
+        name: 'objectFit',
+        initialValue: 'fill',
+        prefix: false,
+        type: 1 /* PropertyDescriptorParsingType.LIST */,
+        parse: function (_context, tokens) {
+            return tokens.filter(isIdentToken).reduce(function (bit, token) {
+                return bit | parseDisplayValue(token.value);
+            }, 0 /* OBJECT_FIT.FILL */);
+        }
+    };
+    var parseDisplayValue = function (display) {
+        switch (display) {
+            case 'contain':
+                return 2 /* OBJECT_FIT.CONTAIN */;
+            case 'cover':
+                return 4 /* OBJECT_FIT.COVER */;
+            case 'none':
+                return 8 /* OBJECT_FIT.NONE */;
+            case 'scale-down':
+                return 16 /* OBJECT_FIT.SCALE_DOWN */;
+        }
+        return 0 /* OBJECT_FIT.FILL */;
+    };
+
     var CSSParsedDeclaration = /** @class */ (function () {
         function CSSParsedDeclaration(context, declaration) {
             var _a, _b;
@@ -3818,9 +4664,10 @@ var html2canvas = createCommonjsModule(function (module, exports) {
             this.webkitTextStrokeWidth = parse(context, webkitTextStrokeWidth, declaration.webkitTextStrokeWidth);
             this.wordBreak = parse(context, wordBreak, declaration.wordBreak);
             this.zIndex = parse(context, zIndex, declaration.zIndex);
+            this.objectFit = parse(context, objectFit, declaration.objectFit);
         }
         CSSParsedDeclaration.prototype.isVisible = function () {
-            return this.display > 0 && this.opacity > 0 && this.visibility === 0 /* VISIBLE */;
+            return this.display > 0 && this.opacity > 0 && this.visibility === 0 /* VISIBILITY.VISIBLE */;
         };
         CSSParsedDeclaration.prototype.isTransparent = function () {
             return isTransparent(this.backgroundColor);
@@ -3829,21 +4676,21 @@ var html2canvas = createCommonjsModule(function (module, exports) {
             return this.transform !== null;
         };
         CSSParsedDeclaration.prototype.isPositioned = function () {
-            return this.position !== 0 /* STATIC */;
+            return this.position !== 0 /* POSITION.STATIC */;
         };
         CSSParsedDeclaration.prototype.isPositionedWithZIndex = function () {
             return this.isPositioned() && !this.zIndex.auto;
         };
         CSSParsedDeclaration.prototype.isFloating = function () {
-            return this.float !== 0 /* NONE */;
+            return this.float !== 0 /* FLOAT.NONE */;
         };
         CSSParsedDeclaration.prototype.isInlineLevel = function () {
-            return (contains(this.display, 4 /* INLINE */) ||
-                contains(this.display, 33554432 /* INLINE_BLOCK */) ||
-                contains(this.display, 268435456 /* INLINE_FLEX */) ||
-                contains(this.display, 536870912 /* INLINE_GRID */) ||
-                contains(this.display, 67108864 /* INLINE_LIST_ITEM */) ||
-                contains(this.display, 134217728 /* INLINE_TABLE */));
+            return (contains(this.display, 4 /* DISPLAY.INLINE */) ||
+                contains(this.display, 33554432 /* DISPLAY.INLINE_BLOCK */) ||
+                contains(this.display, 268435456 /* DISPLAY.INLINE_FLEX */) ||
+                contains(this.display, 536870912 /* DISPLAY.INLINE_GRID */) ||
+                contains(this.display, 67108864 /* DISPLAY.INLINE_LIST_ITEM */) ||
+                contains(this.display, 134217728 /* DISPLAY.INLINE_TABLE */));
         };
         return CSSParsedDeclaration;
     }());
@@ -3868,16 +4715,16 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         tokenizer.write(value);
         var parser = new Parser(tokenizer.read());
         switch (descriptor.type) {
-            case 2 /* IDENT_VALUE */:
+            case 2 /* PropertyDescriptorParsingType.IDENT_VALUE */:
                 var token = parser.parseComponentValue();
                 return descriptor.parse(context, isIdentToken(token) ? token.value : descriptor.initialValue);
-            case 0 /* VALUE */:
+            case 0 /* PropertyDescriptorParsingType.VALUE */:
                 return descriptor.parse(context, parser.parseComponentValue());
-            case 1 /* LIST */:
+            case 1 /* PropertyDescriptorParsingType.LIST */:
                 return descriptor.parse(context, parser.parseComponentValues());
-            case 4 /* TOKEN_VALUE */:
+            case 4 /* PropertyDescriptorParsingType.TOKEN_VALUE */:
                 return parser.parseComponentValue();
-            case 3 /* TYPE_VALUE */:
+            case 3 /* PropertyDescriptorParsingType.TYPE_VALUE */:
                 switch (descriptor.format) {
                     case 'angle':
                         return angle.parse(context, parser.parseComponentValue());
@@ -3903,20 +4750,20 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         var attribute = element.getAttribute(elementDebuggerAttribute);
         switch (attribute) {
             case 'all':
-                return 1 /* ALL */;
+                return 1 /* DebuggerType.ALL */;
             case 'clone':
-                return 2 /* CLONE */;
+                return 2 /* DebuggerType.CLONE */;
             case 'parse':
-                return 3 /* PARSE */;
+                return 3 /* DebuggerType.PARSE */;
             case 'render':
-                return 4 /* RENDER */;
+                return 4 /* DebuggerType.RENDER */;
             default:
-                return 0 /* NONE */;
+                return 0 /* DebuggerType.NONE */;
         }
     };
     var isDebugging = function (element, type) {
         var elementType = getElementDebugType(element);
-        return elementType === 1 /* ALL */ || type === elementType;
+        return elementType === 1 /* DebuggerType.ALL */ || type === elementType;
     };
 
     var ElementContainer = /** @class */ (function () {
@@ -3925,7 +4772,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
             this.textNodes = [];
             this.elements = [];
             this.flags = 0;
-            if (isDebugging(element, 3 /* PARSE */)) {
+            if (isDebugging(element, 3 /* DebuggerType.PARSE */)) {
                 debugger;
             }
             this.styles = new CSSParsedDeclaration(context, window.getComputedStyle(element, null));
@@ -3939,8 +4786,8 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                 }
             }
             this.bounds = parseBounds(this.context, element);
-            if (isDebugging(element, 4 /* RENDER */)) {
-                this.flags |= 16 /* DEBUG_RENDER */;
+            if (isDebugging(element, 4 /* DebuggerType.RENDER */)) {
+                this.flags |= 16 /* FLAGS.DEBUG_RENDER */;
             }
         }
         return ElementContainer;
@@ -4334,7 +5181,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
             var range = document.createRange();
             if (range.getBoundingClientRect) {
                 var testElement = document.createElement('boundtest');
-                testElement.style.height = TEST_HEIGHT + "px";
+                testElement.style.height = "".concat(TEST_HEIGHT, "px");
                 testElement.style.display = 'block';
                 document.body.appendChild(testElement);
                 range.selectNode(testElement);
@@ -4424,8 +5271,8 @@ var html2canvas = createCommonjsModule(function (module, exports) {
             ctx.fillStyle = 'red';
             ctx.fillRect(0, 0, size, size);
             var node = document.createElement('div');
-            node.style.backgroundImage = "url(" + greenImageSrc + ")";
-            node.style.height = size + "px";
+            node.style.backgroundImage = "url(".concat(greenImageSrc, ")");
+            node.style.height = "".concat(size, "px");
             // Firefox 55 does not render inline <img /> tags
             return isGreenPixel(data)
                 ? loadSerializedSVG$1(createForeignObjectSVG(size, size, 0, 0, node))
@@ -4458,7 +5305,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
             var img = new Image();
             img.onload = function () { return resolve(img); };
             img.onerror = reject;
-            img.src = "data:image/svg+xml;charset=utf-8," + encodeURIComponent(new XMLSerializer().serializeToString(svg));
+            img.src = "data:image/svg+xml;charset=utf-8,".concat(encodeURIComponent(new XMLSerializer().serializeToString(svg)));
         });
     };
     var FEATURES = {
@@ -4602,7 +5449,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
     var breakWords = function (str, styles) {
         var breaker = LineBreaker(str, {
             lineBreak: styles.lineBreak,
-            wordBreak: styles.overflowWrap === "break-word" /* BREAK_WORD */ ? 'break-word' : styles.wordBreak
+            wordBreak: styles.overflowWrap === "break-word" /* OVERFLOW_WRAP.BREAK_WORD */ ? 'break-word' : styles.wordBreak
         });
         var words = [];
         var bk;
@@ -4643,11 +5490,11 @@ var html2canvas = createCommonjsModule(function (module, exports) {
     }());
     var transform = function (text, transform) {
         switch (transform) {
-            case 1 /* LOWERCASE */:
+            case 1 /* TEXT_TRANSFORM.LOWERCASE */:
                 return text.toLowerCase();
-            case 3 /* CAPITALIZE */:
+            case 3 /* TEXT_TRANSFORM.CAPITALIZE */:
                 return text.replace(CAPITALIZE, capitalize);
-            case 2 /* UPPERCASE */:
+            case 2 /* TEXT_TRANSFORM.UPPERCASE */:
                 return text.toUpperCase();
             default:
                 return text;
@@ -4692,9 +5539,9 @@ var html2canvas = createCommonjsModule(function (module, exports) {
             var _this = _super.call(this, context, img) || this;
             var s = new XMLSerializer();
             var bounds = parseBounds(context, img);
-            img.setAttribute('width', bounds.width + "px");
-            img.setAttribute('height', bounds.height + "px");
-            _this.svg = "data:image/svg+xml," + encodeURIComponent(s.serializeToString(img));
+            img.setAttribute('width', "".concat(bounds.width, "px"));
+            img.setAttribute('height', "".concat(bounds.height, "px"));
+            _this.svg = "data:image/svg+xml,".concat(encodeURIComponent(s.serializeToString(img)));
             _this.intrinsicWidth = img.width.baseVal.value;
             _this.intrinsicHeight = img.height.baseVal.value;
             _this.context.cache.addImage(_this.svg);
@@ -4726,7 +5573,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
 
     var CHECKBOX_BORDER_RADIUS = [
         {
-            type: 15 /* DIMENSION_TOKEN */,
+            type: 15 /* TokenType.DIMENSION_TOKEN */,
             flags: 0,
             unit: 'px',
             number: 3
@@ -4734,7 +5581,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
     ];
     var RADIO_BORDER_RADIUS = [
         {
-            type: 16 /* PERCENTAGE_TOKEN */,
+            type: 16 /* TokenType.PERCENTAGE_TOKEN */,
             flags: 0,
             number: 50
         }
@@ -4779,9 +5626,9 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                     _this.styles.borderRightStyle =
                         _this.styles.borderBottomStyle =
                             _this.styles.borderLeftStyle =
-                                1 /* SOLID */;
-                _this.styles.backgroundClip = [0 /* BORDER_BOX */];
-                _this.styles.backgroundOrigin = [0 /* BORDER_BOX */];
+                                1 /* BORDER_STYLE.SOLID */;
+                _this.styles.backgroundClip = [0 /* BACKGROUND_CLIP.BORDER_BOX */];
+                _this.styles.backgroundOrigin = [0 /* BACKGROUND_ORIGIN.BORDER_BOX */];
                 _this.bounds = reformatInputBounds(_this.bounds);
             }
             switch (_this.type) {
@@ -4863,7 +5710,8 @@ var html2canvas = createCommonjsModule(function (module, exports) {
     var parseNodeTree = function (context, node, parent, root) {
         for (var childNode = node.firstChild, nextNode = void 0; childNode; childNode = nextNode) {
             nextNode = childNode.nextSibling;
-            if (isTextNode(childNode) && childNode.data.trim().length > 0) {
+            // Fixes #2238 #1624 - Fix the issue of TextNode content being overlooked in rendering due to being perceived as blank by trim().
+            if (isTextNode(childNode) && childNode.data.length > 0) {
                 parent.textNodes.push(new TextContainer(context, childNode, parent.styles));
             }
             else if (isElementNode(childNode)) {
@@ -4874,13 +5722,13 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                     var container = createContainer(context, childNode);
                     if (container.styles.isVisible()) {
                         if (createsRealStackingContext(childNode, container, root)) {
-                            container.flags |= 4 /* CREATES_REAL_STACKING_CONTEXT */;
+                            container.flags |= 4 /* FLAGS.CREATES_REAL_STACKING_CONTEXT */;
                         }
                         else if (createsStackingContext(container.styles)) {
-                            container.flags |= 2 /* CREATES_STACKING_CONTEXT */;
+                            container.flags |= 2 /* FLAGS.CREATES_STACKING_CONTEXT */;
                         }
                         if (LIST_OWNERS.indexOf(childNode.tagName) !== -1) {
-                            container.flags |= 8 /* IS_LIST_OWNER */;
+                            container.flags |= 8 /* FLAGS.IS_LIST_OWNER */;
                         }
                         parent.elements.push(container);
                         if (childNode.shadowRoot) {
@@ -4928,7 +5776,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
     };
     var parseTree = function (context, element) {
         var container = createContainer(context, element);
-        container.flags |= 4 /* CREATES_REAL_STACKING_CONTEXT */;
+        container.flags |= 4 /* FLAGS.CREATES_REAL_STACKING_CONTEXT */;
         parseNodeTree(context, element, container, container);
         return container;
     };
@@ -5196,7 +6044,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
     var CJK_HUNDRED_COEFFICIENTS = 1 << 3;
     var createCJKCounter = function (value, numbers, multipliers, negativeSign, suffix, flags) {
         if (value < -9999 || value > 9999) {
-            return createCounterText(value, 4 /* CJK_DECIMAL */, suffix.length > 0);
+            return createCounterText(value, 4 /* LIST_STYLE_TYPE.CJK_DECIMAL */, suffix.length > 0);
         }
         var tmp = Math.abs(value);
         var string = suffix;
@@ -5232,101 +6080,101 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         var koreanSuffix = appendSuffix ? ', ' : '';
         var spaceSuffix = appendSuffix ? ' ' : '';
         switch (type) {
-            case 0 /* DISC */:
+            case 0 /* LIST_STYLE_TYPE.DISC */:
                 return '•' + spaceSuffix;
-            case 1 /* CIRCLE */:
+            case 1 /* LIST_STYLE_TYPE.CIRCLE */:
                 return '◦' + spaceSuffix;
-            case 2 /* SQUARE */:
+            case 2 /* LIST_STYLE_TYPE.SQUARE */:
                 return '◾' + spaceSuffix;
-            case 5 /* DECIMAL_LEADING_ZERO */:
+            case 5 /* LIST_STYLE_TYPE.DECIMAL_LEADING_ZERO */:
                 var string = createCounterStyleFromRange(value, 48, 57, true, defaultSuffix);
-                return string.length < 4 ? "0" + string : string;
-            case 4 /* CJK_DECIMAL */:
+                return string.length < 4 ? "0".concat(string) : string;
+            case 4 /* LIST_STYLE_TYPE.CJK_DECIMAL */:
                 return createCounterStyleFromSymbols(value, '〇一二三四五六七八九', cjkSuffix);
-            case 6 /* LOWER_ROMAN */:
-                return createAdditiveCounter(value, 1, 3999, ROMAN_UPPER, 3 /* DECIMAL */, defaultSuffix).toLowerCase();
-            case 7 /* UPPER_ROMAN */:
-                return createAdditiveCounter(value, 1, 3999, ROMAN_UPPER, 3 /* DECIMAL */, defaultSuffix);
-            case 8 /* LOWER_GREEK */:
+            case 6 /* LIST_STYLE_TYPE.LOWER_ROMAN */:
+                return createAdditiveCounter(value, 1, 3999, ROMAN_UPPER, 3 /* LIST_STYLE_TYPE.DECIMAL */, defaultSuffix).toLowerCase();
+            case 7 /* LIST_STYLE_TYPE.UPPER_ROMAN */:
+                return createAdditiveCounter(value, 1, 3999, ROMAN_UPPER, 3 /* LIST_STYLE_TYPE.DECIMAL */, defaultSuffix);
+            case 8 /* LIST_STYLE_TYPE.LOWER_GREEK */:
                 return createCounterStyleFromRange(value, 945, 969, false, defaultSuffix);
-            case 9 /* LOWER_ALPHA */:
+            case 9 /* LIST_STYLE_TYPE.LOWER_ALPHA */:
                 return createCounterStyleFromRange(value, 97, 122, false, defaultSuffix);
-            case 10 /* UPPER_ALPHA */:
+            case 10 /* LIST_STYLE_TYPE.UPPER_ALPHA */:
                 return createCounterStyleFromRange(value, 65, 90, false, defaultSuffix);
-            case 11 /* ARABIC_INDIC */:
+            case 11 /* LIST_STYLE_TYPE.ARABIC_INDIC */:
                 return createCounterStyleFromRange(value, 1632, 1641, true, defaultSuffix);
-            case 12 /* ARMENIAN */:
-            case 49 /* UPPER_ARMENIAN */:
-                return createAdditiveCounter(value, 1, 9999, ARMENIAN, 3 /* DECIMAL */, defaultSuffix);
-            case 35 /* LOWER_ARMENIAN */:
-                return createAdditiveCounter(value, 1, 9999, ARMENIAN, 3 /* DECIMAL */, defaultSuffix).toLowerCase();
-            case 13 /* BENGALI */:
+            case 12 /* LIST_STYLE_TYPE.ARMENIAN */:
+            case 49 /* LIST_STYLE_TYPE.UPPER_ARMENIAN */:
+                return createAdditiveCounter(value, 1, 9999, ARMENIAN, 3 /* LIST_STYLE_TYPE.DECIMAL */, defaultSuffix);
+            case 35 /* LIST_STYLE_TYPE.LOWER_ARMENIAN */:
+                return createAdditiveCounter(value, 1, 9999, ARMENIAN, 3 /* LIST_STYLE_TYPE.DECIMAL */, defaultSuffix).toLowerCase();
+            case 13 /* LIST_STYLE_TYPE.BENGALI */:
                 return createCounterStyleFromRange(value, 2534, 2543, true, defaultSuffix);
-            case 14 /* CAMBODIAN */:
-            case 30 /* KHMER */:
+            case 14 /* LIST_STYLE_TYPE.CAMBODIAN */:
+            case 30 /* LIST_STYLE_TYPE.KHMER */:
                 return createCounterStyleFromRange(value, 6112, 6121, true, defaultSuffix);
-            case 15 /* CJK_EARTHLY_BRANCH */:
+            case 15 /* LIST_STYLE_TYPE.CJK_EARTHLY_BRANCH */:
                 return createCounterStyleFromSymbols(value, '子丑寅卯辰巳午未申酉戌亥', cjkSuffix);
-            case 16 /* CJK_HEAVENLY_STEM */:
+            case 16 /* LIST_STYLE_TYPE.CJK_HEAVENLY_STEM */:
                 return createCounterStyleFromSymbols(value, '甲乙丙丁戊己庚辛壬癸', cjkSuffix);
-            case 17 /* CJK_IDEOGRAPHIC */:
-            case 48 /* TRAD_CHINESE_INFORMAL */:
+            case 17 /* LIST_STYLE_TYPE.CJK_IDEOGRAPHIC */:
+            case 48 /* LIST_STYLE_TYPE.TRAD_CHINESE_INFORMAL */:
                 return createCJKCounter(value, '零一二三四五六七八九', CHINESE_INFORMAL_MULTIPLIERS, '負', cjkSuffix, CJK_TEN_COEFFICIENTS | CJK_TEN_HIGH_COEFFICIENTS | CJK_HUNDRED_COEFFICIENTS);
-            case 47 /* TRAD_CHINESE_FORMAL */:
+            case 47 /* LIST_STYLE_TYPE.TRAD_CHINESE_FORMAL */:
                 return createCJKCounter(value, '零壹貳參肆伍陸柒捌玖', CHINESE_FORMAL_MULTIPLIERS, '負', cjkSuffix, CJK_ZEROS | CJK_TEN_COEFFICIENTS | CJK_TEN_HIGH_COEFFICIENTS | CJK_HUNDRED_COEFFICIENTS);
-            case 42 /* SIMP_CHINESE_INFORMAL */:
+            case 42 /* LIST_STYLE_TYPE.SIMP_CHINESE_INFORMAL */:
                 return createCJKCounter(value, '零一二三四五六七八九', CHINESE_INFORMAL_MULTIPLIERS, '负', cjkSuffix, CJK_TEN_COEFFICIENTS | CJK_TEN_HIGH_COEFFICIENTS | CJK_HUNDRED_COEFFICIENTS);
-            case 41 /* SIMP_CHINESE_FORMAL */:
+            case 41 /* LIST_STYLE_TYPE.SIMP_CHINESE_FORMAL */:
                 return createCJKCounter(value, '零壹贰叁肆伍陆柒捌玖', CHINESE_FORMAL_MULTIPLIERS, '负', cjkSuffix, CJK_ZEROS | CJK_TEN_COEFFICIENTS | CJK_TEN_HIGH_COEFFICIENTS | CJK_HUNDRED_COEFFICIENTS);
-            case 26 /* JAPANESE_INFORMAL */:
+            case 26 /* LIST_STYLE_TYPE.JAPANESE_INFORMAL */:
                 return createCJKCounter(value, '〇一二三四五六七八九', '十百千万', JAPANESE_NEGATIVE, cjkSuffix, 0);
-            case 25 /* JAPANESE_FORMAL */:
+            case 25 /* LIST_STYLE_TYPE.JAPANESE_FORMAL */:
                 return createCJKCounter(value, '零壱弐参四伍六七八九', '拾百千万', JAPANESE_NEGATIVE, cjkSuffix, CJK_ZEROS | CJK_TEN_COEFFICIENTS | CJK_TEN_HIGH_COEFFICIENTS);
-            case 31 /* KOREAN_HANGUL_FORMAL */:
+            case 31 /* LIST_STYLE_TYPE.KOREAN_HANGUL_FORMAL */:
                 return createCJKCounter(value, '영일이삼사오육칠팔구', '십백천만', KOREAN_NEGATIVE, koreanSuffix, CJK_ZEROS | CJK_TEN_COEFFICIENTS | CJK_TEN_HIGH_COEFFICIENTS);
-            case 33 /* KOREAN_HANJA_INFORMAL */:
+            case 33 /* LIST_STYLE_TYPE.KOREAN_HANJA_INFORMAL */:
                 return createCJKCounter(value, '零一二三四五六七八九', '十百千萬', KOREAN_NEGATIVE, koreanSuffix, 0);
-            case 32 /* KOREAN_HANJA_FORMAL */:
+            case 32 /* LIST_STYLE_TYPE.KOREAN_HANJA_FORMAL */:
                 return createCJKCounter(value, '零壹貳參四五六七八九', '拾百千', KOREAN_NEGATIVE, koreanSuffix, CJK_ZEROS | CJK_TEN_COEFFICIENTS | CJK_TEN_HIGH_COEFFICIENTS);
-            case 18 /* DEVANAGARI */:
+            case 18 /* LIST_STYLE_TYPE.DEVANAGARI */:
                 return createCounterStyleFromRange(value, 0x966, 0x96f, true, defaultSuffix);
-            case 20 /* GEORGIAN */:
-                return createAdditiveCounter(value, 1, 19999, GEORGIAN, 3 /* DECIMAL */, defaultSuffix);
-            case 21 /* GUJARATI */:
+            case 20 /* LIST_STYLE_TYPE.GEORGIAN */:
+                return createAdditiveCounter(value, 1, 19999, GEORGIAN, 3 /* LIST_STYLE_TYPE.DECIMAL */, defaultSuffix);
+            case 21 /* LIST_STYLE_TYPE.GUJARATI */:
                 return createCounterStyleFromRange(value, 0xae6, 0xaef, true, defaultSuffix);
-            case 22 /* GURMUKHI */:
+            case 22 /* LIST_STYLE_TYPE.GURMUKHI */:
                 return createCounterStyleFromRange(value, 0xa66, 0xa6f, true, defaultSuffix);
-            case 22 /* HEBREW */:
-                return createAdditiveCounter(value, 1, 10999, HEBREW, 3 /* DECIMAL */, defaultSuffix);
-            case 23 /* HIRAGANA */:
+            case 22 /* LIST_STYLE_TYPE.HEBREW */:
+                return createAdditiveCounter(value, 1, 10999, HEBREW, 3 /* LIST_STYLE_TYPE.DECIMAL */, defaultSuffix);
+            case 23 /* LIST_STYLE_TYPE.HIRAGANA */:
                 return createCounterStyleFromSymbols(value, 'あいうえおかきくけこさしすせそたちつてとなにぬねのはひふへほまみむめもやゆよらりるれろわゐゑをん');
-            case 24 /* HIRAGANA_IROHA */:
+            case 24 /* LIST_STYLE_TYPE.HIRAGANA_IROHA */:
                 return createCounterStyleFromSymbols(value, 'いろはにほへとちりぬるをわかよたれそつねならむうゐのおくやまけふこえてあさきゆめみしゑひもせす');
-            case 27 /* KANNADA */:
+            case 27 /* LIST_STYLE_TYPE.KANNADA */:
                 return createCounterStyleFromRange(value, 0xce6, 0xcef, true, defaultSuffix);
-            case 28 /* KATAKANA */:
+            case 28 /* LIST_STYLE_TYPE.KATAKANA */:
                 return createCounterStyleFromSymbols(value, 'アイウエオカキクケコサシスセソタチツテトナニヌネノハヒフヘホマミムメモヤユヨラリルレロワヰヱヲン', cjkSuffix);
-            case 29 /* KATAKANA_IROHA */:
+            case 29 /* LIST_STYLE_TYPE.KATAKANA_IROHA */:
                 return createCounterStyleFromSymbols(value, 'イロハニホヘトチリヌルヲワカヨタレソツネナラムウヰノオクヤマケフコエテアサキユメミシヱヒモセス', cjkSuffix);
-            case 34 /* LAO */:
+            case 34 /* LIST_STYLE_TYPE.LAO */:
                 return createCounterStyleFromRange(value, 0xed0, 0xed9, true, defaultSuffix);
-            case 37 /* MONGOLIAN */:
+            case 37 /* LIST_STYLE_TYPE.MONGOLIAN */:
                 return createCounterStyleFromRange(value, 0x1810, 0x1819, true, defaultSuffix);
-            case 38 /* MYANMAR */:
+            case 38 /* LIST_STYLE_TYPE.MYANMAR */:
                 return createCounterStyleFromRange(value, 0x1040, 0x1049, true, defaultSuffix);
-            case 39 /* ORIYA */:
+            case 39 /* LIST_STYLE_TYPE.ORIYA */:
                 return createCounterStyleFromRange(value, 0xb66, 0xb6f, true, defaultSuffix);
-            case 40 /* PERSIAN */:
+            case 40 /* LIST_STYLE_TYPE.PERSIAN */:
                 return createCounterStyleFromRange(value, 0x6f0, 0x6f9, true, defaultSuffix);
-            case 43 /* TAMIL */:
+            case 43 /* LIST_STYLE_TYPE.TAMIL */:
                 return createCounterStyleFromRange(value, 0xbe6, 0xbef, true, defaultSuffix);
-            case 44 /* TELUGU */:
+            case 44 /* LIST_STYLE_TYPE.TELUGU */:
                 return createCounterStyleFromRange(value, 0xc66, 0xc6f, true, defaultSuffix);
-            case 45 /* THAI */:
+            case 45 /* LIST_STYLE_TYPE.THAI */:
                 return createCounterStyleFromRange(value, 0xe50, 0xe59, true, defaultSuffix);
-            case 46 /* TIBETAN */:
+            case 46 /* LIST_STYLE_TYPE.TIBETAN */:
                 return createCounterStyleFromRange(value, 0xf20, 0xf29, true, defaultSuffix);
-            case 3 /* DECIMAL */:
+            case 3 /* LIST_STYLE_TYPE.DECIMAL */:
             default:
                 return createCounterStyleFromRange(value, 48, 57, true, defaultSuffix);
         }
@@ -5376,7 +6224,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                             onclone = this.options.onclone;
                             referenceElement = this.clonedReferenceElement;
                             if (typeof referenceElement === 'undefined') {
-                                return [2 /*return*/, Promise.reject("Error finding the " + this.referenceElement.nodeName + " in the cloned document")];
+                                return [2 /*return*/, Promise.reject("Error finding the ".concat(this.referenceElement.nodeName, " in the cloned document"))];
                             }
                             if (!(documentClone.fonts && documentClone.fonts.ready)) return [3 /*break*/, 2];
                             return [4 /*yield*/, documentClone.fonts.ready];
@@ -5399,16 +6247,22 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                     }
                 });
             }); });
+            var adoptedNode = documentClone.adoptNode(this.documentElement);
+            /**
+             * The baseURI of the document will be lost after documentClone.open().
+             * We can avoid it by adding <base> element.
+             * */
+            addBase(adoptedNode, documentClone);
             documentClone.open();
-            documentClone.write(serializeDoctype(document.doctype) + "<html></html>");
+            documentClone.write("".concat(serializeDoctype(document.doctype), "<html></html>"));
             // Chrome scrolls the parent document for some reason after the write to the cloned window???
             restoreOwnerScroll(this.referenceElement.ownerDocument, scrollX, scrollY);
-            documentClone.replaceChild(documentClone.adoptNode(this.documentElement), documentClone.documentElement);
+            documentClone.replaceChild(adoptedNode, documentClone.documentElement);
             documentClone.close();
             return iframeLoad;
         };
         DocumentCloner.prototype.createElementClone = function (node) {
-            if (isDebugging(node, 2 /* CLONE */)) {
+            if (isDebugging(node, 2 /* DebuggerType.CLONE */)) {
                 debugger;
             }
             if (isCanvasElement(node)) {
@@ -5481,7 +6335,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                 clonedCanvas.width = canvas.width;
                 clonedCanvas.height = canvas.height;
                 var ctx = canvas.getContext('2d');
-                var clonedCtx = clonedCanvas.getContext('2d');
+                var clonedCtx = clonedCanvas.getContext('2d', { willReadFrequently: true });
                 if (clonedCtx) {
                     if (!this.options.allowTaint && ctx) {
                         clonedCtx.putImageData(ctx.getImageData(0, 0, canvas.width, canvas.height), 0, 0);
@@ -5616,16 +6470,16 @@ var html2canvas = createCommonjsModule(function (module, exports) {
             var anonymousReplacedElement = document.createElement('html2canvaspseudoelement');
             copyCSSStyles(style, anonymousReplacedElement);
             declaration.content.forEach(function (token) {
-                if (token.type === 0 /* STRING_TOKEN */) {
+                if (token.type === 0 /* TokenType.STRING_TOKEN */) {
                     anonymousReplacedElement.appendChild(document.createTextNode(token.value));
                 }
-                else if (token.type === 22 /* URL_TOKEN */) {
+                else if (token.type === 22 /* TokenType.URL_TOKEN */) {
                     var img = document.createElement('img');
                     img.src = token.value;
                     img.style.opacity = '1';
                     anonymousReplacedElement.appendChild(img);
                 }
-                else if (token.type === 18 /* FUNCTION */) {
+                else if (token.type === 18 /* TokenType.FUNCTION */) {
                     if (token.name === 'attr') {
                         var attr = token.values.filter(isIdentToken);
                         if (attr.length) {
@@ -5638,7 +6492,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                             var counterState = _this.counters.getCounterValue(counter.value);
                             var counterType = counterStyle && isIdentToken(counterStyle)
                                 ? listStyleType.parse(_this.context, counterStyle.value)
-                                : 3 /* DECIMAL */;
+                                : 3 /* LIST_STYLE_TYPE.DECIMAL */;
                             anonymousReplacedElement.appendChild(document.createTextNode(createCounterText(counterState, counterType, false)));
                         }
                     }
@@ -5648,8 +6502,8 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                             var counterStates = _this.counters.getCounterValues(counter.value);
                             var counterType_1 = counterStyle && isIdentToken(counterStyle)
                                 ? listStyleType.parse(_this.context, counterStyle.value)
-                                : 3 /* DECIMAL */;
-                            var separator = delim && delim.type === 0 /* STRING_TOKEN */ ? delim.value : '';
+                                : 3 /* LIST_STYLE_TYPE.DECIMAL */;
+                            var separator = delim && delim.type === 0 /* TokenType.STRING_TOKEN */ ? delim.value : '';
                             var text = counterStates
                                 .map(function (value) { return createCounterText(value, counterType_1, false); })
                                 .join(separator);
@@ -5658,7 +6512,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                     }
                     else ;
                 }
-                else if (token.type === 20 /* IDENT_TOKEN */) {
+                else if (token.type === 20 /* TokenType.IDENT_TOKEN */) {
                     switch (token.value) {
                         case 'open-quote':
                             anonymousReplacedElement.appendChild(document.createTextNode(getQuote(declaration.quotes, _this.quoteDepth++, true)));
@@ -5672,10 +6526,10 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                     }
                 }
             });
-            anonymousReplacedElement.className = PSEUDO_HIDE_ELEMENT_CLASS_BEFORE + " " + PSEUDO_HIDE_ELEMENT_CLASS_AFTER;
+            anonymousReplacedElement.className = "".concat(PSEUDO_HIDE_ELEMENT_CLASS_BEFORE, " ").concat(PSEUDO_HIDE_ELEMENT_CLASS_AFTER);
             var newClassName = pseudoElt === PseudoElementType.BEFORE
-                ? " " + PSEUDO_HIDE_ELEMENT_CLASS_BEFORE
-                : " " + PSEUDO_HIDE_ELEMENT_CLASS_AFTER;
+                ? " ".concat(PSEUDO_HIDE_ELEMENT_CLASS_BEFORE)
+                : " ".concat(PSEUDO_HIDE_ELEMENT_CLASS_AFTER);
             if (isSVGElementNode(clone)) {
                 clone.className.baseValue += newClassName;
             }
@@ -5774,10 +6628,10 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                 str += doctype.internalSubset;
             }
             if (doctype.publicId) {
-                str += "\"" + doctype.publicId + "\"";
+                str += "\"".concat(doctype.publicId, "\"");
             }
             if (doctype.systemId) {
-                str += "\"" + doctype.systemId + "\"";
+                str += "\"".concat(doctype.systemId, "\"");
             }
             str += '>';
         }
@@ -5801,7 +6655,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
     var PSEUDO_HIDE_ELEMENT_CLASS_AFTER = '___html2canvas___pseudoelement_after';
     var PSEUDO_HIDE_ELEMENT_STYLE = "{\n    content: \"\" !important;\n    display: none !important;\n}";
     var createPseudoHideStyles = function (body) {
-        createStyles(body, "." + PSEUDO_HIDE_ELEMENT_CLASS_BEFORE + PSEUDO_BEFORE + PSEUDO_HIDE_ELEMENT_STYLE + "\n         ." + PSEUDO_HIDE_ELEMENT_CLASS_AFTER + PSEUDO_AFTER + PSEUDO_HIDE_ELEMENT_STYLE);
+        createStyles(body, ".".concat(PSEUDO_HIDE_ELEMENT_CLASS_BEFORE).concat(PSEUDO_BEFORE).concat(PSEUDO_HIDE_ELEMENT_STYLE, "\n         .").concat(PSEUDO_HIDE_ELEMENT_CLASS_AFTER).concat(PSEUDO_AFTER).concat(PSEUDO_HIDE_ELEMENT_STYLE));
     };
     var createStyles = function (body, styles) {
         var document = body.ownerDocument;
@@ -5811,6 +6665,13 @@ var html2canvas = createCommonjsModule(function (module, exports) {
             body.appendChild(style);
         }
     };
+    var addBase = function (targetELement, referenceDocument) {
+        var _a;
+        var baseNode = referenceDocument.createElement('base');
+        baseNode.href = referenceDocument.baseURI;
+        var headEle = targetELement.getElementsByTagName('head').item(0);
+        headEle === null || headEle === void 0 ? void 0 : headEle.insertBefore(baseNode, (_a = headEle === null || headEle === void 0 ? void 0 : headEle.firstChild) !== null && _a !== void 0 ? _a : null);
+    };
 
     var CacheStorage = /** @class */ (function () {
         function CacheStorage() {
@@ -5888,7 +6749,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                             src = _a.sent();
                             _a.label = 2;
                         case 2:
-                            this.context.logger.debug("Added image " + key.substring(0, 256));
+                            this.context.logger.debug("Added image ".concat(key.substring(0, 256)));
                             return [4 /*yield*/, new Promise(function (resolve, reject) {
                                     var img = new Image();
                                     img.onload = function () { return resolve(img); };
@@ -5903,7 +6764,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                                         setTimeout(function () { return resolve(img); }, 500);
                                     }
                                     if (_this._options.imageTimeout > 0) {
-                                        setTimeout(function () { return reject("Timed out (" + _this._options.imageTimeout + "ms) loading image"); }, _this._options.imageTimeout);
+                                        setTimeout(function () { return reject("Timed out (".concat(_this._options.imageTimeout, "ms) loading image")); }, _this._options.imageTimeout);
                                     }
                                 })];
                         case 3: return [2 /*return*/, _a.sent()];
@@ -5940,19 +6801,19 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                         }
                     }
                     else {
-                        reject("Failed to proxy resource " + key + " with status code " + xhr.status);
+                        reject("Failed to proxy resource ".concat(key, " with status code ").concat(xhr.status));
                     }
                 };
                 xhr.onerror = reject;
                 var queryString = proxy.indexOf('?') > -1 ? '&' : '?';
-                xhr.open('GET', "" + proxy + queryString + "url=" + encodeURIComponent(src) + "&responseType=" + responseType);
+                xhr.open('GET', "".concat(proxy).concat(queryString, "url=").concat(encodeURIComponent(src), "&responseType=").concat(responseType));
                 if (responseType !== 'text' && xhr instanceof XMLHttpRequest) {
                     xhr.responseType = responseType;
                 }
                 if (_this._options.imageTimeout) {
                     var timeout_1 = _this._options.imageTimeout;
                     xhr.timeout = timeout_1;
-                    xhr.ontimeout = function () { return reject("Timed out (" + timeout_1 + "ms) proxying " + key); };
+                    xhr.ontimeout = function () { return reject("Timed out (".concat(timeout_1, "ms) proxying ").concat(key)); };
                 }
                 xhr.send();
             });
@@ -5970,7 +6831,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
 
     var Vector = /** @class */ (function () {
         function Vector(x, y) {
-            this.type = 0 /* VECTOR */;
+            this.type = 0 /* PathType.VECTOR */;
             this.x = x;
             this.y = y;
         }
@@ -5985,7 +6846,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
     };
     var BezierCurve = /** @class */ (function () {
         function BezierCurve(start, startControl, endControl, end) {
-            this.type = 1 /* BEZIER_CURVE */;
+            this.type = 1 /* PathType.BEZIER_CURVE */;
             this.start = start;
             this.startControl = startControl;
             this.endControl = endControl;
@@ -6008,7 +6869,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         };
         return BezierCurve;
     }());
-    var isBezierCurve = function (path) { return path.type === 1 /* BEZIER_CURVE */; };
+    var isBezierCurve = function (path) { return path.type === 1 /* PathType.BEZIER_CURVE */; };
 
     var BoundCurves = /** @class */ (function () {
         function BoundCurves(element) {
@@ -6195,8 +7056,8 @@ var html2canvas = createCommonjsModule(function (module, exports) {
             this.offsetX = offsetX;
             this.offsetY = offsetY;
             this.matrix = matrix;
-            this.type = 0 /* TRANSFORM */;
-            this.target = 2 /* BACKGROUND_BORDERS */ | 4 /* CONTENT */;
+            this.type = 0 /* EffectType.TRANSFORM */;
+            this.target = 2 /* EffectTarget.BACKGROUND_BORDERS */ | 4 /* EffectTarget.CONTENT */;
         }
         return TransformEffect;
     }());
@@ -6204,23 +7065,23 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         function ClipEffect(path, target) {
             this.path = path;
             this.target = target;
-            this.type = 1 /* CLIP */;
+            this.type = 1 /* EffectType.CLIP */;
         }
         return ClipEffect;
     }());
     var OpacityEffect = /** @class */ (function () {
         function OpacityEffect(opacity) {
             this.opacity = opacity;
-            this.type = 2 /* OPACITY */;
-            this.target = 2 /* BACKGROUND_BORDERS */ | 4 /* CONTENT */;
+            this.type = 2 /* EffectType.OPACITY */;
+            this.target = 2 /* EffectTarget.BACKGROUND_BORDERS */ | 4 /* EffectTarget.CONTENT */;
         }
         return OpacityEffect;
     }());
     var isTransformEffect = function (effect) {
-        return effect.type === 0 /* TRANSFORM */;
+        return effect.type === 0 /* EffectType.TRANSFORM */;
     };
-    var isClipEffect = function (effect) { return effect.type === 1 /* CLIP */; };
-    var isOpacityEffect = function (effect) { return effect.type === 2 /* OPACITY */; };
+    var isClipEffect = function (effect) { return effect.type === 1 /* EffectType.CLIP */; };
+    var isOpacityEffect = function (effect) { return effect.type === 2 /* EffectType.OPACITY */; };
 
     var equalPath = function (a, b) {
         if (a.length === b.length) {
@@ -6272,34 +7133,34 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                 var matrix = this.container.styles.transform;
                 this.effects.push(new TransformEffect(offsetX, offsetY, matrix));
             }
-            if (this.container.styles.overflowX !== 0 /* VISIBLE */) {
+            if (this.container.styles.overflowX !== 0 /* OVERFLOW.VISIBLE */) {
                 var borderBox = calculateBorderBoxPath(this.curves);
                 var paddingBox = calculatePaddingBoxPath(this.curves);
                 if (equalPath(borderBox, paddingBox)) {
-                    this.effects.push(new ClipEffect(borderBox, 2 /* BACKGROUND_BORDERS */ | 4 /* CONTENT */));
+                    this.effects.push(new ClipEffect(borderBox, 2 /* EffectTarget.BACKGROUND_BORDERS */ | 4 /* EffectTarget.CONTENT */));
                 }
                 else {
-                    this.effects.push(new ClipEffect(borderBox, 2 /* BACKGROUND_BORDERS */));
-                    this.effects.push(new ClipEffect(paddingBox, 4 /* CONTENT */));
+                    this.effects.push(new ClipEffect(borderBox, 2 /* EffectTarget.BACKGROUND_BORDERS */));
+                    this.effects.push(new ClipEffect(paddingBox, 4 /* EffectTarget.CONTENT */));
                 }
             }
         }
         ElementPaint.prototype.getEffects = function (target) {
-            var inFlow = [2 /* ABSOLUTE */, 3 /* FIXED */].indexOf(this.container.styles.position) === -1;
+            var inFlow = [2 /* POSITION.ABSOLUTE */, 3 /* POSITION.FIXED */].indexOf(this.container.styles.position) === -1;
             var parent = this.parent;
             var effects = this.effects.slice(0);
             while (parent) {
                 var croplessEffects = parent.effects.filter(function (effect) { return !isClipEffect(effect); });
-                if (inFlow || parent.container.styles.position !== 0 /* STATIC */ || !parent.parent) {
-                    effects.unshift.apply(effects, croplessEffects);
-                    inFlow = [2 /* ABSOLUTE */, 3 /* FIXED */].indexOf(parent.container.styles.position) === -1;
-                    if (parent.container.styles.overflowX !== 0 /* VISIBLE */) {
+                if (inFlow || parent.container.styles.position !== 0 /* POSITION.STATIC */ || !parent.parent) {
+                    inFlow = [2 /* POSITION.ABSOLUTE */, 3 /* POSITION.FIXED */].indexOf(parent.container.styles.position) === -1;
+                    if (parent.container.styles.overflowX !== 0 /* OVERFLOW.VISIBLE */) {
                         var borderBox = calculateBorderBoxPath(parent.curves);
                         var paddingBox = calculatePaddingBoxPath(parent.curves);
                         if (!equalPath(borderBox, paddingBox)) {
-                            effects.unshift(new ClipEffect(paddingBox, 2 /* BACKGROUND_BORDERS */ | 4 /* CONTENT */));
+                            effects.unshift(new ClipEffect(paddingBox, 2 /* EffectTarget.BACKGROUND_BORDERS */ | 4 /* EffectTarget.CONTENT */));
                         }
                     }
+                    effects.unshift.apply(effects, croplessEffects);
                 }
                 else {
                     effects.unshift.apply(effects, croplessEffects);
@@ -6312,13 +7173,13 @@ var html2canvas = createCommonjsModule(function (module, exports) {
     }());
     var parseStackTree = function (parent, stackingContext, realStackingContext, listItems) {
         parent.container.elements.forEach(function (child) {
-            var treatAsRealStackingContext = contains(child.flags, 4 /* CREATES_REAL_STACKING_CONTEXT */);
-            var createsStackingContext = contains(child.flags, 2 /* CREATES_STACKING_CONTEXT */);
+            var treatAsRealStackingContext = contains(child.flags, 4 /* FLAGS.CREATES_REAL_STACKING_CONTEXT */);
+            var createsStackingContext = contains(child.flags, 2 /* FLAGS.CREATES_STACKING_CONTEXT */);
             var paintContainer = new ElementPaint(child, parent);
-            if (contains(child.styles.display, 2048 /* LIST_ITEM */)) {
+            if (contains(child.styles.display, 2048 /* DISPLAY.LIST_ITEM */)) {
                 listItems.push(paintContainer);
             }
-            var listOwnerItems = contains(child.flags, 8 /* IS_LIST_OWNER */) ? [] : listItems;
+            var listOwnerItems = contains(child.flags, 8 /* FLAGS.IS_LIST_OWNER */) ? [] : listItems;
             if (treatAsRealStackingContext || createsStackingContext) {
                 var parentStack = treatAsRealStackingContext || child.styles.isPositioned() ? realStackingContext : stackingContext;
                 var stack = new StackingContext(paintContainer);
@@ -6375,7 +7236,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                 }
                 parseStackTree(paintContainer, stackingContext, realStackingContext, listOwnerItems);
             }
-            if (contains(child.flags, 8 /* IS_LIST_OWNER */)) {
+            if (contains(child.flags, 8 /* FLAGS.IS_LIST_OWNER */)) {
                 processListItems(child, listOwnerItems);
             }
         });
@@ -6516,19 +7377,19 @@ var html2canvas = createCommonjsModule(function (module, exports) {
     };
 
     var calculateBackgroundPositioningArea = function (backgroundOrigin, element) {
-        if (backgroundOrigin === 0 /* BORDER_BOX */) {
+        if (backgroundOrigin === 0 /* BACKGROUND_ORIGIN.BORDER_BOX */) {
             return element.bounds;
         }
-        if (backgroundOrigin === 2 /* CONTENT_BOX */) {
+        if (backgroundOrigin === 2 /* BACKGROUND_ORIGIN.CONTENT_BOX */) {
             return contentBox(element);
         }
         return paddingBox(element);
     };
     var calculateBackgroundPaintingArea = function (backgroundClip, element) {
-        if (backgroundClip === 0 /* BORDER_BOX */) {
+        if (backgroundClip === 0 /* BACKGROUND_CLIP.BORDER_BOX */) {
             return element.bounds;
         }
-        if (backgroundClip === 2 /* CONTENT_BOX */) {
+        if (backgroundClip === 2 /* BACKGROUND_CLIP.CONTENT_BOX */) {
             return contentBox(element);
         }
         return paddingBox(element);
@@ -6542,6 +7403,8 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         var path = calculateBackgroundRepeatPath(getBackgroundValueForIndex(container.styles.backgroundRepeat, index), position, backgroundImageSize, backgroundPositioningArea, backgroundPaintingArea);
         var offsetX = Math.round(backgroundPositioningArea.left + position[0]);
         var offsetY = Math.round(backgroundPositioningArea.top + position[1]);
+        sizeWidth = Math.max(1, sizeWidth);
+        sizeHeight = Math.max(1, sizeHeight);
         return [path, offsetX, offsetY, sizeWidth, sizeHeight];
     };
     var isAuto = function (token) { return isIdentToken(token) && token.value === BACKGROUND_SIZE.AUTO; };
@@ -6656,21 +7519,21 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         var x = _a[0], y = _a[1];
         var width = _b[0], height = _b[1];
         switch (repeat) {
-            case 2 /* REPEAT_X */:
+            case 2 /* BACKGROUND_REPEAT.REPEAT_X */:
                 return [
                     new Vector(Math.round(backgroundPositioningArea.left), Math.round(backgroundPositioningArea.top + y)),
                     new Vector(Math.round(backgroundPositioningArea.left + backgroundPositioningArea.width), Math.round(backgroundPositioningArea.top + y)),
                     new Vector(Math.round(backgroundPositioningArea.left + backgroundPositioningArea.width), Math.round(height + backgroundPositioningArea.top + y)),
                     new Vector(Math.round(backgroundPositioningArea.left), Math.round(height + backgroundPositioningArea.top + y))
                 ];
-            case 3 /* REPEAT_Y */:
+            case 3 /* BACKGROUND_REPEAT.REPEAT_Y */:
                 return [
                     new Vector(Math.round(backgroundPositioningArea.left + x), Math.round(backgroundPositioningArea.top)),
                     new Vector(Math.round(backgroundPositioningArea.left + x + width), Math.round(backgroundPositioningArea.top)),
                     new Vector(Math.round(backgroundPositioningArea.left + x + width), Math.round(backgroundPositioningArea.height + backgroundPositioningArea.top)),
                     new Vector(Math.round(backgroundPositioningArea.left + x), Math.round(backgroundPositioningArea.height + backgroundPositioningArea.top))
                 ];
-            case 1 /* NO_REPEAT */:
+            case 1 /* BACKGROUND_REPEAT.NO_REPEAT */:
                 return [
                     new Vector(Math.round(backgroundPositioningArea.left + x), Math.round(backgroundPositioningArea.top + y)),
                     new Vector(Math.round(backgroundPositioningArea.left + x + width), Math.round(backgroundPositioningArea.top + y)),
@@ -6730,7 +7593,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
             return { baseline: baseline, middle: middle };
         };
         FontMetrics.prototype.getMetrics = function (fontFamily, fontSize) {
-            var key = fontFamily + " " + fontSize;
+            var key = "".concat(fontFamily, " ").concat(fontSize);
             if (typeof this._data[key] === 'undefined') {
                 this._data[key] = this.parseMetrics(fontFamily, fontSize);
             }
@@ -6758,15 +7621,15 @@ var html2canvas = createCommonjsModule(function (module, exports) {
             if (!options.canvas) {
                 _this.canvas.width = Math.floor(options.width * options.scale);
                 _this.canvas.height = Math.floor(options.height * options.scale);
-                _this.canvas.style.width = options.width + "px";
-                _this.canvas.style.height = options.height + "px";
+                _this.canvas.style.width = "".concat(options.width, "px");
+                _this.canvas.style.height = "".concat(options.height, "px");
             }
             _this.fontMetrics = new FontMetrics(document);
             _this.ctx.scale(_this.options.scale, _this.options.scale);
             _this.ctx.translate(-options.x, -options.y);
             _this.ctx.textBaseline = 'bottom';
             _this._activeEffects = [];
-            _this.context.logger.debug("Canvas renderer initialized (" + options.width + "x" + options.height + ") with scale " + options.scale);
+            _this.context.logger.debug("Canvas renderer initialized (".concat(options.width, "x").concat(options.height, ") with scale ").concat(options.scale));
             return _this;
         }
         CanvasRenderer.prototype.applyEffects = function (effects) {
@@ -6818,7 +7681,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                 return __generator(this, function (_a) {
                     switch (_a.label) {
                         case 0:
-                            if (contains(paint.container.flags, 16 /* DEBUG_RENDER */)) {
+                            if (contains(paint.container.flags, 16 /* FLAGS.DEBUG_RENDER */)) {
                                 debugger;
                             }
                             if (!paint.container.styles.isVisible()) return [3 /*break*/, 3];
@@ -6837,7 +7700,15 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         CanvasRenderer.prototype.renderTextWithLetterSpacing = function (text, letterSpacing, baseline) {
             var _this = this;
             if (letterSpacing === 0) {
-                this.ctx.fillText(text.text, text.bounds.left, text.bounds.top + baseline);
+                // Fixed an issue with characters moving up in non-Firefox.
+                // https://github.com/niklasvh/html2canvas/issues/2107#issuecomment-692462900
+                if (navigator.userAgent.indexOf('Firefox') === -1) {
+                    this.ctx.textBaseline = 'ideographic';
+                    this.ctx.fillText(text.text, text.bounds.left, text.bounds.top + text.bounds.height);
+                }
+                else {
+                    this.ctx.fillText(text.text, text.bounds.left, text.bounds.top + baseline);
+                }
             }
             else {
                 var letters = segmentGraphemes(text.text);
@@ -6853,8 +7724,8 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                 .join('');
             var fontFamily = fixIOSSystemFonts(styles.fontFamily).join(', ');
             var fontSize = isDimensionToken(styles.fontSize)
-                ? "" + styles.fontSize.number + styles.fontSize.unit
-                : styles.fontSize.number + "px";
+                ? "".concat(styles.fontSize.number).concat(styles.fontSize.unit)
+                : "".concat(styles.fontSize.number, "px");
             return [
                 [styles.fontStyle, fontVariant, styles.fontWeight, fontSize, fontFamily].join(' '),
                 fontFamily,
@@ -6863,22 +7734,21 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         };
         CanvasRenderer.prototype.renderTextNode = function (text, styles) {
             return __awaiter(this, void 0, void 0, function () {
-                var _a, font, fontFamily, fontSize, _b, baseline, middle, paintOrder;
+                var font, paintOrder;
                 var _this = this;
-                return __generator(this, function (_c) {
-                    _a = this.createFontStyle(styles), font = _a[0], fontFamily = _a[1], fontSize = _a[2];
+                return __generator(this, function (_a) {
+                    font = this.createFontStyle(styles)[0];
                     this.ctx.font = font;
-                    this.ctx.direction = styles.direction === 1 /* RTL */ ? 'rtl' : 'ltr';
+                    this.ctx.direction = styles.direction === 1 /* DIRECTION.RTL */ ? 'rtl' : 'ltr';
                     this.ctx.textAlign = 'left';
                     this.ctx.textBaseline = 'alphabetic';
-                    _b = this.fontMetrics.getMetrics(fontFamily, fontSize), baseline = _b.baseline, middle = _b.middle;
                     paintOrder = styles.paintOrder;
                     text.textBounds.forEach(function (text) {
                         paintOrder.forEach(function (paintOrderLayer) {
                             switch (paintOrderLayer) {
-                                case 0 /* FILL */:
+                                case 0 /* PAINT_ORDER_LAYER.FILL */:
                                     _this.ctx.fillStyle = asString(styles.color);
-                                    _this.renderTextWithLetterSpacing(text, styles.letterSpacing, baseline);
+                                    _this.renderTextWithLetterSpacing(text, styles.letterSpacing, styles.fontSize.number);
                                     var textShadows = styles.textShadow;
                                     if (textShadows.length && text.text.trim().length) {
                                         textShadows
@@ -6889,7 +7759,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                                             _this.ctx.shadowOffsetX = textShadow.offsetX.number * _this.options.scale;
                                             _this.ctx.shadowOffsetY = textShadow.offsetY.number * _this.options.scale;
                                             _this.ctx.shadowBlur = textShadow.blur.number;
-                                            _this.renderTextWithLetterSpacing(text, styles.letterSpacing, baseline);
+                                            _this.renderTextWithLetterSpacing(text, styles.letterSpacing, styles.fontSize.number);
                                         });
                                         _this.ctx.shadowColor = '';
                                         _this.ctx.shadowOffsetX = 0;
@@ -6898,32 +7768,30 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                                     }
                                     if (styles.textDecorationLine.length) {
                                         _this.ctx.fillStyle = asString(styles.textDecorationColor || styles.color);
+                                        var decorationLineHeight_1 = 1;
                                         styles.textDecorationLine.forEach(function (textDecorationLine) {
+                                            // Fix the issue where textDecorationLine exhibits x-axis positioning errors on high-resolution devices due to varying devicePixelRatio, corrected by using relative values of element heights.
                                             switch (textDecorationLine) {
-                                                case 1 /* UNDERLINE */:
-                                                    // Draws a line at the baseline of the font
-                                                    // TODO As some browsers display the line as more than 1px if the font-size is big,
-                                                    // need to take that into account both in position and size
-                                                    _this.ctx.fillRect(text.bounds.left, Math.round(text.bounds.top + baseline), text.bounds.width, 1);
+                                                case 1 /* TEXT_DECORATION_LINE.UNDERLINE */:
+                                                    _this.ctx.fillRect(text.bounds.left, text.bounds.top + text.bounds.height - decorationLineHeight_1, text.bounds.width, decorationLineHeight_1);
                                                     break;
-                                                case 2 /* OVERLINE */:
-                                                    _this.ctx.fillRect(text.bounds.left, Math.round(text.bounds.top), text.bounds.width, 1);
+                                                case 2 /* TEXT_DECORATION_LINE.OVERLINE */:
+                                                    _this.ctx.fillRect(text.bounds.left, text.bounds.top, text.bounds.width, decorationLineHeight_1);
                                                     break;
-                                                case 3 /* LINE_THROUGH */:
-                                                    // TODO try and find exact position for line-through
-                                                    _this.ctx.fillRect(text.bounds.left, Math.ceil(text.bounds.top + middle), text.bounds.width, 1);
+                                                case 3 /* TEXT_DECORATION_LINE.LINE_THROUGH */:
+                                                    _this.ctx.fillRect(text.bounds.left, text.bounds.top + (text.bounds.height / 2 - decorationLineHeight_1 / 2), text.bounds.width, decorationLineHeight_1);
                                                     break;
                                             }
                                         });
                                     }
                                     break;
-                                case 1 /* STROKE */:
+                                case 1 /* PAINT_ORDER_LAYER.STROKE */:
                                     if (styles.webkitTextStrokeWidth && text.text.trim().length) {
                                         _this.ctx.strokeStyle = asString(styles.webkitTextStrokeColor);
                                         _this.ctx.lineWidth = styles.webkitTextStrokeWidth;
                                         // eslint-disable-next-line @typescript-eslint/no-explicit-any
                                         _this.ctx.lineJoin = !!window.chrome ? 'miter' : 'round';
-                                        _this.ctx.strokeText(text.text, text.bounds.left, text.bounds.top + baseline);
+                                        _this.ctx.strokeText(text.text, text.bounds.left, text.bounds.top + text.bounds.height);
                                     }
                                     _this.ctx.strokeStyle = '';
                                     _this.ctx.lineWidth = 0;
@@ -6937,13 +7805,89 @@ var html2canvas = createCommonjsModule(function (module, exports) {
             });
         };
         CanvasRenderer.prototype.renderReplacedElement = function (container, curves, image) {
-            if (image && container.intrinsicWidth > 0 && container.intrinsicHeight > 0) {
+            var intrinsicWidth = image.naturalWidth || container.intrinsicWidth;
+            var intrinsicHeight = image.naturalHeight || container.intrinsicHeight;
+            if (image && intrinsicWidth > 0 && intrinsicHeight > 0) {
                 var box = contentBox(container);
                 var path = calculatePaddingBoxPath(curves);
                 this.path(path);
                 this.ctx.save();
                 this.ctx.clip();
-                this.ctx.drawImage(image, 0, 0, container.intrinsicWidth, container.intrinsicHeight, box.left, box.top, box.width, box.height);
+                var sx = 0, sy = 0, sw = intrinsicWidth, sh = intrinsicHeight, dx = box.left, dy = box.top, dw = box.width, dh = box.height;
+                var objectFit = container.styles.objectFit;
+                var boxRatio = dw / dh;
+                var imgRatio = sw / sh;
+                if (objectFit === 2 /* OBJECT_FIT.CONTAIN */) {
+                    if (imgRatio > boxRatio) {
+                        dh = dw / imgRatio;
+                        dy += (box.height - dh) / 2;
+                    }
+                    else {
+                        dw = dh * imgRatio;
+                        dx += (box.width - dw) / 2;
+                    }
+                }
+                else if (objectFit === 4 /* OBJECT_FIT.COVER */) {
+                    if (imgRatio > boxRatio) {
+                        sw = sh * boxRatio;
+                        sx += (intrinsicWidth - sw) / 2;
+                    }
+                    else {
+                        sh = sw / boxRatio;
+                        sy += (intrinsicHeight - sh) / 2;
+                    }
+                }
+                else if (objectFit === 8 /* OBJECT_FIT.NONE */) {
+                    if (sw > dw) {
+                        sx += (sw - dw) / 2;
+                        sw = dw;
+                    }
+                    else {
+                        dx += (dw - sw) / 2;
+                        dw = sw;
+                    }
+                    if (sh > dh) {
+                        sy += (sh - dh) / 2;
+                        sh = dh;
+                    }
+                    else {
+                        dy += (dh - sh) / 2;
+                        dh = sh;
+                    }
+                }
+                else if (objectFit === 16 /* OBJECT_FIT.SCALE_DOWN */) {
+                    var containW = imgRatio > boxRatio ? dw : dh * imgRatio;
+                    var noneW = sw > dw ? sw : dw;
+                    if (containW < noneW) {
+                        if (imgRatio > boxRatio) {
+                            dh = dw / imgRatio;
+                            dy += (box.height - dh) / 2;
+                        }
+                        else {
+                            dw = dh * imgRatio;
+                            dx += (box.width - dw) / 2;
+                        }
+                    }
+                    else {
+                        if (sw > dw) {
+                            sx += (sw - dw) / 2;
+                            sw = dw;
+                        }
+                        else {
+                            dx += (dw - sw) / 2;
+                            dw = sw;
+                        }
+                        if (sh > dh) {
+                            sy += (sh - dh) / 2;
+                            sh = dh;
+                        }
+                        else {
+                            dy += (dh - sh) / 2;
+                            dh = sh;
+                        }
+                    }
+                }
+                this.ctx.drawImage(image, sx, sy, sw, sh, dx, dy, dw, dh);
                 this.ctx.restore();
             }
         };
@@ -6953,7 +7897,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                 return __generator(this, function (_c) {
                     switch (_c.label) {
                         case 0:
-                            this.applyEffects(paint.getEffects(4 /* CONTENT */));
+                            this.applyEffects(paint.getEffects(4 /* EffectTarget.CONTENT */));
                             container = paint.container;
                             curves = paint.curves;
                             styles = container.styles;
@@ -6981,7 +7925,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                             return [3 /*break*/, 8];
                         case 7:
                             _c.sent();
-                            this.context.logger.error("Error loading image " + container.src);
+                            this.context.logger.error("Error loading image ".concat(container.src));
                             return [3 /*break*/, 8];
                         case 8:
                             if (container instanceof CanvasElementContainer) {
@@ -6998,7 +7942,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                             return [3 /*break*/, 12];
                         case 11:
                             _c.sent();
-                            this.context.logger.error("Error loading svg " + container.svg.substring(0, 255));
+                            this.context.logger.error("Error loading svg ".concat(container.svg.substring(0, 255)));
                             return [3 /*break*/, 12];
                         case 12:
                             if (!(container instanceof IFrameElementContainer && container.tree)) return [3 /*break*/, 14];
@@ -7058,10 +8002,10 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                                 bounds = contentBox(container);
                                 x = 0;
                                 switch (container.styles.textAlign) {
-                                    case 1 /* CENTER */:
+                                    case 1 /* TEXT_ALIGN.CENTER */:
                                         x += bounds.width / 2;
                                         break;
-                                    case 2 /* RIGHT */:
+                                    case 2 /* TEXT_ALIGN.RIGHT */:
                                         x += bounds.width;
                                         break;
                                 }
@@ -7079,10 +8023,10 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                                 this.ctx.textBaseline = 'alphabetic';
                                 this.ctx.textAlign = 'left';
                             }
-                            if (!contains(container.styles.display, 2048 /* LIST_ITEM */)) return [3 /*break*/, 20];
+                            if (!contains(container.styles.display, 2048 /* DISPLAY.LIST_ITEM */)) return [3 /*break*/, 20];
                             if (!(container.styles.listStyleImage !== null)) return [3 /*break*/, 19];
                             img = container.styles.listStyleImage;
-                            if (!(img.type === 0 /* URL */)) return [3 /*break*/, 18];
+                            if (!(img.type === 0 /* CSSImageType.URL */)) return [3 /*break*/, 18];
                             image = void 0;
                             url = img.url;
                             _c.label = 15;
@@ -7095,11 +8039,11 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                             return [3 /*break*/, 18];
                         case 17:
                             _c.sent();
-                            this.context.logger.error("Error loading list-style-image " + url);
+                            this.context.logger.error("Error loading list-style-image ".concat(url));
                             return [3 /*break*/, 18];
                         case 18: return [3 /*break*/, 20];
                         case 19:
-                            if (paint.listValue && container.styles.listStyleType !== -1 /* NONE */) {
+                            if (paint.listValue && container.styles.listStyleType !== -1 /* LIST_STYLE_TYPE.NONE */) {
                                 fontFamily = this.createFontStyle(styles)[0];
                                 this.ctx.font = fontFamily;
                                 this.ctx.fillStyle = asString(styles.color);
@@ -7122,7 +8066,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                 return __generator(this, function (_p) {
                     switch (_p.label) {
                         case 0:
-                            if (contains(stack.element.container.flags, 16 /* DEBUG_RENDER */)) {
+                            if (contains(stack.element.container.flags, 16 /* FLAGS.DEBUG_RENDER */)) {
                                 debugger;
                             }
                             // https://www.w3.org/TR/css-position-3/#painting-order
@@ -7270,10 +8214,11 @@ var html2canvas = createCommonjsModule(function (module, exports) {
             this.ctx.translate(-offsetX, -offsetY);
         };
         CanvasRenderer.prototype.resizeImage = function (image, width, height) {
+            // https://github.com/niklasvh/html2canvas/pull/2911
+            // if (image.width === width && image.height === height) {
+            //     return image;
+            // }
             var _a;
-            if (image.width === width && image.height === height) {
-                return image;
-            }
             var ownerDocument = (_a = this.canvas.ownerDocument) !== null && _a !== void 0 ? _a : document;
             var canvas = ownerDocument.createElement('canvas');
             canvas.width = Math.max(1, width);
@@ -7290,11 +8235,11 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                         case 0:
                             index = container.styles.backgroundImage.length - 1;
                             _loop_1 = function (backgroundImage) {
-                                var image, url, _c, path, x, y, width, height, pattern, _d, path, x, y, width, height, _e, lineLength, x0, x1, y0, y1, canvas, ctx, gradient_1, pattern, _f, path, left, top_1, width, height, position, x, y, _g, rx, ry, radialGradient_1, midX, midY, f, invF;
+                                var image, url, imageWidth, imageHeight, _c, path, x, y, width, height, pattern, _d, path, x, y, width, height, _e, lineLength, x0, x1, y0, y1, canvas, ctx, gradient_1, pattern, _f, path, left, top_1, width, height, position, x, y, _g, rx, ry, radialGradient_1, midX, midY, f, invF;
                                 return __generator(this, function (_h) {
                                     switch (_h.label) {
                                         case 0:
-                                            if (!(backgroundImage.type === 0 /* URL */)) return [3 /*break*/, 5];
+                                            if (!(backgroundImage.type === 0 /* CSSImageType.URL */)) return [3 /*break*/, 5];
                                             image = void 0;
                                             url = backgroundImage.url;
                                             _h.label = 1;
@@ -7306,14 +8251,16 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                                             return [3 /*break*/, 4];
                                         case 3:
                                             _h.sent();
-                                            this_1.context.logger.error("Error loading background-image " + url);
+                                            this_1.context.logger.error("Error loading background-image ".concat(url));
                                             return [3 /*break*/, 4];
                                         case 4:
                                             if (image) {
+                                                imageWidth = isNaN(image.width) || image.width === 0 ? 1 : image.width;
+                                                imageHeight = isNaN(image.height) || image.height === 0 ? 1 : image.height;
                                                 _c = calculateBackgroundRendering(container, index, [
-                                                    image.width,
-                                                    image.height,
-                                                    image.width / image.height
+                                                    imageWidth,
+                                                    imageHeight,
+                                                    imageWidth / imageHeight
                                                 ]), path = _c[0], x = _c[1], y = _c[2], width = _c[3], height = _c[4];
                                                 pattern = this_1.ctx.createPattern(this_1.resizeImage(image, width, height), 'repeat');
                                                 this_1.renderRepeat(path, pattern, x, y);
@@ -7438,7 +8385,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                 return __generator(this, function (_a) {
                     switch (_a.label) {
                         case 0:
-                            this.applyEffects(paint.getEffects(2 /* BACKGROUND_BORDERS */));
+                            this.applyEffects(paint.getEffects(2 /* EffectTarget.BACKGROUND_BORDERS */));
                             styles = paint.container.styles;
                             hasBackground = !isTransparent(styles.backgroundColor) || styles.backgroundImage.length;
                             borders = [
@@ -7494,20 +8441,20 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                         case 3:
                             if (!(_i < borders_1.length)) return [3 /*break*/, 13];
                             border = borders_1[_i];
-                            if (!(border.style !== 0 /* NONE */ && !isTransparent(border.color) && border.width > 0)) return [3 /*break*/, 11];
-                            if (!(border.style === 2 /* DASHED */)) return [3 /*break*/, 5];
-                            return [4 /*yield*/, this.renderDashedDottedBorder(border.color, border.width, side, paint.curves, 2 /* DASHED */)];
+                            if (!(border.style !== 0 /* BORDER_STYLE.NONE */ && !isTransparent(border.color) && border.width > 0)) return [3 /*break*/, 11];
+                            if (!(border.style === 2 /* BORDER_STYLE.DASHED */)) return [3 /*break*/, 5];
+                            return [4 /*yield*/, this.renderDashedDottedBorder(border.color, border.width, side, paint.curves, 2 /* BORDER_STYLE.DASHED */)];
                         case 4:
                             _a.sent();
                             return [3 /*break*/, 11];
                         case 5:
-                            if (!(border.style === 3 /* DOTTED */)) return [3 /*break*/, 7];
-                            return [4 /*yield*/, this.renderDashedDottedBorder(border.color, border.width, side, paint.curves, 3 /* DOTTED */)];
+                            if (!(border.style === 3 /* BORDER_STYLE.DOTTED */)) return [3 /*break*/, 7];
+                            return [4 /*yield*/, this.renderDashedDottedBorder(border.color, border.width, side, paint.curves, 3 /* BORDER_STYLE.DOTTED */)];
                         case 6:
                             _a.sent();
                             return [3 /*break*/, 11];
                         case 7:
-                            if (!(border.style === 4 /* DOUBLE */)) return [3 /*break*/, 9];
+                            if (!(border.style === 4 /* BORDER_STYLE.DOUBLE */)) return [3 /*break*/, 9];
                             return [4 /*yield*/, this.renderDoubleBorder(border.color, border.width, side, paint.curves)];
                         case 8:
                             _a.sent();
@@ -7534,7 +8481,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                     this.ctx.save();
                     strokePaths = parsePathForBorderStroke(curvePoints, side);
                     boxPaths = parsePathForBorder(curvePoints, side);
-                    if (style === 2 /* DASHED */) {
+                    if (style === 2 /* BORDER_STYLE.DASHED */) {
                         this.path(boxPaths);
                         this.ctx.clip();
                     }
@@ -7561,7 +8508,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                         length = Math.abs(startY - endY);
                     }
                     this.ctx.beginPath();
-                    if (style === 3 /* DOTTED */) {
+                    if (style === 3 /* BORDER_STYLE.DOTTED */) {
                         this.formatPath(strokePaths);
                     }
                     else {
@@ -7569,7 +8516,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                     }
                     dashLength = width < 3 ? width * 3 : width * 2;
                     spaceLength = width < 3 ? width * 2 : width;
-                    if (style === 3 /* DOTTED */) {
+                    if (style === 3 /* BORDER_STYLE.DOTTED */) {
                         dashLength = width;
                         spaceLength = width;
                     }
@@ -7592,14 +8539,14 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                                 : maxSpace;
                     }
                     if (useLineDash) {
-                        if (style === 3 /* DOTTED */) {
+                        if (style === 3 /* BORDER_STYLE.DOTTED */) {
                             this.ctx.setLineDash([0, dashLength + spaceLength]);
                         }
                         else {
                             this.ctx.setLineDash([dashLength, spaceLength]);
                         }
                     }
-                    if (style === 3 /* DOTTED */) {
+                    if (style === 3 /* BORDER_STYLE.DOTTED */) {
                         this.ctx.lineCap = 'round';
                         this.ctx.lineWidth = width;
                     }
@@ -7610,7 +8557,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                     this.ctx.stroke();
                     this.ctx.setLineDash([]);
                     // dashed round edge gap
-                    if (style === 2 /* DASHED */) {
+                    if (style === 2 /* BORDER_STYLE.DASHED */) {
                         if (isBezierCurve(boxPaths[0])) {
                             path1 = boxPaths[3];
                             path2 = boxPaths[0];
@@ -7667,22 +8614,22 @@ var html2canvas = createCommonjsModule(function (module, exports) {
     };
     var calculateBackgroundCurvedPaintingArea = function (clip, curves) {
         switch (clip) {
-            case 0 /* BORDER_BOX */:
+            case 0 /* BACKGROUND_CLIP.BORDER_BOX */:
                 return calculateBorderBoxPath(curves);
-            case 2 /* CONTENT_BOX */:
+            case 2 /* BACKGROUND_CLIP.CONTENT_BOX */:
                 return calculateContentBoxPath(curves);
-            case 1 /* PADDING_BOX */:
+            case 1 /* BACKGROUND_CLIP.PADDING_BOX */:
             default:
                 return calculatePaddingBoxPath(curves);
         }
     };
     var canvasTextAlign = function (textAlign) {
         switch (textAlign) {
-            case 1 /* CENTER */:
+            case 1 /* TEXT_ALIGN.CENTER */:
                 return 'center';
-            case 2 /* RIGHT */:
+            case 2 /* TEXT_ALIGN.RIGHT */:
                 return 'right';
-            case 0 /* LEFT */:
+            case 0 /* TEXT_ALIGN.LEFT */:
             default:
                 return 'left';
         }
@@ -7704,11 +8651,11 @@ var html2canvas = createCommonjsModule(function (module, exports) {
             _this.options = options;
             _this.canvas.width = Math.floor(options.width * options.scale);
             _this.canvas.height = Math.floor(options.height * options.scale);
-            _this.canvas.style.width = options.width + "px";
-            _this.canvas.style.height = options.height + "px";
+            _this.canvas.style.width = "".concat(options.width, "px");
+            _this.canvas.style.height = "".concat(options.height, "px");
             _this.ctx.scale(_this.options.scale, _this.options.scale);
             _this.ctx.translate(-options.x, -options.y);
-            _this.context.logger.debug("EXPERIMENTAL ForeignObject renderer initialized (" + options.width + "x" + options.height + " at " + options.x + "," + options.y + ") with scale " + options.scale);
+            _this.context.logger.debug("EXPERIMENTAL ForeignObject renderer initialized (".concat(options.width, "x").concat(options.height, " at ").concat(options.x, ",").concat(options.y, ") with scale ").concat(options.scale));
             return _this;
         }
         ForeignObjectRenderer.prototype.render = function (element) {
@@ -7740,7 +8687,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                 resolve(img);
             };
             img.onerror = reject;
-            img.src = "data:image/svg+xml;charset=utf-8," + encodeURIComponent(new XMLSerializer().serializeToString(svg));
+            img.src = "data:image/svg+xml;charset=utf-8,".concat(encodeURIComponent(new XMLSerializer().serializeToString(svg)));
         });
     };
 
@@ -7761,7 +8708,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                 // eslint-disable-next-line no-console
                 if (typeof window !== 'undefined' && window.console && typeof console.debug === 'function') {
                     // eslint-disable-next-line no-console
-                    console.debug.apply(console, __spreadArray([this.id, this.getTime() + "ms"], args));
+                    console.debug.apply(console, __spreadArray([this.id, "".concat(this.getTime(), "ms")], args, false));
                 }
                 else {
                     this.info.apply(this, args);
@@ -7781,7 +8728,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                 // eslint-disable-next-line no-console
                 if (typeof window !== 'undefined' && window.console && typeof console.info === 'function') {
                     // eslint-disable-next-line no-console
-                    console.info.apply(console, __spreadArray([this.id, this.getTime() + "ms"], args));
+                    console.info.apply(console, __spreadArray([this.id, "".concat(this.getTime(), "ms")], args, false));
                 }
             }
         };
@@ -7795,7 +8742,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                 // eslint-disable-next-line no-console
                 if (typeof window !== 'undefined' && window.console && typeof console.warn === 'function') {
                     // eslint-disable-next-line no-console
-                    console.warn.apply(console, __spreadArray([this.id, this.getTime() + "ms"], args));
+                    console.warn.apply(console, __spreadArray([this.id, "".concat(this.getTime(), "ms")], args, false));
                 }
                 else {
                     this.info.apply(this, args);
@@ -7812,7 +8759,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                 // eslint-disable-next-line no-console
                 if (typeof window !== 'undefined' && window.console && typeof console.error === 'function') {
                     // eslint-disable-next-line no-console
-                    console.error.apply(console, __spreadArray([this.id, this.getTime() + "ms"], args));
+                    console.error.apply(console, __spreadArray([this.id, "".concat(this.getTime(), "ms")], args, false));
                 }
                 else {
                     this.info.apply(this, args);
@@ -7827,7 +8774,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
         function Context(options, windowBounds) {
             var _a;
             this.windowBounds = windowBounds;
-            this.instanceName = "#" + Context.instanceCount++;
+            this.instanceName = "#".concat(Context.instanceCount++);
             this.logger = new Logger({ id: this.instanceName, enabled: options.logging });
             this.cache = (_a = options.cache) !== null && _a !== void 0 ? _a : new Cache(this, options);
         }
@@ -7882,7 +8829,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                         inlineImages: foreignObjectRendering,
                         copyStyles: foreignObjectRendering
                     };
-                    context.logger.debug("Starting document clone with size " + windowBounds.width + "x" + windowBounds.height + " scrolled to " + -windowBounds.left + "," + -windowBounds.top);
+                    context.logger.debug("Starting document clone with size ".concat(windowBounds.width, "x").concat(windowBounds.height, " scrolled to ").concat(-windowBounds.left, ",").concat(-windowBounds.top));
                     documentCloner = new DocumentCloner(context, element, cloneOptions);
                     clonedElement = documentCloner.clonedReferenceElement;
                     if (!clonedElement) {
@@ -7912,13 +8859,13 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                     canvas = _u.sent();
                     return [3 /*break*/, 5];
                 case 3:
-                    context.logger.debug("Document cloned, element located at " + left + "," + top + " with size " + width + "x" + height + " using computed rendering");
+                    context.logger.debug("Document cloned, element located at ".concat(left, ",").concat(top, " with size ").concat(width, "x").concat(height, " using computed rendering"));
                     context.logger.debug("Starting DOM parsing");
                     root = parseTree(context, clonedElement);
                     if (backgroundColor === root.styles.backgroundColor) {
                         root.styles.backgroundColor = COLORS.TRANSPARENT;
                     }
-                    context.logger.debug("Starting renderer for element at " + renderOptions.x + "," + renderOptions.y + " with size " + renderOptions.width + "x" + renderOptions.height);
+                    context.logger.debug("Starting renderer for element at ".concat(renderOptions.x, ",").concat(renderOptions.y, " with size ").concat(renderOptions.width, "x").concat(renderOptions.height));
                     renderer = new CanvasRenderer(context, renderOptions);
                     return [4 /*yield*/, renderer.render(root)];
                 case 4:
@@ -7960,8 +8907,8 @@ var html2canvas = createCommonjsModule(function (module, exports) {
 
     return html2canvas;
 
-})));
-//# sourceMappingURL=html2canvas.js.map
+}));
+//# sourceMappingURL=html2canvas-pro.js.map
 });
 
 const feedbackModalCss = ".text-center{flex-grow:1;text-align:center}.feedback-modal-wrapper *{font-family:var(--feedback-font-family)}.feedback-modal-wrapper--custom-font *{font-family:inherit}.feedback-modal-wrapper{position:absolute;z-index:var(--feedback-modal-modal-wrapper-z-index)}.feedback-overlay{background-color:var(--feedback-modal-screenshot-bg-color);height:100%;left:0;opacity:0;position:fixed;top:0;width:100%;z-index:var(--feedback-modal-screnshot-z-index);transition:opacity 0.2s ease-out}.feedback-overlay--visible{opacity:1}.feedback-modal{display:inline-block;position:relative}.feedback-modal-content{background-color:var(--feedback-modal-content-bg-color);border-color:1px solid var(--feedback-modal-header-text-color);border-radius:var(--feedback-modal-content-border-radius);box-shadow:0px 1px 2px 0px rgba(60, 64, 67, .30), 0px 2px 6px 2px rgba(60, 64, 67, .15);box-sizing:border-box;color:var(--feedback-modal-content-text-color);display:flex;flex-direction:column;left:50%;max-width:90%;padding:20px;position:fixed;top:50%;transform:translate(-50%, -50%) scale(0.95);opacity:0;width:100%;z-index:var(--feedback-modal-content-z-index);transition:transform 0.2s ease-out, opacity 0.2s ease-out}.feedback-modal-content--open{transform:translate(-50%, -50%) scale(1);opacity:1}.feedback-modal-header{align-items:center;color:var(--feedback-modal-header-text-color);display:flex;font-size:var(--feedback-header-font-size);font-weight:var(--feedback-modal-header-font-weight);justify-content:space-between;margin-bottom:20px}.feedback-modal-rating-buttons{width:100%;margin-bottom:20px}.feedback-modal-rating-button{padding:0;background-color:transparent;border:transparent;margin-right:5px;cursor:pointer}.feedback-modal-rating-buttons--thumbs .feedback-modal-rating-button{border:1px solid var(--feedback-modal-button-border-color);border-radius:var(--feedback-modal-button-border-radius);color:var(--feedback-modal-button-text-color);font-size:var(--feedback-modal-button-font-size);font-weight:500;margin-right:10px;justify-content:center;padding:5px 10px}.feedback-modal-rating-buttons--thumbs .feedback-modal-rating-button:hover,.feedback-modal-rating-buttons--thumbs .feedback-modal-rating-button--selected{background-color:var(--feedback-modal-button-bg-color-active);border:1px solid var(--feedback-modal-button-border-color-active);color:var(--feedback-modal-button-text-color-active)}.feedback-modal-rating-buttons--thumbs .feedback-modal-rating-button:hover svg,.feedback-modal-rating-buttons--thumbs .feedback-modal-rating-button--selected svg{stroke:var(--feedback-modal-rating-button-selected-color)}.feedback-modal-rating-buttons svg{stroke:var(--feedback-modal-rating-button-color);cursor:pointer}.feedback-modal-rating-buttons--stars .feedback-modal-rating-button--selected svg{fill:var(--feedback-modal-rating-button-stars-selected-color);stroke:var(--feedback-modal-rating-button-stars-selected-color)}.feedback-modal-text textarea{background-color:var(--feedback-modal-input-bg-color);border:1px solid var(--feedback-modal-input-border-color);border-radius:var(--feedback-modal-input-border-radius);box-sizing:border-box;color:var(--feedback-modal-input-text-color);font-size:var(--feedback-modal-input-font-size);margin-bottom:20px;height:100px;min-height:100px;padding:10px;resize:vertical;width:100%}.feedback-modal-email input{background-color:var(--feedback-modal-input-bg-color);border:1px solid var(--feedback-modal-input-border-color);border-radius:var(--feedback-modal-input-border-radius);box-sizing:border-box;color:var(--feedback-modal-input-text-color);font-size:var(--feedback-modal-input-font-size);margin-bottom:20px;height:40px;padding:10px;width:100%;margin-bottom:20px}.feedback-modal-privacy{font-size:var(--feedback-modal-input-font-size);margin-bottom:20px}.feedback-modal-text textarea:focus,.feedback-modal-email input:focus{border:1px solid var(--feedback-modal-input-border-color-focused);outline:none}.feedback-modal-buttons{display:flex;flex-direction:column}.feedback-modal-buttons .feedback-modal-button{margin-bottom:20px}.feedback-modal-button{align-items:center;background-color:transparent;border:1px solid var(--feedback-modal-button-border-color);border-radius:var(--feedback-modal-button-border-radius);color:var(--feedback-modal-button-text-color);cursor:pointer;display:flex;font-size:var(--feedback-modal-button-font-size);font-weight:500;justify-content:center;min-height:40px;padding:5px 10px}.feedback-modal-button svg{margin-right:6px}.feedback-modal-button path{fill:var(--feedback-modal-button-icon-color)}.feedback-modal-button:hover path,.feedback-modal-button--active path{fill:var(--feedback-modal-button-icon-color-active)}.feedback-modal-button--submit{background-color:var(--feedback-modal-button-submit-bg-color);border:1px solid var(--feedback-modal-button-border-color-active);color:var(--feedback-modal-button-submit-text-color)}.feedback-modal-button:hover,.feedback-modal-button--active{background-color:var(--feedback-modal-button-bg-color-active);border:1px solid var(--feedback-modal-button-border-color-active);color:var(--feedback-modal-button-text-color-active)}.feedback-modal-button--submit:hover{background-color:var(--feedback-modal-button-submit-bg-color-hover);border:1px solid var(--feedback-modal-button-submit-border-color-hover);color:var(--feedback-modal-button-submit-text-color-hover)}.feedback-modal-input-heading{display:block;font-size:14px;font-weight:300;padding-bottom:10px}.feedback-modal-footer{font-size:12px;text-align:center}.feedback-modal-footer a{color:var(--feedback-modal-footer-link);font-weight:500;text-decoration:none}.feedback-logo{align-items:center;display:flex;justify-content:center;margin-top:5px}.feedback-logo a{margin-left:3px}.feedback-modal-close{background-color:var(--feedback-modal-close-bg-color);border:0;border-radius:50%;cursor:pointer;height:22px;margin-left:auto;padding:0;width:22px}.feedback-modal-close svg{stroke:var(--feedback-modal-close-color)}.feedback-modal-screenshot{background-color:var(--feedback-modal-screenshot-bg-color);height:100%;left:0;position:fixed;top:0;width:100%;z-index:var(--feedback-modal-screnshot-z-index)}.feedback-modal-screenshot-header{align-items:center;background-color:var(--feedback-modal-screenshot-header-bg-color);border-radius:var(--feedback-modal-content-border-radius);box-shadow:0px 1px 2px 0px rgba(60, 64, 67, .30), 0px 2px 6px 2px rgba(60, 64, 67, .15);box-sizing:border-box;color:var(--feedback-modal-screenshot-header-text-color);cursor:pointer;display:flex;left:50%;top:20px;transform:translateX(-50%);padding:10px;position:fixed;width:max-content;z-index:var(--feedback-modal-screenshot-header-z-index)}.feedback-modal-screenshot-close{height:24px;padding-left:10px;width:24px}.feedback-modal-screenshot-close svg{stroke:var(--feedback-modal-close-color)}.feedback-modal-message{font-size:var(--feedback-modal-message-font-size);margin-top:0}.feedback-modal-element-hover{background-color:transparent;cursor:pointer;border:1px solid var(--feedback-modal-element-hover-border-color)}.feedback-modal-element-selected{background-color:transparent;border:1px solid var(--feedback-modal-element-selected-border-color)}@media screen and (min-width: 768px){.feedback-modal-content{max-width:var(--feedback-modal-content-max-width)}.feedback-modal-content.feedback-modal-content--bottom-right{bottom:var(--feedback-modal-content-position-bottom);left:initial;right:var(--feedback-modal-content-position-right);top:initial;transform:initial}.feedback-modal-content.feedback-modal-content--bottom-left{bottom:var(--feedback-modal-content-position-bottom);left:var(--feedback-modal-content-position-left);top:initial;transform:initial}.feedback-modal-content.feedback-modal-content--top-right{right:var(--feedback-modal-content-position-right);top:var(--feedback-modal-content-position-top);transform:initial}.feedback-modal-content.feedback-modal-content--top-left{left:var(--feedback-modal-content-position-left);top:var(--feedback-modal-content-position-top);transform:initial}.feedback-modal-content.feedback-modal-content--center-left{left:5px;right:auto;top:50%;transform:translateY(-50%)}.feedback-modal-content.feedback-modal-content--center-right{left:auto;right:5px;top:50%;transform:translateY(-50%)}.feedback-modal-content.feedback-modal-content--sidebar-left.feedback-modal-content--open,.feedback-modal-content.feedback-modal-content--sidebar-right.feedback-modal-content--open{transform:translateX(0)}.feedback-modal-content.feedback-modal-content--sidebar-left{max-width:var(--feedback-modal-content-sidebar-max-width);left:0;right:auto;height:100vh;top:0;transform:translateX(-100%);transition:transform 0.5s ease-in-out;border-radius:0}.feedback-modal-content.feedback-modal-content--sidebar-right{max-width:var(--feedback-modal-content-sidebar-max-width);left:auto;right:0;height:100vh;top:0;transform:translateX(100%);transition:transform 0.5s ease-in-out;border-radius:0}.feedback-modal-text textarea{height:150px;min-height:150px}.feedback-modal-content.feedback-modal-content--bottom-right{transform:translateY(20px)}.feedback-modal-content.feedback-modal-content--bottom-right.feedback-modal-content--open{transform:translateY(0)}.feedback-modal-content.feedback-modal-content--bottom-left{transform:translateY(20px)}.feedback-modal-content.feedback-modal-content--bottom-left.feedback-modal-content--open{transform:translateY(0)}.feedback-modal-content.feedback-modal-content--top-right{transform:translateY(-20px)}.feedback-modal-content.feedback-modal-content--top-right.feedback-modal-content--open{transform:translateY(0)}.feedback-modal-content.feedback-modal-content--top-left{transform:translateY(-20px)}.feedback-modal-content.feedback-modal-content--top-left.feedback-modal-content--open{transform:translateY(0)}}";
@@ -8244,7 +9191,7 @@ const FeedbackModal = class {
   captureScreenshot() {
     return new Promise((resolve, reject) => {
       requestAnimationFrame(() => {
-        html2canvas(document.body, {
+        html2canvasPro(document.body, {
           x: window.scrollX,
           y: window.scrollY,
           width: window.innerWidth,