html2canvas-pro 1.5.13 → 1.6.1

package/dist/lib/css/syntax/tokenizer.js

@@ -2,95 +2,87 @@
 // https://www.w3.org/TR/css-syntax-3
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Tokenizer = exports.EOF_TOKEN = exports.FLAG_NUMBER = exports.FLAG_INTEGER = exports.FLAG_ID = exports.FLAG_UNRESTRICTED = void 0;
-var css_line_break_1 = require("css-line-break");
+const css_line_break_1 = require("css-line-break");
 exports.FLAG_UNRESTRICTED = 1 << 0;
 exports.FLAG_ID = 1 << 1;
 exports.FLAG_INTEGER = 1 << 2;
 exports.FLAG_NUMBER = 1 << 3;
-var LINE_FEED = 0x000a;
-var SOLIDUS = 0x002f;
-var REVERSE_SOLIDUS = 0x005c;
-var CHARACTER_TABULATION = 0x0009;
-var SPACE = 0x0020;
-var QUOTATION_MARK = 0x0022;
-var EQUALS_SIGN = 0x003d;
-var NUMBER_SIGN = 0x0023;
-var DOLLAR_SIGN = 0x0024;
-var PERCENTAGE_SIGN = 0x0025;
-var APOSTROPHE = 0x0027;
-var LEFT_PARENTHESIS = 0x0028;
-var RIGHT_PARENTHESIS = 0x0029;
-var LOW_LINE = 0x005f;
-var HYPHEN_MINUS = 0x002d;
-var EXCLAMATION_MARK = 0x0021;
-var LESS_THAN_SIGN = 0x003c;
-var GREATER_THAN_SIGN = 0x003e;
-var COMMERCIAL_AT = 0x0040;
-var LEFT_SQUARE_BRACKET = 0x005b;
-var RIGHT_SQUARE_BRACKET = 0x005d;
-var CIRCUMFLEX_ACCENT = 0x003d;
-var LEFT_CURLY_BRACKET = 0x007b;
-var QUESTION_MARK = 0x003f;
-var RIGHT_CURLY_BRACKET = 0x007d;
-var VERTICAL_LINE = 0x007c;
-var TILDE = 0x007e;
-var CONTROL = 0x0080;
-var REPLACEMENT_CHARACTER = 0xfffd;
-var ASTERISK = 0x002a;
-var PLUS_SIGN = 0x002b;
-var COMMA = 0x002c;
-var COLON = 0x003a;
-var SEMICOLON = 0x003b;
-var FULL_STOP = 0x002e;
-var NULL = 0x0000;
-var BACKSPACE = 0x0008;
-var LINE_TABULATION = 0x000b;
-var SHIFT_OUT = 0x000e;
-var INFORMATION_SEPARATOR_ONE = 0x001f;
-var DELETE = 0x007f;
-var EOF = -1;
-var ZERO = 0x0030;
-var a = 0x0061;
-var e = 0x0065;
-var f = 0x0066;
-var u = 0x0075;
-var z = 0x007a;
-var A = 0x0041;
-var E = 0x0045;
-var F = 0x0046;
-var U = 0x0055;
-var Z = 0x005a;
-var isDigit = function (codePoint) { return codePoint >= ZERO && codePoint <= 0x0039; };
-var isSurrogateCodePoint = function (codePoint) { return codePoint >= 0xd800 && codePoint <= 0xdfff; };
-var isHex = function (codePoint) {
-    return isDigit(codePoint) || (codePoint >= A && codePoint <= F) || (codePoint >= a && codePoint <= f);
-};
-var isLowerCaseLetter = function (codePoint) { return codePoint >= a && codePoint <= z; };
-var isUpperCaseLetter = function (codePoint) { return codePoint >= A && codePoint <= Z; };
-var isLetter = function (codePoint) { return isLowerCaseLetter(codePoint) || isUpperCaseLetter(codePoint); };
-var isNonASCIICodePoint = function (codePoint) { return codePoint >= CONTROL; };
-var isWhiteSpace = function (codePoint) {
-    return codePoint === LINE_FEED || codePoint === CHARACTER_TABULATION || codePoint === SPACE;
-};
-var isNameStartCodePoint = function (codePoint) {
-    return isLetter(codePoint) || isNonASCIICodePoint(codePoint) || codePoint === LOW_LINE;
-};
-var isNameCodePoint = function (codePoint) {
-    return isNameStartCodePoint(codePoint) || isDigit(codePoint) || codePoint === HYPHEN_MINUS;
-};
-var isNonPrintableCodePoint = function (codePoint) {
+const LINE_FEED = 0x000a;
+const SOLIDUS = 0x002f;
+const REVERSE_SOLIDUS = 0x005c;
+const CHARACTER_TABULATION = 0x0009;
+const SPACE = 0x0020;
+const QUOTATION_MARK = 0x0022;
+const EQUALS_SIGN = 0x003d;
+const NUMBER_SIGN = 0x0023;
+const DOLLAR_SIGN = 0x0024;
+const PERCENTAGE_SIGN = 0x0025;
+const APOSTROPHE = 0x0027;
+const LEFT_PARENTHESIS = 0x0028;
+const RIGHT_PARENTHESIS = 0x0029;
+const LOW_LINE = 0x005f;
+const HYPHEN_MINUS = 0x002d;
+const EXCLAMATION_MARK = 0x0021;
+const LESS_THAN_SIGN = 0x003c;
+const GREATER_THAN_SIGN = 0x003e;
+const COMMERCIAL_AT = 0x0040;
+const LEFT_SQUARE_BRACKET = 0x005b;
+const RIGHT_SQUARE_BRACKET = 0x005d;
+const CIRCUMFLEX_ACCENT = 0x003d;
+const LEFT_CURLY_BRACKET = 0x007b;
+const QUESTION_MARK = 0x003f;
+const RIGHT_CURLY_BRACKET = 0x007d;
+const VERTICAL_LINE = 0x007c;
+const TILDE = 0x007e;
+const CONTROL = 0x0080;
+const REPLACEMENT_CHARACTER = 0xfffd;
+const ASTERISK = 0x002a;
+const PLUS_SIGN = 0x002b;
+const COMMA = 0x002c;
+const COLON = 0x003a;
+const SEMICOLON = 0x003b;
+const FULL_STOP = 0x002e;
+const NULL = 0x0000;
+const BACKSPACE = 0x0008;
+const LINE_TABULATION = 0x000b;
+const SHIFT_OUT = 0x000e;
+const INFORMATION_SEPARATOR_ONE = 0x001f;
+const DELETE = 0x007f;
+const EOF = -1;
+const ZERO = 0x0030;
+const a = 0x0061;
+const e = 0x0065;
+const f = 0x0066;
+const u = 0x0075;
+const z = 0x007a;
+const A = 0x0041;
+const E = 0x0045;
+const F = 0x0046;
+const U = 0x0055;
+const Z = 0x005a;
+const isDigit = (codePoint) => codePoint >= ZERO && codePoint <= 0x0039;
+const isSurrogateCodePoint = (codePoint) => codePoint >= 0xd800 && codePoint <= 0xdfff;
+const isHex = (codePoint) => isDigit(codePoint) || (codePoint >= A && codePoint <= F) || (codePoint >= a && codePoint <= f);
+const isLowerCaseLetter = (codePoint) => codePoint >= a && codePoint <= z;
+const isUpperCaseLetter = (codePoint) => codePoint >= A && codePoint <= Z;
+const isLetter = (codePoint) => isLowerCaseLetter(codePoint) || isUpperCaseLetter(codePoint);
+const isNonASCIICodePoint = (codePoint) => codePoint >= CONTROL;
+const isWhiteSpace = (codePoint) => codePoint === LINE_FEED || codePoint === CHARACTER_TABULATION || codePoint === SPACE;
+const isNameStartCodePoint = (codePoint) => isLetter(codePoint) || isNonASCIICodePoint(codePoint) || codePoint === LOW_LINE;
+const isNameCodePoint = (codePoint) => isNameStartCodePoint(codePoint) || isDigit(codePoint) || codePoint === HYPHEN_MINUS;
+const isNonPrintableCodePoint = (codePoint) => {
     return ((codePoint >= NULL && codePoint <= BACKSPACE) ||
         codePoint === LINE_TABULATION ||
         (codePoint >= SHIFT_OUT && codePoint <= INFORMATION_SEPARATOR_ONE) ||
         codePoint === DELETE);
 };
-var isValidEscape = function (c1, c2) {
+const isValidEscape = (c1, c2) => {
     if (c1 !== REVERSE_SOLIDUS) {
         return false;
     }
     return c2 !== LINE_FEED;
 };
-var isIdentifierStart = function (c1, c2, c3) {
+const isIdentifierStart = (c1, c2, c3) => {
     if (c1 === HYPHEN_MINUS) {
         return isNameStartCodePoint(c2) || isValidEscape(c2, c3);
     }
@@ -102,7 +94,7 @@ var isIdentifierStart = function (c1, c2, c3) {
     }
     return false;
 };
-var isNumberStart = function (c1, c2, c3) {
+const isNumberStart = (c1, c2, c3) => {
     if (c1 === PLUS_SIGN || c1 === HYPHEN_MINUS) {
         if (isDigit(c2)) {
             return true;
@@ -114,108 +106,108 @@ var isNumberStart = function (c1, c2, c3) {
     }
     return isDigit(c1);
 };
-var stringToNumber = function (codePoints) {
-    var c = 0;
-    var sign = 1;
+const stringToNumber = (codePoints) => {
+    let c = 0;
+    let sign = 1;
     if (codePoints[c] === PLUS_SIGN || codePoints[c] === HYPHEN_MINUS) {
         if (codePoints[c] === HYPHEN_MINUS) {
             sign = -1;
         }
         c++;
     }
-    var integers = [];
+    const integers = [];
     while (isDigit(codePoints[c])) {
         integers.push(codePoints[c++]);
     }
-    var int = integers.length ? parseInt(css_line_break_1.fromCodePoint.apply(void 0, integers), 10) : 0;
+    const int = integers.length ? parseInt((0, css_line_break_1.fromCodePoint)(...integers), 10) : 0;
     if (codePoints[c] === FULL_STOP) {
         c++;
     }
-    var fraction = [];
+    const fraction = [];
     while (isDigit(codePoints[c])) {
         fraction.push(codePoints[c++]);
     }
-    var fracd = fraction.length;
-    var frac = fracd ? parseInt(css_line_break_1.fromCodePoint.apply(void 0, fraction), 10) : 0;
+    const fracd = fraction.length;
+    const frac = fracd ? parseInt((0, css_line_break_1.fromCodePoint)(...fraction), 10) : 0;
     if (codePoints[c] === E || codePoints[c] === e) {
         c++;
     }
-    var expsign = 1;
+    let expsign = 1;
     if (codePoints[c] === PLUS_SIGN || codePoints[c] === HYPHEN_MINUS) {
         if (codePoints[c] === HYPHEN_MINUS) {
             expsign = -1;
         }
         c++;
     }
-    var exponent = [];
+    const exponent = [];
     while (isDigit(codePoints[c])) {
         exponent.push(codePoints[c++]);
     }
-    var exp = exponent.length ? parseInt(css_line_break_1.fromCodePoint.apply(void 0, exponent), 10) : 0;
+    const exp = exponent.length ? parseInt((0, css_line_break_1.fromCodePoint)(...exponent), 10) : 0;
     return sign * (int + frac * Math.pow(10, -fracd)) * Math.pow(10, expsign * exp);
 };
-var LEFT_PARENTHESIS_TOKEN = {
+const LEFT_PARENTHESIS_TOKEN = {
     type: 2 /* TokenType.LEFT_PARENTHESIS_TOKEN */
 };
-var RIGHT_PARENTHESIS_TOKEN = {
+const RIGHT_PARENTHESIS_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 = {
+const COMMA_TOKEN = { type: 4 /* TokenType.COMMA_TOKEN */ };
+const SUFFIX_MATCH_TOKEN = { type: 13 /* TokenType.SUFFIX_MATCH_TOKEN */ };
+const PREFIX_MATCH_TOKEN = { type: 8 /* TokenType.PREFIX_MATCH_TOKEN */ };
+const COLUMN_TOKEN = { type: 21 /* TokenType.COLUMN_TOKEN */ };
+const DASH_MATCH_TOKEN = { type: 9 /* TokenType.DASH_MATCH_TOKEN */ };
+const INCLUDE_MATCH_TOKEN = { type: 10 /* TokenType.INCLUDE_MATCH_TOKEN */ };
+const LEFT_CURLY_BRACKET_TOKEN = {
     type: 11 /* TokenType.LEFT_CURLY_BRACKET_TOKEN */
 };
-var RIGHT_CURLY_BRACKET_TOKEN = {
+const RIGHT_CURLY_BRACKET_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 = {
+const SUBSTRING_MATCH_TOKEN = { type: 14 /* TokenType.SUBSTRING_MATCH_TOKEN */ };
+const BAD_URL_TOKEN = { type: 23 /* TokenType.BAD_URL_TOKEN */ };
+const BAD_STRING_TOKEN = { type: 1 /* TokenType.BAD_STRING_TOKEN */ };
+const CDO_TOKEN = { type: 25 /* TokenType.CDO_TOKEN */ };
+const CDC_TOKEN = { type: 24 /* TokenType.CDC_TOKEN */ };
+const COLON_TOKEN = { type: 26 /* TokenType.COLON_TOKEN */ };
+const SEMICOLON_TOKEN = { type: 27 /* TokenType.SEMICOLON_TOKEN */ };
+const LEFT_SQUARE_BRACKET_TOKEN = {
     type: 28 /* TokenType.LEFT_SQUARE_BRACKET_TOKEN */
 };
-var RIGHT_SQUARE_BRACKET_TOKEN = {
+const RIGHT_SQUARE_BRACKET_TOKEN = {
     type: 29 /* TokenType.RIGHT_SQUARE_BRACKET_TOKEN */
 };
-var WHITESPACE_TOKEN = { type: 31 /* TokenType.WHITESPACE_TOKEN */ };
+const WHITESPACE_TOKEN = { type: 31 /* TokenType.WHITESPACE_TOKEN */ };
 exports.EOF_TOKEN = { type: 32 /* TokenType.EOF_TOKEN */ };
-var Tokenizer = /** @class */ (function () {
-    function Tokenizer() {
+class Tokenizer {
+    constructor() {
         this._value = [];
     }
-    Tokenizer.prototype.write = function (chunk) {
+    write(chunk) {
         this._value = this._value.concat((0, css_line_break_1.toCodePoints)(chunk));
-    };
-    Tokenizer.prototype.read = function () {
-        var tokens = [];
-        var token = this.consumeToken();
+    }
+    read() {
+        const tokens = [];
+        let token = this.consumeToken();
         while (token !== exports.EOF_TOKEN) {
             tokens.push(token);
             token = this.consumeToken();
         }
         return tokens;
-    };
-    Tokenizer.prototype.consumeToken = function () {
-        var codePoint = this.consumeCodePoint();
+    }
+    consumeToken() {
+        const codePoint = this.consumeCodePoint();
         switch (codePoint) {
             case QUOTATION_MARK:
                 return this.consumeStringToken(QUOTATION_MARK);
             case NUMBER_SIGN:
-                var c1 = this.peekCodePoint(0);
-                var c2 = this.peekCodePoint(1);
-                var c3 = this.peekCodePoint(2);
+                const c1 = this.peekCodePoint(0);
+                const c2 = this.peekCodePoint(1);
+                const c3 = this.peekCodePoint(2);
                 if (isNameCodePoint(c1) || isValidEscape(c2, c3)) {
-                    var flags = isIdentifierStart(c1, c2, c3) ? exports.FLAG_ID : exports.FLAG_UNRESTRICTED;
-                    var value = this.consumeName();
-                    return { type: 5 /* TokenType.HASH_TOKEN */, value: value, flags: flags };
+                    const flags = isIdentifierStart(c1, c2, c3) ? exports.FLAG_ID : exports.FLAG_UNRESTRICTED;
+                    const value = this.consumeName();
+                    return { type: 5 /* TokenType.HASH_TOKEN */, value, flags };
                 }
                 break;
             case DOLLAR_SIGN:
@@ -245,9 +237,9 @@ var Tokenizer = /** @class */ (function () {
             case COMMA:
                 return COMMA_TOKEN;
             case HYPHEN_MINUS:
-                var e1 = codePoint;
-                var e2 = this.peekCodePoint(0);
-                var e3 = this.peekCodePoint(1);
+                const e1 = codePoint;
+                const e2 = this.peekCodePoint(0);
+                const e3 = this.peekCodePoint(1);
                 if (isNumberStart(e1, e2, e3)) {
                     this.reconsumeCodePoint(codePoint);
                     return this.consumeNumericToken();
@@ -272,7 +264,7 @@ var Tokenizer = /** @class */ (function () {
                 if (this.peekCodePoint(0) === ASTERISK) {
                     this.consumeCodePoint();
                     while (true) {
-                        var c = this.consumeCodePoint();
+                        let c = this.consumeCodePoint();
                         if (c === ASTERISK) {
                             c = this.consumeCodePoint();
                             if (c === SOLIDUS) {
@@ -299,12 +291,12 @@ var Tokenizer = /** @class */ (function () {
                 }
                 break;
             case COMMERCIAL_AT:
-                var a1 = this.peekCodePoint(0);
-                var a2 = this.peekCodePoint(1);
-                var a3 = this.peekCodePoint(2);
+                const a1 = this.peekCodePoint(0);
+                const a2 = this.peekCodePoint(1);
+                const a3 = this.peekCodePoint(2);
                 if (isIdentifierStart(a1, a2, a3)) {
-                    var value = this.consumeName();
-                    return { type: 7 /* TokenType.AT_KEYWORD_TOKEN */, value: value };
+                    const value = this.consumeName();
+                    return { type: 7 /* TokenType.AT_KEYWORD_TOKEN */, value };
                 }
                 break;
             case LEFT_SQUARE_BRACKET:
@@ -329,8 +321,8 @@ var Tokenizer = /** @class */ (function () {
                 return RIGHT_CURLY_BRACKET_TOKEN;
             case u:
             case U:
-                var u1 = this.peekCodePoint(0);
-                var u2 = this.peekCodePoint(1);
+                const u1 = this.peekCodePoint(0);
+                const u2 = this.peekCodePoint(1);
                 if (u1 === PLUS_SIGN && (isHex(u2) || u2 === QUESTION_MARK)) {
                     this.consumeCodePoint();
                     this.consumeUnicodeRangeToken();
@@ -369,75 +361,75 @@ var Tokenizer = /** @class */ (function () {
             return this.consumeIdentLikeToken();
         }
         return { type: 6 /* TokenType.DELIM_TOKEN */, value: (0, css_line_break_1.fromCodePoint)(codePoint) };
-    };
-    Tokenizer.prototype.consumeCodePoint = function () {
-        var value = this._value.shift();
+    }
+    consumeCodePoint() {
+        const value = this._value.shift();
         return typeof value === 'undefined' ? -1 : value;
-    };
-    Tokenizer.prototype.reconsumeCodePoint = function (codePoint) {
+    }
+    reconsumeCodePoint(codePoint) {
         this._value.unshift(codePoint);
-    };
-    Tokenizer.prototype.peekCodePoint = function (delta) {
+    }
+    peekCodePoint(delta) {
         if (delta >= this._value.length) {
             return -1;
         }
         return this._value[delta];
-    };
-    Tokenizer.prototype.consumeUnicodeRangeToken = function () {
-        var digits = [];
-        var codePoint = this.consumeCodePoint();
+    }
+    consumeUnicodeRangeToken() {
+        const digits = [];
+        let codePoint = this.consumeCodePoint();
         while (isHex(codePoint) && digits.length < 6) {
             digits.push(codePoint);
             codePoint = this.consumeCodePoint();
         }
-        var questionMarks = false;
+        let questionMarks = false;
         while (codePoint === QUESTION_MARK && digits.length < 6) {
             digits.push(codePoint);
             codePoint = this.consumeCodePoint();
             questionMarks = true;
         }
         if (questionMarks) {
-            var start_1 = parseInt(css_line_break_1.fromCodePoint.apply(void 0, digits.map(function (digit) { return (digit === QUESTION_MARK ? ZERO : digit); })), 16);
-            var end = parseInt(css_line_break_1.fromCodePoint.apply(void 0, digits.map(function (digit) { return (digit === QUESTION_MARK ? F : digit); })), 16);
-            return { type: 30 /* TokenType.UNICODE_RANGE_TOKEN */, start: start_1, end: end };
+            const start = parseInt((0, css_line_break_1.fromCodePoint)(...digits.map((digit) => (digit === QUESTION_MARK ? ZERO : digit))), 16);
+            const end = parseInt((0, css_line_break_1.fromCodePoint)(...digits.map((digit) => (digit === QUESTION_MARK ? F : digit))), 16);
+            return { type: 30 /* TokenType.UNICODE_RANGE_TOKEN */, start, end };
         }
-        var start = parseInt(css_line_break_1.fromCodePoint.apply(void 0, digits), 16);
+        const start = parseInt((0, css_line_break_1.fromCodePoint)(...digits), 16);
         if (this.peekCodePoint(0) === HYPHEN_MINUS && isHex(this.peekCodePoint(1))) {
             this.consumeCodePoint();
             codePoint = this.consumeCodePoint();
-            var endDigits = [];
+            const endDigits = [];
             while (isHex(codePoint) && endDigits.length < 6) {
                 endDigits.push(codePoint);
                 codePoint = this.consumeCodePoint();
             }
-            var end = parseInt(css_line_break_1.fromCodePoint.apply(void 0, endDigits), 16);
-            return { type: 30 /* TokenType.UNICODE_RANGE_TOKEN */, start: start, end: end };
+            const end = parseInt((0, css_line_break_1.fromCodePoint)(...endDigits), 16);
+            return { type: 30 /* TokenType.UNICODE_RANGE_TOKEN */, start, end };
         }
         else {
-            return { type: 30 /* TokenType.UNICODE_RANGE_TOKEN */, start: start, end: start };
+            return { type: 30 /* TokenType.UNICODE_RANGE_TOKEN */, start, end: start };
         }
-    };
-    Tokenizer.prototype.consumeIdentLikeToken = function () {
-        var value = this.consumeName();
+    }
+    consumeIdentLikeToken() {
+        const value = this.consumeName();
         if (value.toLowerCase() === 'url' && this.peekCodePoint(0) === LEFT_PARENTHESIS) {
             this.consumeCodePoint();
             return this.consumeUrlToken();
         }
         else if (this.peekCodePoint(0) === LEFT_PARENTHESIS) {
             this.consumeCodePoint();
-            return { type: 19 /* TokenType.FUNCTION_TOKEN */, value: value };
+            return { type: 19 /* TokenType.FUNCTION_TOKEN */, value };
         }
-        return { type: 20 /* TokenType.IDENT_TOKEN */, value: value };
-    };
-    Tokenizer.prototype.consumeUrlToken = function () {
-        var value = [];
+        return { type: 20 /* TokenType.IDENT_TOKEN */, value };
+    }
+    consumeUrlToken() {
+        const value = [];
         this.consumeWhiteSpace();
         if (this.peekCodePoint(0) === EOF) {
             return { type: 22 /* TokenType.URL_TOKEN */, value: '' };
         }
-        var next = this.peekCodePoint(0);
+        const next = this.peekCodePoint(0);
         if (next === APOSTROPHE || next === QUOTATION_MARK) {
-            var stringToken = this.consumeStringToken(this.consumeCodePoint());
+            const stringToken = this.consumeStringToken(this.consumeCodePoint());
             if (stringToken.type === 0 /* TokenType.STRING_TOKEN */) {
                 this.consumeWhiteSpace();
                 if (this.peekCodePoint(0) === EOF || this.peekCodePoint(0) === RIGHT_PARENTHESIS) {
@@ -449,15 +441,15 @@ var Tokenizer = /** @class */ (function () {
             return BAD_URL_TOKEN;
         }
         while (true) {
-            var codePoint = this.consumeCodePoint();
+            const codePoint = this.consumeCodePoint();
             if (codePoint === EOF || codePoint === RIGHT_PARENTHESIS) {
-                return { type: 22 /* TokenType.URL_TOKEN */, value: css_line_break_1.fromCodePoint.apply(void 0, value) };
+                return { type: 22 /* TokenType.URL_TOKEN */, value: (0, css_line_break_1.fromCodePoint)(...value) };
             }
             else if (isWhiteSpace(codePoint)) {
                 this.consumeWhiteSpace();
                 if (this.peekCodePoint(0) === EOF || this.peekCodePoint(0) === RIGHT_PARENTHESIS) {
                     this.consumeCodePoint();
-                    return { type: 22 /* TokenType.URL_TOKEN */, value: css_line_break_1.fromCodePoint.apply(void 0, value) };
+                    return { type: 22 /* TokenType.URL_TOKEN */, value: (0, css_line_break_1.fromCodePoint)(...value) };
                 }
                 this.consumeBadUrlRemnants();
                 return BAD_URL_TOKEN;
@@ -482,15 +474,15 @@ var Tokenizer = /** @class */ (function () {
                 value.push(codePoint);
             }
         }
-    };
-    Tokenizer.prototype.consumeWhiteSpace = function () {
+    }
+    consumeWhiteSpace() {
         while (isWhiteSpace(this.peekCodePoint(0))) {
             this.consumeCodePoint();
         }
-    };
-    Tokenizer.prototype.consumeBadUrlRemnants = function () {
+    }
+    consumeBadUrlRemnants() {
         while (true) {
-            var codePoint = this.consumeCodePoint();
+            const codePoint = this.consumeCodePoint();
             if (codePoint === RIGHT_PARENTHESIS || codePoint === EOF) {
                 return;
             }
@@ -498,33 +490,33 @@ var Tokenizer = /** @class */ (function () {
                 this.consumeEscapedCodePoint();
             }
         }
-    };
-    Tokenizer.prototype.consumeStringSlice = function (count) {
-        var SLICE_STACK_SIZE = 50000;
-        var value = '';
+    }
+    consumeStringSlice(count) {
+        const SLICE_STACK_SIZE = 50000;
+        let value = '';
         while (count > 0) {
-            var amount = Math.min(SLICE_STACK_SIZE, count);
-            value += css_line_break_1.fromCodePoint.apply(void 0, this._value.splice(0, amount));
+            const amount = Math.min(SLICE_STACK_SIZE, count);
+            value += (0, css_line_break_1.fromCodePoint)(...this._value.splice(0, amount));
             count -= amount;
         }
         this._value.shift();
         return value;
-    };
-    Tokenizer.prototype.consumeStringToken = function (endingCodePoint) {
-        var value = '';
-        var i = 0;
+    }
+    consumeStringToken(endingCodePoint) {
+        let value = '';
+        let i = 0;
         do {
-            var codePoint = this._value[i];
+            const codePoint = this._value[i];
             if (codePoint === EOF || codePoint === undefined || codePoint === endingCodePoint) {
                 value += this.consumeStringSlice(i);
-                return { type: 0 /* TokenType.STRING_TOKEN */, value: value };
+                return { type: 0 /* TokenType.STRING_TOKEN */, value };
             }
             if (codePoint === LINE_FEED) {
                 this._value.splice(0, i);
                 return BAD_STRING_TOKEN;
             }
             if (codePoint === REVERSE_SOLIDUS) {
-                var next = this._value[i + 1];
+                const next = this._value[i + 1];
                 if (next !== EOF && next !== undefined) {
                     if (next === LINE_FEED) {
                         value += this.consumeStringSlice(i);
@@ -540,11 +532,11 @@ var Tokenizer = /** @class */ (function () {
             }
             i++;
         } while (true);
-    };
-    Tokenizer.prototype.consumeNumber = function () {
-        var repr = [];
-        var type = exports.FLAG_INTEGER;
-        var c1 = this.peekCodePoint(0);
+    }
+    consumeNumber() {
+        const repr = [];
+        let type = exports.FLAG_INTEGER;
+        let c1 = this.peekCodePoint(0);
         if (c1 === PLUS_SIGN || c1 === HYPHEN_MINUS) {
             repr.push(this.consumeCodePoint());
         }
@@ -552,7 +544,7 @@ var Tokenizer = /** @class */ (function () {
             repr.push(this.consumeCodePoint());
         }
         c1 = this.peekCodePoint(0);
-        var c2 = this.peekCodePoint(1);
+        let c2 = this.peekCodePoint(1);
         if (c1 === FULL_STOP && isDigit(c2)) {
             repr.push(this.consumeCodePoint(), this.consumeCodePoint());
             type = exports.FLAG_NUMBER;
@@ -562,7 +554,7 @@ var Tokenizer = /** @class */ (function () {
         }
         c1 = this.peekCodePoint(0);
         c2 = this.peekCodePoint(1);
-        var c3 = this.peekCodePoint(2);
+        const c3 = this.peekCodePoint(2);
         if ((c1 === E || c1 === e) && (((c2 === PLUS_SIGN || c2 === HYPHEN_MINUS) && isDigit(c3)) || isDigit(c2))) {
             repr.push(this.consumeCodePoint(), this.consumeCodePoint());
             type = exports.FLAG_NUMBER;
@@ -571,33 +563,33 @@ var Tokenizer = /** @class */ (function () {
             }
         }
         return [stringToNumber(repr), type];
-    };
-    Tokenizer.prototype.consumeNumericToken = function () {
-        var _a = this.consumeNumber(), number = _a[0], flags = _a[1];
-        var c1 = this.peekCodePoint(0);
-        var c2 = this.peekCodePoint(1);
-        var c3 = this.peekCodePoint(2);
+    }
+    consumeNumericToken() {
+        const [number, flags] = this.consumeNumber();
+        const c1 = this.peekCodePoint(0);
+        const c2 = this.peekCodePoint(1);
+        const c3 = this.peekCodePoint(2);
         if (isIdentifierStart(c1, c2, c3)) {
-            var unit = this.consumeName();
-            return { type: 15 /* TokenType.DIMENSION_TOKEN */, number: number, flags: flags, unit: unit };
+            const unit = this.consumeName();
+            return { type: 15 /* TokenType.DIMENSION_TOKEN */, number, flags, unit };
         }
         if (c1 === PERCENTAGE_SIGN) {
             this.consumeCodePoint();
-            return { type: 16 /* TokenType.PERCENTAGE_TOKEN */, number: number, flags: flags };
+            return { type: 16 /* TokenType.PERCENTAGE_TOKEN */, number, flags };
         }
-        return { type: 17 /* TokenType.NUMBER_TOKEN */, number: number, flags: flags };
-    };
-    Tokenizer.prototype.consumeEscapedCodePoint = function () {
-        var codePoint = this.consumeCodePoint();
+        return { type: 17 /* TokenType.NUMBER_TOKEN */, number, flags };
+    }
+    consumeEscapedCodePoint() {
+        const codePoint = this.consumeCodePoint();
         if (isHex(codePoint)) {
-            var hex = (0, css_line_break_1.fromCodePoint)(codePoint);
+            let hex = (0, css_line_break_1.fromCodePoint)(codePoint);
             while (isHex(this.peekCodePoint(0)) && hex.length < 6) {
                 hex += (0, css_line_break_1.fromCodePoint)(this.consumeCodePoint());
             }
             if (isWhiteSpace(this.peekCodePoint(0))) {
                 this.consumeCodePoint();
             }
-            var hexCodePoint = parseInt(hex, 16);
+            const hexCodePoint = parseInt(hex, 16);
             if (hexCodePoint === 0 || isSurrogateCodePoint(hexCodePoint) || hexCodePoint > 0x10ffff) {
                 return REPLACEMENT_CHARACTER;
             }
@@ -607,11 +599,11 @@ var Tokenizer = /** @class */ (function () {
             return REPLACEMENT_CHARACTER;
         }
         return codePoint;
-    };
-    Tokenizer.prototype.consumeName = function () {
-        var result = '';
+    }
+    consumeName() {
+        let result = '';
         while (true) {
-            var codePoint = this.consumeCodePoint();
+            const codePoint = this.consumeCodePoint();
             if (isNameCodePoint(codePoint)) {
                 result += (0, css_line_break_1.fromCodePoint)(codePoint);
             }
@@ -623,8 +615,7 @@ var Tokenizer = /** @class */ (function () {
                 return result;
             }
         }
-    };
-    return Tokenizer;
-}());
+    }
+}
 exports.Tokenizer = Tokenizer;
 //# sourceMappingURL=tokenizer.js.map