https://secularpolicyinstitute.net/wp-content/plugins/pdf-print/js/html2canvas.js?ver=6.2.11

1/*!
2 * html2canvas 1.0.0-rc.3 <https://html2canvas.hertzen.com>
3 * Copyright (c) 2019 Niklas von Hertzen <https://hertzen.com>
4 * Released under MIT License
5 */
6(function (global, factory) {
7    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
8    typeof define === 'function' && define.amd ? define(factory) :
9    (global = global || self, global.html2canvas = factory());
10}(this, function () { 'use strict';
11
12    /*! *****************************************************************************
13    Copyright (c) Microsoft Corporation. All rights reserved.
14    Licensed under the Apache License, Version 2.0 (the "License"); you may not use
15    this file except in compliance with the License. You may obtain a copy of the
16    License at http://www.apache.org/licenses/LICENSE-2.0
17
18    THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
19    KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
20    WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
21    MERCHANTABLITY OR NON-INFRINGEMENT.
22
23    See the Apache Version 2.0 License for specific language governing permissions
24    and limitations under the License.
25    ***************************************************************************** */
26    /* global Reflect, Promise */
27
28    var extendStatics = function(d, b) {
29        extendStatics = Object.setPrototypeOf ||
30            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
31            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
32        return extendStatics(d, b);
33    };
34
35    function __extends(d, b) {
36        extendStatics(d, b);
37        function __() { this.constructor = d; }
38        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
39    }
40
41    var __assign = function() {
42        __assign = Object.assign || function __assign(t) {
43            for (var s, i = 1, n = arguments.length; i < n; i++) {
44                s = arguments[i];
45                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
46            }
47            return t;
48        };
49        return __assign.apply(this, arguments);
50    };
51
52    function __awaiter(thisArg, _arguments, P, generator) {
53        return new (P || (P = Promise))(function (resolve, reject) {
54            function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
55            function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
56            function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
57            step((generator = generator.apply(thisArg, _arguments || [])).next());
58        });
59    }
60
61    function __generator(thisArg, body) {
62        var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
63        return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
64        function verb(n) { return function (v) { return step([n, v]); }; }
65        function step(op) {
66            if (f) throw new TypeError("Generator is already executing.");
67            while (_) try {
68                if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
69                if (y = 0, t) op = [op[0] & 2, t.value];
70                switch (op[0]) {
71                    case 0: case 1: t = op; break;
72                    case 4: _.label++; return { value: op[1], done: false };
73                    case 5: _.label++; y = op[1]; op = [0]; continue;
74                    case 7: op = _.ops.pop(); _.trys.pop(); continue;
75                    default:
76                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
77                        if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
78                        if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
79                        if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
80                        if (t[2]) _.ops.pop();
81                        _.trys.pop(); continue;
82                }
83                op = body.call(thisArg, _);
84            } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
85            if (op[0] & 5) throw op[1];

85 return { value: op[0] ? op[1] : void 0, done: true };
86        }
87    }
88
89    var Bounds = /** @class */ (function () {
90        function Bounds(x, y, w, h) {
91            this.left = x;
92            this.top = y;
93            this.width = w;
94            this.height = h;
95        }
96        Bounds.prototype.add = function (x, y, w, h) {
97            return new Bounds(this.left + x, this.top + y, this.width + w, this.height + h);
98        };
99        Bounds.fromClientRect = function (clientRect) {
100            return new Bounds(clientRect.left, clientRect.top, clientRect.width, clientRect.height);
101        };
102        return Bounds;
103    }());
104    var parseBounds = function (node) {
105        return Bounds.fromClientRect(node.getBoundingClientRect());
106    };
107    var parseDocumentSize = function (document) {
108        var body = document.body;
109        var documentElement = document.documentElement;
110        if (!body || !documentElement) {
111            throw new Error("Unable to get document size");
112        }
113        var width = Math.max(Math.max(body.scrollWidth, documentElement.scrollWidth), Math.max(body.offsetWidth, documentElement.offsetWidth), Math.max(body.clientWidth, documentElement.clientWidth));
114        var height = Math.max(Math.max(body.scrollHeight, documentElement.scrollHeight), Math.max(body.offsetHeight, documentElement.offsetHeight), Math.max(body.clientHeight, documentElement.clientHeight));
115        return new Bounds(0, 0, width, height);
116    };
117
118    /*
119     * css-line-break 1.1.1 <https://github.com/niklasvh/css-line-break#readme>
120     * Copyright (c) 2019 Niklas von Hertzen <https://hertzen.com>
121     * Released under MIT License
122     */
123    var toCodePoints = function (str) {
124        var codePoints = [];
125        var i = 0;
126        var length = str.length;
127        while (i < length) {
128            var value = str.charCodeAt(i++);
129            if (value >= 0xd800 && value <= 0xdbff && i < length) {
130                var extra = str.charCodeAt(i++);
131                if ((extra & 0xfc00) === 0xdc00) {
132                    codePoints.push(((value & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000);
133                }
134                else {
135                    codePoints.push(value);
136                    i--;
137                }
138            }
139            else {
140                codePoints.push(value);
141            }
142        }
143        return codePoints;
144    };
145    var fromCodePoint = function () {
146        var codePoints = [];
147        for (var _i = 0; _i < arguments.length; _i++) {
148            codePoints[_i] = arguments[_i];
149        }
150        if (String.fromCodePoint) {
151            return String.fromCodePoint.apply(String, codePoints);
152        }
153        var length = codePoints.length;
154        if (!length) {
155            return '';
156        }
157        var codeUnits = [];
158        var index = -1;
159        var result = '';
160        while (++index < length) {
161            var codePoint = codePoints[index];
162            if (codePoint <= 0xffff) {
163                codeUnits.push(codePoint);
164            }
165            else {
166                codePoint -= 0x10000;
167                codeUnits.push((codePoint >> 10) + 0xd800, codePoint % 0x400 + 0xdc00);
168            }
169            if (index + 1 === length || codeUnits.length > 0x4000) {
170                result += String.fromCharCode.apply(String, codeUnits);
171                codeUnits.length = 0;
172            }
173        }
174        return result;
175    };
176    var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
177    // Use a lookup table to find the index.
178    var lookup = typeof Uint8Array === 'undefined' ? [] : new Uint8Array(256);
179    for (var i = 0; i < chars.length; i++) {
180        lookup[chars.charCodeAt(i)] = i;
181    }
182    var decode = function (base64) {
183        var bufferLength = base64.length * 0.75, len = base64.length, i, p = 0, encoded1, encoded2, encoded3, encoded4;
184        if (base64[base64.length - 1] === '=') {
185            bufferLength--;
186            if (base64[base64.length - 2] === '=') {
187                bufferLength--;
188            }
189        }
190        var buffer = typeof ArrayBuffer !== 'undefined' &&
191            typeof Uint8Array !== 'undefined' &&
192            typeof Uint8Array.prototype.slice !== 'undefined'
193            ? new ArrayBuffer(bufferLength)
194            : new Array(bufferLength);
195        var bytes = Array.isArray(buffer) ? buffer : new Uint8Array(buffer);
196        for (i = 0; i < len; i += 4) {
197            encoded1 = lookup[base64.charCodeAt(i)];
198            encoded2 = lookup[base64.charCodeAt(i + 1)];
199            encoded3 = lookup[base64.charCodeAt(i + 2)];
200            encoded4 = lookup[base64.charCodeAt(i + 3)];
201            bytes[p++] = (encoded1 << 2) | (encoded2 >> 4);
202            bytes[p++] = ((encoded2 & 15) << 4) | (encoded3 >> 2);
203            bytes[p++] = ((encoded3 & 3) << 6) | (encoded4 & 63);
204        }
205        return buffer;
206    };
207    var polyUint16Array = function (buffer) {
208        var length = buffer.length;
209        var bytes = [];
210        for (var i = 0; i < length; i += 2) {
211            bytes.push((buffer[i + 1] << 8) | buffer[i]);
212        }
213        return bytes;
214    };
215    var polyUint32Array = function (buffer) {
216        var length = buffer.length;
217        var bytes = [];
218        for (var i = 0; i < length; i += 4) {
219            bytes.push((buffer[i + 3] << 24) | (buffer[i + 2] << 16) | (buffer[i + 1] << 8) | buffer[i]);
220        }
221        return bytes;
222    };
223
224    /** Shift size for getting the index-2 table offset. */
225    var UTRIE2_SHIFT_2 = 5;
226    /** Shift size for getting the index-1 table offset. */
227    var UTRIE2_SHIFT_1 = 6 + 5;
228    /**
229     * Shift size for shifting left the index array values.
230     * Increases possible data size with 16-bit index values at the cost
231     * of compactability.
232     * This requires data blocks to be aligned by UTRIE2_DATA_GRANULARITY.
233     */
234    var UTRIE2_INDEX_SHIFT = 2;
235    /**
236     * Difference between the two shift sizes,
237     * for getting an index-1 offset from an index-2 offset. 6=11-5
238     */
239    var UTRIE2_SHIFT_1_2 = UTRIE2_SHIFT_1 - UTRIE2_SHIFT_2;
240    /**
241     * The part of the index-2 table for U+D800..U+DBFF stores values for
242     * lead surrogate code _units_ not code _points_.
243     * Values for lead surrogate code _points_ are indexed with this portion of the table.
244     * Length=32=0x20=0x400>>UTRIE2_SHIFT_2. (There are 1024=0x400 lead surrogates.)
245     */
246    var UTRIE2_LSCP_INDEX_2_OFFSET = 0x10000 >> UTRIE2_SHIFT_2;
247    /** Number of entries in a data block. 32=0x20 */
248    var UTRIE2_DATA_BLOCK_LENGTH = 1 << UTRIE2_SHIFT_2;
249    /** Mask for getting the lower bits for the in-data-block offset. */
250    var UTRIE2_DATA_MASK = UTRIE2_DATA_BLOCK_LENGTH - 1;
251    var UTRIE2_LSCP_INDEX_2_LENGTH = 0x400 >> UTRIE2_SHIFT_2;
252    /** Count the lengths of both BMP pieces. 2080=0x820 */
253    var UTRIE2_INDEX_2_BMP_LENGTH = UTRIE2_LSCP_INDEX_2_OFFSET + UTRIE2_LSCP_INDEX_2_LENGTH;
254    /**
255     * The 2-byte UTF-8 version of the index-2 table follows at offset 2080=0x820.
256     * Length 32=0x20 for lead bytes C0..DF, regardless of UTRIE2_SHIFT_2.
257     */
258    var UTRIE2_UTF8_2B_INDEX_2_OFFSET = UTRIE2_INDEX_2_BMP_LENGTH;
259    var UTRIE2_UTF8_2B_INDEX_2_LENGTH = 0x800 >> 6; /* U+0800 is the first code point after 2-byte UTF-8 */
260    /**
261     * The index-1 table, only used for supplementary code points, at offset 2112=0x840.
262     * Variable length, for code points up to highStart, where the last single-value range starts.
263     * Maximum length 512=0x200=0x100000>>UTRIE2_SHIFT_1.
264     * (For 0x100000 supplementary code points U+10000..U+10ffff.)
265     *
266     * The part of the index-2 table for supplementary code points starts
267     * after this index-1 table.
268     *
269     * Both the index-1 table and the following part of the index-2 table
270     * are omitted completely if there is only BMP data.
271     */
272    var UTRIE2_INDEX_1_OFFSET = UTRIE2_UTF8_2B_INDEX_2_OFFSET + UTRIE2_UTF8_2B_INDEX_2_LENGTH;
273    /**
274     * Number of index-1 entries for the BMP. 32=0x20
275     * This part of the index-1 table is omitted from the serialized form.
276     */
277    var UTRIE2_OMITTED_BMP_INDEX_1_LENGTH = 0x10000 >> UTRIE2_SHIFT_1;
278    /** Number of entries in an index-2 block. 64=0x40 */
279    var UTRIE2_INDEX_2_BLOCK_LENGTH = 1 << UTRIE2_SHIFT_1_2;
280    /** Mask for getting the lower bits for the in-index-2-block offset. */
281    var UTRIE2_INDEX_2_MASK = UTRIE2_INDEX_2_BLOCK_LENGTH - 1;
282    var slice16 = function (view, start, end) {
283        if (view.slice) {
284            return view.slice(start, end);
285        }
286        return new Uint16Array(Array.prototype.slice.call(view, start, end));
287    };
288    var slice32 = function (view, start, end) {
289        if (view.slice) {
290            return view.slice(start, end);
291        }
292        return new Uint32Array(Array.prototype.slice.call(view, start, end));
293    };
294    var createTrieFromBase64 = function (base64) {
295        var buffer = decode(base64);
296        var view32 = Array.isArray(buffer) ? polyUint32Array(buffer) : new Uint32Array(buffer);
297        var view16 = Array.isArray(buffer) ? polyUint16Array(buffer) : new Uint16Array(buffer);
298        var headerLength = 24;
299        var index = slice16(view16, headerLength / 2, view32[4] / 2);
300        var data = view32[5] === 2
301            ? slice16(view16, (headerLength + view32[4]) / 2)
302            : slice32(view32, Math.ceil((headerLength + view32[4]) / 4));
303        return new Trie(view32[0], view32[1], view32[2], view32[3], index, data);
304    };
305    var Trie = /** @class */ (function () {
306        function Trie(initialValue, errorValue, highStart, highValueIndex, index, data) {
307            this.initialValue = initialValue;
308            this.errorValue = errorValue;
309            this.highStart = highStart;
310            this.highValueIndex = highValueIndex;
311            this.index = index;
312            this.data = data;
313        }
314        /**
315         * Get the value for a code point as stored in the Trie.
316         *
317         * @param codePoint the code point
318         * @return the value
319         */
320        Trie.prototype.get = function (codePoint) {
321            var ix;
322            if (codePoint >= 0) {
323                if (codePoint < 0x0d800 || (codePoint > 0x0dbff && codePoint <= 0x0ffff)) {
324                    // Ordinary BMP code point, excluding leading surrogates.
325                    // BMP uses a single level lookup.  BMP index starts at offset 0 in the Trie2 index.
326                    // 16 bit data is stored in the index array itself.
327                    ix = this.index[codePoint >> UTRIE2_SHIFT_2];
328                    ix = (ix << UTRIE2_INDEX_SHIFT) + (codePoint & UTRIE2_DATA_MASK);
329                    return this.data[ix];
330                }
331                if (codePoint <= 0xffff) {
332                    // Lead Surrogate Code Point.  A Separate index section is stored for
333                    // lead surrogate code units and code points.
334                    //   The main index has the code unit data.
335                    //   For this function, we need the code point data.
336                    // Note: this expression could be refactored for slightly improved efficiency, but
337                    //       surrogate code points will be so rare in practice that it's not worth it.
338                    ix = this.index[UTRIE2_LSCP_INDEX_2_OFFSET + ((codePoint - 0xd800) >> UTRIE2_SHIFT_2)];
339                    ix = (ix << UTRIE2_INDEX_SHIFT) + (codePoint & UTRIE2_DATA_MASK);
340                    return this.data[ix];
341                }
342                if (codePoint < this.highStart) {
343                    // Supplemental code point, use two-level lookup.
344                    ix = UTRIE2_INDEX_1_OFFSET - UTRIE2_OMITTED_BMP_INDEX_1_LENGTH + (codePoint >> UTRIE2_SHIFT_1);
345                    ix = this.index[ix];
346                    ix += (codePoint >> UTRIE2_SHIFT_2) & UTRIE2_INDEX_2_MASK;
347                    ix = this.index[ix];
348                    ix = (ix << UTRIE2_INDEX_SHIFT) + (codePoint & UTRIE2_DATA_MASK);
349                    return this.data[ix];
350                }
351                if (codePoint <= 0x10ffff) {
352                    return this.data[this.highValueIndex];
353                }
354            }
355            // Fall through.  The code point is outside of the legal range of 0..0x10ffff.
356            return this.errorValue;
357        };
358        return Trie;
359    }());
360
361    var base64 = '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';
362
363    /* @flow */
364    var LETTER_NUMBER_MODIFIER = 50;
365    // Non-tailorable Line Breaking Classes
366    var BK = 1; //  Cause a line break (after)
367    var CR = 2; //  Cause a line break (after), except between CR and LF
368    var LF = 3; //  Cause a line break (after)
369    var CM = 4; //  Prohibit a line break between the character and the preceding character
370    var NL = 5; //  Cause a line break (after)
371    var WJ = 7; //  Prohibit line breaks before and after
372    var ZW = 8; //  Provide a break opportunity
373    var GL = 9; //  Prohibit line breaks before and after
374    var SP = 10; // Enable indirect line breaks
375    var ZWJ = 11; // Prohibit line breaks within joiner sequences
376    // Break Opportunities
377    var B2 = 12; //  Provide a line break opportunity before and after the character
378    var BA = 13; //  Generally provide a line break opportunity after the character
379    var BB = 14; //  Generally provide a line break opportunity before the character
380    var HY = 15; //  Provide a line break opportunity after the character, except in numeric context
381    var CB = 16; //   Provide a line break opportunity contingent on additional information
382    // Characters Prohibiting Certain Breaks
383    var CL = 17; //  Prohibit line breaks before
384    var CP = 18; //  Prohibit line breaks before
385    var EX = 19; //  Prohibit line breaks before
386    var IN = 20; //  Allow only indirect line breaks between pairs
387    var NS = 21; //  Allow only indirect line breaks before
388    var OP = 22; //  Prohibit line breaks after
389    var QU = 23; //  Act like they are both opening and closing
390    // Numeric Context
391    var IS = 24; //  Prevent breaks after any and before numeric
392    var NU = 25; //  Form numeric expressions for line breaking purposes
393    var PO = 26; //  Do not break following a numeric expression
394    var PR = 27; //  Do not break in front of a numeric expression
395    var SY = 28; //  Prevent a break before; and allow a break after
396    // Other Characters
397    var AI = 29; //  Act like AL when the resolvedEAW is N; otherwise; act as ID
398    var AL = 30; //  Are alphabetic characters or symbols that are used with alphabetic characters
399    var CJ = 31; //  Treat as NS or ID for strict or normal breaking.
400    var EB = 32; //  Do not break from following Emoji Modifier
401    var EM = 33; //  Do not break from preceding Emoji Base
402    var H2 = 34; //  Form Korean syllable blocks
403    var H3 = 35; //  Form Korean syllable blocks
404    var HL = 36; //  Do not break around a following hyphen; otherwise act as Alphabetic
405    var ID = 37; //  Break before or after; except in some numeric context
406    var JL = 38; //  Form Korean syllable blocks
407    var JV = 39; //  Form Korean syllable blocks
408    var JT = 40; //  Form Korean syllable blocks
409    var RI = 41; //  Keep pairs together. For pairs; break before and after other classes
410    var SA = 42; //  Provide a line break opportunity contingent on additional, language-specific context analysis
411    var XX = 43; //  Have as yet unknown line breaking behavior or unassigned code positions
412    var BREAK_MANDATORY = '!';
413    var BREAK_NOT_ALLOWED = '×';
414    var BREAK_ALLOWED = '÷';
415    var UnicodeTrie = createTrieFromBase64(base64);
416    var ALPHABETICS = [AL, HL];
417    var HARD_LINE_BREAKS = [BK, CR, LF, NL];
418    var SPACE = [SP, ZW];
419    var PREFIX_POSTFIX = [PR, PO];
420    var LINE_BREAKS = HARD_LINE_BREAKS.concat(SPACE);
421    var KOREAN_SYLLABLE_BLOCK = [JL, JV, JT, H2, H3];
422    var HYPHEN = [HY, BA];
423    var codePointsToCharacterClasses = function (codePoints, lineBreak) {
424        if (lineBreak === void 0) { lineBreak = 'strict'; }
425        var types = [];
426        var indicies = [];
427        var categories = [];

428        codePoints.forEach(function (codePoint, index) {
429            var classType = UnicodeTrie.get(codePoint);
430            if (classType > LETTER_NUMBER_MODIFIER) {
431                categories.push(true);
432                classType -= LETTER_NUMBER_MODIFIER;
433            }
434            else {
435                categories.push(false);
436            }
437            if (['normal', 'auto', 'loose'].indexOf(lineBreak) !== -1) {
438                // U+2010, – U+2013, 〜 U+301C, ゠ U+30A0
439                if ([0x2010, 0x2013, 0x301c, 0x30a0].indexOf(codePoint) !== -1) {
440                    indicies.push(index);
441                    return types.push(CB);
442                }
443            }
444            if (classType === CM || classType === ZWJ) {
445                // LB10 Treat any remaining combining mark or ZWJ as AL.
446                if (index === 0) {
447                    indicies.push(index);
448                    return types.push(AL);
449                }
450                // LB9 Do not break a combining character sequence; treat it as if it has the line breaking class of
451                // the base character in all of the following rules. Treat ZWJ as if it were CM.
452                var prev = types[index - 1];
453                if (LINE_BREAKS.indexOf(prev) === -1) {
454                    indicies.push(indicies[index - 1]);
455                    return types.push(prev);
456                }
457                indicies.push(index);
458                return types.push(AL);
459            }
460            indicies.push(index);
461            if (classType === CJ) {
462                return types.push(lineBreak === 'strict' ? NS : ID);
463            }
464            if (classType === SA) {
465                return types.push(AL);
466            }
467            if (classType === AI) {
468                return types.push(AL);
469            }
470            // For supplementary characters, a useful default is to treat characters in the range 10000..1FFFD as AL
471            // and characters in the ranges 20000..2FFFD and 30000..3FFFD as ID, until the implementation can be revised
472            // to take into account the actual line breaking properties for these characters.
473            if (classType === XX) {
474                if ((codePoint >= 0x20000 && codePoint <= 0x2fffd) || (codePoint >= 0x30000 && codePoint <= 0x3fffd)) {
475                    return types.push(ID);
476                }
477                else {
478                    return types.push(AL);
479                }
480            }
481            types.push(classType);
482        });
483        return [indicies, types, categories];
484    };
485    var isAdjacentWithSpaceIgnored = function (a, b, currentIndex, classTypes) {
486        var current = classTypes[currentIndex];
487        if (Array.isArray(a) ? a.indexOf(current) !== -1 : a === current) {
488            var i = currentIndex;
489            while (i <= classTypes.length) {
490                i++;
491                var next = classTypes[i];
492                if (next === b) {
493                    return true;
494                }
495                if (next !== SP) {
496                    break;
497                }
498            }
499        }
500        if (current === SP) {
501            var i = currentIndex;
502            while (i > 0) {
503                i--;
504                var prev = classTypes[i];
505                if (Array.isArray(a) ? a.indexOf(prev) !== -1 : a === prev) {
506                    var n = currentIndex;
507                    while (n <= classTypes.length) {
508                        n++;
509                        var next = classTypes[n];
510                        if (next === b) {
511                            return true;
512                        }
513                        if (next !== SP) {
514                            break;
515                        }
516                    }
517                }
518                if (prev !== SP) {
519                    break;
520                }
521            }
522        }
523        return false;
524    };
525    var previousNonSpaceClassType = function (currentIndex, classTypes) {
526        var i = currentIndex;
527        while (i >= 0) {
528            var type = classTypes[i];
529            if (type === SP) {
530                i--;
531            }
532            else {
533                return type;
534            }
535        }
536        return 0;
537    };
538    var _lineBreakAtIndex = function (codePoints, classTypes, indicies, index, forbiddenBreaks) {
539        if (indicies[index] === 0) {
540            return BREAK_NOT_ALLOWED;
541        }
542        var currentIndex = index - 1;
543        if (Array.isArray(forbiddenBreaks) && forbiddenBreaks[currentIndex] === true) {
544            return BREAK_NOT_ALLOWED;
545        }
546        var beforeIndex = currentIndex - 1;
547        var afterIndex = currentIndex + 1;
548        var current = classTypes[currentIndex];
549        // LB4 Always break after hard line breaks.
550        // LB5 Treat CR followed by LF, as well as CR, LF, and NL as hard line breaks.
551        var before = beforeIndex >= 0 ? classTypes[beforeIndex] : 0;
552        var next = classTypes[afterIndex];
553        if (current === CR && next === LF) {
554            return BREAK_NOT_ALLOWED;
555        }
556        if (HARD_LINE_BREAKS.indexOf(current) !== -1) {
557            return BREAK_MANDATORY;
558        }
559        // LB6 Do not break before hard line breaks.
560        if (HARD_LINE_BREAKS.indexOf(next) !== -1) {
561            return BREAK_NOT_ALLOWED;
562        }
563        // LB7 Do not break before spaces or zero width space.
564        if (SPACE.indexOf(next) !== -1) {
565            return BREAK_NOT_ALLOWED;
566        }
567        // LB8 Break before any character following a zero-width space, even if one or more spaces intervene.
568        if (previousNonSpaceClassType(currentIndex, classTypes) === ZW) {
569            return BREAK_ALLOWED;
570        }
571        // LB8a Do not break between a zero width joiner and an ideograph, emoji base or emoji modifier.
572        if (UnicodeTrie.get(codePoints[currentIndex]) === ZWJ && (next === ID || next === EB || next === EM)) {
573            return BREAK_NOT_ALLOWED;
574        }
575        // LB11 Do not break before or after Word joiner and related characters.
576        if (current === WJ || next === WJ) {
577            return BREAK_NOT_ALLOWED;
578        }
579        // LB12 Do not break after NBSP and related characters.
580        if (current === GL) {
581            return BREAK_NOT_ALLOWED;
582        }
583        // LB12a Do not break before NBSP and related characters, except after spaces and hyphens.
584        if ([SP, BA, HY].indexOf(current) === -1 && next === GL) {
585            return BREAK_NOT_ALLOWED;
586        }
587        // LB13 Do not break before ‘]’ or ‘!’ or ‘;’ or ‘/’, even after spaces.
588        if ([CL, CP, EX, IS, SY].indexOf(next) !== -1) {
589            return BREAK_NOT_ALLOWED;
590        }
591        // LB14 Do not break after ‘[’, even after spaces.
592        if (previousNonSpaceClassType(currentIndex, classTypes) === OP) {
593            return BREAK_NOT_ALLOWED;
594        }
595        // LB15 Do not break within ‘”[’, even with intervening spaces.
596        if (isAdjacentWithSpaceIgnored(QU, OP, currentIndex, classTypes)) {
597            return BREAK_NOT_ALLOWED;
598        }
599        // LB16 Do not break between closing punctuation and a nonstarter (lb=NS), even with intervening spaces.
600        if (isAdjacentWithSpaceIgnored([CL, CP], NS, currentIndex, classTypes)) {
601            return BREAK_NOT_ALLOWED;
602        }
603        // LB17 Do not break within ‘——’, even with intervening spaces.
604        if (isAdjacentWithSpaceIgnored(B2, B2, currentIndex, classTypes)) {
605            return BREAK_NOT_ALLOWED;
606        }
607        // LB18 Break after spaces.
608        if (current === SP) {
609            return BREAK_ALLOWED;
610        }
611        // LB19 Do not break before or after quotation marks, such as ‘ ” ’.
612        if (current === QU || next === QU) {
613            return BREAK_NOT_ALLOWED;
614        }
615        // LB20 Break before and after unresolved CB.
616        if (next === CB || current === CB) {
617            return BREAK_ALLOWED;
618        }
619        // LB21 Do not break before hyphen-minus, other hyphens, fixed-width spaces, small kana, and other non-starters, or after acute accents.
620        if ([BA, HY, NS].indexOf(next) !== -1 || current === BB) {
621            return BREAK_NOT_ALLOWED;
622        }
623        // LB21a Don't break after Hebrew + Hyphen.
624        if (before === HL && HYPHEN.indexOf(current) !== -1) {
625            return BREAK_NOT_ALLOWED;
626        }
627        // LB21b Don’t break between Solidus and Hebrew letters.
628        if (current === SY && next === HL) {
629            return BREAK_NOT_ALLOWED;
630        }
631        // LB22 Do not break between two ellipses, or between letters, numbers or exclamations and ellipsis.
632        if (next === IN && ALPHABETICS.concat(IN, EX, NU, ID, EB, EM).indexOf(current) !== -1) {
633            return BREAK_NOT_ALLOWED;
634        }
635        // LB23 Do not break between digits and letters.
636        if ((ALPHABETICS.indexOf(next) !== -1 && current === NU) || (ALPHABETICS.indexOf(current) !== -1 && next === NU)) {
637            return BREAK_NOT_ALLOWED;
638        }
639        // LB23a Do not break between numeric prefixes and ideographs, or between ideographs and numeric postfixes.
640        if ((current === PR && [ID, EB, EM].indexOf(next) !== -1) ||
641            ([ID, EB, EM].indexOf(current) !== -1 && next === PO)) {
642            return BREAK_NOT_ALLOWED;
643        }
644        // LB24 Do not break between numeric prefix/postfix and letters, or between letters and prefix/postfix.
645        if ((ALPHABETICS.indexOf(current) !== -1 && PREFIX_POSTFIX.indexOf(next) !== -1) ||
646            (PREFIX_POSTFIX.indexOf(current) !== -1 && ALPHABETICS.indexOf(next) !== -1)) {
647            return BREAK_NOT_ALLOWED;
648        }
649        // LB25 Do not break between the following pairs of classes relevant to numbers:
650        if (
651        // (PR | PO) × ( OP | HY )? NU
652        ([PR, PO].indexOf(current) !== -1 &&
653            (next === NU || ([OP, HY].indexOf(next) !== -1 && classTypes[afterIndex + 1] === NU))) ||
654            // ( OP | HY ) × NU
655            ([OP, HY].indexOf(current) !== -1 && next === NU) ||
656            // NU ×	(NU | SY | IS)
657            (current === NU && [NU, SY, IS].indexOf(next) !== -1)) {
658            return BREAK_NOT_ALLOWED;
659        }
660        // NU (NU | SY | IS)* × (NU | SY | IS | CL | CP)
661        if ([NU, SY, IS, CL, CP].indexOf(next) !== -1) {
662            var prevIndex = currentIndex;
663            while (prevIndex >= 0) {
664                var type = classTypes[prevIndex];
665                if (type === NU) {
666                    return BREAK_NOT_ALLOWED;
667                }
668                else if ([SY, IS].indexOf(type) !== -1) {
669                    prevIndex--;
670                }
671                else {
672                    break;
673                }
674            }
675        }
676        // NU (NU | SY | IS)* (CL | CP)? × (PO | PR))
677        if ([PR, PO].indexOf(next) !== -1) {
678            var prevIndex = [CL, CP].indexOf(current) !== -1 ? beforeIndex : currentIndex;
679            while (prevIndex >= 0) {
680                var type = classTypes[prevIndex];
681                if (type === NU) {
682                    return BREAK_NOT_ALLOWED;
683                }
684                else if ([SY, IS].indexOf(type) !== -1) {
685                    prevIndex--;
686                }
687                else {
688                    break;
689                }
690            }
691        }
692        // LB26 Do not break a Korean syllable.
693        if ((JL === current && [JL, JV, H2, H3].indexOf(next) !== -1) ||
694            ([JV, H2].indexOf(current) !== -1 && [JV, JT].indexOf(next) !== -1) ||
695            ([JT, H3].indexOf(current) !== -1 && next === JT)) {
696            return BREAK_NOT_ALLOWED;
697        }
698        // LB27 Treat a Korean Syllable Block the same as ID.
699        if ((KOREAN_SYLLABLE_BLOCK.indexOf(current) !== -1 && [IN, PO].indexOf(next) !== -1) ||
700            (KOREAN_SYLLABLE_BLOCK.indexOf(next) !== -1 && current === PR)) {
701            return BREAK_NOT_ALLOWED;
702        }
703        // LB28 Do not break between alphabetics (“at”).
704        if (ALPHABETICS.indexOf(current) !== -1 && ALPHABETICS.indexOf(next) !== -1) {
705            return BREAK_NOT_ALLOWED;
706        }
707        // LB29 Do not break between numeric punctuation and alphabetics (“e.g.”).
708        if (current === IS && ALPHABETICS.indexOf(next) !== -1) {
709            return BREAK_NOT_ALLOWED;
710        }
711        // LB30 Do not break between letters, numbers, or ordinary symbols and opening or closing parentheses.
712        if ((ALPHABETICS.concat(NU).indexOf(current) !== -1 && next === OP) ||
713            (ALPHABETICS.concat(NU).indexOf(next) !== -1 && current === CP)) {
714            return BREAK_NOT_ALLOWED;
715        }
716        // LB30a Break between two regional indicator symbols if and only if there are an even number of regional
717        // indicators preceding the position of the break.
718        if (current === RI && next === RI) {
719            var i = indicies[currentIndex];
720            var count = 1;
721            while (i > 0) {
722                i--;
723                if (classTypes[i] === RI) {
724                    count++;
725                }
726                else {
727                    break;
728                }
729            }
730            if (count % 2 !== 0) {
731                return BREAK_NOT_ALLOWED;
732            }
733        }
734        // LB30b Do not break between an emoji base and an emoji modifier.
735        if (current === EB && next === EM) {
736            return BREAK_NOT_ALLOWED;
737        }
738        return BREAK_ALLOWED;
739    };
740    var cssFormattedClasses = function (codePoints, options) {
741        if (!options) {
742            options = { lineBreak: 'normal', wordBreak: 'normal' };
743        }
744        var _a = codePointsToCharacterClasses(codePoints, options.lineBreak), indicies = _a[0], classTypes = _a[1], isLetterNumber = _a[2];
745        if (options.wordBreak === 'break-all' || options.wordBreak === 'break-word') {
746            classTypes = classTypes.map(function (type) { return ([NU, AL, SA].indexOf(type) !== -1 ? ID : type); });
747        }
748        var forbiddenBreakpoints = options.wordBreak === 'keep-all'
749            ? isLetterNumber.map(function (letterNumber, i) {
750                return letterNumber && codePoints[i] >= 0x4e00 && codePoints[i] <= 0x9fff;
751            })
752            : undefined;
753        return [indicies, classTypes, forbiddenBreakpoints];
754    };
755    var Break = /** @class */ (function () {
756        function Break(codePoints, lineBreak, start, end) {
757            this.codePoints = codePoints;
758            this.required = lineBreak === BREAK_MANDATORY;
759            this.start = start;
760            this.end = end;
761        }
762        Break.prototype.slice = function () {
763            return fromCodePoint.apply(void 0, this.codePoints.slice(this.start, this.end));
764        };
765        return Break;
766    }());
767    var LineBreaker = function (str, options) {
768        var codePoints = toCodePoints(str);
769        var _a = cssFormattedClasses(codePoints, options), indicies = _a[0], classTypes = _a[1], forbiddenBreakpoints = _a[2];
770        var length = codePoints.length;
771        var lastEnd = 0;
772        var nextIndex = 0;
773        return {
774            next: function () {
775                if (nextIndex >= length) {
776                    return { done: true, value: null };
777                }
778                var lineBreak = BREAK_NOT_ALLOWED;
779                while (nextIndex < length &&
780                    (lineBreak = _lineBreakAtIndex(codePoints, classTypes, indicies, ++nextIndex, forbiddenBreakpoints)) ===
781                        BREAK_NOT_ALLOWED) { }
782                if (lineBreak !== BREAK_NOT_ALLOWED || nextIndex === length) {
783                    var value = new Break(codePoints, lineBreak, lastEnd, nextIndex);
784                    lastEnd = nextIndex;
785                    return { value: value, done: false };
786                }
787                return { done: true, value: null };
788            },
789        };
790    };
791
792    // https://www.w3.org/TR/css-syntax-3
793    var TokenType;
794    (function (TokenType) {
795        TokenType[TokenType["STRING_TOKEN"] = 0] = "STRING_TOKEN";
796        TokenType[TokenType["BAD_STRING_TOKEN"] = 1] = "BAD_STRING_TOKEN";
797        TokenType[TokenType["LEFT_PARENTHESIS_TOKEN"] = 2] = "LEFT_PARENTHESIS_TOKEN";
798        TokenType[TokenType["RIGHT_PARENTHESIS_TOKEN"] = 3] = "RIGHT_PARENTHESIS_TOKEN";
799        TokenType[TokenType["COMMA_TOKEN"] = 4] = "COMMA_TOKEN";
800        TokenType[TokenType["HASH_TOKEN"] = 5] = "HASH_TOKEN";
801        TokenType[TokenType["DELIM_TOKEN"] = 6] = "DELIM_TOKEN";
802        TokenType[TokenType["AT_KEYWORD_TOKEN"] = 7] = "AT_KEYWORD_TOKEN";
803        TokenType[TokenType["PREFIX_MATCH_TOKEN"] = 8] = "PREFIX_MATCH_TOKEN";
804        TokenType[TokenType["DASH_MATCH_TOKEN"] = 9] = "DASH_MATCH_TOKEN";
805        TokenType[TokenType["INCLUDE_MATCH_TOKEN"] = 10] = "INCLUDE_MATCH_TOKEN";
806        TokenType[TokenType["LEFT_CURLY_BRACKET_TOKEN"] = 11] = "LEFT_CURLY_BRACKET_TOKEN";
807        TokenType[TokenType["RIGHT_CURLY_BRACKET_TOKEN"] = 12] = "RIGHT_CURLY_BRACKET_TOKEN";
808        TokenType[TokenType["SUFFIX_MATCH_TOKEN"] = 13] = "SUFFIX_MATCH_TOKEN";
809        TokenType[TokenType["SUBSTRING_MATCH_TOKEN"] = 14] = "SUBSTRING_MATCH_TOKEN";
810        TokenType[TokenType["DIMENSION_TOKEN"] = 15] = "DIMENSION_TOKEN";
811        TokenType[TokenType["PERCENTAGE_TOKEN"] = 16] = "PERCENTAGE_TOKEN";
812        TokenType[TokenType["NUMBER_TOKEN"] = 17] = "NUMBER_TOKEN";
813        TokenType[TokenType["FUNCTION"] = 18] = "FUNCTION";
814        TokenType[TokenType["FUNCTION_TOKEN"] = 19] = "FUNCTION_TOKEN";
815        TokenType[TokenType["IDENT_TOKEN"] = 20] = "IDENT_TOKEN";
816        TokenType[TokenType["COLUMN_TOKEN"] = 21] = "COLUMN_TOKEN";
817        TokenType[TokenType["URL_TOKEN"] = 22] = "URL_TOKEN";
818        TokenType[TokenType["BAD_URL_TOKEN"] = 23] = "BAD_URL_TOKEN";
819        TokenType[TokenType["CDC_TOKEN"] = 24] = "CDC_TOKEN";
820        TokenType[TokenType["CDO_TOKEN"] = 25] = "CDO_TOKEN";
821        TokenType[TokenType["COLON_TOKEN"] = 26] = "COLON_TOKEN";
822        TokenType[TokenType["SEMICOLON_TOKEN"] = 27] = "SEMICOLON_TOKEN";
823        TokenType[TokenType["LEFT_SQUARE_BRACKET_TOKEN"] = 28] = "LEFT_SQUARE_BRACKET_TOKEN";
824        TokenType[TokenType["RIGHT_SQUARE_BRACKET_TOKEN"] = 29] = "RIGHT_SQUARE_BRACKET_TOKEN";
825        TokenType[TokenType["UNICODE_RANGE_TOKEN"] = 30] = "UNICODE_RANGE_TOKEN";
826        TokenType[TokenType["WHITESPACE_TOKEN"] = 31] = "WHITESPACE_TOKEN";
827        TokenType[TokenType["EOF_TOKEN"] = 32] = "EOF_TOKEN";
828    })(TokenType || (TokenType = {}));
829    var FLAG_UNRESTRICTED = 1 << 0;
830    var FLAG_ID = 1 << 1;
831    var FLAG_INTEGER = 1 << 2;
832    var FLAG_NUMBER = 1 << 3;
833    var LINE_FEED = 0x000a;
834    var SOLIDUS = 0x002f;
835    var REVERSE_SOLIDUS = 0x005c;
836    var CHARACTER_TABULATION = 0x0009;
837    var SPACE$1 = 0x0020;
838    var QUOTATION_MARK = 0x0022;
839    var EQUALS_SIGN = 0x003d;
840    var NUMBER_SIGN = 0x0023;
841    var DOLLAR_SIGN = 0x0024;
842    var PERCENTAGE_SIGN = 0x0025;
843    var APOSTROPHE = 0x0027;
844    var LEFT_PARENTHESIS = 0x0028;
845    var RIGHT_PARENTHESIS = 0x0029;
846    var LOW_LINE = 0x005f;
847    var HYPHEN_MINUS = 0x002d;
848    var EXCLAMATION_MARK = 0x0021;
849    var LESS_THAN_SIGN = 0x003c;
850    var GREATER_THAN_SIGN = 0x003e;
851    var COMMERCIAL_AT = 0x0040;
852    var LEFT_SQUARE_BRACKET = 0x005b;
853    var RIGHT_SQUARE_BRACKET = 0x005d;
854    var CIRCUMFLEX_ACCENT = 0x003d;
855    var LEFT_CURLY_BRACKET = 0x007b;
856    var QUESTION_MARK = 0x003f;
857    var RIGHT_CURLY_BRACKET = 0x007d;
858    var VERTICAL_LINE = 0x007c;
859    var TILDE = 0x007e;
860    var CONTROL = 0x0080;
861    var REPLACEMENT_CHARACTER = 0xfffd;
862    var ASTERISK = 0x002a;
863    var PLUS_SIGN = 0x002b;
864    var COMMA = 0x002c;
865    var COLON = 0x003a;
866    var SEMICOLON = 0x003b;
867    var FULL_STOP = 0x002e;
868    var NULL = 0x0000;
869    var BACKSPACE = 0x0008;
870    var LINE_TABULATION = 0x000b;
871    var SHIFT_OUT = 0x000e;
872    var INFORMATION_SEPARATOR_ONE = 0x001f;
873    var DELETE = 0x007f;
874    var EOF = -1;
875    var ZERO = 0x0030;
876    var a = 0x0061;
877    var e = 0x0065;
878    var f = 0x0066;
879    var u = 0x0075;
880    var z = 0x007a;
881    var A = 0x0041;
882    var E = 0x0045;
883    var F = 0x0046;
884    var U = 0x0055;
885    var Z = 0x005a;
886    var isDigit = function (codePoint) { return codePoint >= ZERO && codePoint <= 0x0039; };
887    var isSurrogateCodePoint = function (codePoint) { return codePoint >= 0xd800 && codePoint <= 0xdfff; };
888    var isHex = function (codePoint) {
889        return isDigit(codePoint) || (codePoint >= A && codePoint <= F) || (codePoint >= a && codePoint <= f);
890    };
891    var isLowerCaseLetter = function (codePoint) { return codePoint >= a && codePoint <= z; };
892    var isUpperCaseLetter = function (codePoint) { return codePoint >= A && codePoint <= Z; };
893    var isLetter = function (codePoint) { return isLowerCaseLetter(codePoint) || isUpperCaseLetter(codePoint); };
894    var isNonASCIICodePoint = function (codePoint) { return codePoint >= CONTROL; };
895    var isWhiteSpace = function (codePoint) {
896        return codePoint === LINE_FEED || codePoint === CHARACTER_TABULATION || codePoint === SPACE$1;
897    };
898    var isNameStartCodePoint = function (codePoint) {
899        return isLetter(codePoint) || isNonASCIICodePoint(codePoint) || codePoint === LOW_LINE;
900    };
901    var isNameCodePoint = function (codePoint) {
902        return isNameStartCodePoint(codePoint) || isDigit(codePoint) || codePoint === HYPHEN_MINUS;
903    };
904    var isNonPrintableCodePoint = function (codePoint) {
905        return ((codePoint >= NULL && codePoint <= BACKSPACE) ||
906            codePoint === LINE_TABULATION ||
907            (codePoint >= SHIFT_OUT && codePoint <= INFORMATION_SEPARATOR_ONE) ||
908            codePoint === DELETE);
909    };
910    var isValidEscape = function (c1, c2) {
911        if (c1 !== REVERSE_SOLIDUS) {
912            return false;
913        }
914        return c2 !== LINE_FEED;
915    };
916    var isIdentifierStart = function (c1, c2, c3) {
917        if (c1 === HYPHEN_MINUS) {
918            return isNameStartCodePoint(c2) || isValidEscape(c2, c3);
919        }
920        else if (isNameStartCodePoint(c1)) {
921            return true;
922        }
923        else if (c1 === REVERSE_SOLIDUS && isValidEscape(c1, c2)) {
924            return true;
925        }
926        return false;
927    };
928    var isNumberStart = function (c1, c2, c3) {
929        if (c1 === PLUS_SIGN || c1 === HYPHEN_MINUS) {
930            if (isDigit(c2)) {
931                return true;
932            }
933            return c2 === FULL_STOP && isDigit(c3);
934        }
935        if (c1 === FULL_STOP) {
936            return isDigit(c2);
937        }
938        return isDigit(c1);
939    };
940    var stringToNumber = function (codePoints) {
941        var c = 0;
942        var sign = 1;
943        if (codePoints[c] === PLUS_SIGN || codePoints[c] === HYPHEN_MINUS) {
944            if (codePoints[c] === HYPHEN_MINUS) {
945                sign = -1;
946            }
947            c++;
948        }
949        var integers = [];
950        while (isDigit(codePoints[c])) {
951            integers.push(codePoints[c++]);
952        }
953        var int = integers.length ? parseInt(fromCodePoint.apply(void 0, integers), 10) : 0;
954        if (codePoints[c] === FULL_STOP) {
955            c++;
956        }
957        var fraction = [];
958        while (isDigit(codePoints[c])) {
959            fraction.push(codePoints[c++]);
960        }
961        var fracd = fraction.length;
962        var frac = fracd ? parseInt(fromCodePoint.apply(void 0, fraction), 10) : 0;
963        if (codePoints[c] === E || codePoints[c] === e) {
964            c++;
965        }
966        var expsign = 1;
967        if (codePoints[c] === PLUS_SIGN || codePoints[c] === HYPHEN_MINUS) {
968            if (codePoints[c] === HYPHEN_MINUS) {
969                expsign = -1;
970            }
971            c++;
972        }
973        var exponent = [];
974        while (isDigit(codePoints[c])) {
975            exponent.push(codePoints[c++]);
976        }
977        var exp = exponent.length ? parseInt(fromCodePoint.apply(void 0, exponent), 10) : 0;
978        return sign * (int + frac * Math.pow(10, -fracd)) * Math.pow(10, expsign * exp);
979    };
980    var LEFT_PARENTHESIS_TOKEN = {
981        type: TokenType.LEFT_PARENTHESIS_TOKEN
982    };
983    var RIGHT_PARENTHESIS_TOKEN = {
984        type: TokenType.RIGHT_PARENTHESIS_TOKEN
985    };
986    var COMMA_TOKEN = { type: TokenType.COMMA_TOKEN };
987    var SUFFIX_MATCH_TOKEN = { type: TokenType.SUFFIX_MATCH_TOKEN };
988    var PREFIX_MATCH_TOKEN = { type: TokenType.PREFIX_MATCH_TOKEN };
989    var COLUMN_TOKEN = { type: TokenType.COLUMN_TOKEN };
990    var DASH_MATCH_TOKEN = { type: TokenType.DASH_MATCH_TOKEN };
991    var INCLUDE_MATCH_TOKEN = { type: TokenType.INCLUDE_MATCH_TOKEN };
992    var LEFT_CURLY_BRACKET_TOKEN = {
993        type: TokenType.LEFT_CURLY_BRACKET_TOKEN
994    };
995    var RIGHT_CURLY_BRACKET_TOKEN = {
996        type: TokenType.RIGHT_CURLY_BRACKET_TOKEN
997    };
998    var SUBSTRING_MATCH_TOKEN = { type: TokenType.SUBSTRING_MATCH_TOKEN };
999    var BAD_URL_TOKEN = { type: TokenType.BAD_URL_TOKEN };
1000    var BAD_STRING_TOKEN = { type: TokenType.BAD_STRING_TOKEN };
1001    var CDO_TOKEN = { type: TokenType.CDO_TOKEN };
1002    var CDC_TOKEN = { type: TokenType.CDC_TOKEN };
1003    var COLON_TOKEN = { type: TokenType.COLON_TOKEN };
1004    var SEMICOLON_TOKEN = { type: TokenType.SEMICOLON_TOKEN };
1005    var LEFT_SQUARE_BRACKET_TOKEN = {
1006        type: TokenType.LEFT_SQUARE_BRACKET_TOKEN
1007    };
1008    var RIGHT_SQUARE_BRACKET_TOKEN = {
1009        type: TokenType.RIGHT_SQUARE_BRACKET_TOKEN
1010    };
1011    var WHITESPACE_TOKEN = { type: TokenType.WHITESPACE_TOKEN };
1012    var EOF_TOKEN = { type: TokenType.EOF_TOKEN };
1013    var Tokenizer = /** @class */ (function () {
1014        function Tokenizer() {
1015            this._value = [];
1016        }
1017        Tokenizer.prototype.write = function (chunk) {
1018            this._value = this._value.concat(toCodePoints(chunk));
1019        };
1020        Tokenizer.prototype.read = function () {
1021            var tokens = [];
1022            var token = this.consumeToken();
1023            while (token !== EOF_TOKEN) {
1024                tokens.push(token);
1025                token = this.consumeToken();
1026            }
1027            return tokens;
1028        };
1029        Tokenizer.prototype.consumeToken = function () {
1030            var codePoint = this.consumeCodePoint();
1031            switch (codePoint) {
1032                case QUOTATION_MARK:
1033                    return this.consumeStringToken(QUOTATION_MARK);
1034                case NUMBER_SIGN:
1035                    var c1 = this.peekCodePoint(0);
1036                    var c2 = this.peekCodePoint(1);
1037                    var c3 = this.peekCodePoint(2);
1038                    if (isNameCodePoint(c1) || isValidEscape(c2, c3)) {
1039                        var flags = isIdentifierStart(c1, c2, c3) ? FLAG_ID : FLAG_UNRESTRICTED;
1040                        var value = this.consumeName();
1041                        return { type: TokenType.HASH_TOKEN, value: value, flags: flags };
1042                    }
1043                    break;
1044                case DOLLAR_SIGN:
1045                    if (this.peekCodePoint(0) === EQUALS_SIGN) {
1046                        this.consumeCodePoint();
1047                        return SUFFIX_MATCH_TOKEN;
1048                    }
1049                    break;
1050                case APOSTROPHE:
1051                    return this.consumeStringToken(APOSTROPHE);
1052                case LEFT_PARENTHESIS:
1053                    return LEFT_PARENTHESIS_TOKEN;
1054                case RIGHT_PARENTHESIS:
1055                    return RIGHT_PARENTHESIS_TOKEN;
1056                case ASTERISK:
1057                    if (this.peekCodePoint(0) === EQUALS_SIGN) {
1058                        this.consumeCodePoint();
1059                        return SUBSTRING_MATCH_TOKEN;
1060                    }
1061                    break;
1062                case PLUS_SIGN:
1063                    if (isNumberStart(codePoint, this.peekCodePoint(0), this.peekCodePoint(1))) {
1064                        this.reconsumeCodePoint(codePoint);
1065                        return this.consumeNumericToken();
1066                    }
1067                    break;
1068                case COMMA:
1069                    return COMMA_TOKEN;
1070                case HYPHEN_MINUS:
1071                    var e1 = codePoint;
1072                    var e2 = this.peekCodePoint(0);
1073                    var e3 = this.peekCodePoint(1);
1074                    if (isNumberStart(e1, e2, e3)) {
1075                        this.reconsumeCodePoint(codePoint);
1076                        return this.consumeNumericToken();
1077                    }
1078                    if (isIdentifierStart(e1, e2, e3)) {
1079                        this.reconsumeCodePoint(codePoint);
1080                        return this.consumeIdentLikeToken();
1081                    }
1082                    if (e2 === HYPHEN_MINUS && e3 === GREATER_THAN_SIGN) {
1083                        this.consumeCodePoint();
1084                        this.consumeCodePoint();
1085                        return CDC_TOKEN;
1086                    }
1087                    break;
1088                case FULL_STOP:
1089                    if (isNumberStart(codePoint, this.peekCodePoint(0), this.peekCodePoint(1))) {
1090                        this.reconsumeCodePoint(codePoint);
1091                        return this.consumeNumericToken();
1092                    }
1093                    break;
1094                case SOLIDUS:
1095                    if (this.peekCodePoint(0) === ASTERISK) {
1096                        this.consumeCodePoint();
1097                        while (true) {
1098                            var c = this.consumeCodePoint();
1099                            if (c === ASTERISK) {
1100                                c = this.consumeCodePoint();
1101                                if (c === SOLIDUS) {
1102                                    return this.consumeToken();
1103                                }
1104                            }
1105                            if (c === EOF) {
1106                                return this.consumeToken();
1107                            }
1108                        }
1109                    }
1110                    break;
1111                case COLON:
1112                    return COLON_TOKEN;
1113                case SEMICOLON:
1114                    return SEMICOLON_TOKEN;
1115                case LESS_THAN_SIGN:
1116                    if (this.peekCodePoint(0) === EXCLAMATION_MARK &&
1117                        this.peekCodePoint(1) === HYPHEN_MINUS &&
1118                        this.peekCodePoint(2) === HYPHEN_MINUS) {
1119                        this.consumeCodePoint();
1120                        this.consumeCodePoint();
1121                        return CDO_TOKEN;
1122                    }
1123                    break;
1124                case COMMERCIAL_AT:
1125                    var a1 = this.peekCodePoint(0);
1126                    var a2 = this.peekCodePoint(1);
1127                    var a3 = this.peekCodePoint(2);
1128                    if (isIdentifierStart(a1, a2, a3)) {
1129                        var value = this.consumeName();
1130                        return { type: TokenType.AT_KEYWORD_TOKEN, value: value };
1131                    }
1132                    break;
1133                case LEFT_SQUARE_BRACKET:
1134                    return LEFT_SQUARE_BRACKET_TOKEN;
1135                case REVERSE_SOLIDUS:
1136                    if (isValidEscape(codePoint, this.peekCodePoint(0))) {
1137                        this.reconsumeCodePoint(codePoint);
1138                        return this.consumeIdentLikeToken();
1139                    }
1140                    break;
1141                case RIGHT_SQUARE_BRACKET:
1142                    return RIGHT_SQUARE_BRACKET_TOKEN;
1143                case CIRCUMFLEX_ACCENT:
1144                    if (this.peekCodePoint(0) === EQUALS_SIGN) {
1145                        this.consumeCodePoint();
1146                        return PREFIX_MATCH_TOKEN;
1147                    }
1148                    break;
1149                case LEFT_CURLY_BRACKET:
1150                    return LEFT_CURLY_BRACKET_TOKEN;
1151                case RIGHT_CURLY_BRACKET:
1152                    return RIGHT_CURLY_BRACKET_TOKEN;
1153                case u:
1154                case U:
1155                    var u1 = this.peekCodePoint(0);
1156                    var u2 = this.peekCodePoint(1);
1157                    if (u1 === PLUS_SIGN && (isHex(u2) || u2 === QUESTION_MARK)) {
1158                        this.consumeCodePoint();
1159                        this.consumeUnicodeRangeToken();
1160                    }
1161                    this.reconsumeCodePoint(codePoint);
1162                    return this.consumeIdentLikeToken();
1163                case VERTICAL_LINE:
1164                    if (this.peekCodePoint(0) === EQUALS_SIGN) {
1165                        this.consumeCodePoint();
1166                        return DASH_MATCH_TOKEN;
1167                    }
1168                    if (this.peekCodePoint(0) === VERTICAL_LINE) {
1169                        this.consumeCodePoint();
1170                        return COLUMN_TOKEN;
1171                    }
1172                    break;
1173                case TILDE:
1174                    if (this.peekCodePoint(0) === EQUALS_SIGN) {
1175                        this.consumeCodePoint();
1176                        return INCLUDE_MATCH_TOKEN;
1177                    }
1178                    break;
1179                case EOF:
1180                    return EOF_TOKEN;
1181            }
1182            if (isWhiteSpace(codePoint)) {
1183                this.consumeWhiteSpace();
1184                return WHITESPACE_TOKEN;
1185            }
1186            if (isDigit(codePoint)) {
1187                this.reconsumeCodePoint(codePoint);
1188                return this.consumeNumericToken();
1189            }
1190            if (isNameStartCodePoint(codePoint)) {
1191                this.reconsumeCodePoint(codePoint);
1192                return this.consumeIdentLikeToken();
1193            }
1194            return { type: TokenType.DELIM_TOKEN, value: fromCodePoint(codePoint) };
1195        };
1196        Tokenizer.prototype.consumeCodePoint = function () {
1197            var value = this._value.shift();
1198            return typeof value === 'undefined' ? -1 : value;
1199        };
1200        Tokenizer.prototype.reconsumeCodePoint = function (codePoint) {
1201            this._value.unshift(codePoint);
1202        };
1203        Tokenizer.prototype.peekCodePoint = function (delta) {
1204            if (delta >= this._value.length) {
1205                return -1;
1206            }
1207            return this._value[delta];
1208        };
1209        Tokenizer.prototype.consumeUnicodeRangeToken = function () {
1210            var digits = [];
1211            var codePoint = this.consumeCodePoint();
1212            while (isHex(codePoint) && digits.length < 6) {
1213                digits.push(codePoint);
1214                codePoint = this.consumeCodePoint();
1215            }
1216            var questionMarks = false;

1217            while (codePoint === QUESTION_MARK && digits.length < 6) {
1218                digits.push(codePoint);
1219                codePoint = this.consumeCodePoint();
1220                questionMarks = true;
1221            }
1222            if (questionMarks) {
1223                var start_1 = parseInt(fromCodePoint.apply(void 0, digits.map(function (digit) { return (digit === QUESTION_MARK ? ZERO : digit); })), 16);
1224                var end = parseInt(fromCodePoint.apply(void 0, digits.map(function (digit) { return (digit === QUESTION_MARK ? F : digit); })), 16);
1225                return { type: TokenType.UNICODE_RANGE_TOKEN, start: start_1, end: end };
1226            }
1227            var start = parseInt(fromCodePoint.apply(void 0, digits), 16);
1228            if (this.peekCodePoint(0) === HYPHEN_MINUS && isHex(this.peekCodePoint(1))) {
1229                this.consumeCodePoint();
1230                codePoint = this.consumeCodePoint();
1231                var endDigits = [];
1232                while (isHex(codePoint) && endDigits.length < 6) {
1233                    endDigits.push(codePoint);
1234                    codePoint = this.consumeCodePoint();
1235                }
1236                var end = parseInt(fromCodePoint.apply(void 0, endDigits), 16);
1237                return { type: TokenType.UNICODE_RANGE_TOKEN, start: start, end: end };
1238            }
1239            else {
1240                return { type: TokenType.UNICODE_RANGE_TOKEN, start: start, end: start };
1241            }
1242        };
1243        Tokenizer.prototype.consumeIdentLikeToken = function () {
1244            var value = this.consumeName();
1245            if (value.toLowerCase() === 'url' && this.peekCodePoint(0) === LEFT_PARENTHESIS) {
1246                this.consumeCodePoint();
1247                return this.consumeUrlToken();
1248            }
1249            else if (this.peekCodePoint(0) === LEFT_PARENTHESIS) {
1250                this.consumeCodePoint();
1251                return { type: TokenType.FUNCTION_TOKEN, value: value };
1252            }
1253            return { type: TokenType.IDENT_TOKEN, value: value };
1254        };
1255        Tokenizer.prototype.consumeUrlToken = function () {
1256            var value = [];
1257            this.consumeWhiteSpace();
1258            if (this.peekCodePoint(0) === EOF) {
1259                return { type: TokenType.URL_TOKEN, value: '' };
1260            }
1261            var next = this.peekCodePoint(0);
1262            if (next === APOSTROPHE || next === QUOTATION_MARK) {
1263                var stringToken = this.consumeStringToken(this.consumeCodePoint());
1264                if (stringToken.type === TokenType.STRING_TOKEN) {
1265                    this.consumeWhiteSpace();
1266                    if (this.peekCodePoint(0) === EOF || this.peekCodePoint(0) === RIGHT_PARENTHESIS) {
1267                        this.consumeCodePoint();
1268                        return { type: TokenType.URL_TOKEN, value: stringToken.value };
1269                    }
1270                }
1271                this.consumeBadUrlRemnants();
1272                return BAD_URL_TOKEN;
1273            }
1274            while (true) {
1275                var codePoint = this.consumeCodePoint();
1276                if (codePoint === EOF || codePoint === RIGHT_PARENTHESIS) {
1277                    return { type: TokenType.URL_TOKEN, value: fromCodePoint.apply(void 0, value) };
1278                }
1279                else if (isWhiteSpace(codePoint)) {
1280                    this.consumeWhiteSpace();
1281                    if (this.peekCodePoint(0) === EOF || this.peekCodePoint(0) === RIGHT_PARENTHESIS) {
1282                        this.consumeCodePoint();
1283                        return { type: TokenType.URL_TOKEN, value: fromCodePoint.apply(void 0, value) };
1284                    }
1285                    this.consumeBadUrlRemnants();
1286                    return BAD_URL_TOKEN;
1287                }
1288                else if (codePoint === QUOTATION_MARK ||
1289                    codePoint === APOSTROPHE ||
1290                    codePoint === LEFT_PARENTHESIS ||
1291                    isNonPrintableCodePoint(codePoint)) {
1292                    this.consumeBadUrlRemnants();
1293                    return BAD_URL_TOKEN;
1294                }
1295                else if (codePoint === REVERSE_SOLIDUS) {
1296                    if (isValidEscape(codePoint, this.peekCodePoint(0))) {
1297                        value.push(this.consumeEscapedCodePoint());
1298                    }
1299                    else {
1300                        this.consumeBadUrlRemnants();
1301                        return BAD_URL_TOKEN;
1302                    }
1303                }
1304                else {
1305                    value.push(codePoint);
1306                }
1307            }
1308        };
1309        Tokenizer.prototype.consumeWhiteSpace = function () {
1310            while (isWhiteSpace(this.peekCodePoint(0))) {
1311                this.consumeCodePoint();
1312            }
1313        };
1314        Tokenizer.prototype.consumeBadUrlRemnants = function () {
1315            while (true) {
1316                var codePoint = this.consumeCodePoint();
1317                if (codePoint === RIGHT_PARENTHESIS || codePoint === EOF) {
1318                    return;
1319                }
1320                if (isValidEscape(codePoint, this.peekCodePoint(0))) {
1321                    this.consumeEscapedCodePoint();
1322                }
1323            }
1324        };
1325        Tokenizer.prototype.consumeStringSlice = function (count) {
1326            var SLICE_STACK_SIZE = 60000;
1327            var value = '';
1328            while (count > 0) {
1329                var amount = Math.min(SLICE_STACK_SIZE, count);
1330                value += fromCodePoint.apply(void 0, this._value.splice(0, amount));
1331                count -= amount;
1332            }
1333            this._value.shift();
1334            return value;
1335        };
1336        Tokenizer.prototype.consumeStringToken = function (endingCodePoint) {
1337            var value = '';
1338            var i = 0;
1339            do {
1340                var codePoint = this._value[i];
1341                if (codePoint === EOF || codePoint === undefined || codePoint === endingCodePoint) {
1342                    value += this.consumeStringSlice(i);
1343                    return { type: TokenType.STRING_TOKEN, value: value };
1344                }
1345                if (codePoint === LINE_FEED) {
1346                    this._value.splice(0, i);
1347                    return BAD_STRING_TOKEN;
1348                }
1349                if (codePoint === REVERSE_SOLIDUS) {
1350                    var next = this._value[i + 1];
1351                    if (next !== EOF && next !== undefined) {
1352                        if (next === LINE_FEED) {
1353                            value += this.consumeStringSlice(i);
1354                            i = -1;
1355                            this._value.shift();
1356                        }
1357                        else if (isValidEscape(codePoint, next)) {
1358                            value += this.consumeStringSlice(i);
1359                            value += fromCodePoint(this.consumeEscapedCodePoint());
1360                            i = -1;
1361                        }
1362                    }
1363                }
1364                i++;
1365            } while (true);
1366        };
1367        Tokenizer.prototype.consumeNumber = function () {
1368            var repr = [];
1369            var type = FLAG_INTEGER;
1370            var c1 = this.peekCodePoint(0);
1371            if (c1 === PLUS_SIGN || c1 === HYPHEN_MINUS) {
1372                repr.push(this.consumeCodePoint());
1373            }
1374            while (isDigit(this.peekCodePoint(0))) {
1375                repr.push(this.consumeCodePoint());
1376            }
1377            c1 = this.peekCodePoint(0);
1378            var c2 = this.peekCodePoint(1);
1379            if (c1 === FULL_STOP && isDigit(c2)) {
1380                repr.push(this.consumeCodePoint(), this.consumeCodePoint());
1381                type = FLAG_NUMBER;
1382                while (isDigit(this.peekCodePoint(0))) {
1383                    repr.push(this.consumeCodePoint());
1384                }
1385            }
1386            c1 = this.peekCodePoint(0);
1387            c2 = this.peekCodePoint(1);
1388            var c3 = this.peekCodePoint(2);
1389            if ((c1 === E || c1 === e) && (((c2 === PLUS_SIGN || c2 === HYPHEN_MINUS) && isDigit(c3)) || isDigit(c2))) {
1390                repr.push(this.consumeCodePoint(), this.consumeCodePoint());
1391                type = FLAG_NUMBER;
1392                while (isDigit(this.peekCodePoint(0))) {
1393                    repr.push(this.consumeCodePoint());
1394                }
1395            }
1396            return [stringToNumber(repr), type];
1397        };
1398        Tokenizer.prototype.consumeNumericToken = function () {
1399            var _a = this.consumeNumber(), number = _a[0], flags = _a[1];
1400            var c1 = this.peekCodePoint(0);
1401            var c2 = this.peekCodePoint(1);
1402            var c3 = this.peekCodePoint(2);
1403            if (isIdentifierStart(c1, c2, c3)) {
1404                var unit = this.consumeName();
1405                return { type: TokenType.DIMENSION_TOKEN, number: number, flags: flags, unit: unit };
1406            }
1407            if (c1 === PERCENTAGE_SIGN) {
1408                this.consumeCodePoint();
1409                return { type: TokenType.PERCENTAGE_TOKEN, number: number, flags: flags };
1410            }
1411            return { type: TokenType.NUMBER_TOKEN, number: number, flags: flags };
1412        };
1413        Tokenizer.prototype.consumeEscapedCodePoint = function () {
1414            var codePoint = this.consumeCodePoint();
1415            if (isHex(codePoint)) {
1416                var hex = fromCodePoint(codePoint);
1417                while (isHex(this.peekCodePoint(0)) && hex.length < 6) {
1418                    hex += fromCodePoint(this.consumeCodePoint());
1419                }
1420                if (isWhiteSpace(this.peekCodePoint(0))) {
1421                    this.consumeCodePoint();
1422                }
1423                var hexCodePoint = parseInt(hex, 16);
1424                if (hexCodePoint === 0 || isSurrogateCodePoint(hexCodePoint) || hexCodePoint > 0x10ffff) {
1425                    return REPLACEMENT_CHARACTER;
1426                }
1427                return hexCodePoint;
1428            }
1429            if (codePoint === EOF) {
1430                return REPLACEMENT_CHARACTER;
1431            }
1432            return codePoint;
1433        };
1434        Tokenizer.prototype.consumeName = function () {
1435            var result = '';
1436            while (true) {
1437                var codePoint = this.consumeCodePoint();
1438                if (isNameCodePoint(codePoint)) {
1439                    result += fromCodePoint(codePoint);
1440                }
1441                else if (isValidEscape(codePoint, this.peekCodePoint(0))) {
1442                    result += fromCodePoint(this.consumeEscapedCodePoint());
1443                }
1444                else {
1445                    this.reconsumeCodePoint(codePoint);
1446                    return result;
1447                }
1448            }
1449        };
1450        return Tokenizer;
1451    }());
1452
1453    var Parser = /** @class */ (function () {
1454        function Parser(tokens) {
1455            this._tokens = tokens;
1456        }
1457        Parser.create = function (value) {
1458            var tokenizer = new Tokenizer();
1459            tokenizer.write(value);
1460            return new Parser(tokenizer.read());
1461        };
1462        Parser.parseValue = function (value) {
1463            return Parser.create(value).parseComponentValue();
1464        };
1465        Parser.parseValues = function (value) {
1466            return Parser.create(value).parseComponentValues();
1467        };
1468        Parser.prototype.parseComponentValue = function () {
1469            var token = this.consumeToken();
1470            while (token.type === TokenType.WHITESPACE_TOKEN) {
1471                token = this.consumeToken();
1472            }
1473            if (token.type === TokenType.EOF_TOKEN) {
1474                throw new SyntaxError("Error parsing CSS component value, unexpected EOF");
1475            }
1476            this.reconsumeToken(token);
1477            var value = this.consumeComponentValue();
1478            do {
1479                token = this.consumeToken();
1480            } while (token.type === TokenType.WHITESPACE_TOKEN);
1481            if (token.type === TokenType.EOF_TOKEN) {
1482                return value;
1483            }
1484            throw new SyntaxError("Error parsing CSS component value, multiple values found when expecting only one");
1485        };
1486        Parser.prototype.parseComponentValues = function () {
1487            var values = [];
1488            while (true) {
1489                var value = this.consumeComponentValue();
1490                if (value.type === TokenType.EOF_TOKEN) {
1491                    return values;
1492                }
1493                values.push(value);
1494                values.push();
1495            }
1496        };
1497        Parser.prototype.consumeComponentValue = function () {
1498            var token = this.consumeToken();
1499            switch (token.type) {
1500                case TokenType.LEFT_CURLY_BRACKET_TOKEN:
1501                case TokenType.LEFT_SQUARE_BRACKET_TOKEN:
1502                case TokenType.LEFT_PARENTHESIS_TOKEN:
1503                    return this.consumeSimpleBlock(token.type);
1504                case TokenType.FUNCTION_TOKEN:
1505                    return this.consumeFunction(token);
1506            }
1507            return token;
1508        };
1509        Parser.prototype.consumeSimpleBlock = function (type) {
1510            var block = { type: type, values: [] };
1511            var token = this.consumeToken();
1512            while (true) {
1513                if (token.type === TokenType.EOF_TOKEN || isEndingTokenFor(token, type)) {
1514                    return block;
1515                }
1516                this.reconsumeToken(token);
1517                block.values.push(this.consumeComponentValue());
1518                token = this.consumeToken();
1519            }
1520        };
1521        Parser.prototype.consumeFunction = function (functionToken) {
1522            var cssFunction = {
1523                name: functionToken.value,
1524                values: [],
1525                type: TokenType.FUNCTION
1526            };
1527            while (true) {
1528                var token = this.consumeToken();
1529                if (token.type === TokenType.EOF_TOKEN || token.type === TokenType.RIGHT_PARENTHESIS_TOKEN) {
1530                    return cssFunction;
1531                }
1532                this.reconsumeToken(token);
1533                cssFunction.values.push(this.consumeComponentValue());
1534            }
1535        };
1536        Parser.prototype.consumeToken = function () {
1537            var token = this._tokens.shift();
1538            return typeof token === 'undefined' ? EOF_TOKEN : token;
1539        };
1540        Parser.prototype.reconsumeToken = function (token) {
1541            this._tokens.unshift(token);
1542        };
1543        return Parser;
1544    }());
1545    var isDimensionToken = function (token) { return token.type === TokenType.DIMENSION_TOKEN; };
1546    var isNumberToken = function (token) { return token.type === TokenType.NUMBER_TOKEN; };
1547    var isIdentToken = function (token) { return token.type === TokenType.IDENT_TOKEN; };
1548    var isStringToken = function (token) { return token.type === TokenType.STRING_TOKEN; };
1549    var isIdentWithValue = function (token, value) {
1550        return isIdentToken(token) && token.value === value;
1551    };
1552    var nonWhiteSpace = function (token) { return token.type !== TokenType.WHITESPACE_TOKEN; };
1553    var nonFunctionArgSeparator = function (token) {
1554        return token.type !== TokenType.WHITESPACE_TOKEN && token.type !== TokenType.COMMA_TOKEN;
1555    };
1556    var parseFunctionArgs = function (tokens) {
1557        var args = [];
1558        var arg = [];
1559        tokens.forEach(function (token) {
1560            if (token.type === TokenType.COMMA_TOKEN) {
1561                if (arg.length === 0) {
1562                    throw new Error("Error parsing function args, zero tokens for arg");
1563                }
1564                args.push(arg);
1565                arg = [];
1566                return;
1567            }
1568            if (token.type !== TokenType.WHITESPACE_TOKEN) {
1569                arg.push(token);
1570            }
1571        });
1572        if (arg.length) {
1573            args.push(arg);
1574        }
1575        return args;
1576    };
1577    var isEndingTokenFor = function (token, type) {
1578        if (type === TokenType.LEFT_CURLY_BRACKET_TOKEN && token.type === TokenType.RIGHT_CURLY_BRACKET_TOKEN) {
1579            return true;
1580        }
1581        if (type === TokenType.LEFT_SQUARE_BRACKET_TOKEN && token.type === TokenType.RIGHT_SQUARE_BRACKET_TOKEN) {
1582            return true;
1583        }
1584        return type === TokenType.LEFT_PARENTHESIS_TOKEN && token.type === TokenType.RIGHT_PARENTHESIS_TOKEN;
1585    };
1586
1587    var isLength = function (token) {
1588        return token.type === TokenType.NUMBER_TOKEN || token.type === TokenType.DIMENSION_TOKEN;
1589    };
1590
1591    var isLengthPercentage = function (token) {
1592        return token.type === TokenType.PERCENTAGE_TOKEN || isLength(token);
1593    };
1594    var parseLengthPercentageTuple = function (tokens) {
1595        return tokens.length > 1 ? [tokens[0], tokens[1]] : [tokens[0]];
1596    };
1597    var ZERO_LENGTH = {
1598        type: TokenType.NUMBER_TOKEN,
1599        number: 0,
1600        flags: FLAG_INTEGER
1601    };
1602    var FIFTY_PERCENT = {
1603        type: TokenType.PERCENTAGE_TOKEN,
1604        number: 50,
1605        flags: FLAG_INTEGER
1606    };
1607    var HUNDRED_PERCENT = {
1608        type: TokenType.PERCENTAGE_TOKEN,
1609        number: 100,
1610        flags: FLAG_INTEGER
1611    };
1612    var getAbsoluteValueForTuple = function (tuple, width, height) {
1613        var x = tuple[0], y = tuple[1];
1614        return [getAbsoluteValue(x, width), getAbsoluteValue(typeof y !== 'undefined' ? y : x, height)];
1615    };
1616    var getAbsoluteValue = function (token, parent) {
1617        if (token.type === TokenType.PERCENTAGE_TOKEN) {
1618            return (token.number / 100) * parent;
1619        }
1620        if (isDimensionToken(token)) {
1621            switch (token.unit) {
1622                case 'rem':
1623                case 'em':
1624                    return 16 * token.number; // TODO use correct font-size
1625                case 'px':
1626                default:
1627                    return token.number;
1628            }
1629        }
1630        return token.number;
1631    };
1632
1633    var DEG = 'deg';
1634    var GRAD = 'grad';
1635    var RAD = 'rad';
1636    var TURN = 'turn';
1637    var angle = {
1638        name: 'angle',
1639        parse: function (value) {
1640            if (value.type === TokenType.DIMENSION_TOKEN) {
1641                switch (value.unit) {
1642                    case DEG:
1643                        return (Math.PI * value.number) / 180;
1644                    case GRAD:
1645                        return (Math.PI / 200) * value.number;
1646                    case RAD:
1647                        return value.number;
1648                    case TURN:
1649                        return Math.PI * 2 * value.number;
1650                }
1651            }
1652            throw new Error("Unsupported angle type");
1653        }
1654    };
1655    var isAngle = function (value) {
1656        if (value.type === TokenType.DIMENSION_TOKEN) {
1657            if (value.unit === DEG || value.unit === GRAD || value.unit === RAD || value.unit === TURN) {
1658                return true;
1659            }
1660        }
1661        return false;
1662    };
1663    var parseNamedSide = function (tokens) {
1664        var sideOrCorner = tokens
1665            .filter(isIdentToken)
1666            .map(function (ident) { return ident.value; })
1667            .join(' ');
1668        switch (sideOrCorner) {
1669            case 'to bottom right':
1670            case 'to right bottom':
1671            case 'left top':
1672            case 'top left':
1673                return [ZERO_LENGTH, ZERO_LENGTH];
1674            case 'to top':
1675            case 'bottom':
1676                return deg(0);
1677            case 'to bottom left':
1678            case 'to left bottom':
1679            case 'right top':
1680            case 'top right':
1681                return [ZERO_LENGTH, HUNDRED_PERCENT];
1682            case 'to right':
1683            case 'left':
1684                return deg(90);
1685            case 'to top left':
1686            case 'to left top':
1687            case 'right bottom':
1688            case 'bottom right':
1689                return [HUNDRED_PERCENT, HUNDRED_PERCENT];
1690            case 'to bottom':
1691            case 'top':
1692                return deg(180);
1693            case 'to top right':
1694            case 'to right top':
1695            case 'left bottom':
1696            case 'bottom left':
1697                return [HUNDRED_PERCENT, ZERO_LENGTH];
1698            case 'to left':
1699            case 'right':
1700                return deg(270);
1701        }
1702        return 0;
1703    };
1704    var deg = function (deg) { return (Math.PI * deg) / 180; };
1705
1706    var color = {
1707        name: 'color',
1708        parse: function (value) {
1709            if (value.type === TokenType.FUNCTION) {
1710                var colorFunction = SUPPORTED_COLOR_FUNCTIONS[value.name];
1711                if (typeof colorFunction === 'undefined') {
1712                    throw new Error("Attempting to parse an unsupported color function \"" + value.name + "\"");
1713                }
1714                return colorFunction(value.values);
1715            }
1716            if (value.type === TokenType.HASH_TOKEN) {
1717                if (value.value.length === 3) {
1718                    var r = value.value.substring(0, 1);
1719                    var g = value.value.substring(1, 2);
1720                    var b = value.value.substring(2, 3);
1721                    return pack(parseInt(r + r, 16), parseInt(g + g, 16), parseInt(b + b, 16), 1);
1722                }
1723                if (value.value.length === 4) {
1724                    var r = value.value.substring(0, 1);
1725                    var g = value.value.substring(1, 2);
1726                    var b = value.value.substring(2, 3);
1727                    var a = value.value.substring(3, 4);
1728                    return pack(parseInt(r + r, 16), parseInt(g + g, 16), parseInt(b + b, 16), parseInt(a + a, 16) / 25

17285);
1729                }
1730                if (value.value.length === 6) {
1731                    var r = value.value.substring(0, 2);
1732                    var g = value.value.substring(2, 4);
1733                    var b = value.value.substring(4, 6);
1734                    return pack(parseInt(r, 16), parseInt(g, 16), parseInt(b, 16), 1);
1735                }
1736                if (value.value.length === 8) {
1737                    var r = value.value.substring(0, 2);
1738                    var g = value.value.substring(2, 4);
1739                    var b = value.value.substring(4, 6);
1740                    var a = value.value.substring(6, 8);
1741                    return pack(parseInt(r, 16), parseInt(g, 16), parseInt(b, 16), parseInt(a, 16) / 255);
1742                }
1743            }
1744            if (value.type === TokenType.IDENT_TOKEN) {
1745                var namedColor = COLORS[value.value.toUpperCase()];
1746                if (typeof namedColor !== 'undefined') {
1747                    return namedColor;
1748                }
1749            }
1750            return COLORS.TRANSPARENT;
1751        }
1752    };
1753    var isTransparent = function (color) { return (0xff & color) === 0; };
1754    var asString = function (color) {
1755        var alpha = 0xff & color;
1756        var blue = 0xff & (color >> 8);
1757        var green = 0xff & (color >> 16);
1758        var red = 0xff & (color >> 24);
1759        return alpha < 255 ? "rgba(" + red + "," + green + "," + blue + "," + alpha / 255 + ")" : "rgb(" + red + "," + green + "," + blue + ")";
1760    };
1761    var pack = function (r, g, b, a) {
1762        return ((r << 24) | (g << 16) | (b << 8) | (Math.round(a * 255) << 0)) >>> 0;
1763    };
1764    var getTokenColorValue = function (token, i) {
1765        if (token.type === TokenType.NUMBER_TOKEN) {
1766            return token.number;
1767        }
1768        if (token.type === TokenType.PERCENTAGE_TOKEN) {
1769            var max = i === 3 ? 1 : 255;
1770            return i === 3 ? (token.number / 100) * max : Math.round((token.number / 100) * max);
1771        }
1772        return 0;
1773    };
1774    var rgb = function (args) {
1775        var tokens = args.filter(nonFunctionArgSeparator);
1776        if (tokens.length === 3) {
1777            var _a = tokens.map(getTokenColorValue), r = _a[0], g = _a[1], b = _a[2];
1778            return pack(r, g, b, 1);
1779        }
1780        if (tokens.length === 4) {
1781            var _b = tokens.map(getTokenColorValue), r = _b[0], g = _b[1], b = _b[2], a = _b[3];
1782            return pack(r, g, b, a);
1783        }
1784        return 0;
1785    };
1786    function hue2rgb(t1, t2, hue) {
1787        if (hue < 0) {
1788            hue += 1;
1789        }
1790        if (hue >= 1) {
1791            hue -= 1;
1792        }
1793        if (hue < 1 / 6) {
1794            return (t2 - t1) * hue * 6 + t1;
1795        }
1796        else if (hue < 1 / 2) {
1797            return t2;
1798        }
1799        else if (hue < 2 / 3) {
1800            return (t2 - t1) * 6 * (2 / 3 - hue) + t1;
1801        }
1802        else {
1803            return t1;
1804        }
1805    }
1806    var hsl = function (args) {
1807        var tokens = args.filter(nonFunctionArgSeparator);
1808        var hue = tokens[0], saturation = tokens[1], lightness = tokens[2], alpha = tokens[3];
1809        var h = (hue.type === TokenType.NUMBER_TOKEN ? deg(hue.number) : angle.parse(hue)) / (Math.PI * 2);
1810        var s = isLengthPercentage(saturation) ? saturation.number / 100 : 0;
1811        var l = isLengthPercentage(lightness) ? lightness.number / 100 : 0;
1812        var a = typeof alpha !== 'undefined' && isLengthPercentage(alpha) ? getAbsoluteValue(alpha, 1) : 1;
1813        if (s === 0) {
1814            return pack(l * 255, l * 255, l * 255, 1);
1815        }
1816        var t2 = l <= 0.5 ? l * (s + 1) : l + s - l * s;
1817        var t1 = l * 2 - t2;
1818        var r = hue2rgb(t1, t2, h + 1 / 3);
1819        var g = hue2rgb(t1, t2, h);
1820        var b = hue2rgb(t1, t2, h - 1 / 3);
1821        return pack(r * 255, g * 255, b * 255, a);
1822    };
1823    var SUPPORTED_COLOR_FUNCTIONS = {
1824        hsl: hsl,
1825        hsla: hsl,
1826        rgb: rgb,
1827        rgba: rgb
1828    };
1829    var COLORS = {
1830        ALICEBLUE: 0xf0f8ffff,
1831        ANTIQUEWHITE: 0xfaebd7ff,
1832        AQUA: 0x00ffffff,
1833        AQUAMARINE: 0x7fffd4ff,
1834        AZURE: 0xf0ffffff,
1835        BEIGE: 0xf5f5dcff,
1836        BISQUE: 0xffe4c4ff,
1837        BLACK: 0x000000ff,

1993ING_BOX";
1994        BACKGROUND_CLIP[BACKGROUND_CLIP["CONTENT_BOX"] = 2] = "CONTENT_BOX";
1995    })(BACKGROUND_CLIP || (BACKGROUND_CLIP = {}));
1996    var backgroundClip = {
1997        name: 'background-clip',
1998        initialValue: 'border-box',
1999        prefix: false,
2000        type: PropertyDescriptorParsingType.LIST,
2001        parse: function (tokens) {
2002            return tokens.map(function (token) {
2003                if (isIdentToken(token)) {
2004                    switch (token.value) {
2005                        case 'padding-box':
2006                            return BACKGROUND_CLIP.PADDING_BOX;
2007                        case 'content-box':
2008                            return BACKGROUND_CLIP.CONTENT_BOX;
2009                    }
2010                }
2011                return BACKGROUND_CLIP.BORDER_BOX;
2012            });
2013        }
2014    };
2015
2016    var backgroundColor = {
2017        name: "background-color",
2018        initialValue: 'transparent',
2019        prefix: false,
2020        type: PropertyDescriptorParsingType.TYPE_VALUE,
2021        format: 'color'
2022    };
2023
2024    var parseColorStop = function (args) {
2025        var color$1 = color.parse(args[0]);
2026        var stop = args[1];
2027        return stop && isLengthPercentage(stop) ? { color: color$1, stop: stop } : { color: color$1, stop: null };
2028    };
2029    var processColorStops = function (stops, lineLength) {
2030        var first = stops[0];
2031        var last = stops[stops.length - 1];
2032        if (first.stop === null) {
2033            first.stop = ZERO_LENGTH;
2034        }
2035        if (last.stop === null) {
2036            last.stop = HUNDRED_PERCENT;
2037        }
2038        var processStops = [];
2039        var previous = 0;
2040        for (var i = 0; i < stops.length; i++) {
2041            var stop_1 = stops[i].stop;
2042            if (stop_1 !== null) {
2043                var absoluteValue = getAbsoluteValue(stop_1, lineLength);
2044                if (absoluteValue > previous) {
2045                    processStops.push(absoluteValue);
2046                }
2047                else {
2048                    processStops.push(previous);
2049                }
2050                previous = absoluteValue;
2051            }
2052            else {
2053                processStops.push(null);
2054            }
2055        }
2056        var gapBegin = null;
2057        for (var i = 0; i < processStops.length; i++) {
2058            var stop_2 = processStops[i];
2059            if (stop_2 === null) {
2060                if (gapBegin === null) {
2061                    gapBegin = i;
2062                }
2063            }
2064            else if (gapBegin !== null) {
2065                var gapLength = i - gapBegin;
2066                var beforeGap = processStops[gapBegin - 1];
2067                var gapValue = (stop_2 - beforeGap) / (gapLength + 1);
2068                for (var g = 1; g <= gapLength; g++) {
2069                    processStops[gapBegin + g - 1] = gapValue * g;
2070                }
2071                gapBegin = null;
2072            }
2073        }
2074        return stops.map(function (_a, i) {
2075            var color = _a.color;
2076            return { color: color, stop: Math.max(Math.min(1, processStops[i] / lineLength), 0) };
2077        });
2078    };
2079    var getAngleFromCorner = function (corner, width, height) {
2080        var centerX = width / 2;
2081        var centerY = height / 2;
2082        var x = getAbsoluteValue(corner[0], width) - centerX;
2083        var y = centerY - getAbsoluteValue(corner[1], height);
2084        return (Math.atan2(y, x) + Math.PI * 2) % (Math.PI * 2);
2085    };
2086    var calculateGradientDirection = function (angle, width, height) {
2087        var radian = typeof angle === 'number' ? angle : getAngleFromCorner(angle, width, height);
2088        var lineLength = Math.abs(width * Math.sin(radian)) + Math.abs(height * Math.cos(radian));
2089        var halfWidth = width / 2;
2090        var halfHeight = height / 2;
2091        var halfLineLength = lineLength / 2;
2092        var yDiff = Math.sin(radian - Math.PI / 2) * halfLineLength;
2093        var xDiff = Math.cos(radian - Math.PI / 2) * halfLineLength;
2094        return [lineLength, halfWidth - xDiff, halfWidth + xDiff, halfHeight - yDiff, halfHeight + yDiff];
2095    };
2096    var distance = function (a, b) { return Math.sqrt(a * a + b * b); };
2097    var findCorner = function (width, height, x, y, closest) {
2098        var corners = [[0, 0], [0, height], [width, 0], [width, height]];
2099        return corners.reduce(function (stat, corner) {
2100            var cx = corner[0], cy = corner[1];
2101            var d = distance(x - cx, y - cy);
2102            if (closest ? d < stat.optimumDistance : d > stat.optimumDistance) {
2103                return {
2104                    optimumCorner: corner,
2105                    optimumDistance: d
2106                };
2107            }
2108            return stat;
2109        }, {
2110            optimumDistance: closest ? Infinity : -Infinity,
2111            optimumCorner: null
2112        }).optimumCorner;
2113    };
2114    var calculateRadius = function (gradient, x, y, width, height) {
2115        var rx = 0;
2116        var ry = 0;
2117        switch (gradient.size) {
2118            case CSSRadialExtent.CLOSEST_SIDE:
2119                // The ending shape is sized so that that it exactly meets the side of the gradient box closest to the gradient’s center.
2120                // If the shape is an ellipse, it exactly meets the closest side in each dimension.
2121                if (gradient.shape === CSSRadialShape.CIRCLE) {
2122                    rx = ry = Math.min(Math.abs(x), Math.abs(x - width), Math.abs(y), Math.abs(y - height));
2123                }
2124                else if (gradient.shape === CSSRadialShape.ELLIPSE) {
2125                    rx = Math.min(Math.abs(x), Math.abs(x - width));
2126                    ry = Math.min(Math.abs(y), Math.abs(y - height));
2127                }
2128                break;
2129            case CSSRadialExtent.CLOSEST_CORNER:
2130                // The ending shape is sized so that that it passes through the corner of the gradient box closest to the gradient’s center.
2131                // If the shape is an ellipse, the ending shape is given the same aspect-ratio it would have if closest-side were specified.
2132                if (gradient.shape === CSSRadialShape.CIRCLE) {
2133                    rx = ry = Math.min(distance(x, y), distance(x, y - height), distance(x - width, y), distance(x - width, y - height));
2134                }
2135                else if (gradient.shape === CSSRadialShape.ELLIPSE) {
2136                    // Compute the ratio ry/rx (which is to be the same as for "closest-side")
2137                    var c = Math.min(Math.abs(y), Math.abs(y - height)) / Math.min(Math.abs(x), Math.abs(x - width));
2138                    var _a = findCorner(width, height, x, y, true), cx = _a[0], cy = _a[1];
2139                    rx = distance(cx - x, (cy - y) / c);
2140                    ry = c * rx;
2141                }
2142                break;
2143            case CSSRadialExtent.FARTHEST_SIDE:
2144                // Same as closest-side, except the ending shape is sized based on the farthest side(s)
2145                if (gradient.shape === CSSRadialShape.CIRCLE) {
2146                    rx = ry = Math.max(Math.abs(x), Math.abs(x - width), Math.abs(y), Math.abs(y - height));
2147                }
2148                else if (gradient.shape === CSSRadialShape.ELLIPSE) {
2149                    rx = Math.max(Math.abs(x), Math.abs(x - width));
2150                    ry = Math.max(Math.abs(y), Math.abs(y - height));
2151                }
2152                break;
2153            case CSSRadialExtent.FARTHEST_CORNER:
2154                // Same as closest-corner, except the ending shape is sized based on the farthest corner.
2155                // If the shape is an ellipse, the ending shape is given the same aspect ratio it would have if farthest-side were specified.
2156                if (gradient.shape === CSSRadialShape.CIRCLE) {
2157                    rx = ry = Math.max(distance(x, y), distance(x, y - height), distance(x - width, y), distance(x - width, y - height));
2158                }
2159                else if (gradient.shape === CSSRadialShape.ELLIPSE) {
2160                    // Compute the ratio ry/rx (which is to be the same as for "farthest-side")
2161                    var c = Math.max(Math.abs(y), Math.abs(y - height)) / Math.max(Math.abs(x), Math.abs(x - width));
2162                    var _b = findCorner(width, height, x, y, false), cx = _b[0], cy = _b[1];
2163                    rx = distance(cx - x, (cy - y) / c);
2164                    ry = c * rx;
2165                }
2166                break;
2167        }
2168        if (Array.isArray(gradient.size)) {
2169            rx = getAbsoluteValue(gradient.size[0], width);
2170            ry = gradient.size.length === 2 ? getAbsoluteValue(gradient.size[1], height) : rx;
2171        }
2172        return [rx, ry];
2173    };
2174
2175    var linearGradient = function (tokens) {
2176        var angle$1 = deg(180);
2177        var stops = [];
2178        parseFunctionArgs(tokens).forEach(function (arg, i) {
2179            if (i === 0) {
2180                var firstToken = arg[0];
2181                if (firstToken.type === TokenType.IDENT_TOKEN && firstToken.value === 'to') {
2182                    angle$1 = parseNamedSide(arg);
2183                    return;
2184                }
2185                else if (isAngle(firstToken)) {
2186                    angle$1 = angle.parse(firstToken);
2187                    return;
2188                }
2189            }
2190            var colorStop = parseColorStop(arg);
2191            stops.push(colorStop);
2192        });
2193        return { angle: angle$1, stops: stops, type: CSSImageType.LINEAR_GRADIENT };
2194    };
2195
2196    var prefixLinearGradient = function (tokens) {
2197        var angle$1 = deg(180);
2198        var stops = [];
2199        parseFunctionArgs(tokens).forEach(function (arg, i) {
2200            if (i === 0) {
2201                var firstToken = arg[0];
2202                if (firstToken.type === TokenType.IDENT_TOKEN &&
2203                    ['top', 'left', 'right', 'bottom'].indexOf(firstToken.value) !== -1) {
2204                    angle$1 = parseNamedSide(arg);
2205                    return;
2206                }
2207                else if (isAngle(firstToken)) {
2208                    angle$1 = (angle.parse(firstToken) + deg(270)) % deg(360);
2209                    return;
2210                }
2211            }
2212            var colorStop = parseColorStop(arg);
2213            stops.push(colorStop);
2214        });
2215        return {
2216            angle: angle$1,
2217            stops: stops,
2218            type: CSSImageType.LINEAR_GRADIENT
2219        };
2220    };
2221
2222    var testRangeBounds = function (document) {
2223        var TEST_HEIGHT = 123;
2224        if (document.createRange) {
2225            var range = document.createRange();
2226            if (range.getBoundingClientRect) {
2227                var testElement = document.createElement('boundtest');
2228                testElement.style.height = TEST_HEIGHT + "px";
2229                testElement.style.display = 'block';
2230                document.body.appendChild(testElement);
2231                range.selectNode(testElement);
2232                var rangeBounds = range.getBoundingClientRect();
2233                var rangeHeight = Math.round(rangeBounds.height);
2234                document.body.removeChild(testElement);
2235                if (rangeHeight === TEST_HEIGHT) {
2236                    return true;
2237                }
2238            }
2239        }
2240        return false;
2241    };
2242    var testCORS = function () { return typeof new Image().crossOrigin !== 'undefined'; };
2243    var testResponseType = function () { return typeof new XMLHttpRequest().responseType === 'string'; };
2244    var testSVG = function (document) {
2245        var img = new Image();
2246        var canvas = document.createElement('canvas');
2247        var ctx = canvas.getContext('2d');
2248        if (!ctx) {
2249            return false;
2250        }
2251        img.src = "data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg'></svg>";
2252        try {
2253            ctx.drawImage(img, 0, 0);
2254            canvas.toDataURL();
2255        }
2256        catch (e) {
2257            return false;
2258        }
2259        return true;
2260    };
2261    var isGreenPixel = function (data) {
2262        return data[0] === 0 && data[1] === 255 && data[2] === 0 && data[3] === 255;
2263    };
2264    var testForeignObject = function (document) {
2265        var canvas = document.createElement('canvas');
2266        var size = 100;
2267        canvas.width = size;
2268        canvas.height = size;
2269        var ctx = canvas.getContext('2d');
2270        if (!ctx) {
2271            return Promise.reject(false);
2272        }
2273        ctx.fillStyle = 'rgb(0, 255, 0)';
2274        ctx.fillRect(0, 0, size, size);
2275        var img = new Image();
2276        var greenImageSrc = canvas.toDataURL();
2277        img.src = greenImageSrc;
2278        var svg = createForeignObjectSVG(size, size, 0, 0, img);
2279        ctx.fillStyle = 'red';
2280        ctx.fillRect(0, 0, size, size);
2281        return loadSerializedSVG(svg)
2282            .then(function (img) {
2283            ctx.drawImage(img, 0, 0);
2284            var data = ctx.getImageData(0, 0, size, size).data;
2285            ctx.fillStyle = 'red';
2286            ctx.fillRect(0, 0, size, size);
2287            var node = document.createElement('div');
2288            node.style.backgroundImage = "url(" + greenImageSrc + ")";
2289            node.style.height = size + "px";
2290            // Firefox 55 does not render inline <img /> tags
2291            return isGreenPixel(data)
2292                ? loadSerializedSVG(createForeignObjectSVG(size, size, 0, 0, node))
2293                : Promise.reject(false);
2294        })
2295            .then(function (img) {
2296            ctx.drawImage(img, 0, 0);
2297            // Edge does not render background-images
2298            return isGreenPixel(ctx.getImageData(0, 0, size, size).data);
2299        })
2300            .catch(function () { return false; });
2301    };
2302    var createForeignObjectSVG = function (width, height, x, y, node) {
2303        var xmlns = 'http://www.w3.org/2000/svg';
2304        var svg = document.createElementNS(xmlns, 'svg');
2305        var foreignObject = document.createElementNS(xmlns, 'foreignObject');
2306        svg.setAttributeNS(null, 'width', width.toString());
2307        svg.setAttributeNS(null, 'height', height.toString());
2308        foreignObject.setAttributeNS(null, 'width', '100%');
2309        foreignObject.setAttributeNS(null, 'height', '100%');
2310        foreignObject.setAttributeNS(null, 'x', x.toString());
2311        foreignObject.setAttributeNS(null, 'y', y.toString());
2312        foreignObject.setAttributeNS(null, 'externalResourcesRequired', 'true');
2313        svg.appendChild(foreignObject);
2314        foreignObject.appendChild(node);
2315        return svg;
2316    };
2317    var loadSerializedSVG = function (svg) {
2318        return new Promise(function (resolve, reject) {
2319            var img = new Image();
2320            img.onload = function () { return resolve(img); };
2321            img.onerror = reject;
2322            img.src = "data:image/svg+xml;charset=utf-8," + encodeURIComponent(new XMLSerializer().serializeToString(svg));
2323        });
2324    };
2325    var FEATURES = {
2326        get SUPPORT_RANGE_BOUNDS() {
2327            var value = testRangeBounds(document);
2328            Object.defineProperty(FEATURES, 'SUPPORT_RANGE_BOUNDS', { value: value });
2329            return value;
2330        },
2331        get SUPPORT_SVG_DRAWING() {
2332            var value = testSVG(document);
2333            Object.defineProperty(FEATURES, 'SUPPORT_SVG_DRAWING', { value: value });
2334            return value;
2335        },
2336        get SUPPORT_FOREIGNOBJECT_DRAWING() {
2337            var value = typeof Array.from === 'function' && typeof window.fetch === 'function'
2338                ? testForeignObject(document)
2339                : Promise.resolve(false);
2340            Object.defineProperty(FEATURES, 'SUPPORT_FOREIGNOBJECT_DRAWING', { value: value });
2341            return value;
2342        },
2343        get SUPPORT_CORS_IMAGES() {
2344            var value = testCORS();
2345            Object.defineProperty(FEATURES, 'SUPPORT_CORS_IMAGES', { value: value });
2346            return value;
2347        },
2348        get SUPPORT_RESPONSE_TYPE() {
2349            var value = testResponseType();
2350            Object.defineProperty(FEATURES, 'SUPPORT_RESPONSE_TYPE', { value: value });
2351            return value;
2352        },
2353        get SUPPORT_CORS_XHR() {
2354            var value = 'withCredentials' in new XMLHttpRequest();
2355            Object.defineProperty(FEATURES, 'SUPPORT_CORS_XHR', { value: value });
2356            return value;
2357        }
2358    };
2359
2360    var Logger = /** @class */ (function () {
2361        function Logger(id) {
2362            this.id = id;
2363            this.start = Date.now();
2364        }
2365        // eslint-disable-next-line @typescript-eslint/no-explicit-any
2366        Logger.prototype.debug = function () {
2367            var args = [];
2368            for (var _i = 0; _i < arguments.length; _i++) {
2369                args[_i] = arguments[_i];
2370            }
2371            // eslint-disable-next-line no-console
2372            if (typeof window !== 'undefined' && window.console && typeof console.debug === 'function') {
2373                // eslint-disable-next-line no-console
2374                console.debug.apply(console, [this.id, this.getTime() + "ms"].concat(args));
2375            }
2376            else {
2377                this.info.apply(this, args);
2378            }
2379        };
2380        Logger.prototype.getTime = function () {
2381            return Date.now() - this.start;
2382        };
2383        Logger.create = function (id) {
2384            Logger.instances[id] = new Logger(id);
2385        };
2386        Logger.destroy = function (id) {
2387            delete Logger.instances[id];
2388        };
2389        Logger.getInstance = function (id) {
2390            var instance = Logger.instances[id];
2391            if (typeof instance === 'undefined') {
2392                throw new Error("No logger instance found with id " + id);
2393            }
2394            return instance;
2395        };
2396        // eslint-disable-next-line @typescript-eslint/no-explicit-any
2397        Logger.prototype.info = function () {
2398            var args = [];
2399            for (var _i = 0; _i < arguments.length; _i++) {
2400                args[_i] = arguments[_i];
2401            }
2402            // eslint-disable-next-line no-console
2403            if (typeof window !== 'undefined' && window.console && typeof console.info === 'function') {
2404                // eslint-disable-next-line no-console
2405                console.info.apply(console, [this.id, this.getTime() + "ms"].concat(args));
2406            }
2407        };
2408        // eslint-disable-next-line @typescript-eslint/no-explicit-any
2409        Logger.prototype.error = function () {
2410            var args = [];
2411            for (var _i = 0; _i < arguments.length; _i++) {
2412                args[_i] = arguments[_i];
2413            }
2414            // eslint-disable-next-line no-console
2415            if (typeof window !== 'undefined' && window.console && typeof console.error === 'function') {
2416                // eslint-disable-next-line no-console
2417                console.error.apply(console, [this.id, this.getTime() + "ms"].concat(args));
2418            }
2419            else {
2420                this.info.apply(this, args);
2421            }
2422        };
2423        Logger.instances = {};
2424        return Logger;
2425    }());
2426
2427    var CacheStorage = /** @class */ (function () {
2428        function CacheStorage() {
2429        }
2430        CacheStorage.create = function (name, options) {
2431            return (CacheStorage._caches[name] = new Cache(name, options));
2432        };
2433        CacheStorage.destroy = function (name) {
2434            delete CacheStorage._caches[name];
2435        };
2436        CacheStorage.open = function (name) {
2437            var cache = CacheStorage._caches[name];
2438            if (typeof cache !== 'undefined') {
2439                return cache;
2440            }
2441            throw new Error("Cache with key \"" + name + "\" not found");
2442        };
2443        CacheStorage.getOrigin = function (url) {
2444            var link = CacheStorage._link;
2445            if (!link) {
2446                return 'about:blank';
2447            }
2448            link.href = url;
2449            link.href = link.href; // IE9, LOL! - http://jsfiddle.net/niklasvh/2e48b/
2450            return link.protocol + link.hostname + link.port;
2451        };
2452        CacheStorage.isSameOrigin = function (src) {
2453            return CacheStorage.getOrigin(src) === CacheStorage._origin;
2454        };
2455        CacheStorage.setContext = function (window) {
2456            CacheStorage._link = window.document.createElement('a');
2457            CacheStorage._origin = CacheStorage.getOrigin(window.location.href);
2458        };
2459        CacheStorage.getInstance = function () {
2460            var current = CacheStorage._current;
2461            if (current === null) {
2462                throw new Error("No cache instance attached");
2463            }
2464            return current;
2465        };
2466        CacheStorage.attachInstance = function (cache) {
2467            CacheStorage._current = cache;
2468        };
2469        CacheStorage.detachInstance = function () {
2470            CacheStorage._current = null;
2471        };
2472        CacheStorage._caches = {};
2473        CacheStorage._origin = 'about:blank';
2474        CacheStorage._current = null;
2475        return CacheStorage;
2476    }());
2477    var Cache = /** @class */ (function () {
2478        function Cache(id, options) {
2479            this.id = id;
2480            this._options = options;
2481            this._cache = {};
2482        }
2483        Cache.prototype.addImage = function (src) {
2484            var result = Promise.resolve();
2485            if (this.has(src)) {
2486                return result;
2487            }
2488            if (isBlobImage(src) || isRenderable(src)) {
2489                this._cache[src] = this.loadImage(src);
2490                return result;
2491            }
2492            return result;
2493        };
2494        // eslint-disable-next-line @typescript-eslint/no-explicit-any
2495        Cache.prototype.match = function (src) {
2496            return this._cache[src];
2497        };
2498        Cache.prototype.loadImage = function (key) {
2499            return __awaiter(this, void 0, void 0, function () {
2500                var isSameOrigin, useCORS, useProxy, src;
2501                var _this = this;
2502                return __generator(this, function (_a) {
2503                    switch (_a.label) {
2504                        case 0:
2505                            isSameOrigin = CacheStorage.isSameOrigin(key);
2506                            useCORS = !isInlineImage(key) && this._options.useCORS === true && FEATURES.SUPPORT_CORS_IMAGES && !isSameOrigin;
2507                            useProxy = !isInlineImage(key) &&
2508                                !isSameOrigin &&
2509                                typeof this._options.proxy === 'string' &&
2510                                FEATURES.SUPPORT_CORS_XHR &&
2511                                !useCORS;
2512                            if (!isSameOrigin && this._options.allowTaint === false && !isInlineImage(key) && !useProxy && !useCORS) {
2513                                return [2 /*return*/];
2514                            }
2515                            src = key;
2516                            if (!useProxy) return [3 /*break*/, 2];
2517                            return [4 /*yield*/, this.proxy(src)];
2518                        case 1:
2519                            src = _a.sent();
2520                            _a.label = 2;
2521                        case 2:

2522                            Logger.getInstance(this.id).debug("Added image " + key.substring(0, 256));
2523                            return [4 /*yield*/, new Promise(function (resolve, reject) {
2524                                    var img = new Image();
2525                                    img.onload = function () { return resolve(img); };
2526                                    img.onerror = reject;
2527                                    //ios safari 10.3 taints canvas with data urls unless crossOrigin is set to anonymous
2528                                    if (isInlineBase64Image(src) || useCORS) {
2529                                        img.crossOrigin = 'anonymous';
2530                                    }
2531                                    img.src = src;
2532                                    if (img.complete === true) {
2533                                        // Inline XML images may fail to parse, throwing an Error later on
2534                                        setTimeout(function () { return resolve(img); }, 500);
2535                                    }
2536                                    if (_this._options.imageTimeout > 0) {
2537                                        setTimeout(function () { return reject("Timed out (" + _this._options.imageTimeout + "ms) loading image"); }, _this._options.imageTimeout);
2538                                    }
2539                                })];
2540                        case 3: return [2 /*return*/, _a.sent()];
2541                    }
2542                });
2543            });
2544        };
2545        Cache.prototype.has = function (key) {
2546            return typeof this._cache[key] !== 'undefined';
2547        };
2548        Cache.prototype.keys = function () {
2549            return Promise.resolve(Object.keys(this._cache));
2550        };
2551        Cache.prototype.proxy = function (src) {
2552            var _this = this;
2553            var proxy = this._options.proxy;
2554            if (!proxy) {
2555                throw new Error('No proxy defined');
2556            }
2557            var key = src.substring(0, 256);
2558            return new Promise(function (resolve, reject) {
2559                var responseType = FEATURES.SUPPORT_RESPONSE_TYPE ? 'blob' : 'text';
2560                var xhr = new XMLHttpRequest();
2561                xhr.onload = function () {
2562                    if (xhr.status === 200) {
2563                        if (responseType === 'text') {
2564                            resolve(xhr.response);
2565                        }
2566                        else {
2567                            var reader_1 = new FileReader();
2568                            reader_1.addEventListener('load', function () { return resolve(reader_1.result); }, false);
2569                            reader_1.addEventListener('error', function (e) { return reject(e); }, false);
2570                            reader_1.readAsDataURL(xhr.response);
2571                        }
2572                    }
2573                    else {
2574                        reject("Failed to proxy resource " + key + " with status code " + xhr.status);
2575                    }
2576                };
2577                xhr.onerror = reject;
2578                xhr.open('GET', proxy + "?url=" + encodeURIComponent(src) + "&responseType=" + responseType);
2579                if (responseType !== 'text' && xhr instanceof XMLHttpRequest) {
2580                    xhr.responseType = responseType;
2581                }
2582                if (_this._options.imageTimeout) {
2583                    var timeout_1 = _this._options.imageTimeout;
2584                    xhr.timeout = timeout_1;
2585                    xhr.ontimeout = function () { return reject("Timed out (" + timeout_1 + "ms) proxying " + key); };
2586                }
2587                xhr.send();
2588            });
2589        };
2590        return Cache;
2591    }());
2592    var INLINE_SVG = /^data:image\/svg\+xml/i;
2593    var INLINE_BASE64 = /^data:image\/.*;base64,/i;
2594    var INLINE_IMG = /^data:image\/.*/i;
2595    var isRenderable = function (src) { return FEATURES.SUPPORT_SVG_DRAWING || !isSVG(src); };
2596    var isInlineImage = function (src) { return INLINE_IMG.test(src); };
2597    var isInlineBase64Image = function (src) { return INLINE_BASE64.test(src); };
2598    var isBlobImage = function (src) { return src.substr(0, 4) === 'blob'; };
2599    var isSVG = function (src) { return src.substr(-3).toLowerCase() === 'svg' || INLINE_SVG.test(src); };
2600
2601    var webkitGradient = function (tokens) {
2602        var angle = deg(180);
2603        var stops = [];
2604        var type = CSSImageType.LINEAR_GRADIENT;
2605        var shape = CSSRadialShape.CIRCLE;
2606        var size = CSSRadialExtent.FARTHEST_CORNER;
2607        var position = [];