1/*! 2 * html2canvas 1.0.0-rc.7 <https://html2canvas.hertzen.com> 3 * Copyright (c) 2020 Niklas von Hertzen <https://hertzen.com> 4 * Released under MIT License 5 */ 6(function (global, factory) { 7 typeof exports === "object" && typeof module !== "undefined" 8 ? (module.exports = factory()) 9 : typeof define === "function" && define.amd 10 ? define(factory) 11 : ((global = global || self), (global.html2canvas = factory())); 12})(this, function () { 13 "use strict"; 14 15 /*! ***************************************************************************** 16 Copyright (c) Microsoft Corporation. All rights reserved. 17 Licensed under the Apache License, Version 2.0 (the "License"); you may not use 18 this file except in compliance with the License. You may obtain a copy of the 19 License at http://www.apache.org/licenses/LICENSE-2.0 20 21 THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 22 KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED 23 WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, 24 MERCHANTABLITY OR NON-INFRINGEMENT. 25 26 See the Apache Version 2.0 License for specific language governing permissions 27 and limitations under the License. 28 ***************************************************************************** */ 29 /* global Reflect, Promise */ 30 31 var extendStatics = function (d, b) { 32 extendStatics = 33 Object.setPrototypeOf || 34 ({ __proto__: [] } instanceof Array && 35 function (d, b) { 36 d.__proto__ = b; 37 }) || 38 function (d, b) { 39 for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; 40 }; 41 return extendStatics(d, b); 42 }; 43 44 function __extends(d, b) { 45 extendStatics(d, b); 46 function __() { 47 this.constructor = d; 48 } 49 d.prototype = 50 b === null ? Object.create(b) : ((__.prototype = b.prototype), new __()); 51 } 52 53 var __assign = function () { 54 __assign = 55 Object.assign || 56 function __assign(t) { 57 for (var s, i = 1, n = arguments.length; i < n; i++) { 58 s = arguments[i]; 59 for (var p in s) 60 if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p]; 61 } 62 return t; 63 }; 64 return __assign.apply(this, arguments); 65 }; 66 67 function __awaiter(thisArg, _arguments, P, generator) { 68 return new (P || (P = Promise))(function (resolve, reject) { 69 function fulfilled(value) { 70 try { 71 step(generator.next(value)); 72 } catch (e) { 73 reject(e); 74 } 75 } 76 function rejected(value) { 77 try { 78 step(generator["throw"](value)); 79 } catch (e) { 80 reject(e); 81 } 82 } 83 function step(result) { 84 result.done 85 ? resolve(result.value) 86 : new P(function (resolve) { 87 resolve(result.value); 88 }).then(fulfilled, rejected); 89 } 90 step((generator = generator.apply(thisArg, _arguments || [])).next()); 91 }); 92 } 93 94 function __generator(thisArg, body) { 95 var _ = { 96 label: 0, 97 sent: function () { 98 if (t[0] & 1) throw t[1]; 99 return t[1]; 100 }, 101 trys: [], 102 ops: [], 103 }, 104 f, 105 y, 106 t, 107 g; 108 return ( 109 (g = { next: verb(0), throw: verb(1), return: verb(2) }), 110 typeof Symbol === "function" && 111 (g[Symbol.iterator] = function () { 112 return this; 113 }), 114 g 115 ); 116 function verb(n) { 117 return function (v) { 118 return step([n, v]); 119 }; 120 } 121 function step(op) { 122 if (f) throw new TypeError("Generator is already executing."); 123 while (_) 124 try { 125 if ( 126 ((f = 1), 127 y && 128 (t = 129 op[0] & 2 130 ? y["return"] 131 : op[0] 132 ? y["throw"] || ((t = y["return"]) && t.call(y), 0) 133 : y.next) && 134 !(t = t.call(y, op[1])).done) 135 ) 136 return t; 137 if (((y = 0), t)) op = [op[0] & 2, t.value]; 138 switch (op[0]) { 139 case 0: 140 case 1: 141 t = op; 142 break; 143 case 4: 144 _.label++; 145 return { value: op[1], done: false }; 146 case 5: 147 _.label++; 148 y = op[1]; 149 op = [0]; 150 continue; 151 case 7: 152 op = _.ops.pop(); 153 _.trys.pop(); 154 continue; 155 default: 156 if ( 157 !((t = _.trys), (t = t.length > 0 && t[t.length - 1])) && 158 (op[0] === 6 || op[0] === 2) 159 ) { 160 _ = 0; 161 continue; 162 } 163 if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { 164 _.label = op[1]; 165 break; 166 } 167 if (op[0] === 6 && _.label < t[1]) { 168 _.label = t[1]; 169 t = op; 170 break; 171 } 172 if (t && _.label < t[2]) { 173 _.label = t[2];
vendor: 12,266 bytes, lines 174-520
174 _.ops.push(op); 175 break; 176 } 177 if (t[2]) _.ops.pop(); 178 _.trys.pop(); 179 continue; 180 } 181 op = body.call(thisArg, _); 182 } catch (e) { 183 op = [6, e]; 184 y = 0; 185 } finally { 186 f = t = 0; 187 } 188 if (op[0] & 5) throw op[1]; 189 return { value: op[0] ? op[1] : void 0, done: true }; 190 } 191 } 192 193 var Bounds = /** @class */ (function () { 194 function Bounds(x, y, w, h) { 195 this.left = x; 196 this.top = y; 197 this.width = w; 198 this.height = h; 199 } 200 Bounds.prototype.add = function (x, y, w, h) { 201 return new Bounds( 202 this.left + x, 203 this.top + y, 204 this.width + w, 205 this.height + h 206 ); 207 }; 208 Bounds.fromClientRect = function (clientRect) { 209 return new Bounds( 210 clientRect.left, 211 clientRect.top, 212 clientRect.width, 213 clientRect.height 214 ); 215 }; 216 return Bounds; 217 })(); 218 var parseBounds = function (node) { 219 return Bounds.fromClientRect(node.getBoundingClientRect()); 220 }; 221 var parseDocumentSize = function (document) { 222 var body = document.body; 223 var documentElement = document.documentElement; 224 if (!body || !documentElement) { 225 throw new Error("Unable to get document size"); 226 } 227 var width = Math.max( 228 Math.max(body.scrollWidth, documentElement.scrollWidth), 229 Math.max(body.offsetWidth, documentElement.offsetWidth), 230 Math.max(body.clientWidth, documentElement.clientWidth) 231 ); 232 var height = Math.max( 233 Math.max(body.scrollHeight, documentElement.scrollHeight), 234 Math.max(body.offsetHeight, documentElement.offsetHeight), 235 Math.max(body.clientHeight, documentElement.clientHeight) 236 ); 237 return new Bounds(0, 0, width, height); 238 }; 239 240 /* 241 * css-line-break 1.1.1 <https://github.com/niklasvh/css-line-break#readme> 242 * Copyright (c) 2019 Niklas von Hertzen <https://hertzen.com> 243 * Released under MIT License 244 */ 245 var toCodePoints = function (str) { 246 var codePoints = []; 247 var i = 0; 248 var length = str.length; 249 while (i < length) { 250 var value = str.charCodeAt(i++); 251 if (value >= 0xd800 && value <= 0xdbff && i < length) { 252 var extra = str.charCodeAt(i++); 253 if ((extra & 0xfc00) === 0xdc00) { 254 codePoints.push(((value & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000); 255 } else { 256 codePoints.push(value); 257 i--; 258 } 259 } else { 260 codePoints.push(value); 261 } 262 } 263 return codePoints; 264 }; 265 var fromCodePoint = function () { 266 var codePoints = []; 267 for (var _i = 0; _i < arguments.length; _i++) { 268 codePoints[_i] = arguments[_i]; 269 } 270 if (String.fromCodePoint) { 271 return String.fromCodePoint.apply(String, codePoints); 272 } 273 var length = codePoints.length; 274 if (!length) { 275 return ""; 276 } 277 var codeUnits = []; 278 var index = -1; 279 var result = ""; 280 while (++index < length) { 281 var codePoint = codePoints[index]; 282 if (codePoint <= 0xffff) { 283 codeUnits.push(codePoint); 284 } else { 285 codePoint -= 0x10000; 286 codeUnits.push( 287 (codePoint >> 10) + 0xd800, 288 (codePoint % 0x400) + 0xdc00 289 ); 290 } 291 if (index + 1 === length || codeUnits.length > 0x4000) { 292 result += String.fromCharCode.apply(String, codeUnits); 293 codeUnits.length = 0; 294 } 295 } 296 return result; 297 }; 298 var chars = 299 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; 300 // Use a lookup table to find the index. 301 var lookup = typeof Uint8Array === "undefined" ? [] : new Uint8Array(256); 302 for (var i = 0; i < chars.length; i++) { 303 lookup[chars.charCodeAt(i)] = i; 304 } 305 var decode = function (base64) { 306 var bufferLength = base64.length * 0.75, 307 len = base64.length, 308 i, 309 p = 0, 310 encoded1, 311 encoded2, 312 encoded3, 313 encoded4; 314 if (base64[base64.length - 1] === "=") { 315 bufferLength--; 316 if (base64[base64.length - 2] === "=") { 317 bufferLength--; 318 } 319 } 320 var buffer = 321 typeof ArrayBuffer !== "undefined" && 322 typeof Uint8Array !== "undefined" && 323 typeof Uint8Array.prototype.slice !== "undefined" 324 ? new ArrayBuffer(bufferLength) 325 : new Array(bufferLength); 326 var bytes = Array.isArray(buffer) ? buffer : new Uint8Array(buffer); 327 for (i = 0; i < len; i += 4) { 328 encoded1 = lookup[base64.charCodeAt(i)]; 329 encoded2 = lookup[base64.charCodeAt(i + 1)]; 330 encoded3 = lookup[base64.charCodeAt(i + 2)]; 331 encoded4 = lookup[base64.charCodeAt(i + 3)]; 332 bytes[p++] = (encoded1 << 2) | (encoded2 >> 4); 333 bytes[p++] = ((encoded2 & 15) << 4) | (encoded3 >> 2); 334 bytes[p++] = ((encoded3 & 3) << 6) | (encoded4 & 63); 335 } 336 return buffer; 337 }; 338 var polyUint16Array = function (buffer) { 339 var length = buffer.length; 340 var bytes = []; 341 for (var i = 0; i < length; i += 2) { 342 bytes.push((buffer[i + 1] << 8) | buffer[i]); 343 } 344 return bytes; 345 }; 346 var polyUint32Array = function (buffer) { 347 var length = buffer.length; 348 var bytes = []; 349 for (var i = 0; i < length; i += 4) { 350 bytes.push( 351 (buffer[i + 3] << 24) | 352 (buffer[i + 2] << 16) | 353 (buffer[i + 1] << 8) | 354 buffer[i] 355 ); 356 } 357 return bytes; 358 }; 359 360 /** Shift size for getting the index-2 table offset. */ 361 var UTRIE2_SHIFT_2 = 5; 362 /** Shift size for getting the index-1 table offset. */ 363 var UTRIE2_SHIFT_1 = 6 + 5; 364 /** 365 * Shift size for shifting left the index array values. 366 * Increases possible data size with 16-bit index values at the cost 367 * of compactability. 368 * This requires data blocks to be aligned by UTRIE2_DATA_GRANULARITY. 369 */ 370 var UTRIE2_INDEX_SHIFT = 2; 371 /** 372 * Difference between the two shift sizes, 373 * for getting an index-1 offset from an index-2 offset. 6=11-5 374 */ 375 var UTRIE2_SHIFT_1_2 = UTRIE2_SHIFT_1 - UTRIE2_SHIFT_2; 376 /** 377 * The part of the index-2 table for U+D800..U+DBFF stores values for 378 * lead surrogate code _units_ not code _points_. 379 * Values for lead surrogate code _points_ are indexed with this portion of the table. 380 * Length=32=0x20=0x400>>UTRIE2_SHIFT_2. (There are 1024=0x400 lead surrogates.) 381 */ 382 var UTRIE2_LSCP_INDEX_2_OFFSET = 0x10000 >> UTRIE2_SHIFT_2; 383 /** Number of entries in a data block. 32=0x20 */ 384 var UTRIE2_DATA_BLOCK_LENGTH = 1 << UTRIE2_SHIFT_2; 385 /** Mask for getting the lower bits for the in-data-block offset. */ 386 var UTRIE2_DATA_MASK = UTRIE2_DATA_BLOCK_LENGTH - 1; 387 var UTRIE2_LSCP_INDEX_2_LENGTH = 0x400 >> UTRIE2_SHIFT_2; 388 /** Count the lengths of both BMP pieces. 2080=0x820 */ 389 var UTRIE2_INDEX_2_BMP_LENGTH = 390 UTRIE2_LSCP_INDEX_2_OFFSET + UTRIE2_LSCP_INDEX_2_LENGTH; 391 /** 392 * The 2-byte UTF-8 version of the index-2 table follows at offset 2080=0x820. 393 * Length 32=0x20 for lead bytes C0..DF, regardless of UTRIE2_SHIFT_2. 394 */ 395 var UTRIE2_UTF8_2B_INDEX_2_OFFSET = UTRIE2_INDEX_2_BMP_LENGTH; 396 var UTRIE2_UTF8_2B_INDEX_2_LENGTH = 397 0x800 >> 6; /* U+0800 is the first code point after 2-byte UTF-8 */ 398 /** 399 * The index-1 table, only used for supplementary code points, at offset 2112=0x840. 400 * Variable length, for code points up to highStart, where the last single-value range starts. 401 * Maximum length 512=0x200=0x100000>>UTRIE2_SHIFT_1. 402 * (For 0x100000 supplementary code points U+10000..U+10ffff.) 403 * 404 * The part of the index-2 table for supplementary code points starts 405 * after this index-1 table. 406 * 407 * Both the index-1 table and the following part of the index-2 table 408 * are omitted completely if there is only BMP data. 409 */ 410 var UTRIE2_INDEX_1_OFFSET = 411 UTRIE2_UTF8_2B_INDEX_2_OFFSET + UTRIE2_UTF8_2B_INDEX_2_LENGTH; 412 /** 413 * Number of index-1 entries for the BMP. 32=0x20 414 * This part of the index-1 table is omitted from the serialized form. 415 */ 416 var UTRIE2_OMITTED_BMP_INDEX_1_LENGTH = 0x10000 >> UTRIE2_SHIFT_1; 417 /** Number of entries in an index-2 block. 64=0x40 */ 418 var UTRIE2_INDEX_2_BLOCK_LENGTH = 1 << UTRIE2_SHIFT_1_2; 419 /** Mask for getting the lower bits for the in-index-2-block offset. */ 420 var UTRIE2_INDEX_2_MASK = UTRIE2_INDEX_2_BLOCK_LENGTH - 1; 421 var slice16 = function (view, start, end) { 422 if (view.slice) { 423 return view.slice(start, end); 424 } 425 return new Uint16Array(Array.prototype.slice.call(view, start, end)); 426 }; 427 var slice32 = function (view, start, end) { 428 if (view.slice) { 429 return view.slice(start, end); 430 } 431 return new Uint32Array(Array.prototype.slice.call(view, start, end)); 432 }; 433 var createTrieFromBase64 = function (base64) { 434 var buffer = decode(base64); 435 var view32 = Array.isArray(buffer) 436 ? polyUint32Array(buffer) 437 : new Uint32Array(buffer); 438 var view16 = Array.isArray(buffer) 439 ? polyUint16Array(buffer) 440 : new Uint16Array(buffer); 441 var headerLength = 24; 442 var index = slice16(view16, headerLength / 2, view32[4] / 2); 443 var data = 444 view32[5] === 2 445 ? slice16(view16, (headerLength + view32[4]) / 2) 446 : slice32(view32, Math.ceil((headerLength + view32[4]) / 4)); 447 return new Trie(view32[0], view32[1], view32[2], view32[3], index, data); 448 }; 449 var Trie = /** @class */ (function () { 450 function Trie( 451 initialValue, 452 errorValue, 453 highStart, 454 highValueIndex, 455 index, 456 data 457 ) { 458 this.initialValue = initialValue; 459 this.errorValue = errorValue; 460 this.highStart = highStart; 461 this.highValueIndex = highValueIndex; 462 this.index = index; 463 this.data = data; 464 } 465 /** 466 * Get the value for a code point as stored in the Trie. 467 * 468 * @param codePoint the code point 469 * @return the value 470 */ 471 Trie.prototype.get = function (codePoint) { 472 var ix; 473 if (codePoint >= 0) { 474 if ( 475 codePoint < 0x0d800 || 476 (codePoint > 0x0dbff && codePoint <= 0x0ffff) 477 ) { 478 // Ordinary BMP code point, excluding leading surrogates. 479 // BMP uses a single level lookup. BMP index starts at offset 0 in the Trie2 index. 480 // 16 bit data is stored in the index array itself. 481 ix = this.index[codePoint >> UTRIE2_SHIFT_2]; 482 ix = (ix << UTRIE2_INDEX_SHIFT) + (codePoint & UTRIE2_DATA_MASK); 483 return this.data[ix]; 484 } 485 if (codePoint <= 0xffff) { 486 // Lead Surrogate Code Point. A Separate index section is stored for 487 // lead surrogate code units and code points. 488 // The main index has the code unit data. 489 // For this function, we need the code point data. 490 // Note: this expression could be refactored for slightly improved efficiency, but 491 // surrogate code points will be so rare in practice that it's not worth it. 492 ix = 493 this.index[ 494 UTRIE2_LSCP_INDEX_2_OFFSET + 495 ((codePoint - 0xd800) >> UTRIE2_SHIFT_2) 496 ]; 497 ix = (ix << UTRIE2_INDEX_SHIFT) + (codePoint & UTRIE2_DATA_MASK); 498 return this.data[ix]; 499 } 500 if (codePoint < this.highStart) { 501 // Supplemental code point, use two-level lookup. 502 ix = 503 UTRIE2_INDEX_1_OFFSET - 504 UTRIE2_OMITTED_BMP_INDEX_1_LENGTH + 505 (codePoint >> UTRIE2_SHIFT_1); 506 ix = this.index[ix]; 507 ix += (codePoint >> UTRIE2_SHIFT_2) & UTRIE2_INDEX_2_MASK; 508 ix = this.index[ix]; 509 ix = (ix << UTRIE2_INDEX_SHIFT) + (codePoint & UTRIE2_DATA_MASK); 510 return this.data[ix]; 511 } 512 if (codePoint <= 0x10ffff) { 513 return this.data[this.highValueIndex]; 514 } 515 } 516 // Fall through. The code point is outside of the legal range of 0..0x10ffff. 517 return this.errorValue; 518 }; 519 return Trie; 520 })();
521 522 var base64 = 523
vendor: 50,626 bytes, line 523
523"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"
523; 524 525 /* @flow */ 526 var LETTER_NUMBER_MODIFIER = 50; 527 // Non-tailorable Line Breaking Classes 528 var BK = 1; // Cause a line break (after) 529 var CR = 2; // Cause a line break (after), except between CR and LF 530 var LF = 3; // Cause a line break (after) 531 var CM = 4; // Prohibit a line break between the character and the preceding character 532 var NL = 5; // Cause a line break (after) 533 var WJ = 7; // Prohibit line breaks before and after 534 var ZW = 8; // Provide a break opportunity 535 var GL = 9; // Prohibit line breaks before and after 536 var SP = 10; // Enable indirect line breaks 537 var ZWJ = 11; // Prohibit line breaks within joiner sequences 538 // Break Opportunities 539 var B2 = 12; // Provide a line break opportunity before and after the character 540 var BA = 13; // Generally provide a line break opportunity after the character 541 var BB = 14; // Generally provide a line break opportunity before the character 542 var HY = 15; // Provide a line break opportunity after the character, except in numeric context 543 var CB = 16; // Provide a line break opportunity contingent on additional information 544 // Characters Prohibiting Certain Breaks 545 var CL = 17; // Prohibit line breaks before 546 var CP = 18; // Prohibit line breaks before 547 var EX = 19; // Prohibit line breaks before 548 var IN = 20; // Allow only indirect line breaks between pairs 549 var NS = 21; // Allow only indirect line breaks before 550 var OP = 22; // Prohibit line breaks after 551 var QU = 23; // Act like they are both opening and closing 552 // Numeric Context 553 var IS = 24; // Prevent breaks after any and before numeric 554 var NU = 25; // Form numeric expressions for line breaking purposes 555 var PO = 26; // Do not break following a numeric expression 556 var PR = 27; // Do not break in front of a numeric expression 557 var SY = 28; // Prevent a break before; and allow a break after 558 // Other Characters 559 var AI = 29; // Act like AL when the resolvedEAW is N; otherwise; act as ID 560 var AL = 30; // Are alphabetic characters or symbols that are used with alphabetic characters 561 var CJ = 31; // Treat as NS or ID for strict or normal breaking. 562 var EB = 32; // Do not break from following Emoji Modifier 563 var EM = 33; // Do not break from preceding Emoji Base 564 var H2 = 34; // Form Korean syllable blocks 565 var H3 = 35; // Form Korean syllable blocks 566 var HL = 36; // Do not break around a following hyphen; otherwise act as Alphabetic 567 var ID = 37; // Break before or after; except in some numeric context 568 var JL = 38; // Form Korean syllable blocks 569 var JV = 39; // Form Korean syllable blocks 570 var JT = 40; // Form Korean syllable blocks 571 var RI = 41; // Keep pairs together. For pairs; break before and after other classes 572 var SA = 42; // Provide a line break opportunity contingent on additional, language-specific context analysis 573 var XX = 43; // Have as yet unknown line breaking behavior or unassigned code positions 574 var BREAK_MANDATORY = "!"; 575 var BREAK_NOT_ALLOWED = "Ã"; 576 var BREAK_ALLOWED = "÷"; 577 var UnicodeTrie = createTrieFromBase64(base64); 578 var ALPHABETICS = [AL, HL]; 579 var HARD_LINE_BREAKS = [BK, CR, LF, NL]; 580 var SPACE = [SP, ZW]; 581 var PREFIX_POSTFIX = [PR, PO]; 582 var LINE_BREAKS = HARD_LINE_BREAKS.concat(SPACE); 583 var KOREAN_SYLLABLE_BLOCK = [JL, JV, JT, H2, H3]; 584 var HYPHEN = [HY, BA]; 585 var codePointsToCharacterClasses = function (codePoints, lineBreak) { 586 if (lineBreak === void 0) { 587 lineBreak = "strict"; 588 } 589 var types = []; 590 var indicies = []; 591 var categories = [];
vendor: 11,163 bytes, lines 592-906
592 codePoints.forEach(function (codePoint, index) { 593 var classType = UnicodeTrie.get(codePoint); 594 if (classType > LETTER_NUMBER_MODIFIER) { 595 categories.push(true); 596 classType -= LETTER_NUMBER_MODIFIER; 597 } else { 598 categories.push(false); 599 } 600 if (["normal", "auto", "loose"].indexOf(lineBreak) !== -1) { 601 // U+2010, â U+2013, ã U+301C, ã U+30A0 602 if ([0x2010, 0x2013, 0x301c, 0x30a0].indexOf(codePoint) !== -1) { 603 indicies.push(index); 604 return types.push(CB); 605 } 606 } 607 if (classType === CM || classType === ZWJ) { 608 // LB10 Treat any remaining combining mark or ZWJ as AL. 609 if (index === 0) { 610 indicies.push(index); 611 return types.push(AL); 612 } 613 // LB9 Do not break a combining character sequence; treat it as if it has the line breaking class of 614 // the base character in all of the following rules. Treat ZWJ as if it were CM. 615 var prev = types[index - 1]; 616 if (LINE_BREAKS.indexOf(prev) === -1) { 617 indicies.push(indicies[index - 1]); 618 return types.push(prev); 619 } 620 indicies.push(index); 621 return types.push(AL); 622 } 623 indicies.push(index); 624 if (classType === CJ) { 625 return types.push(lineBreak === "strict" ? NS : ID); 626 } 627 if (classType === SA) { 628 return types.push(AL); 629 } 630 if (classType === AI) { 631 return types.push(AL); 632 } 633 // For supplementary characters, a useful default is to treat characters in the range 10000..1FFFD as AL 634 // and characters in the ranges 20000..2FFFD and 30000..3FFFD as ID, until the implementation can be revised 635 // to take into account the actual line breaking properties for these characters. 636 if (classType === XX) { 637 if ( 638 (codePoint >= 0x20000 && codePoint <= 0x2fffd) || 639 (codePoint >= 0x30000 && codePoint <= 0x3fffd) 640 ) { 641 return types.push(ID); 642 } else { 643 return types.push(AL); 644 } 645 } 646 types.push(classType); 647 }); 648 return [indicies, types, categories]; 649 }; 650 var isAdjacentWithSpaceIgnored = function (a, b, currentIndex, classTypes) { 651 var current = classTypes[currentIndex]; 652 if (Array.isArray(a) ? a.indexOf(current) !== -1 : a === current) { 653 var i = currentIndex; 654 while (i <= classTypes.length) { 655 i++; 656 var next = classTypes[i]; 657 if (next === b) { 658 return true; 659 } 660 if (next !== SP) { 661 break; 662 } 663 } 664 } 665 if (current === SP) { 666 var i = currentIndex; 667 while (i > 0) { 668 i--; 669 var prev = classTypes[i]; 670 if (Array.isArray(a) ? a.indexOf(prev) !== -1 : a === prev) { 671 var n = currentIndex; 672 while (n <= classTypes.length) { 673 n++; 674 var next = classTypes[n]; 675 if (next === b) { 676 return true; 677 } 678 if (next !== SP) { 679 break; 680 } 681 } 682 } 683 if (prev !== SP) { 684 break; 685 } 686 } 687 } 688 return false; 689 }; 690 var previousNonSpaceClassType = function (currentIndex, classTypes) { 691 var i = currentIndex; 692 while (i >= 0) { 693 var type = classTypes[i]; 694 if (type === SP) { 695 i--; 696 } else { 697 return type; 698 } 699 } 700 return 0; 701 }; 702 var _lineBreakAtIndex = function ( 703 codePoints, 704 classTypes, 705 indicies, 706 index, 707 forbiddenBreaks 708 ) { 709 if (indicies[index] === 0) { 710 return BREAK_NOT_ALLOWED; 711 } 712 var currentIndex = index - 1; 713 if ( 714 Array.isArray(forbiddenBreaks) && 715 forbiddenBreaks[currentIndex] === true 716 ) { 717 return BREAK_NOT_ALLOWED; 718 } 719 var beforeIndex = currentIndex - 1; 720 var afterIndex = currentIndex + 1; 721 var current = classTypes[currentIndex]; 722 // LB4 Always break after hard line breaks. 723 // LB5 Treat CR followed by LF, as well as CR, LF, and NL as hard line breaks. 724 var before = beforeIndex >= 0 ? classTypes[beforeIndex] : 0; 725 var next = classTypes[afterIndex]; 726 if (current === CR && next === LF) { 727 return BREAK_NOT_ALLOWED; 728 } 729 if (HARD_LINE_BREAKS.indexOf(current) !== -1) { 730 return BREAK_MANDATORY; 731 } 732 // LB6 Do not break before hard line breaks. 733 if (HARD_LINE_BREAKS.indexOf(next) !== -1) { 734 return BREAK_NOT_ALLOWED; 735 } 736 // LB7 Do not break before spaces or zero width space. 737 if (SPACE.indexOf(next) !== -1) { 738 return BREAK_NOT_ALLOWED; 739 } 740 // LB8 Break before any character following a zero-width space, even if one or more spaces intervene. 741 if (previousNonSpaceClassType(currentIndex, classTypes) === ZW) { 742 return BREAK_ALLOWED; 743 } 744 // LB8a Do not break between a zero width joiner and an ideograph, emoji base or emoji modifier. 745 if ( 746 UnicodeTrie.get(codePoints[currentIndex]) === ZWJ && 747 (next === ID || next === EB || next === EM) 748 ) { 749 return BREAK_NOT_ALLOWED; 750 } 751 // LB11 Do not break before or after Word joiner and related characters. 752 if (current === WJ || next === WJ) { 753 return BREAK_NOT_ALLOWED; 754 } 755 // LB12 Do not break after NBSP and related characters. 756 if (current === GL) { 757 return BREAK_NOT_ALLOWED; 758 } 759 // LB12a Do not break before NBSP and related characters, except after spaces and hyphens. 760 if ([SP, BA, HY].indexOf(current) === -1 && next === GL) { 761 return BREAK_NOT_ALLOWED; 762 } 763 // LB13 Do not break before â]â or â!â or â;â or â/â, even after spaces. 764 if ([CL, CP, EX, IS, SY].indexOf(next) !== -1) { 765 return BREAK_NOT_ALLOWED; 766 } 767 // LB14 Do not break after â[â, even after spaces. 768 if (previousNonSpaceClassType(currentIndex, classTypes) === OP) { 769 return BREAK_NOT_ALLOWED; 770 } 771 // LB15 Do not break within ââ[â, even with intervening spaces. 772 if (isAdjacentWithSpaceIgnored(QU, OP, currentIndex, classTypes)) { 773 return BREAK_NOT_ALLOWED; 774 } 775 // LB16 Do not break between closing punctuation and a nonstarter (lb=NS), even with intervening spaces. 776 if (isAdjacentWithSpaceIgnored([CL, CP], NS, currentIndex, classTypes)) { 777 return BREAK_NOT_ALLOWED; 778 } 779 // LB17 Do not break within ââââ, even with intervening spaces. 780 if (isAdjacentWithSpaceIgnored(B2, B2, currentIndex, classTypes)) { 781 return BREAK_NOT_ALLOWED; 782 } 783 // LB18 Break after spaces. 784 if (current === SP) { 785 return BREAK_ALLOWED; 786 } 787 // LB19 Do not break before or after quotation marks, such as â â â. 788 if (current === QU || next === QU) { 789 return BREAK_NOT_ALLOWED; 790 } 791 // LB20 Break before and after unresolved CB. 792 if (next === CB || current === CB) { 793 return BREAK_ALLOWED; 794 } 795 // LB21 Do not break before hyphen-minus, other hyphens, fixed-width spaces, small kana, and other non-starters, or after acute accents. 796 if ([BA, HY, NS].indexOf(next) !== -1 || current === BB) { 797 return BREAK_NOT_ALLOWED; 798 } 799 // LB21a Don't break after Hebrew + Hyphen. 800 if (before === HL && HYPHEN.indexOf(current) !== -1) { 801 return BREAK_NOT_ALLOWED; 802 } 803 // LB21b Donât break between Solidus and Hebrew letters. 804 if (current === SY && next === HL) { 805 return BREAK_NOT_ALLOWED; 806 } 807 // LB22 Do not break between two ellipses, or between letters, numbers or exclamations and ellipsis. 808 if ( 809 next === IN && 810 ALPHABETICS.concat(IN, EX, NU, ID, EB, EM).indexOf(current) !== -1 811 ) { 812 return BREAK_NOT_ALLOWED; 813 } 814 // LB23 Do not break between digits and letters. 815 if ( 816 (ALPHABETICS.indexOf(next) !== -1 && current === NU) || 817 (ALPHABETICS.indexOf(current) !== -1 && next === NU) 818 ) { 819 return BREAK_NOT_ALLOWED; 820 } 821 // LB23a Do not break between numeric prefixes and ideographs, or between ideographs and numeric postfixes. 822 if ( 823 (current === PR && [ID, EB, EM].indexOf(next) !== -1) || 824 ([ID, EB, EM].indexOf(current) !== -1 && next === PO) 825 ) { 826 return BREAK_NOT_ALLOWED; 827 } 828 // LB24 Do not break between numeric prefix/postfix and letters, or between letters and prefix/postfix. 829 if ( 830 (ALPHABETICS.indexOf(current) !== -1 && 831 PREFIX_POSTFIX.indexOf(next) !== -1) || 832 (PREFIX_POSTFIX.indexOf(current) !== -1 && 833 ALPHABETICS.indexOf(next) !== -1) 834 ) { 835 return BREAK_NOT_ALLOWED; 836 } 837 // LB25 Do not break between the following pairs of classes relevant to numbers: 838 if ( 839 // (PR | PO) Ã ( OP | HY )? NU 840 ([PR, PO].indexOf(current) !== -1 && 841 (next === NU || 842 ([OP, HY].indexOf(next) !== -1 && 843 classTypes[afterIndex + 1] === NU))) || 844 // ( OP | HY ) Ã NU 845 ([OP, HY].indexOf(current) !== -1 && next === NU) || 846 // NU Ã (NU | SY | IS) 847 (current === NU && [NU, SY, IS].indexOf(next) !== -1) 848 ) { 849 return BREAK_NOT_ALLOWED; 850 } 851 // NU (NU | SY | IS)* Ã (NU | SY | IS | CL | CP) 852 if ([NU, SY, IS, CL, CP].indexOf(next) !== -1) { 853 var prevIndex = currentIndex; 854 while (prevIndex >= 0) { 855 var type = classTypes[prevIndex]; 856 if (type === NU) { 857 return BREAK_NOT_ALLOWED; 858 } else if ([SY, IS].indexOf(type) !== -1) { 859 prevIndex--; 860 } else { 861 break; 862 } 863 } 864 } 865 // NU (NU | SY | IS)* (CL | CP)? Ã (PO | PR)) 866 if ([PR, PO].indexOf(next) !== -1) { 867 var prevIndex = 868 [CL, CP].indexOf(current) !== -1 ? beforeIndex : currentIndex; 869 while (prevIndex >= 0) { 870 var type = classTypes[prevIndex]; 871 if (type === NU) { 872 return BREAK_NOT_ALLOWED; 873 } else if ([SY, IS].indexOf(type) !== -1) { 874 prevIndex--; 875 } else { 876 break; 877 } 878 } 879 } 880 // LB26 Do not break a Korean syllable. 881 if ( 882 (JL === current && [JL, JV, H2, H3].indexOf(next) !== -1) || 883 ([JV, H2].indexOf(current) !== -1 && [JV, JT].indexOf(next) !== -1) || 884 ([JT, H3].indexOf(current) !== -1 && next === JT) 885 ) { 886 return BREAK_NOT_ALLOWED; 887 } 888 // LB27 Treat a Korean Syllable Block the same as ID. 889 if ( 890 (KOREAN_SYLLABLE_BLOCK.indexOf(current) !== -1 && 891 [IN, PO].indexOf(next) !== -1) || 892 (KOREAN_SYLLABLE_BLOCK.indexOf(next) !== -1 && current === PR) 893 ) { 894 return BREAK_NOT_ALLOWED; 895 } 896 // LB28 Do not break between alphabetics (âatâ). 897 if ( 898 ALPHABETICS.indexOf(current) !== -1 && 899 ALPHABETICS.indexOf(next) !== -1 900 ) { 901 return BREAK_NOT_ALLOWED; 902 } 903 // LB29 Do not break between numeric punctuation and alphabetics (âe.g.â). 904 if (current === IS && ALPHABETICS.indexOf(next) !== -1) { 905 return BREAK_NOT_ALLOWED; 906 }
907 // LB30 Do not break between letters, numbers, or ordinary symbols and opening or closing parentheses. 908 if ( 909 (ALPHABETICS.concat(NU).indexOf(current) !== -1 && next === OP) || 910 (ALPHABETICS.concat(NU).indexOf(next) !== -1 && current === CP) 911 ) { 912 return BREAK_NOT_ALLOWED; 913 } 914 // LB30a Break between two regional indicator symbols if and only if there are an even number of regional 915 // indicators preceding the position of the break. 916 if (current === RI && next === RI) { 917 var i = indicies[currentIndex]; 918 var count = 1; 919 while (i > 0) { 920 i--; 921 if (classTypes[i] === RI) { 922 count++; 923 } else { 924 break; 925 } 926 } 927 if (count % 2 !== 0) { 928 return BREAK_NOT_ALLOWED; 929 } 930 } 931 // LB30b Do not break between an emoji base and an emoji modifier. 932 if (current === EB && next === EM) { 933 return BREAK_NOT_ALLOWED; 934 } 935 return BREAK_ALLOWED; 936 }; 937 var cssFormattedClasses = function (codePoints, options) { 938 if (!options) { 939 options = { lineBreak: "normal", wordBreak: "normal" }; 940 } 941 var _a = codePointsToCharacterClasses(codePoints, options.lineBreak), 942 indicies = _a[0], 943 classTypes = _a[1], 944 isLetterNumber = _a[2]; 945 if ( 946 options.wordBreak === "break-all" || 947 options.wordBreak === "break-word" 948 ) { 949 classTypes = classTypes.map(function (type) { 950 return [NU, AL, SA].indexOf(type) !== -1 ? ID : type; 951 }); 952 } 953 var forbiddenBreakpoints = 954 options.wordBreak === "keep-all" 955 ? isLetterNumber.map(function (letterNumber, i) { 956 return ( 957 letterNumber && codePoints[i] >= 0x4e00 && codePoints[i] <= 0x9fff 958 ); 959 }) 960 : undefined; 961 return [indicies, classTypes, forbiddenBreakpoints]; 962 }; 963 var Break = /** @class */ (function () { 964 function Break(codePoints, lineBreak, start, end) { 965 this.codePoints = codePoints; 966 this.required = lineBreak === BREAK_MANDATORY; 967 this.start = start; 968 this.end = end; 969 } 970 Break.prototype.slice = function () { 971 return fromCodePoint.apply( 972 void 0, 973 this.codePoints.slice(this.start, this.end) 974 ); 975 }; 976 return Break; 977 })(); 978 var LineBreaker = function (str, options) { 979 var codePoints = toCodePoints(str); 980 var _a = cssFormattedClasses(codePoints, options), 981 indicies = _a[0], 982 classTypes = _a[1], 983 forbiddenBreakpoints = _a[2]; 984 var length = codePoints.length; 985 var lastEnd = 0; 986 var nextIndex = 0; 987 return { 988 next: function () { 989 if (nextIndex >= length) { 990 return { done: true, value: null }; 991 } 992 var lineBreak = BREAK_NOT_ALLOWED; 993 while ( 994 nextIndex < length && 995 (lineBreak = _lineBreakAtIndex( 996 codePoints, 997 classTypes, 998 indicies, 999 ++nextIndex, 1000 forbiddenBreakpoints 1001 )) === BREAK_NOT_ALLOWED 1002 ) {} 1003 if (lineBreak !== BREAK_NOT_ALLOWED || nextIndex === length) { 1004 var value = new Break(codePoints, lineBreak, lastEnd, nextIndex); 1005 lastEnd = nextIndex; 1006 return { value: value, done: false }; 1007 } 1008 return { done: true, value: null }; 1009 }, 1010 }; 1011 }; 1012 1013 // https://www.w3.org/TR/css-syntax-3 1014 var TokenType; 1015 (function (TokenType) { 1016 TokenType[(TokenType["STRING_TOKEN"] = 0)] = "STRING_TOKEN"; 1017 TokenType[(TokenType["BAD_STRING_TOKEN"] = 1)] = "BAD_STRING_TOKEN"; 1018 TokenType[(TokenType["LEFT_PARENTHESIS_TOKEN"] = 2)] = 1019 "LEFT_PARENTHESIS_TOKEN"; 1020 TokenType[(TokenType["RIGHT_PARENTHESIS_TOKEN"] = 3)] = 1021 "RIGHT_PARENTHESIS_TOKEN"; 1022 TokenType[(TokenType["COMMA_TOKEN"] = 4)] = "COMMA_TOKEN"; 1023 TokenType[(TokenType["HASH_TOKEN"] = 5)] = "HASH_TOKEN"; 1024 TokenType[(TokenType["DELIM_TOKEN"] = 6)] = "DELIM_TOKEN"; 1025 TokenType[(TokenType["AT_KEYWORD_TOKEN"] = 7)] = "AT_KEYWORD_TOKEN"; 1026 TokenType[(TokenType["PREFIX_MATCH_TOKEN"] = 8)] = "PREFIX_MATCH_TOKEN"; 1027 TokenType[(TokenType["DASH_MATCH_TOKEN"] = 9)] = "DASH_MATCH_TOKEN"; 1028 TokenType[(TokenType["INCLUDE_MATCH_TOKEN"] = 10)] = "INCLUDE_MATCH_TOKEN"; 1029 TokenType[(TokenType["LEFT_CURLY_BRACKET_TOKEN"] = 11)] = 1030 "LEFT_CURLY_BRACKET_TOKEN"; 1031 TokenType[(TokenType["RIGHT_CURLY_BRACKET_TOKEN"] = 12)] = 1032 "RIGHT_CURLY_BRACKET_TOKEN"; 1033 TokenType[(TokenType["SUFFIX_MATCH_TOKEN"] = 13)] = "SUFFIX_MATCH_TOKEN"; 1034 TokenType[(TokenType["SUBSTRING_MATCH_TOKEN"] = 14)] = 1035 "SUBSTRING_MATCH_TOKEN"; 1036 TokenType[(TokenType["DIMENSION_TOKEN"] = 15)] = "DIMENSION_TOKEN"; 1037 TokenType[(TokenType["PERCENTAGE_TOKEN"] = 16)] = "PERCENTAGE_TOKEN"; 1038 TokenType[(TokenType["NUMBER_TOKEN"] = 17)] = "NUMBER_TOKEN"; 1039 TokenType[(TokenType["FUNCTION"] = 18)] = "FUNCTION"; 1040 TokenType[(TokenType["FUNCTION_TOKEN"] = 19)] = "FUNCTION_TOKEN"; 1041 TokenType[(TokenType["IDENT_TOKEN"] = 20)] = "IDENT_TOKEN"; 1042 TokenType[(TokenType["COLUMN_TOKEN"] = 21)] = "COLUMN_TOKEN"; 1043 TokenType[(TokenType["URL_TOKEN"] = 22)] = "URL_TOKEN"; 1044 TokenType[(TokenType["BAD_URL_TOKEN"] = 23)] = "BAD_URL_TOKEN"; 1045 TokenType[(TokenType["CDC_TOKEN"] = 24)] = "CDC_TOKEN"; 1046 TokenType[(TokenType["CDO_TOKEN"] = 25)] = "CDO_TOKEN"; 1047 TokenType[(TokenType["COLON_TOKEN"] = 26)] = "COLON_TOKEN"; 1048 TokenType[(TokenType["SEMICOLON_TOKEN"] = 27)] = "SEMICOLON_TOKEN"; 1049 TokenType[(TokenType["LEFT_SQUARE_BRACKET_TOKEN"] = 28)] = 1050 "LEFT_SQUARE_BRACKET_TOKEN"; 1051 TokenType[(TokenType["RIGHT_SQUARE_BRACKET_TOKEN"] = 29)] = 1052 "RIGHT_SQUARE_BRACKET_TOKEN"; 1053 TokenType[(TokenType["UNICODE_RANGE_TOKEN"] = 30)] = "UNICODE_RANGE_TOKEN"; 1054 TokenType[(TokenType["WHITESPACE_TOKEN"] = 31)] = "WHITESPACE_TOKEN"; 1055 TokenType[(TokenType["EOF_TOKEN"] = 32)] = "EOF_TOKEN"; 1056 })(TokenType || (TokenType = {})); 1057 var FLAG_UNRESTRICTED = 1 << 0; 1058 var FLAG_ID = 1 << 1; 1059 var FLAG_INTEGER = 1 << 2; 1060 var FLAG_NUMBER = 1 << 3; 1061 var LINE_FEED = 0x000a; 1062 var SOLIDUS = 0x002f; 1063 var REVERSE_SOLIDUS = 0x005c; 1064 var CHARACTER_TABULATION = 0x0009; 1065 var SPACE$1 = 0x0020; 1066 var QUOTATION_MARK = 0x0022; 1067 var EQUALS_SIGN = 0x003d; 1068 var NUMBER_SIGN = 0x0023; 1069 var DOLLAR_SIGN = 0x0024; 1070 var PERCENTAGE_SIGN = 0x0025; 1071 var APOSTROPHE = 0x0027; 1072 var LEFT_PARENTHESIS = 0x0028; 1073 var RIGHT_PARENTHESIS = 0x0029; 1074 var LOW_LINE = 0x005f; 1075 var HYPHEN_MINUS = 0x002d; 1076 var EXCLAMATION_MARK = 0x0021; 1077 var LESS_THAN_SIGN = 0x003c;
vendor: 4,335 bytes, lines 1078-1226
1078 var GREATER_THAN_SIGN = 0x003e; 1079 var COMMERCIAL_AT = 0x0040; 1080 var LEFT_SQUARE_BRACKET = 0x005b; 1081 var RIGHT_SQUARE_BRACKET = 0x005d; 1082 var CIRCUMFLEX_ACCENT = 0x003d; 1083 var LEFT_CURLY_BRACKET = 0x007b; 1084 var QUESTION_MARK = 0x003f; 1085 var RIGHT_CURLY_BRACKET = 0x007d; 1086 var VERTICAL_LINE = 0x007c; 1087 var TILDE = 0x007e; 1088 var CONTROL = 0x0080; 1089 var REPLACEMENT_CHARACTER = 0xfffd; 1090 var ASTERISK = 0x002a; 1091 var PLUS_SIGN = 0x002b; 1092 var COMMA = 0x002c; 1093 var COLON = 0x003a; 1094 var SEMICOLON = 0x003b; 1095 var FULL_STOP = 0x002e; 1096 var NULL = 0x0000; 1097 var BACKSPACE = 0x0008; 1098 var LINE_TABULATION = 0x000b; 1099 var SHIFT_OUT = 0x000e; 1100 var INFORMATION_SEPARATOR_ONE = 0x001f; 1101 var DELETE = 0x007f; 1102 var EOF = -1; 1103 var ZERO = 0x0030; 1104 var a = 0x0061; 1105 var e = 0x0065; 1106 var f = 0x0066; 1107 var u = 0x0075; 1108 var z = 0x007a; 1109 var A = 0x0041; 1110 var E = 0x0045; 1111 var F = 0x0046; 1112 var U = 0x0055; 1113 var Z = 0x005a; 1114 var isDigit = function (codePoint) { 1115 return codePoint >= ZERO && codePoint <= 0x0039; 1116 }; 1117 var isSurrogateCodePoint = function (codePoint) { 1118 return codePoint >= 0xd800 && codePoint <= 0xdfff; 1119 }; 1120 var isHex = function (codePoint) { 1121 return ( 1122 isDigit(codePoint) || 1123 (codePoint >= A && codePoint <= F) || 1124 (codePoint >= a && codePoint <= f) 1125 ); 1126 }; 1127 var isLowerCaseLetter = function (codePoint) { 1128 return codePoint >= a && codePoint <= z; 1129 }; 1130 var isUpperCaseLetter = function (codePoint) { 1131 return codePoint >= A && codePoint <= Z; 1132 }; 1133 var isLetter = function (codePoint) { 1134 return isLowerCaseLetter(codePoint) || isUpperCaseLetter(codePoint); 1135 }; 1136 var isNonASCIICodePoint = function (codePoint) { 1137 return codePoint >= CONTROL; 1138 }; 1139 var isWhiteSpace = function (codePoint) { 1140 return ( 1141 codePoint === LINE_FEED || 1142 codePoint === CHARACTER_TABULATION || 1143 codePoint === SPACE$1 1144 ); 1145 }; 1146 var isNameStartCodePoint = function (codePoint) { 1147 return ( 1148 isLetter(codePoint) || 1149 isNonASCIICodePoint(codePoint) || 1150 codePoint === LOW_LINE 1151 ); 1152 }; 1153 var isNameCodePoint = function (codePoint) { 1154 return ( 1155 isNameStartCodePoint(codePoint) || 1156 isDigit(codePoint) || 1157 codePoint === HYPHEN_MINUS 1158 ); 1159 }; 1160 var isNonPrintableCodePoint = function (codePoint) { 1161 return ( 1162 (codePoint >= NULL && codePoint <= BACKSPACE) || 1163 codePoint === LINE_TABULATION || 1164 (codePoint >= SHIFT_OUT && codePoint <= INFORMATION_SEPARATOR_ONE) || 1165 codePoint === DELETE 1166 ); 1167 }; 1168 var isValidEscape = function (c1, c2) { 1169 if (c1 !== REVERSE_SOLIDUS) { 1170 return false; 1171 } 1172 return c2 !== LINE_FEED; 1173 }; 1174 var isIdentifierStart = function (c1, c2, c3) { 1175 if (c1 === HYPHEN_MINUS) { 1176 return isNameStartCodePoint(c2) || isValidEscape(c2, c3); 1177 } else if (isNameStartCodePoint(c1)) { 1178 return true; 1179 } else if (c1 === REVERSE_SOLIDUS && isValidEscape(c1, c2)) { 1180 return true; 1181 } 1182 return false; 1183 }; 1184 var isNumberStart = function (c1, c2, c3) { 1185 if (c1 === PLUS_SIGN || c1 === HYPHEN_MINUS) { 1186 if (isDigit(c2)) { 1187 return true; 1188 } 1189 return c2 === FULL_STOP && isDigit(c3); 1190 } 1191 if (c1 === FULL_STOP) { 1192 return isDigit(c2); 1193 } 1194 return isDigit(c1); 1195 }; 1196 var stringToNumber = function (codePoints) { 1197 var c = 0; 1198 var sign = 1; 1199 if (codePoints[c] === PLUS_SIGN || codePoints[c] === HYPHEN_MINUS) { 1200 if (codePoints[c] === HYPHEN_MINUS) { 1201 sign = -1; 1202 } 1203 c++; 1204 } 1205 var integers = []; 1206 while (isDigit(codePoints[c])) { 1207 integers.push(codePoints[c++]); 1208 } 1209 var int = integers.length 1210 ? parseInt(fromCodePoint.apply(void 0, integers), 10) 1211 : 0; 1212 if (codePoints[c] === FULL_STOP) { 1213 c++; 1214 } 1215 var fraction = []; 1216 while (isDigit(codePoints[c])) { 1217 fraction.push(codePoints[c++]); 1218 } 1219 var fracd = fraction.length; 1220 var frac = fracd ? parseInt(fromCodePoint.apply(void 0, fraction), 10) : 0; 1221 if (codePoints[c] === E || codePoints[c] === e) { 1222 c++; 1223 } 1224 var expsign = 1; 1225 if (codePoints[c] === PLUS_SIGN || codePoints[c] === HYPHEN_MINUS) { 1226 if (codePoints[c] === HYPHEN_MINUS) {
vendor: 15,253 bytes, lines 1227-1669
1227 expsign = -1; 1228 } 1229 c++; 1230 } 1231 var exponent = []; 1232 while (isDigit(codePoints[c])) { 1233 exponent.push(codePoints[c++]); 1234 } 1235 var exp = exponent.length 1236 ? parseInt(fromCodePoint.apply(void 0, exponent), 10) 1237 : 0; 1238 return ( 1239 sign * (int + frac * Math.pow(10, -fracd)) * Math.pow(10, expsign * exp) 1240 ); 1241 }; 1242 var LEFT_PARENTHESIS_TOKEN = { 1243 type: TokenType.LEFT_PARENTHESIS_TOKEN, 1244 }; 1245 var RIGHT_PARENTHESIS_TOKEN = { 1246 type: TokenType.RIGHT_PARENTHESIS_TOKEN, 1247 }; 1248 var COMMA_TOKEN = { type: TokenType.COMMA_TOKEN }; 1249 var SUFFIX_MATCH_TOKEN = { type: TokenType.SUFFIX_MATCH_TOKEN }; 1250 var PREFIX_MATCH_TOKEN = { type: TokenType.PREFIX_MATCH_TOKEN }; 1251 var COLUMN_TOKEN = { type: TokenType.COLUMN_TOKEN }; 1252 var DASH_MATCH_TOKEN = { type: TokenType.DASH_MATCH_TOKEN }; 1253 var INCLUDE_MATCH_TOKEN = { type: TokenType.INCLUDE_MATCH_TOKEN }; 1254 var LEFT_CURLY_BRACKET_TOKEN = { 1255 type: TokenType.LEFT_CURLY_BRACKET_TOKEN, 1256 }; 1257 var RIGHT_CURLY_BRACKET_TOKEN = { 1258 type: TokenType.RIGHT_CURLY_BRACKET_TOKEN, 1259 }; 1260 var SUBSTRING_MATCH_TOKEN = { type: TokenType.SUBSTRING_MATCH_TOKEN }; 1261 var BAD_URL_TOKEN = { type: TokenType.BAD_URL_TOKEN }; 1262 var BAD_STRING_TOKEN = { type: TokenType.BAD_STRING_TOKEN }; 1263 var CDO_TOKEN = { type: TokenType.CDO_TOKEN }; 1264 var CDC_TOKEN = { type: TokenType.CDC_TOKEN }; 1265 var COLON_TOKEN = { type: TokenType.COLON_TOKEN }; 1266 var SEMICOLON_TOKEN = { type: TokenType.SEMICOLON_TOKEN }; 1267 var LEFT_SQUARE_BRACKET_TOKEN = { 1268 type: TokenType.LEFT_SQUARE_BRACKET_TOKEN, 1269 }; 1270 var RIGHT_SQUARE_BRACKET_TOKEN = { 1271 type: TokenType.RIGHT_SQUARE_BRACKET_TOKEN, 1272 }; 1273 var WHITESPACE_TOKEN = { type: TokenType.WHITESPACE_TOKEN }; 1274 var EOF_TOKEN = { type: TokenType.EOF_TOKEN }; 1275 var Tokenizer = /** @class */ (function () { 1276 function Tokenizer() { 1277 this._value = []; 1278 } 1279 Tokenizer.prototype.write = function (chunk) { 1280 this._value = this._value.concat(toCodePoints(chunk)); 1281 }; 1282 Tokenizer.prototype.read = function () { 1283 var tokens = []; 1284 var token = this.consumeToken(); 1285 while (token !== EOF_TOKEN) { 1286 tokens.push(token); 1287 token = this.consumeToken(); 1288 } 1289 return tokens; 1290 }; 1291 Tokenizer.prototype.consumeToken = function () { 1292 var codePoint = this.consumeCodePoint(); 1293 switch (codePoint) { 1294 case QUOTATION_MARK: 1295 return this.consumeStringToken(QUOTATION_MARK); 1296 case NUMBER_SIGN: 1297 var c1 = this.peekCodePoint(0); 1298 var c2 = this.peekCodePoint(1); 1299 var c3 = this.peekCodePoint(2); 1300 if (isNameCodePoint(c1) || isValidEscape(c2, c3)) { 1301 var flags = isIdentifierStart(c1, c2, c3) 1302 ? FLAG_ID 1303 : FLAG_UNRESTRICTED; 1304 var value = this.consumeName(); 1305 return { type: TokenType.HASH_TOKEN, value: value, flags: flags }; 1306 } 1307 break; 1308 case DOLLAR_SIGN: 1309 if (this.peekCodePoint(0) === EQUALS_SIGN) { 1310 this.consumeCodePoint(); 1311 return SUFFIX_MATCH_TOKEN; 1312 } 1313 break; 1314 case APOSTROPHE: 1315 return this.consumeStringToken(APOSTROPHE); 1316 case LEFT_PARENTHESIS: 1317 return LEFT_PARENTHESIS_TOKEN; 1318 case RIGHT_PARENTHESIS: 1319 return RIGHT_PARENTHESIS_TOKEN; 1320 case ASTERISK: 1321 if (this.peekCodePoint(0) === EQUALS_SIGN) { 1322 this.consumeCodePoint(); 1323 return SUBSTRING_MATCH_TOKEN; 1324 } 1325 break; 1326 case PLUS_SIGN: 1327 if ( 1328 isNumberStart( 1329 codePoint, 1330 this.peekCodePoint(0), 1331 this.peekCodePoint(1) 1332 ) 1333 ) { 1334 this.reconsumeCodePoint(codePoint); 1335 return this.consumeNumericToken(); 1336 } 1337 break; 1338 case COMMA: 1339 return COMMA_TOKEN; 1340 case HYPHEN_MINUS: 1341 var e1 = codePoint; 1342 var e2 = this.peekCodePoint(0); 1343 var e3 = this.peekCodePoint(1); 1344 if (isNumberStart(e1, e2, e3)) { 1345 this.reconsumeCodePoint(codePoint); 1346 return this.consumeNumericToken(); 1347 } 1348 if (isIdentifierStart(e1, e2, e3)) { 1349 this.reconsumeCodePoint(codePoint); 1350 return this.consumeIdentLikeToken(); 1351 } 1352 if (e2 === HYPHEN_MINUS && e3 === GREATER_THAN_SIGN) { 1353 this.consumeCodePoint(); 1354 this.consumeCodePoint(); 1355 return CDC_TOKEN; 1356 } 1357 break; 1358 case FULL_STOP: 1359 if ( 1360 isNumberStart( 1361 codePoint, 1362 this.peekCodePoint(0), 1363 this.peekCodePoint(1) 1364 ) 1365 ) { 1366 this.reconsumeCodePoint(codePoint); 1367 return this.consumeNumericToken(); 1368 } 1369 break; 1370 case SOLIDUS: 1371 if (this.peekCodePoint(0) === ASTERISK) { 1372 this.consumeCodePoint(); 1373 while (true) { 1374 var c = this.consumeCodePoint(); 1375 if (c === ASTERISK) { 1376 c = this.consumeCodePoint(); 1377 if (c === SOLIDUS) { 1378 return this.consumeToken(); 1379 } 1380 } 1381 if (c === EOF) { 1382 return this.consumeToken(); 1383 } 1384 } 1385 } 1386 break; 1387 case COLON: 1388 return COLON_TOKEN; 1389 case SEMICOLON: 1390 return SEMICOLON_TOKEN; 1391 case LESS_THAN_SIGN: 1392 if ( 1393 this.peekCodePoint(0) === EXCLAMATION_MARK && 1394 this.peekCodePoint(1) === HYPHEN_MINUS && 1395 this.peekCodePoint(2) === HYPHEN_MINUS 1396 ) { 1397 this.consumeCodePoint(); 1398 this.consumeCodePoint(); 1399 return CDO_TOKEN; 1400 } 1401 break; 1402 case COMMERCIAL_AT: 1403 var a1 = this.peekCodePoint(0); 1404 var a2 = this.peekCodePoint(1); 1405 var a3 = this.peekCodePoint(2); 1406 if (isIdentifierStart(a1, a2, a3)) { 1407 var value = this.consumeName(); 1408 return { type: TokenType.AT_KEYWORD_TOKEN, value: value }; 1409 } 1410 break; 1411 case LEFT_SQUARE_BRACKET: 1412 return LEFT_SQUARE_BRACKET_TOKEN; 1413 case REVERSE_SOLIDUS: 1414 if (isValidEscape(codePoint, this.peekCodePoint(0))) { 1415 this.reconsumeCodePoint(codePoint); 1416 return this.consumeIdentLikeToken(); 1417 } 1418 break; 1419 case RIGHT_SQUARE_BRACKET: 1420 return RIGHT_SQUARE_BRACKET_TOKEN; 1421 case CIRCUMFLEX_ACCENT: 1422 if (this.peekCodePoint(0) === EQUALS_SIGN) { 1423 this.consumeCodePoint(); 1424 return PREFIX_MATCH_TOKEN; 1425 } 1426 break; 1427 case LEFT_CURLY_BRACKET: 1428 return LEFT_CURLY_BRACKET_TOKEN; 1429 case RIGHT_CURLY_BRACKET: 1430 return RIGHT_CURLY_BRACKET_TOKEN; 1431 case u: 1432 case U: 1433 var u1 = this.peekCodePoint(0); 1434 var u2 = this.peekCodePoint(1); 1435 if (u1 === PLUS_SIGN && (isHex(u2) || u2 === QUESTION_MARK)) { 1436 this.consumeCodePoint(); 1437 this.consumeUnicodeRangeToken(); 1438 } 1439 this.reconsumeCodePoint(codePoint); 1440 return this.consumeIdentLikeToken(); 1441 case VERTICAL_LINE: 1442 if (this.peekCodePoint(0) === EQUALS_SIGN) { 1443 this.consumeCodePoint(); 1444 return DASH_MATCH_TOKEN; 1445 } 1446 if (this.peekCodePoint(0) === VERTICAL_LINE) { 1447 this.consumeCodePoint(); 1448 return COLUMN_TOKEN; 1449 } 1450 break; 1451 case TILDE: 1452 if (this.peekCodePoint(0) === EQUALS_SIGN) { 1453 this.consumeCodePoint(); 1454 return INCLUDE_MATCH_TOKEN; 1455 } 1456 break; 1457 case EOF: 1458 return EOF_TOKEN; 1459 } 1460 if (isWhiteSpace(codePoint)) { 1461 this.consumeWhiteSpace(); 1462 return WHITESPACE_TOKEN; 1463 } 1464 if (isDigit(codePoint)) { 1465 this.reconsumeCodePoint(codePoint); 1466 return this.consumeNumericToken(); 1467 } 1468 if (isNameStartCodePoint(codePoint)) { 1469 this.reconsumeCodePoint(codePoint); 1470 return this.consumeIdentLikeToken(); 1471 } 1472 return { type: TokenType.DELIM_TOKEN, value: fromCodePoint(codePoint) }; 1473 }; 1474 Tokenizer.prototype.consumeCodePoint = function () { 1475 var value = this._value.shift(); 1476 return typeof value === "undefined" ? -1 : value; 1477 }; 1478 Tokenizer.prototype.reconsumeCodePoint = function (codePoint) { 1479 this._value.unshift(codePoint); 1480 }; 1481 Tokenizer.prototype.peekCodePoint = function (delta) { 1482 if (delta >= this._value.length) { 1483 return -1; 1484 } 1485 return this._value[delta]; 1486 }; 1487 Tokenizer.prototype.consumeUnicodeRangeToken = function () { 1488 var digits = []; 1489 var codePoint = this.consumeCodePoint(); 1490 while (isHex(codePoint) && digits.length < 6) { 1491 digits.push(codePoint); 1492 codePoint = this.consumeCodePoint(); 1493 } 1494 var questionMarks = false; 1495 while (codePoint === QUESTION_MARK && digits.length < 6) { 1496 digits.push(codePoint); 1497 codePoint = this.consumeCodePoint(); 1498 questionMarks = true; 1499 } 1500 if (questionMarks) { 1501 var start_1 = parseInt( 1502 fromCodePoint.apply( 1503 void 0, 1504 digits.map(function (digit) { 1505 return digit === QUESTION_MARK ? ZERO : digit; 1506 }) 1507 ), 1508 16 1509 ); 1510 var end = parseInt( 1511 fromCodePoint.apply( 1512 void 0, 1513 digits.map(function (digit) { 1514 return digit === QUESTION_MARK ? F : digit; 1515 }) 1516 ), 1517 16 1518 ); 1519 return { 1520 type: TokenType.UNICODE_RANGE_TOKEN, 1521 start: start_1, 1522 end: end, 1523 }; 1524 } 1525 var start = parseInt(fromCodePoint.apply(void 0, digits), 16); 1526 if ( 1527 this.peekCodePoint(0) === HYPHEN_MINUS && 1528 isHex(this.peekCodePoint(1)) 1529 ) { 1530 this.consumeCodePoint(); 1531 codePoint = this.consumeCodePoint(); 1532 var endDigits = []; 1533 while (isHex(codePoint) && endDigits.length < 6) { 1534 endDigits.push(codePoint); 1535 codePoint = this.consumeCodePoint(); 1536 } 1537 var end = parseInt(fromCodePoint.apply(void 0, endDigits), 16); 1538 return { type: TokenType.UNICODE_RANGE_TOKEN, start: start, end: end }; 1539 } else { 1540 return { 1541 type: TokenType.UNICODE_RANGE_TOKEN, 1542 start: start, 1543 end: start, 1544 }; 1545 } 1546 }; 1547 Tokenizer.prototype.consumeIdentLikeToken = function () { 1548 var value = this.consumeName(); 1549 if ( 1550 value.toLowerCase() === "url" && 1551 this.peekCodePoint(0) === LEFT_PARENTHESIS 1552 ) { 1553 this.consumeCodePoint(); 1554 return this.consumeUrlToken(); 1555 } else if (this.peekCodePoint(0) === LEFT_PARENTHESIS) { 1556 this.consumeCodePoint(); 1557 return { type: TokenType.FUNCTION_TOKEN, value: value }; 1558 } 1559 return { type: TokenType.IDENT_TOKEN, value: value }; 1560 }; 1561 Tokenizer.prototype.consumeUrlToken = function () { 1562 var value = []; 1563 this.consumeWhiteSpace(); 1564 if (this.peekCodePoint(0) === EOF) { 1565 return { type: TokenType.URL_TOKEN, value: "" }; 1566 } 1567 var next = this.peekCodePoint(0); 1568 if (next === APOSTROPHE || next === QUOTATION_MARK) { 1569 var stringToken = this.consumeStringToken(this.consumeCodePoint()); 1570 if (stringToken.type === TokenType.STRING_TOKEN) { 1571 this.consumeWhiteSpace(); 1572 if ( 1573 this.peekCodePoint(0) === EOF || 1574 this.peekCodePoint(0) === RIGHT_PARENTHESIS 1575 ) { 1576 this.consumeCodePoint(); 1577 return { type: TokenType.URL_TOKEN, value: stringToken.value }; 1578 } 1579 } 1580 this.consumeBadUrlRemnants(); 1581 return BAD_URL_TOKEN; 1582 } 1583 while (true) { 1584 var codePoint = this.consumeCodePoint(); 1585 if (codePoint === EOF || codePoint === RIGHT_PARENTHESIS) { 1586 return { 1587 type: TokenType.URL_TOKEN, 1588 value: fromCodePoint.apply(void 0, value), 1589 }; 1590 } else if (isWhiteSpace(codePoint)) { 1591 this.consumeWhiteSpace(); 1592 if ( 1593 this.peekCodePoint(0) === EOF || 1594 this.peekCodePoint(0) === RIGHT_PARENTHESIS 1595 ) { 1596 this.consumeCodePoint(); 1597 return { 1598 type: TokenType.URL_TOKEN, 1599 value: fromCodePoint.apply(void 0, value), 1600 }; 1601 } 1602 this.consumeBadUrlRemnants(); 1603 return BAD_URL_TOKEN; 1604 } else if ( 1605 codePoint === QUOTATION_MARK || 1606 codePoint === APOSTROPHE || 1607 codePoint === LEFT_PARENTHESIS || 1608 isNonPrintableCodePoint(codePoint) 1609 ) { 1610 this.consumeBadUrlRemnants(); 1611 return BAD_URL_TOKEN; 1612 } else if (codePoint === REVERSE_SOLIDUS) { 1613 if (isValidEscape(codePoint, this.peekCodePoint(0))) { 1614 value.push(this.consumeEscapedCodePoint()); 1615 } else { 1616 this.consumeBadUrlRemnants(); 1617 return BAD_URL_TOKEN; 1618 } 1619 } else { 1620 value.push(codePoint); 1621 } 1622 } 1623 }; 1624 Tokenizer.prototype.consumeWhiteSpace = function () { 1625 while (isWhiteSpace(this.peekCodePoint(0))) { 1626 this.consumeCodePoint(); 1627 } 1628 }; 1629 Tokenizer.prototype.consumeBadUrlRemnants = function () { 1630 while (true) { 1631 var codePoint = this.consumeCodePoint(); 1632 if (codePoint === RIGHT_PARENTHESIS || codePoint === EOF) { 1633 return; 1634 } 1635 if (isValidEscape(codePoint, this.peekCodePoint(0))) { 1636 this.consumeEscapedCodePoint(); 1637 } 1638 } 1639 }; 1640 Tokenizer.prototype.consumeStringSlice = function (count) { 1641 var SLICE_STACK_SIZE = 60000; 1642 var value = ""; 1643 while (count > 0) { 1644 var amount = Math.min(SLICE_STACK_SIZE, count); 1645 value += fromCodePoint.apply(void 0, this._value.splice(0, amount)); 1646 count -= amount; 1647 } 1648 this._value.shift(); 1649 return value; 1650 }; 1651 Tokenizer.prototype.consumeStringToken = function (endingCodePoint) { 1652 var value = ""; 1653 var i = 0; 1654 do { 1655 var codePoint = this._value[i]; 1656 if ( 1657 codePoint === EOF || 1658 codePoint === undefined || 1659 codePoint === endingCodePoint 1660 ) { 1661 value += this.consumeStringSlice(i); 1662 return { type: TokenType.STRING_TOKEN, value: value }; 1663 } 1664 if (codePoint === LINE_FEED) { 1665 this._value.splice(0, i); 1666 return BAD_STRING_TOKEN; 1667 } 1668 if (codePoint === REVERSE_SOLIDUS) { 1669 var next = this._value[i + 1];
vendor: 3,863 bytes, lines 1670-1786
1670 if (next !== EOF && next !== undefined) { 1671 if (next === LINE_FEED) { 1672 value += this.consumeStringSlice(i); 1673 i = -1; 1674 this._value.shift(); 1675 } else if (isValidEscape(codePoint, next)) { 1676 value += this.consumeStringSlice(i); 1677 value += fromCodePoint(this.consumeEscapedCodePoint()); 1678 i = -1; 1679 } 1680 } 1681 } 1682 i++; 1683 } while (true); 1684 }; 1685 Tokenizer.prototype.consumeNumber = function () { 1686 var repr = []; 1687 var type = FLAG_INTEGER; 1688 var c1 = this.peekCodePoint(0); 1689 if (c1 === PLUS_SIGN || c1 === HYPHEN_MINUS) { 1690 repr.push(this.consumeCodePoint()); 1691 } 1692 while (isDigit(this.peekCodePoint(0))) { 1693 repr.push(this.consumeCodePoint()); 1694 } 1695 c1 = this.peekCodePoint(0); 1696 var c2 = this.peekCodePoint(1); 1697 if (c1 === FULL_STOP && isDigit(c2)) { 1698 repr.push(this.consumeCodePoint(), this.consumeCodePoint()); 1699 type = FLAG_NUMBER; 1700 while (isDigit(this.peekCodePoint(0))) { 1701 repr.push(this.consumeCodePoint()); 1702 } 1703 } 1704 c1 = this.peekCodePoint(0); 1705 c2 = this.peekCodePoint(1); 1706 var c3 = this.peekCodePoint(2); 1707 if ( 1708 (c1 === E || c1 === e) && 1709 (((c2 === PLUS_SIGN || c2 === HYPHEN_MINUS) && isDigit(c3)) || 1710 isDigit(c2)) 1711 ) { 1712 repr.push(this.consumeCodePoint(), this.consumeCodePoint()); 1713 type = FLAG_NUMBER; 1714 while (isDigit(this.peekCodePoint(0))) { 1715 repr.push(this.consumeCodePoint()); 1716 } 1717 } 1718 return [stringToNumber(repr), type]; 1719 }; 1720 Tokenizer.prototype.consumeNumericToken = function () { 1721 var _a = this.consumeNumber(), 1722 number = _a[0], 1723 flags = _a[1]; 1724 var c1 = this.peekCodePoint(0); 1725 var c2 = this.peekCodePoint(1); 1726 var c3 = this.peekCodePoint(2); 1727 if (isIdentifierStart(c1, c2, c3)) { 1728 var unit = this.consumeName(); 1729 return { 1730 type: TokenType.DIMENSION_TOKEN, 1731 number: number, 1732 flags: flags, 1733 unit: unit, 1734 }; 1735 } 1736 if (c1 === PERCENTAGE_SIGN) { 1737 this.consumeCodePoint(); 1738 return { 1739 type: TokenType.PERCENTAGE_TOKEN, 1740 number: number, 1741 flags: flags, 1742 }; 1743 } 1744 return { type: TokenType.NUMBER_TOKEN, number: number, flags: flags }; 1745 }; 1746 Tokenizer.prototype.consumeEscapedCodePoint = function () { 1747 var codePoint = this.consumeCodePoint(); 1748 if (isHex(codePoint)) { 1749 var hex = fromCodePoint(codePoint); 1750 while (isHex(this.peekCodePoint(0)) && hex.length < 6) { 1751 hex += fromCodePoint(this.consumeCodePoint()); 1752 } 1753 if (isWhiteSpace(this.peekCodePoint(0))) { 1754 this.consumeCodePoint(); 1755 } 1756 var hexCodePoint = parseInt(hex, 16); 1757 if ( 1758 hexCodePoint === 0 || 1759 isSurrogateCodePoint(hexCodePoint) || 1760 hexCodePoint > 0x10ffff 1761 ) { 1762 return REPLACEMENT_CHARACTER; 1763 } 1764 return hexCodePoint; 1765 } 1766 if (codePoint === EOF) { 1767 return REPLACEMENT_CHARACTER; 1768 } 1769 return codePoint; 1770 }; 1771 Tokenizer.prototype.consumeName = function () { 1772 var result = ""; 1773 while (true) { 1774 var codePoint = this.consumeCodePoint(); 1775 if (isNameCodePoint(codePoint)) { 1776 result += fromCodePoint(codePoint); 1777 } else if (isValidEscape(codePoint, this.peekCodePoint(0))) { 1778 result += fromCodePoint(this.consumeEscapedCodePoint()); 1779 } else { 1780 this.reconsumeCodePoint(codePoint); 1781 return result; 1782 } 1783 } 1784 }; 1785 return Tokenizer; 1786 })();
1787 1788 var Parser = /** @class */ (function () { 1789 function Parser(tokens) { 1790 this._tokens = tokens; 1791 } 1792 Parser.create = function (value) { 1793 var tokenizer = new Tokenizer(); 1794 tokenizer.write(value); 1795 return new Parser(tokenizer.read()); 1796 }; 1797 Parser.parseValue = function (value) { 1798 return Parser.create(value).parseComponentValue(); 1799 }; 1800 Parser.parseValues = function (value) { 1801 return Parser.create(value).parseComponentValues(); 1802 }; 1803 Parser.prototype.parseComponentValue = function () { 1804 var token = this.consumeToken(); 1805 while (token.type === TokenType.WHITESPACE_TOKEN) { 1806 token = this.consumeToken(); 1807 } 1808 if (token.type === TokenType.EOF_TOKEN) { 1809 throw new SyntaxError( 1810 "Error parsing CSS component value, unexpected EOF" 1811 ); 1812 } 1813 this.reconsumeToken(token); 1814 var value = this.consumeComponentValue(); 1815 do { 1816 token = this.consumeToken(); 1817 } while (token.type === TokenType.WHITESPACE_TOKEN); 1818 if (token.type === TokenType.EOF_TOKEN) { 1819 return value; 1820 } 1821 throw new SyntaxError( 1822 "Error parsing CSS component value, multiple values found when expecting only one" 1823 ); 1824 }; 1825 Parser.prototype.parseComponentValues = function () { 1826 var values = []; 1827 while (true) { 1828 var value = this.consumeComponentValue(); 1829 if (value.type === TokenType.EOF_TOKEN) { 1830 return values; 1831 } 1832 values.push(value); 1833 values.push(); 1834 } 1835 }; 1836 Parser.prototype.consumeComponentValue = function () { 1837 var token = this.consumeToken(); 1838 switch (token.type) { 1839 case TokenType.LEFT_CURLY_BRACKET_TOKEN: 1840 case TokenType.LEFT_SQUARE_BRACKET_TOKEN: 1841 case TokenType.LEFT_PARENTHESIS_TOKEN: 1842 return this.consumeSimpleBlock(token.type); 1843 case TokenType.FUNCTION_TOKEN: 1844 return this.consumeFunction(token); 1845 } 1846 return token; 1847 }; 1848 Parser.prototype.consumeSimpleBlock = function (type) { 1849 var block = { type: type, values: [] }; 1850 var token = this.consumeToken(); 1851 while (true) { 1852 if ( 1853 token.type === TokenType.EOF_TOKEN || 1854 isEndingTokenFor(token, type) 1855 ) { 1856 return block; 1857 } 1858 this.reconsumeToken(token); 1859 block.values.push(this.consumeComponentValue()); 1860 token = this.consumeToken(); 1861 } 1862 }; 1863 Parser.prototype.consumeFunction = function (functionToken) { 1864 var cssFunction = { 1865 name: functionToken.value, 1866 values: [], 1867 type: TokenType.FUNCTION, 1868 }; 1869 while (true) { 1870 var token = this.consumeToken(); 1871 if ( 1872 token.type === TokenType.EOF_TOKEN || 1873 token.type === TokenType.RIGHT_PARENTHESIS_TOKEN 1874 ) { 1875 return cssFunction; 1876 } 1877 this.reconsumeToken(token); 1878 cssFunction.values.push(this.consumeComponentValue()); 1879 } 1880 }; 1881 Parser.prototype.consumeToken = function () { 1882 var token = this._tokens.shift(); 1883 return typeof token === "undefined" ? EOF_TOKEN : token; 1884 }; 1885 Parser.prototype.reconsumeToken = function (token) { 1886 this._tokens.unshift(token); 1887 }; 1888 return Parser; 1889 })();
1890 var isDimensionToken = function (token) { 1891 return token.type === TokenType.DIMENSION_TOKEN; 1892 }; 1893 var isNumberToken = function (token) { 1894 return token.type === TokenType.NUMBER_TOKEN; 1895 }; 1896 var isIdentToken = function (token) { 1897 return token.type === TokenType.IDENT_TOKEN; 1898 }; 1899 var isStringToken = function (token) { 1900 return token.type === TokenType.STRING_TOKEN; 1901 }; 1902 var isIdentWithValue = function (token, value) { 1903 return isIdentToken(token) && token.value === value; 1904 }; 1905 var nonWhiteSpace = function (token) { 1906 return token.type !== TokenType.WHITESPACE_TOKEN; 1907 }; 1908 var nonFunctionArgSeparator = function (token) { 1909 return ( 1910 token.type !== TokenType.WHITESPACE_TOKEN && 1911 token.type !== TokenType.COMMA_TOKEN 1912 ); 1913 }; 1914 var parseFunctionArgs = function (tokens) { 1915 var args = []; 1916 var arg = []; 1917 tokens.forEach(function (token) { 1918 if (token.type === TokenType.COMMA_TOKEN) { 1919 if (arg.length === 0) { 1920 throw new Error("Error parsing function args, zero tokens for arg"); 1921 } 1922 args.push(arg); 1923 arg = []; 1924 return; 1925 } 1926 if (token.type !== TokenType.WHITESPACE_TOKEN) { 1927 arg.push(token); 1928 } 1929 }); 1930 if (arg.length) { 1931 args.push(arg); 1932 } 1933 return args; 1934 }; 1935 var isEndingTokenFor = function (token, type) { 1936 if ( 1937 type === TokenType.LEFT_CURLY_BRACKET_TOKEN && 1938 token.type === TokenType.RIGHT_CURLY_BRACKET_TOKEN 1939 ) { 1940 return true; 1941 } 1942 if ( 1943 type === TokenType.LEFT_SQUARE_BRACKET_TOKEN && 1944 token.type === TokenType.RIGHT_SQUARE_BRACKET_TOKEN 1945 ) { 1946 return true; 1947 } 1948 return ( 1949 type === TokenType.LEFT_PARENTHESIS_TOKEN && 1950 token.type === TokenType.RIGHT_PARENTHESIS_TOKEN 1951 ); 1952 }; 1953 1954 var isLength = function (token) { 1955 return ( 1956 token.type === TokenType.NUMBER_TOKEN || 1957 token.type === TokenType.DIMENSION_TOKEN 1958 ); 1959 }; 1960 1961 var isLengthPercentage = function (token) { 1962 return token.type === TokenType.PERCENTAGE_TOKEN || isLength(token); 1963 }; 1964 var parseLengthPercentageTuple = function (tokens) { 1965 return tokens.length > 1 ? [tokens[0], tokens[1]] : [tokens[0]]; 1966 }; 1967 var ZERO_LENGTH = { 1968 type: TokenType.NUMBER_TOKEN, 1969 number: 0, 1970 flags: FLAG_INTEGER, 1971 }; 1972 var FIFTY_PERCENT = { 1973 type: TokenType.PERCENTAGE_TOKEN, 1974 number: 50, 1975 flags: FLAG_INTEGER, 1976 }; 1977 var HUNDRED_PERCENT = { 1978 type: TokenType.PERCENTAGE_TOKEN, 1979 number: 100, 1980 flags: FLAG_INTEGER, 1981 }; 1982 var getAbsoluteValueForTuple = function (tuple, width, height) { 1983 var x = tuple[0], 1984 y = tuple[1];
vendor: 10,173 bytes, lines 1985-2338
1985 return [ 1986 getAbsoluteValue(x, width), 1987 getAbsoluteValue(typeof y !== "undefined" ? y : x, height), 1988 ]; 1989 }; 1990 var getAbsoluteValue = function (token, parent) { 1991 if (token.type === TokenType.PERCENTAGE_TOKEN) { 1992 return (token.number / 100) * parent; 1993 } 1994 if (isDimensionToken(token)) { 1995 switch (token.unit) { 1996 case "rem": 1997 case "em": 1998 return 16 * token.number; // TODO use correct font-size 1999 case "px": 2000 default: 2001 return token.number; 2002 } 2003 } 2004 return token.number; 2005 }; 2006 2007 var DEG = "deg"; 2008 var GRAD = "grad"; 2009 var RAD = "rad"; 2010 var TURN = "turn"; 2011 var angle = { 2012 name: "angle", 2013 parse: function (value) { 2014 if (value.type === TokenType.DIMENSION_TOKEN) { 2015 switch (value.unit) { 2016 case DEG: 2017 return (Math.PI * value.number) / 180; 2018 case GRAD: 2019 return (Math.PI / 200) * value.number; 2020 case RAD: 2021 return value.number; 2022 case TURN: 2023 return Math.PI * 2 * value.number; 2024 } 2025 } 2026 throw new Error("Unsupported angle type"); 2027 }, 2028 }; 2029 var isAngle = function (value) { 2030 if (value.type === TokenType.DIMENSION_TOKEN) { 2031 if ( 2032 value.unit === DEG || 2033 value.unit === GRAD || 2034 value.unit === RAD || 2035 value.unit === TURN 2036 ) { 2037 return true; 2038 } 2039 } 2040 return false; 2041 }; 2042 var parseNamedSide = function (tokens) { 2043 var sideOrCorner = tokens 2044 .filter(isIdentToken) 2045 .map(function (ident) { 2046 return ident.value; 2047 }) 2048 .join(" "); 2049 switch (sideOrCorner) { 2050 case "to bottom right": 2051 case "to right bottom": 2052 case "left top": 2053 case "top left": 2054 return [ZERO_LENGTH, ZERO_LENGTH]; 2055 case "to top": 2056 case "bottom": 2057 return deg(0); 2058 case "to bottom left": 2059 case "to left bottom": 2060 case "right top": 2061 case "top right": 2062 return [ZERO_LENGTH, HUNDRED_PERCENT]; 2063 case "to right": 2064 case "left": 2065 return deg(90); 2066 case "to top left": 2067 case "to left top": 2068 case "right bottom": 2069 case "bottom right": 2070 return [HUNDRED_PERCENT, HUNDRED_PERCENT]; 2071 case "to bottom": 2072 case "top": 2073 return deg(180); 2074 case "to top right": 2075 case "to right top": 2076 case "left bottom": 2077 case "bottom left": 2078 return [HUNDRED_PERCENT, ZERO_LENGTH]; 2079 case "to left": 2080 case "right": 2081 return deg(270); 2082 } 2083 return 0; 2084 }; 2085 var deg = function (deg) { 2086 return (Math.PI * deg) / 180; 2087 }; 2088 2089 var color = { 2090 name: "color", 2091 parse: function (value) { 2092 if (value.type === TokenType.FUNCTION) { 2093 var colorFunction = SUPPORTED_COLOR_FUNCTIONS[value.name]; 2094 if (typeof colorFunction === "undefined") { 2095 throw new Error( 2096 'Attempting to parse an unsupported color function "' + 2097 value.name + 2098 '"' 2099 ); 2100 } 2101 return colorFunction(value.values); 2102 } 2103 if (value.type === TokenType.HASH_TOKEN) { 2104 if (value.value.length === 3) { 2105 var r = value.value.substring(0, 1); 2106 var g = value.value.substring(1, 2); 2107 var b = value.value.substring(2, 3); 2108 return pack( 2109 parseInt(r + r, 16), 2110 parseInt(g + g, 16), 2111 parseInt(b + b, 16), 2112 1 2113 ); 2114 } 2115 if (value.value.length === 4) { 2116 var r = value.value.substring(0, 1); 2117 var g = value.value.substring(1, 2); 2118 var b = value.value.substring(2, 3); 2119 var a = value.value.substring(3, 4); 2120 return pack( 2121 parseInt(r + r, 16), 2122 parseInt(g + g, 16), 2123 parseInt(b + b, 16), 2124 parseInt(a + a, 16) / 255 2125 ); 2126 } 2127 if (value.value.length === 6) { 2128 var r = value.value.substring(0, 2); 2129 var g = value.value.substring(2, 4); 2130 var b = value.value.substring(4, 6); 2131 return pack(parseInt(r, 16), parseInt(g, 16), parseInt(b, 16), 1); 2132 } 2133 if (value.value.length === 8) { 2134 var r = value.value.substring(0, 2); 2135 var g = value.value.substring(2, 4); 2136 var b = value.value.substring(4, 6); 2137 var a = value.value.substring(6, 8); 2138 return pack( 2139 parseInt(r, 16), 2140 parseInt(g, 16), 2141 parseInt(b, 16), 2142 parseInt(a, 16) / 255 2143 ); 2144 } 2145 } 2146 if (value.type === TokenType.IDENT_TOKEN) { 2147 var namedColor = COLORS[value.value.toUpperCase()]; 2148 if (typeof namedColor !== "undefined") { 2149 return namedColor; 2150 } 2151 } 2152 return COLORS.TRANSPARENT; 2153 }, 2154 }; 2155 var isTransparent = function (color) { 2156 return (0xff & color) === 0; 2157 }; 2158 var asString = function (color) { 2159 var alpha = 0xff & color; 2160 var blue = 0xff & (color >> 8); 2161 var green = 0xff & (color >> 16); 2162 var red = 0xff & (color >> 24); 2163 return alpha < 255 2164 ? "rgba(" + red + "," + green + "," + blue + "," + alpha / 255 + ")" 2165 : "rgb(" + red + "," + green + "," + blue + ")"; 2166 }; 2167 var pack = function (r, g, b, a) { 2168 return ( 2169 ((r << 24) | (g << 16) | (b << 8) | (Math.round(a * 255) << 0)) >>> 0 2170 ); 2171 }; 2172 var getTokenColorValue = function (token, i) { 2173 if (token.type === TokenType.NUMBER_TOKEN) { 2174 return token.number; 2175 } 2176 if (token.type === TokenType.PERCENTAGE_TOKEN) { 2177 var max = i === 3 ? 1 : 255; 2178 return i === 3 2179 ? (token.number / 100) * max 2180 : Math.round((token.number / 100) * max); 2181 } 2182 return 0; 2183 }; 2184 var rgb = function (args) { 2185 var tokens = args.filter(nonFunctionArgSeparator); 2186 if (tokens.length === 3) { 2187 var _a = tokens.map(getTokenColorValue), 2188 r = _a[0], 2189 g = _a[1], 2190 b = _a[2]; 2191 return pack(r, g, b, 1); 2192 } 2193 if (tokens.length === 4) { 2194 var _b = tokens.map(getTokenColorValue), 2195 r = _b[0], 2196 g = _b[1], 2197 b = _b[2], 2198 a = _b[3]; 2199 return pack(r, g, b, a); 2200 } 2201 return 0; 2202 }; 2203 function hue2rgb(t1, t2, hue) { 2204 if (hue < 0) { 2205 hue += 1; 2206 } 2207 if (hue >= 1) { 2208 hue -= 1; 2209 } 2210 if (hue < 1 / 6) { 2211 return (t2 - t1) * hue * 6 + t1; 2212 } else if (hue < 1 / 2) { 2213 return t2; 2214 } else if (hue < 2 / 3) { 2215 return (t2 - t1) * 6 * (2 / 3 - hue) + t1; 2216 } else { 2217 return t1; 2218 } 2219 } 2220 var hsl = function (args) { 2221 var tokens = args.filter(nonFunctionArgSeparator); 2222 var hue = tokens[0], 2223 saturation = tokens[1], 2224 lightness = tokens[2], 2225 alpha = tokens[3]; 2226 var h = 2227 (hue.type === TokenType.NUMBER_TOKEN 2228 ? deg(hue.number) 2229 : angle.parse(hue)) / 2230 (Math.PI * 2); 2231 var s = isLengthPercentage(saturation) ? saturation.number / 100 : 0; 2232 var l = isLengthPercentage(lightness) ? lightness.number / 100 : 0; 2233 var a = 2234 typeof alpha !== "undefined" && isLengthPercentage(alpha) 2235 ? getAbsoluteValue(alpha, 1) 2236 : 1; 2237 if (s === 0) { 2238 return pack(l * 255, l * 255, l * 255, 1); 2239 } 2240 var t2 = l <= 0.5 ? l * (s + 1) : l + s - l * s; 2241 var t1 = l * 2 - t2; 2242 var r = hue2rgb(t1, t2, h + 1 / 3); 2243 var g = hue2rgb(t1, t2, h); 2244 var b = hue2rgb(t1, t2, h - 1 / 3); 2245 return pack(r * 255, g * 255, b * 255, a); 2246 }; 2247 var SUPPORTED_COLOR_FUNCTIONS = { 2248 hsl: hsl, 2249 hsla: hsl, 2250 rgb: rgb, 2251 rgba: rgb, 2252 }; 2253 var COLORS = { 2254 ALICEBLUE: 0xf0f8ffff, 2255 ANTIQUEWHITE: 0xfaebd7ff, 2256 AQUA: 0x00ffffff, 2257 AQUAMARINE: 0x7fffd4ff, 2258 AZURE: 0xf0ffffff, 2259 BEIGE: 0xf5f5dcff, 2260 BISQUE: 0xffe4c4ff, 2261 BLACK: 0x000000ff, 2262 BLANCHEDALMOND: 0xffebcdff, 2263 BLUE: 0x0000ffff, 2264 BLUEVIOLET: 0x8a2be2ff, 2265 BROWN: 0xa52a2aff, 2266 BURLYWOOD: 0xdeb887ff, 2267 CADETBLUE: 0x5f9ea0ff, 2268 CHARTREUSE: 0x7fff00ff, 2269 CHOCOLATE: 0xd2691eff, 2270 CORAL: 0xff7f50ff, 2271 CORNFLOWERBLUE: 0x6495edff, 2272 CORNSILK: 0xfff8dcff, 2273 CRIMSON: 0xdc143cff, 2274 CYAN: 0x00ffffff, 2275 DARKBLUE: 0x00008bff, 2276 DARKCYAN: 0x008b8bff, 2277 DARKGOLDENROD: 0xb886bbff, 2278 DARKGRAY: 0xa9a9a9ff, 2279 DARKGREEN: 0x006400ff, 2280 DARKGREY: 0xa9a9a9ff, 2281 DARKKHAKI: 0xbdb76bff, 2282 DARKMAGENTA: 0x8b008bff, 2283 DARKOLIVEGREEN: 0x556b2fff, 2284 DARKORANGE: 0xff8c00ff, 2285 DARKORCHID: 0x9932ccff, 2286 DARKRED: 0x8b0000ff, 2287 DARKSALMON: 0xe9967aff, 2288 DARKSEAGREEN: 0x8fbc8fff, 2289 DARKSLATEBLUE: 0x483d8bff, 2290 DARKSLATEGRAY: 0x2f4f4fff, 2291 DARKSLATEGREY: 0x2f4f4fff, 2292 DARKTURQUOISE: 0x00ced1ff, 2293 DARKVIOLET: 0x9400d3ff, 2294 DEEPPINK: 0xff1493ff, 2295 DEEPSKYBLUE: 0x00bfffff, 2296 DIMGRAY: 0x696969ff, 2297 DIMGREY: 0x696969ff, 2298 DODGERBLUE: 0x1e90ffff, 2299 FIREBRICK: 0xb22222ff, 2300 FLORALWHITE: 0xfffaf0ff, 2301 FORESTGREEN: 0x228b22ff, 2302 FUCHSIA: 0xff00ffff, 2303 GAINSBORO: 0xdcdcdcff, 2304 GHOSTWHITE: 0xf8f8ffff, 2305 GOLD: 0xffd700ff, 2306 GOLDENROD: 0xdaa520ff, 2307 GRAY: 0x808080ff, 2308 GREEN: 0x008000ff, 2309 GREENYELLOW: 0xadff2fff, 2310 GREY: 0x808080ff, 2311 HONEYDEW: 0xf0fff0ff, 2312 HOTPINK: 0xff69b4ff, 2313 INDIANRED: 0xcd5c5cff, 2314 INDIGO: 0x4b0082ff, 2315 IVORY: 0xfffff0ff, 2316 KHAKI: 0xf0e68cff, 2317 LAVENDER: 0xe6e6faff, 2318 LAVENDERBLUSH: 0xfff0f5ff, 2319 LAWNGREEN: 0x7cfc00ff, 2320 LEMONCHIFFON: 0xfffacdff, 2321 LIGHTBLUE: 0xadd8e6ff, 2322 LIGHTCORAL: 0xf08080ff, 2323 LIGHTCYAN: 0xe0ffffff, 2324 LIGHTGOLDENRODYELLOW: 0xfafad2ff, 2325 LIGHTGRAY: 0xd3d3d3ff, 2326 LIGHTGREEN: 0x90ee90ff, 2327 LIGHTGREY: 0xd3d3d3ff, 2328 LIGHTPINK: 0xffb6c1ff, 2329 LIGHTSALMON: 0xffa07aff, 2330 LIGHTSEAGREEN: 0x20b2aaff, 2331 LIGHTSKYBLUE: 0x87cefaff, 2332 LIGHTSLATEGRAY: 0x778899ff, 2333 LIGHTSLATEGREY: 0x778899ff, 2334 LIGHTSTEELBLUE: 0xb0c4deff, 2335 LIGHTYELLOW: 0xffffe0ff, 2336 LIME: 0x00ff00ff, 2337 LIMEGREEN: 0x32cd32ff, 2338 LINEN: 0xfaf0e6ff,
2339 MAGENTA: 0xff00ffff, 2340 MAROON: 0x800000ff, 2341 MEDIUMAQUAMARINE: 0x66cdaaff, 2342 MEDIUMBLUE: 0x0000cdff, 2343 MEDIUMORCHID: 0xba55d3ff, 2344 MEDIUMPURPLE: 0x9370dbff, 2345 MEDIUMSEAGREEN: 0x3cb371ff, 2346 MEDIUMSLATEBLUE: 0x7b68eeff, 2347 MEDIUMSPRINGGREEN: 0x00fa9aff, 2348 MEDIUMTURQUOISE: 0x48d1ccff, 2349 MEDIUMVIOLETRED: 0xc71585ff, 2350 MIDNIGHTBLUE: 0x191970ff, 2351 MINTCREAM: 0xf5fffaff, 2352 MISTYROSE: 0xffe4e1ff, 2353 MOCCASIN: 0xffe4b5ff, 2354 NAVAJOWHITE: 0xffdeadff, 2355 NAVY: 0x000080ff, 2356 OLDLACE: 0xfdf5e6ff, 2357 OLIVE: 0x808000ff, 2358 OLIVEDRAB: 0x6b8e23ff, 2359 ORANGE: 0xffa500ff, 2360 ORANGERED: 0xff4500ff, 2361 ORCHID: 0xda70d6ff, 2362 PALEGOLDENROD: 0xeee8aaff, 2363 PALEGREEN: 0x98fb98ff, 2364 PALETURQUOISE: 0xafeeeeff, 2365 PALEVIOLETRED: 0xdb7093ff, 2366 PAPAYAWHIP: 0xffefd5ff, 2367 PEACHPUFF: 0xffdab9ff, 2368 PERU: 0xcd853fff, 2369 PINK: 0xffc0cbff, 2370 PLUM: 0xdda0ddff, 2371 POWDERBLUE: 0xb0e0e6ff, 2372 PURPLE: 0x800080ff, 2373 REBECCAPURPLE: 0x663399ff, 2374 RED: 0xff0000ff, 2375 ROSYBROWN: 0xbc8f8fff, 2376 ROYALBLUE: 0x4169e1ff, 2377 SADDLEBROWN: 0x8b4513ff, 2378 SALMON: 0xfa8072ff, 2379 SANDYBROWN: 0xf4a460ff, 2380 SEAGREEN: 0x2e8b57ff, 2381 SEASHELL: 0xfff5eeff, 2382 SIENNA: 0xa0522dff, 2383 SILVER: 0xc0c0c0ff, 2384 SKYBLUE: 0x87ceebff, 2385 SLATEBLUE: 0x6a5acdff, 2386 SLATEGRAY: 0x708090ff, 2387 SLATEGREY: 0x708090ff, 2388 SNOW: 0xfffafaff, 2389 SPRINGGREEN: 0x00ff7fff, 2390 STEELBLUE: 0x4682b4ff, 2391 TAN: 0xd2b48cff, 2392 TEAL: 0x008080ff, 2393 THISTLE: 0xd8bfd8ff, 2394 TOMATO: 0xff6347ff, 2395 TRANSPARENT: 0x00000000, 2396 TURQUOISE: 0x40e0d0ff, 2397 VIOLET: 0xee82eeff, 2398 WHEAT: 0xf5deb3ff, 2399 WHITE: 0xffffffff, 2400 WHITESMOKE: 0xf5f5f5ff, 2401 YELLOW: 0xffff00ff, 2402 YELLOWGREEN: 0x9acd32ff, 2403 }; 2404 2405 var PropertyDescriptorParsingType; 2406 (function (PropertyDescriptorParsingType) { 2407 PropertyDescriptorParsingType[ 2408 (PropertyDescriptorParsingType["VALUE"] = 0) 2409 ] = "VALUE"; 2410 PropertyDescriptorParsingType[(PropertyDescriptorParsingType["LIST"] = 1)] = 2411 "LIST"; 2412 PropertyDescriptorParsingType[ 2413 (PropertyDescriptorParsingType["IDENT_VALUE"] = 2) 2414 ] = "IDENT_VALUE"; 2415 PropertyDescriptorParsingType[ 2416 (PropertyDescriptorParsingType["TYPE_VALUE"] = 3) 2417 ] = "TYPE_VALUE"; 2418 PropertyDescriptorParsingType[ 2419 (PropertyDescriptorParsingType["TOKEN_VALUE"] = 4) 2420 ] = "TOKEN_VALUE"; 2421 })(PropertyDescriptorParsingType || (PropertyDescriptorParsingType = {})); 2422 2423 var BACKGROUND_CLIP; 2424 (function (BACKGROUND_CLIP) { 2425 BACKGROUND_CLIP[(BACKGROUND_CLIP["BORDER_BOX"] = 0)] = "BORDER_BOX"; 2426 BACKGROUND_CLIP[(BACKGROUND_CLIP["PADDING_BOX"] = 1)] = "PADDING_BOX"; 2427 BACKGROUND_CLIP[(BACKGROUND_CLIP["CONTENT_BOX"] = 2)] = "CONTENT_BOX"; 2428 })(BACKGROUND_CLIP || (BACKGROUND_CLIP = {})); 2429 var backgroundClip = { 2430 name: "background-clip", 2431 initialValue: "border-box", 2432 prefix: false, 2433 type: PropertyDescriptorParsingType.LIST, 2434 parse: function (tokens) { 2435 return tokens.map(function (token) { 2436 if (isIdentToken(token)) { 2437 switch (token.value) { 2438 case "padding-box": 2439 return BACKGROUND_CLIP.PADDING_BOX; 2440 case "content-box": 2441 return BACKGROUND_CLIP.CONTENT_BOX; 2442 } 2443 } 2444 return BACKGROUND_CLIP.BORDER_BOX; 2445 }); 2446 }, 2447 }; 2448 2449 var backgroundColor = { 2450 name: "background-color", 2451 initialValue: "transparent", 2452 prefix: false, 2453 type: PropertyDescriptorParsingType.TYPE_VALUE, 2454 format: "color", 2455 }; 2456 2457 var parseColorStop = function (args) { 2458 var color$1 = color.parse(args[0]); 2459 var stop = args[1]; 2460 return stop && isLengthPercentage(stop) 2461 ? { color: color$1, stop: stop } 2462 : { color: color$1, stop: null }; 2463 }; 2464 var processColorStops = function (stops, lineLength) { 2465 var first = stops[0]; 2466 var last = stops[stops.length - 1]; 2467 if (first.stop === null) { 2468 first.stop = ZERO_LENGTH; 2469 } 2470 if (last.stop === null) { 2471 last.stop = HUNDRED_PERCENT; 2472 } 2473 var processStops = []; 2474 var previous = 0; 2475 for (var i = 0; i < stops.length; i++) { 2476 var stop_1 = stops[i].stop; 2477 if (stop_1 !== null) { 2478 var absoluteValue = getAbsoluteValue(stop_1, lineLength); 2479 if (absoluteValue > previous) { 2480 processStops.push(absoluteValue); 2481 } else { 2482 processStops.push(previous); 2483 } 2484 previous = absoluteValue; 2485 } else { 2486 processStops.push(null); 2487 } 2488 } 2489 var gapBegin = null; 2490 for (var i = 0; i < processStops.length; i++) { 2491 var stop_2 = processStops[i]; 2492 if (stop_2 === null) { 2493 if (gapBegin === null) { 2494 gapBegin = i; 2495 } 2496 } else if (gapBegin !== null) { 2497 var gapLength = i - gapBegin; 2498 var beforeGap = processStops[gapBegin - 1]; 2499 var gapValue = (stop_2 - beforeGap) / (gapLength + 1); 2500 for (var g = 1; g <= gapLength; g++) { 2501 processStops[gapBegin + g - 1] = gapValue * g; 2502 } 2503 gapBegin = null; 2504 } 2505 } 2506 return stops.map(function (_a, i) { 2507 var color = _a.color; 2508 return { 2509 color: color, 2510 stop: Math.max(Math.min(1, processStops[i] / lineLength), 0), 2511 }; 2512 });
vendor: 5,621 bytes, lines 2513-2660
2513 }; 2514 var getAngleFromCorner = function (corner, width, height) { 2515 var centerX = width / 2; 2516 var centerY = height / 2; 2517 var x = getAbsoluteValue(corner[0], width) - centerX; 2518 var y = centerY - getAbsoluteValue(corner[1], height); 2519 return (Math.atan2(y, x) + Math.PI * 2) % (Math.PI * 2); 2520 }; 2521 var calculateGradientDirection = function (angle, width, height) { 2522 var radian = 2523 typeof angle === "number" 2524 ? angle 2525 : getAngleFromCorner(angle, width, height); 2526 var lineLength = 2527 Math.abs(width * Math.sin(radian)) + Math.abs(height * Math.cos(radian)); 2528 var halfWidth = width / 2; 2529 var halfHeight = height / 2; 2530 var halfLineLength = lineLength / 2; 2531 var yDiff = Math.sin(radian - Math.PI / 2) * halfLineLength; 2532 var xDiff = Math.cos(radian - Math.PI / 2) * halfLineLength; 2533 return [ 2534 lineLength, 2535 halfWidth - xDiff, 2536 halfWidth + xDiff, 2537 halfHeight - yDiff, 2538 halfHeight + yDiff, 2539 ]; 2540 }; 2541 var distance = function (a, b) { 2542 return Math.sqrt(a * a + b * b); 2543 }; 2544 var findCorner = function (width, height, x, y, closest) { 2545 var corners = [ 2546 [0, 0], 2547 [0, height], 2548 [width, 0], 2549 [width, height], 2550 ]; 2551 return corners.reduce( 2552 function (stat, corner) { 2553 var cx = corner[0], 2554 cy = corner[1]; 2555 var d = distance(x - cx, y - cy); 2556 if (closest ? d < stat.optimumDistance : d > stat.optimumDistance) { 2557 return { 2558 optimumCorner: corner, 2559 optimumDistance: d, 2560 }; 2561 } 2562 return stat; 2563 }, 2564 { 2565 optimumDistance: closest ? Infinity : -Infinity, 2566 optimumCorner: null, 2567 } 2568 ).optimumCorner; 2569 }; 2570 var calculateRadius = function (gradient, x, y, width, height) { 2571 var rx = 0; 2572 var ry = 0; 2573 switch (gradient.size) { 2574 case CSSRadialExtent.CLOSEST_SIDE: 2575 // The ending shape is sized so that that it exactly meets the side of the gradient box closest to the gradientâs center. 2576 // If the shape is an ellipse, it exactly meets the closest side in each dimension. 2577 if (gradient.shape === CSSRadialShape.CIRCLE) { 2578 rx = ry = Math.min( 2579 Math.abs(x), 2580 Math.abs(x - width), 2581 Math.abs(y), 2582 Math.abs(y - height) 2583 ); 2584 } else if (gradient.shape === CSSRadialShape.ELLIPSE) { 2585 rx = Math.min(Math.abs(x), Math.abs(x - width)); 2586 ry = Math.min(Math.abs(y), Math.abs(y - height)); 2587 } 2588 break; 2589 case CSSRadialExtent.CLOSEST_CORNER: 2590 // The ending shape is sized so that that it passes through the corner of the gradient box closest to the gradientâs center. 2591 // If the shape is an ellipse, the ending shape is given the same aspect-ratio it would have if closest-side were specified. 2592 if (gradient.shape === CSSRadialShape.CIRCLE) { 2593 rx = ry = Math.min( 2594 distance(x, y), 2595 distance(x, y - height), 2596 distance(x - width, y), 2597 distance(x - width, y - height) 2598 ); 2599 } else if (gradient.shape === CSSRadialShape.ELLIPSE) { 2600 // Compute the ratio ry/rx (which is to be the same as for "closest-side") 2601 var c = 2602 Math.min(Math.abs(y), Math.abs(y - height)) / 2603 Math.min(Math.abs(x), Math.abs(x - width)); 2604 var _a = findCorner(width, height, x, y, true), 2605 cx = _a[0], 2606 cy = _a[1]; 2607 rx = distance(cx - x, (cy - y) / c); 2608 ry = c * rx; 2609 } 2610 break; 2611 case CSSRadialExtent.FARTHEST_SIDE: 2612 // Same as closest-side, except the ending shape is sized based on the farthest side(s) 2613 if (gradient.shape === CSSRadialShape.CIRCLE) { 2614 rx = ry = Math.max( 2615 Math.abs(x), 2616 Math.abs(x - width), 2617 Math.abs(y), 2618 Math.abs(y - height) 2619 ); 2620 } else if (gradient.shape === CSSRadialShape.ELLIPSE) { 2621 rx = Math.max(Math.abs(x), Math.abs(x - width)); 2622 ry = Math.max(Math.abs(y), Math.abs(y - height)); 2623 } 2624 break; 2625 case CSSRadialExtent.FARTHEST_CORNER: 2626 // Same as closest-corner, except the ending shape is sized based on the farthest corner. 2627 // If the shape is an ellipse, the ending shape is given the same aspect ratio it would have if farthest-side were specified. 2628 if (gradient.shape === CSSRadialShape.CIRCLE) { 2629 rx = ry = Math.max( 2630 distance(x, y), 2631 distance(x, y - height), 2632 distance(x - width, y), 2633 distance(x - width, y - height) 2634 ); 2635 } else if (gradient.shape === CSSRadialShape.ELLIPSE) { 2636 // Compute the ratio ry/rx (which is to be the same as for "farthest-side") 2637 var c = 2638 Math.max(Math.abs(y), Math.abs(y - height)) / 2639 Math.max(Math.abs(x), Math.abs(x - width)); 2640 var _b = findCorner(width, height, x, y, false), 2641 cx = _b[0], 2642 cy = _b[1]; 2643 rx = distance(cx - x, (cy - y) / c); 2644 ry = c * rx; 2645 } 2646 break; 2647 } 2648 if (Array.isArray(gradient.size)) { 2649 rx = getAbsoluteValue(gradient.size[0], width); 2650 ry = 2651 gradient.size.length === 2 2652 ? getAbsoluteValue(gradient.size[1], height) 2653 : rx; 2654 } 2655 return [rx, ry]; 2656 }; 2657 2658 var linearGradient = function (tokens) { 2659 var angle$1 = deg(180); 2660 var stops = [];
vendor: 5,513 bytes, lines 2661-2819
2661 parseFunctionArgs(tokens).forEach(function (arg, i) { 2662 if (i === 0) { 2663 var firstToken = arg[0]; 2664 if ( 2665 firstToken.type === TokenType.IDENT_TOKEN && 2666 firstToken.value === "to" 2667 ) { 2668 angle$1 = parseNamedSide(arg); 2669 return; 2670 } else if (isAngle(firstToken)) { 2671 angle$1 = angle.parse(firstToken); 2672 return; 2673 } 2674 } 2675 var colorStop = parseColorStop(arg); 2676 stops.push(colorStop); 2677 }); 2678 return { angle: angle$1, stops: stops, type: CSSImageType.LINEAR_GRADIENT }; 2679 }; 2680 2681 var prefixLinearGradient = function (tokens) { 2682 var angle$1 = deg(180); 2683 var stops = []; 2684 parseFunctionArgs(tokens).forEach(function (arg, i) { 2685 if (i === 0) { 2686 var firstToken = arg[0]; 2687 if ( 2688 firstToken.type === TokenType.IDENT_TOKEN && 2689 ["top", "left", "right", "bottom"].indexOf(firstToken.value) !== -1 2690 ) { 2691 angle$1 = parseNamedSide(arg); 2692 return; 2693 } else if (isAngle(firstToken)) { 2694 angle$1 = (angle.parse(firstToken) + deg(270)) % deg(360); 2695 return; 2696 } 2697 } 2698 var colorStop = parseColorStop(arg); 2699 stops.push(colorStop); 2700 }); 2701 return { 2702 angle: angle$1, 2703 stops: stops, 2704 type: CSSImageType.LINEAR_GRADIENT, 2705 }; 2706 }; 2707 2708 var testRangeBounds = function (document) { 2709 var TEST_HEIGHT = 123; 2710 if (document.createRange) { 2711 var range = document.createRange(); 2712 if (range.getBoundingClientRect) { 2713 var testElement = document.createElement("boundtest"); 2714 testElement.style.height = TEST_HEIGHT + "px"; 2715 testElement.style.display = "block"; 2716 document.body.appendChild(testElement); 2717 range.selectNode(testElement); 2718 var rangeBounds = range.getBoundingClientRect(); 2719 var rangeHeight = Math.round(rangeBounds.height); 2720 document.body.removeChild(testElement); 2721 if (rangeHeight === TEST_HEIGHT) { 2722 return true; 2723 } 2724 } 2725 } 2726 return false; 2727 }; 2728 var testCORS = function () { 2729 return typeof new Image().crossOrigin !== "undefined"; 2730 }; 2731 var testResponseType = function () { 2732 return typeof new XMLHttpRequest().responseType === "string"; 2733 }; 2734 var testSVG = function (document) { 2735 var img = new Image(); 2736 var canvas = document.createElement("canvas"); 2737 var ctx = canvas.getContext("2d"); 2738 if (!ctx) { 2739 return false; 2740 } 2741 img.src = 2742 "data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg'></svg>"; 2743 try { 2744 ctx.drawImage(img, 0, 0); 2745 canvas.toDataURL(); 2746 } catch (e) { 2747 return false; 2748 } 2749 return true; 2750 }; 2751 var isGreenPixel = function (data) { 2752 return data[0] === 0 && data[1] === 255 && data[2] === 0 && data[3] === 255; 2753 }; 2754 var testForeignObject = function (document) { 2755 var canvas = document.createElement("canvas"); 2756 var size = 100; 2757 canvas.width = size; 2758 canvas.height = size; 2759 var ctx = canvas.getContext("2d"); 2760 if (!ctx) { 2761 return Promise.reject(false); 2762 } 2763 ctx.fillStyle = "rgb(0, 255, 0)"; 2764 ctx.fillRect(0, 0, size, size); 2765 var img = new Image(); 2766 var greenImageSrc = canvas.toDataURL(); 2767 img.src = greenImageSrc; 2768 var svg = createForeignObjectSVG(size, size, 0, 0, img); 2769 ctx.fillStyle = "red"; 2770 ctx.fillRect(0, 0, size, size); 2771 return loadSerializedSVG(svg) 2772 .then(function (img) { 2773 ctx.drawImage(img, 0, 0); 2774 var data = ctx.getImageData(0, 0, size, size).data; 2775 ctx.fillStyle = "red"; 2776 ctx.fillRect(0, 0, size, size); 2777 var node = document.createElement("div"); 2778 node.style.backgroundImage = "url(" + greenImageSrc + ")"; 2779 node.style.height = size + "px"; 2780 // Firefox 55 does not render inline <img /> tags 2781 return isGreenPixel(data) 2782 ? loadSerializedSVG(createForeignObjectSVG(size, size, 0, 0, node)) 2783 : Promise.reject(false); 2784 }) 2785 .then(function (img) { 2786 ctx.drawImage(img, 0, 0); 2787 // Edge does not render background-images 2788 return isGreenPixel(ctx.getImageData(0, 0, size, size).data); 2789 }) 2790 .catch(function () { 2791 return false; 2792 }); 2793 }; 2794 var createForeignObjectSVG = function (width, height, x, y, node) { 2795 var xmlns = "http://www.w3.org/2000/svg"; 2796 var svg = document.createElementNS(xmlns, "svg"); 2797 var foreignObject = document.createElementNS(xmlns, "foreignObject"); 2798 svg.setAttributeNS(null, "width", width.toString()); 2799 svg.setAttributeNS(null, "height", height.toString()); 2800 foreignObject.setAttributeNS(null, "width", "100%"); 2801 foreignObject.setAttributeNS(null, "height", "100%"); 2802 foreignObject.setAttributeNS(null, "x", x.toString()); 2803 foreignObject.setAttributeNS(null, "y", y.toString()); 2804 foreignObject.setAttributeNS(null, "externalResourcesRequired", "true"); 2805 svg.appendChild(foreignObject); 2806 foreignObject.appendChild(node); 2807 return svg; 2808 }; 2809 var loadSerializedSVG = function (svg) { 2810 return new Promise(function (resolve, reject) { 2811 var img = new Image(); 2812 img.onload = function () { 2813 return resolve(img); 2814 }; 2815 img.onerror = reject; 2816 img.src = 2817 "data:image/svg+xml;charset=utf-8," + 2818 encodeURIComponent(new XMLSerializer().serializeToString(svg)); 2819 });
2820 }; 2821 var FEATURES = { 2822 get SUPPORT_RANGE_BOUNDS() { 2823 var value = testRangeBounds(document); 2824 Object.defineProperty(FEATURES, "SUPPORT_RANGE_BOUNDS", { value: value }); 2825 return value; 2826 }, 2827 get SUPPORT_SVG_DRAWING() { 2828 var value = testSVG(document); 2829 Object.defineProperty(FEATURES, "SUPPORT_SVG_DRAWING", { value: value }); 2830 return value; 2831 }, 2832 get SUPPORT_FOREIGNOBJECT_DRAWING() { 2833 var value = 2834 typeof Array.from === "function" && typeof window.fetch === "function" 2835 ? testForeignObject(document) 2836 : Promise.resolve(false); 2837 Object.defineProperty(FEATURES, "SUPPORT_FOREIGNOBJECT_DRAWING", { 2838 value: value, 2839 }); 2840 return value; 2841 }, 2842 get SUPPORT_CORS_IMAGES() { 2843 var value = testCORS(); 2844 Object.defineProperty(FEATURES, "SUPPORT_CORS_IMAGES", { value: value }); 2845 return value; 2846 }, 2847 get SUPPORT_RESPONSE_TYPE() { 2848 var value = testResponseType(); 2849 Object.defineProperty(FEATURES, "SUPPORT_RESPONSE_TYPE", { 2850 value: value, 2851 }); 2852 return value; 2853 }, 2854 get SUPPORT_CORS_XHR() { 2855 var value = "withCredentials" in new XMLHttpRequest(); 2856 Object.defineProperty(FEATURES, "SUPPORT_CORS_XHR", { value: value }); 2857 return value; 2858 }, 2859 }; 2860 2861 var Logger = /** @class */ (function () { 2862 function Logger(_a) { 2863 var id = _a.id, 2864 enabled = _a.enabled; 2865 this.id = id; 2866 this.enabled = enabled; 2867 this.start = Date.now(); 2868 } 2869 // eslint-disable-next-line @typescript-eslint/no-explicit-any 2870 Logger.prototype.debug = function () { 2871 var args = []; 2872 for (var _i = 0; _i < arguments.length; _i++) { 2873 args[_i] = arguments[_i]; 2874 } 2875 if (this.enabled) { 2876 // eslint-disable-next-line no-console 2877 if ( 2878 typeof window !== "undefined" && 2879 window.console && 2880 typeof console.debug === "function" 2881 ) { 2882 // eslint-disable-next-line no-console 2883 console.debug.apply( 2884 console, 2885 [this.id, this.getTime() + "ms"].concat(args) 2886 ); 2887 } else { 2888 this.info.apply(this, args); 2889 } 2890 } 2891 }; 2892 Logger.prototype.getTime = function () { 2893 return Date.now() - this.start; 2894 }; 2895 Logger.create = function (options) { 2896 Logger.instances[options.id] = new Logger(options); 2897 }; 2898 Logger.destroy = function (id) { 2899 delete Logger.instances[id]; 2900 }; 2901 Logger.getInstance = function (id) { 2902 var instance = Logger.instances[id]; 2903 if (typeof instance === "undefined") { 2904 throw new Error("No logger instance found with id " + id); 2905 } 2906 return instance; 2907 }; 2908 // eslint-disable-next-line @typescript-eslint/no-explicit-any 2909 Logger.prototype.info = function () { 2910 var args = []; 2911 for (var _i = 0; _i < arguments.length; _i++) { 2912 args[_i] = arguments[_i]; 2913 } 2914 if (this.enabled) { 2915 // eslint-disable-next-line no-console 2916 if ( 2917 typeof window !== "undefined" && 2918 window.console && 2919 typeof console.info === "function" 2920 ) { 2921 // eslint-disable-next-line no-console 2922 console.info.apply( 2923 console, 2924 [this.id, this.getTime() + "ms"].concat(args) 2925 ); 2926 } 2927 } 2928 }; 2929 // eslint-disable-next-line @typescript-eslint/no-explicit-any 2930 Logger.prototype.error = function () { 2931 var args = []; 2932 for (var _i = 0; _i < arguments.length; _i++) { 2933 args[_i] = arguments[_i]; 2934 } 2935 if (this.enabled) { 2936 // eslint-disable-next-line no-console 2937 if ( 2938 typeof window !== "undefined" && 2939 window.console && 2940 typeof console.error === "function" 2941 ) { 2942 // eslint-disable-next-line no-console 2943 console.error.apply( 2944 console, 2945 [this.id, this.getTime() + "ms"].concat(args) 2946 ); 2947 } else { 2948 this.info.apply(this, args); 2949 } 2950 } 2951 }; 2952 Logger.instances = {}; 2953 return Logger; 2954 })();
2955 2956 var CacheStorage = /** @class */ (function () { 2957 function CacheStorage() {} 2958 CacheStorage.create = function (name, options) { 2959 return (CacheStorage._caches[name] = new Cache(name, options)); 2960 }; 2961 CacheStorage.destroy = function (name) { 2962 delete CacheStorage._caches[name]; 2963 }; 2964 CacheStorage.open = function (name) { 2965 var cache = CacheStorage._caches[name]; 2966 if (typeof cache !== "undefined") { 2967 return cache; 2968 } 2969 throw new Error('Cache with key "' + name + '" not found'); 2970 }; 2971 CacheStorage.getOrigin = function (url) { 2972 var link = CacheStorage._link; 2973 if (!link) { 2974 return "about:blank"; 2975 } 2976 link.href = url; 2977 link.href = link.href; // IE9, LOL! - http://jsfiddle.net/niklasvh/2e48b/ 2978 return link.protocol + link.hostname + link.port; 2979 }; 2980 CacheStorage.isSameOrigin = function (src) { 2981 return CacheStorage.getOrigin(src) === CacheStorage._origin; 2982 }; 2983 CacheStorage.setContext = function (window) { 2984 CacheStorage._link = window.document.createElement("a"); 2985 CacheStorage._origin = CacheStorage.getOrigin(window.location.href); 2986 }; 2987 CacheStorage.getInstance = function () { 2988 var current = CacheStorage._current; 2989 if (current === null) { 2990 throw new Error("No cache instance attached"); 2991 } 2992 return current; 2993 }; 2994 CacheStorage.attachInstance = function (cache) { 2995 CacheStorage._current = cache; 2996 }; 2997 CacheStorage.detachInstance = function () { 2998 CacheStorage._current = null; 2999 }; 3000 CacheStorage._caches = {}; 3001 CacheStorage._origin = "about:blank"; 3002 CacheStorage._current = null; 3003 return CacheStorage; 3004 })(); 3005 var Cache = /** @class */ (function () { 3006 function Cache(id, options) { 3007 this.id = id; 3008 this._options = options; 3009 this._cache = {}; 3010 } 3011 Cache.prototype.addImage = function (src) { 3012 var result = Promise.resolve(); 3013 if (this.has(src)) { 3014 return result; 3015 } 3016 if (isBlobImage(src) || isRenderable(src)) { 3017 this._cache[src] = this.loadImage(src); 3018 return result; 3019 } 3020 return result; 3021 }; 3022 // eslint-disable-next-line @typescript-eslint/no-explicit-any 3023 Cache.prototype.match = function (src) { 3024 return this._cache[src]; 3025 }; 3026 Cache.prototype.loadImage = function (key) { 3027 return __awaiter(this, void 0, void 0, function () { 3028 var isSameOrigin, useCORS, useProxy, src; 3029 var _this = this; 3030 return __generator(this, function (_a) { 3031 switch (_a.label) { 3032 case 0: 3033 isSameOrigin = CacheStorage.isSameOrigin(key); 3034 useCORS = 3035 !isInlineImage(key) && 3036 this._options.useCORS === true && 3037 FEATURES.SUPPORT_CORS_IMAGES && 3038 !isSameOrigin; 3039 useProxy = 3040 !isInlineImage(key) && 3041 !isSameOrigin && 3042 typeof this._options.proxy === "string" && 3043 FEATURES.SUPPORT_CORS_XHR && 3044 !useCORS; 3045 if ( 3046 !isSameOrigin && 3047 this._options.allowTaint === false && 3048 !isInlineImage(key) && 3049 !useProxy && 3050 !useCORS 3051 ) { 3052 return [2 /*return*/]; 3053 } 3054 src = key; 3055 if (!useProxy) return [3 /*break*/, 2]; 3056 return [4 /*yield*/, this.proxy(src)]; 3057 case 1: 3058 src = _a.sent(); 3059 _a.label = 2; 3060 case 2: 3061 Logger.getInstance(this.id).debug( 3062 "Added image " + key.substring(0, 256) 3063 ); 3064 return [ 3065 4 /*yield*/, 3066 new Promise(function (resolve, reject) { 3067 var img = new Image(); 3068 img.onload = function () { 3069 return resolve(img); 3070 }; 3071 img.onerror = reject; 3072 //ios safari 10.3 taints canvas with data urls unless crossOrigin is set to anonymous 3073 if (isInlineBase64Image(src) || useCORS) { 3074 img.crossOrigin = "anonymous"; 3075 } 3076 img.src = src; 3077 if (img.complete === true) { 3078 // Inline XML images may fail to parse, throwing an Error later on 3079 setTimeout(function () { 3080 return resolve(img); 3081 }, 500); 3082 } 3083 if (_this._options.imageTimeout > 0) { 3084 setTimeout(function () { 3085 return reject( 3086 "Timed out (" + 3087 _this._options.imageTimeout + 3088 "ms) loading image" 3089 ); 3090 }, _this._options.imageTimeout); 3091 } 3092 }), 3093 ]; 3094 case 3: 3095 return [2 /*return*/, _a.sent()]; 3096 } 3097 }); 3098 }); 3099 }; 3100 Cache.prototype.has = function (key) { 3101 return typeof this._cache[key] !== "undefined"; 3102 }; 3103 Cache.prototype.keys = function () { 3104 return Promise.resolve(Object.keys(this._cache)); 3105 }; 3106 Cache.prototype.proxy = function (src) { 3107 var _this = this; 3108 var proxy = this._options.proxy; 3109 if (!proxy) { 3110 throw new Error("No proxy defined"); 3111 } 3112 var key = src.substring(0, 256); 3113 return new Promise(function (resolve, reject) { 3114 var responseType = FEATURES.SUPPORT_RESPONSE_TYPE ? "blob" : "text"; 3115 var xhr = new XMLHttpRequest(); 3116 xhr.onload = function () { 3117 if (xhr.status === 200) { 3118 if (responseType === "text") { 3119 resolve(xhr.response); 3120 } else { 3121 var reader_1 = new FileReader(); 3122 reader_1.addEventListener( 3123 "load", 3124 function () { 3125 return resolve(reader_1.result); 3126 }, 3127 false 3128 ); 3129 reader_1.addEventListener( 3130 "error", 3131 function (e) { 3132 return reject(e); 3133 }, 3134 false 3135 ); 3136 reader_1.readAsDataURL(xhr.response); 3137 } 3138 } else { 3139 reject( 3140 "Failed to proxy resource " + 3141 key + 3142 " with status code " + 3143 xhr.status 3144 ); 3145 } 3146 }; 3147 xhr.onerror = reject; 3148 xhr.open( 3149 "GET", 3150 proxy + 3151 "?url=" + 3152 encodeURIComponent(src) + 3153 "&responseType=" + 3154 responseType 3155 ); 3156 if (responseType !== "text" && xhr instanceof XMLHttpRequest) { 3157 xhr.responseType = responseType; 3158 } 3159 if (_this._options.imageTimeout) { 3160 var timeout_1 = _this._options.imageTimeout; 3161 xhr.timeout = timeout_1; 3162 xhr.ontimeout = function () { 3163 return reject("Timed out (" + timeout_1 + "ms) proxying " + key); 3164 }; 3165 } 3166 xhr.send(); 3167 }); 3168 }; 3169 return Cache; 3170 })();
3171 var INLINE_SVG = /^data:image\/svg\+xml/i; 3172 var INLINE_BASE64 = /^data:image\/.*;base64,/i; 3173 var INLINE_IMG = /^data:image\/.*/i; 3174 var isRenderable = function (src) { 3175 return FEATURES.SUPPORT_SVG_DRAWING || !isSVG(src); 3176 }; 3177 var isInlineImage = function (src) { 3178 return INLINE_IMG.test(src); 3179 }; 3180 var isInlineBase64Image = function (src) { 3181 return INLINE_BASE64.test(src); 3182 }; 3183 var isBlobImage = function (src) { 3184 return src.substr(0, 4) === "blob"; 3185 }; 3186 var isSVG = function (src) { 3187 return src.substr(-3).toLowerCase() === "svg" || INLINE_SVG.test(src); 3188 }; 3189 3190 var webkitGradient = function (tokens) { 3191 var angle = deg(180); 3192 var stops = []; 3193 var type = CSSImageType.LINEAR_GRADIENT; 3194 var shape = CSSRadialShape.CIRCLE; 3195 var size = CSSRadialExtent.FARTHEST_CORNER; 3196 var position = []; 3197 parseFunctionArgs(tokens).forEach(function (arg, i) { 3198 var firstToken = arg[0]; 3199 if (i === 0) { 3200 if (isIdentToken(firstToken) && firstToken.value === "linear") { 3201 type = CSSImageType.LINEAR_GRADIENT; 3202 return; 3203 } else if (isIdentToken(firstToken) && firstToken.value === "radial") { 3204 type = CSSImageType.RADIAL_GRADIENT; 3205 return; 3206 } 3207 } 3208 if (firstToken.type === TokenType.FUNCTION) { 3209 if (firstToken.name === "from") { 3210 var color$1 = color.parse(firstToken.values[0]); 3211 stops.push({ stop: ZERO_LENGTH, color: color$1 }); 3212 } else if (firstToken.name === "to") { 3213 var color$1 = color.parse(firstToken.values[0]); 3214 stops.push({ stop: HUNDRED_PERCENT, color: color$1 }); 3215 } else if (firstToken.name === "color-stop") { 3216 var values = firstToken.values.filter(nonFunctionArgSeparator); 3217 if (values.length === 2) { 3218 var color$1 = color.parse(values[1]); 3219 var stop_1 = values[0]; 3220 if (isNumberToken(stop_1)) { 3221 stops.push({ 3222 stop: { 3223 type: TokenType.PERCENTAGE_TOKEN, 3224 number: stop_1.number * 100, 3225 flags: stop_1.flags, 3226 }, 3227 color: color$1, 3228 }); 3229 } 3230 } 3231 } 3232 } 3233 }); 3234 return type === CSSImageType.LINEAR_GRADIENT 3235 ? { 3236 angle: (angle + deg(180)) % deg(360), 3237 stops: stops, 3238 type: type, 3239 } 3240 : { 3241 size: size, 3242 shape: shape, 3243 stops: stops, 3244 position: position, 3245 type: type, 3246 }; 3247 }; 3248 3249 var CLOSEST_SIDE = "closest-side"; 3250 var FARTHEST_SIDE = "farthest-side"; 3251 var CLOSEST_CORNER = "closest-corner"; 3252 var FARTHEST_CORNER = "farthest-corner"; 3253 var CIRCLE = "circle"; 3254 var ELLIPSE = "ellipse"; 3255 var COVER = "cover"; 3256 var CONTAIN = "contain"; 3257 var radialGradient = function (tokens) { 3258 var shape = CSSRadialShape.CIRCLE; 3259 var size = CSSRadialExtent.FARTHEST_CORNER; 3260 var stops = []; 3261 var position = []; 3262 parseFunctionArgs(tokens).forEach(function (arg, i) { 3263 var isColorStop = true; 3264 if (i === 0) { 3265 var isAtPosition_1 = false; 3266 isColorStop = arg.reduce(function (acc, token) { 3267 if (isAtPosition_1) { 3268 if (isIdentToken(token)) { 3269 switch (token.value) { 3270 case "center": 3271 position.push(FIFTY_PERCENT); 3272 return acc; 3273 case "top": 3274 case "left": 3275 position.push(ZERO_LENGTH); 3276 return acc; 3277 case "right": 3278 case "bottom": 3279 position.push(HUNDRED_PERCENT); 3280 return acc; 3281 } 3282 } else if (isLengthPercentage(token) || isLength(token)) { 3283 position.push(token); 3284 } 3285 } else if (isIdentToken(token)) { 3286 switch (token.value) { 3287 case CIRCLE: 3288 shape = CSSRadialShape.CIRCLE; 3289 return false; 3290 case ELLIPSE: 3291 shape = CSSRadialShape.ELLIPSE; 3292 return false; 3293 case "at": 3294 isAtPosition_1 = true; 3295 return false; 3296 case CLOSEST_SIDE: 3297 size = CSSRadialExtent.CLOSEST_SIDE; 3298 return false; 3299 case COVER: 3300 case FARTHEST_SIDE: 3301 size = CSSRadialExtent.FARTHEST_SIDE; 3302 return false; 3303 case CONTAIN: 3304 case CLOSEST_CORNER: 3305 size = CSSRadialExtent.CLOSEST_CORNER; 3306 return false; 3307 case FARTHEST_CORNER: 3308 size = CSSRadialExtent.FARTHEST_CORNER; 3309 return false; 3310 } 3311 } else if (isLength(token) || isLengthPercentage(token)) { 3312 if (!Array.isArray(size)) { 3313 size = []; 3314 } 3315 size.push(token); 3316 return false; 3317 } 3318 return acc; 3319 }, isColorStop); 3320 } 3321 if (isColorStop) { 3322 var colorStop = parseColorStop(arg); 3323 stops.push(colorStop); 3324 } 3325 });
3326 return { 3327 size: size, 3328 shape: shape, 3329 stops: stops, 3330 position: position, 3331 type: CSSImageType.RADIAL_GRADIENT, 3332 }; 3333 }; 3334 3335 var prefixRadialGradient = function (tokens) { 3336 var shape = CSSRadialShape.CIRCLE; 3337 var size = CSSRadialExtent.FARTHEST_CORNER; 3338 var stops = []; 3339 var position = []; 3340 parseFunctionArgs(tokens).forEach(function (arg, i) { 3341 var isColorStop = true; 3342 if (i === 0) { 3343 isColorStop = arg.reduce(function (acc, token) { 3344 if (isIdentToken(token)) { 3345 switch (token.value) { 3346 case "center": 3347 position.push(FIFTY_PERCENT); 3348 return false; 3349 case "top": 3350 case "left": 3351 position.push(ZERO_LENGTH); 3352 return false; 3353 case "right": 3354 case "bottom": 3355 position.push(HUNDRED_PERCENT); 3356 return false; 3357 } 3358 } else if (isLengthPercentage(token) || isLength(token)) { 3359 position.push(token); 3360 return false; 3361 } 3362 return acc; 3363 }, isColorStop); 3364 } else if (i === 1) { 3365 isColorStop = arg.reduce(function (acc, token) { 3366 if (isIdentToken(token)) { 3367 switch (token.value) { 3368 case CIRCLE: 3369 shape = CSSRadialShape.CIRCLE; 3370 return false; 3371 case ELLIPSE: 3372 shape = CSSRadialShape.ELLIPSE; 3373 return false; 3374 case CONTAIN: 3375 case CLOSEST_SIDE: 3376 size = CSSRadialExtent.CLOSEST_SIDE; 3377 return false; 3378 case FARTHEST_SIDE: 3379 size = CSSRadialExtent.FARTHEST_SIDE; 3380 return false; 3381 case CLOSEST_CORNER: 3382 size = CSSRadialExtent.CLOSEST_CORNER; 3383 return false; 3384 case COVER: 3385 case FARTHEST_CORNER: 3386 size = CSSRadialExtent.FARTHEST_CORNER; 3387 return false; 3388 } 3389 } else if (isLength(token) || isLengthPercentage(token)) { 3390 if (!Array.isArray(size)) { 3391 size = []; 3392 } 3393 size.push(token); 3394 return false; 3395 } 3396 return acc; 3397 }, isColorStop); 3398 } 3399 if (isColorStop) { 3400 var colorStop = parseColorStop(arg); 3401 stops.push(colorStop); 3402 } 3403 }); 3404 return { 3405 size: size, 3406 shape: shape, 3407 stops: stops, 3408 position: position, 3409 type: CSSImageType.RADIAL_GRADIENT, 3410 }; 3411 }; 3412 3413 var CSSImageType; 3414 (function (CSSImageType) { 3415 CSSImageType[(CSSImageType["URL"] = 0)] = "URL"; 3416 CSSImageType[(CSSImageType["LINEAR_GRADIENT"] = 1)] = "LINEAR_GRADIENT"; 3417 CSSImageType[(CSSImageType["RADIAL_GRADIENT"] = 2)] = "RADIAL_GRADIENT"; 3418 })(CSSImageType || (CSSImageType = {})); 3419 var isLinearGradient = function (background) { 3420 return background.type === CSSImageType.LINEAR_GRADIENT; 3421 }; 3422 var isRadialGradient = function (background) { 3423 return background.type === CSSImageType.RADIAL_GRADIENT; 3424 }; 3425 var CSSRadialShape; 3426 (function (CSSRadialShape) { 3427 CSSRadialShape[(CSSRadialShape["CIRCLE"] = 0)] = "CIRCLE"; 3428 CSSRadialShape[(CSSRadialShape["ELLIPSE"] = 1)] = "ELLIPSE"; 3429 })(CSSRadialShape || (CSSRadialShape = {})); 3430 var CSSRadialExtent; 3431 (function (CSSRadialExtent) { 3432 CSSRadialExtent[(CSSRadialExtent["CLOSEST_SIDE"] = 0)] = "CLOSEST_SIDE"; 3433 CSSRadialExtent[(CSSRadialExtent["FARTHEST_SIDE"] = 1)] = "FARTHEST_SIDE"; 3434 CSSRadialExtent[(CSSRadialExtent["CLOSEST_CORNER"] = 2)] = "CLOSEST_CORNER"; 3435 CSSRadialExtent[(CSSRadialExtent["FARTHEST_CORNER"] = 3)] = 3436 "FARTHEST_CORNER"; 3437 })(CSSRadialExtent || (CSSRadialExtent = {})); 3438 var image = { 3439 name: "image", 3440 parse: function (value) { 3441 if (value.type === TokenType.URL_TOKEN) { 3442 var image_1 = { url: value.value, type: CSSImageType.URL }; 3443 CacheStorage.getInstance().addImage(value.value); 3444 return image_1; 3445 } 3446 if (value.type === TokenType.FUNCTION) { 3447 var imageFunction = SUPPORTED_IMAGE_FUNCTIONS[value.name]; 3448 if (typeof imageFunction === "undefined") { 3449 throw new Error( 3450 'Attempting to parse an unsupported image function "' + 3451 value.name + 3452 '"' 3453 ); 3454 } 3455 return imageFunction(value.values); 3456 } 3457 throw new Error("Unsupported image type"); 3458 }, 3459 }; 3460 function isSupportedImage(value) { 3461 return ( 3462 value.type !== TokenType.FUNCTION || SUPPORTED_IMAGE_FUNCTIONS[value.name] 3463 ); 3464 } 3465 var SUPPORTED_IMAGE_FUNCTIONS = { 3466 "linear-gradient": linearGradient, 3467 "-moz-linear-gradient": prefixLinearGradient,
3468 "-ms-linear-gradient": prefixLinearGradient, 3469 "-o-linear-gradient": prefixLinearGradient, 3470 "-webkit-linear-gradient": prefixLinearGradient, 3471 "radial-gradient": radialGradient, 3472 "-moz-radial-gradient": prefixRadialGradient, 3473 "-ms-radial-gradient": prefixRadialGradient, 3474 "-o-radial-gradient": prefixRadialGradient, 3475 "-webkit-radial-gradient": prefixRadialGradient, 3476 "-webkit-gradient": webkitGradient, 3477 }; 3478 3479 var backgroundImage = { 3480 name: "background-image", 3481 initialValue: "none", 3482 type: PropertyDescriptorParsingType.LIST, 3483 prefix: false, 3484 parse: function (tokens) { 3485 if (tokens.length === 0) { 3486 return []; 3487 } 3488 var first = tokens[0]; 3489 if (first.type === TokenType.IDENT_TOKEN && first.value === "none") { 3490 return []; 3491 } 3492 return tokens 3493 .filter(function (value) { 3494 return nonFunctionArgSeparator(value) && isSupportedImage(value); 3495 }) 3496 .map(image.parse); 3497 }, 3498 }; 3499 3500 var backgroundOrigin = { 3501 name: "background-origin", 3502 initialValue: "border-box", 3503 prefix: false, 3504 type: PropertyDescriptorParsingType.LIST, 3505 parse: function (tokens) { 3506 return tokens.map(function (token) { 3507 if (isIdentToken(token)) { 3508 switch (token.value) { 3509 case "padding-box": 3510 return 1 /* PADDING_BOX */; 3511 case "content-box": 3512 return 2 /* CONTENT_BOX */; 3513 } 3514 } 3515 return 0 /* BORDER_BOX */; 3516 }); 3517 }, 3518 }; 3519 3520 var backgroundPosition = { 3521 name: "background-position", 3522 initialValue: "0% 0%", 3523 type: PropertyDescriptorParsingType.LIST, 3524 prefix: false, 3525 parse: function (tokens) { 3526 return parseFunctionArgs(tokens) 3527 .map(function (values) { 3528 return values.filter(isLengthPercentage); 3529 }) 3530 .map(parseLengthPercentageTuple); 3531 }, 3532 }; 3533 3534 var BACKGROUND_REPEAT; 3535 (function (BACKGROUND_REPEAT) { 3536 BACKGROUND_REPEAT[(BACKGROUND_REPEAT["REPEAT"] = 0)] = "REPEAT"; 3537 BACKGROUND_REPEAT[(BACKGROUND_REPEAT["NO_REPEAT"] = 1)] = "NO_REPEAT"; 3538 BACKGROUND_REPEAT[(BACKGROUND_REPEAT["REPEAT_X"] = 2)] = "REPEAT_X"; 3539 BACKGROUND_REPEAT[(BACKGROUND_REPEAT["REPEAT_Y"] = 3)] = "REPEAT_Y"; 3540 })(BACKGROUND_REPEAT || (BACKGROUND_REPEAT = {})); 3541 var backgroundRepeat = { 3542 name: "background-repeat", 3543 initialValue: "repeat", 3544 prefix: false, 3545 type: PropertyDescriptorParsingType.LIST, 3546 parse: function (tokens) { 3547 return parseFunctionArgs(tokens) 3548 .map(function (values) { 3549 return values 3550 .filter(isIdentToken) 3551 .map(function (token) { 3552 return token.value; 3553 }) 3554 .join(" "); 3555 }) 3556 .map(parseBackgroundRepeat); 3557 }, 3558 }; 3559 var parseBackgroundRepeat = function (value) { 3560 switch (value) { 3561 case "no-repeat": 3562 return BACKGROUND_REPEAT.NO_REPEAT; 3563 case "repeat-x": 3564 case "repeat no-repeat": 3565 return BACKGROUND_REPEAT.REPEAT_X; 3566 case "repeat-y": 3567 case "no-repeat repeat": 3568 return BACKGROUND_REPEAT.REPEAT_Y; 3569 case "repeat": 3570 default: 3571 return BACKGROUND_REPEAT.REPEAT; 3572 } 3573 }; 3574 3575 var BACKGROUND_SIZE; 3576 (function (BACKGROUND_SIZE) { 3577 BACKGROUND_SIZE["AUTO"] = "auto"; 3578 BACKGROUND_SIZE["CONTAIN"] = "contain"; 3579 BACKGROUND_SIZE["COVER"] = "cover"; 3580 })(BACKGROUND_SIZE || (BACKGROUND_SIZE = {})); 3581 var backgroundSize = { 3582 name: "background-size", 3583 initialValue: "0", 3584 prefix: false, 3585 type: PropertyDescriptorParsingType.LIST, 3586 parse: function (tokens) { 3587 return parseFunctionArgs(tokens).map(function (values) { 3588 return values.filter(isBackgroundSizeInfoToken); 3589 }); 3590 }, 3591 }; 3592 var isBackgroundSizeInfoToken = function (value) { 3593 return isIdentToken(value) || isLengthPercentage(value); 3594 }; 3595 3596 var borderColorForSide = function (side) { 3597 return { 3598 name: "border-" + side + "-color", 3599 initialValue: "transparent", 3600 prefix: false, 3601 type: PropertyDescriptorParsingType.TYPE_VALUE, 3602 format: "color", 3603 }; 3604 }; 3605 var borderTopColor = borderColorForSide("top"); 3606 var borderRightColor = borderColorForSide("right"); 3607 var borderBottomColor = borderColorForSide("bottom"); 3608 var borderLeftColor = borderColorForSide("left"); 3609 3610 var borderRadiusForSide = function (side) { 3611 return { 3612 name: "border-radius-" + side, 3613 initialValue: "0 0", 3614 prefix: false, 3615 type: PropertyDescriptorParsingType.LIST, 3616 parse: function (tokens) { 3617 return parseLengthPercentageTuple(tokens.filter(isLengthPercentage)); 3618 }, 3619 }; 3620 }; 3621 var borderTopLeftRadius = borderRadiusForSide("top-left"); 3622 var borderTopRightRadius = borderRadiusForSide("top-right"); 3623 var borderBottomRightRadius = borderRadiusForSide("bottom-right"); 3624 var borderBottomLeftRadius = borderRadiusForSide("bottom-left"); 3625 3626 var BORDER_STYLE; 3627 (function (BORDER_STYLE) { 3628 BORDER_STYLE[(BORDER_STYLE["NONE"] = 0)] = "NONE";
3629 BORDER_STYLE[(BORDER_STYLE["SOLID"] = 1)] = "SOLID"; 3630 })(BORDER_STYLE || (BORDER_STYLE = {})); 3631 var borderStyleForSide = function (side) { 3632 return { 3633 name: "border-" + side + "-style", 3634 initialValue: "solid", 3635 prefix: false, 3636 type: PropertyDescriptorParsingType.IDENT_VALUE, 3637 parse: function (style) { 3638 switch (style) { 3639 case "none": 3640 return BORDER_STYLE.NONE; 3641 } 3642 return BORDER_STYLE.SOLID; 3643 }, 3644 }; 3645 }; 3646 var borderTopStyle = borderStyleForSide("top"); 3647 var borderRightStyle = borderStyleForSide("right"); 3648 var borderBottomStyle = borderStyleForSide("bottom"); 3649 var borderLeftStyle = borderStyleForSide("left"); 3650 3651 var borderWidthForSide = function (side) { 3652 return { 3653 name: "border-" + side + "-width", 3654 initialValue: "0", 3655 type: PropertyDescriptorParsingType.VALUE, 3656 prefix: false, 3657 parse: function (token) { 3658 if (isDimensionToken(token)) { 3659 return token.number; 3660 } 3661 return 0; 3662 }, 3663 }; 3664 }; 3665 var borderTopWidth = borderWidthForSide("top"); 3666 var borderRightWidth = borderWidthForSide("right"); 3667 var borderBottomWidth = borderWidthForSide("bottom"); 3668 var borderLeftWidth = borderWidthForSide("left"); 3669 3670 var color$1 = { 3671 name: "color", 3672 initialValue: "transparent", 3673 prefix: false, 3674 type: PropertyDescriptorParsingType.TYPE_VALUE, 3675 format: "color", 3676 }; 3677 3678 var display = { 3679 name: "display", 3680 initialValue: "inline-block", 3681 prefix: false, 3682 type: PropertyDescriptorParsingType.LIST, 3683 parse: function (tokens) { 3684 return tokens.filter(isIdentToken).reduce(function (bit, token) { 3685 return bit | parseDisplayValue(token.value); 3686 }, 0 /* NONE */); 3687 }, 3688 }; 3689 var parseDisplayValue = function (display) { 3690 switch (display) { 3691 case "block": 3692 return 2 /* BLOCK */; 3693 case "inline": 3694 return 4 /* INLINE */; 3695 case "run-in": 3696 return 8 /* RUN_IN */; 3697 case "flow": 3698 return 16 /* FLOW */; 3699 case "flow-root": 3700 return 32 /* FLOW_ROOT */; 3701 case "table": 3702 return 64 /* TABLE */; 3703 case "flex": 3704 case "-webkit-flex": 3705 return 128 /* FLEX */; 3706 case "grid": 3707 case "-ms-grid": 3708 return 256 /* GRID */; 3709 case "ruby": 3710 return 512 /* RUBY */; 3711 case "subgrid": 3712 return 1024 /* SUBGRID */; 3713 case "list-item": 3714 return 2048 /* LIST_ITEM */; 3715 case "table-row-group": 3716 return 4096 /* TABLE_ROW_GROUP */; 3717 case "table-header-group": 3718 return 8192 /* TABLE_HEADER_GROUP */; 3719 case "table-footer-group": 3720 return 16384 /* TABLE_FOOTER_GROUP */; 3721 case "table-row": 3722 return 32768 /* TABLE_ROW */; 3723 case "table-cell": 3724 return 65536 /* TABLE_CELL */; 3725 case "table-column-group": 3726 return 131072 /* TABLE_COLUMN_GROUP */; 3727 case "table-column": 3728 return 262144 /* TABLE_COLUMN */; 3729 case "table-caption": 3730 return 524288 /* TABLE_CAPTION */; 3731 case "ruby-base": 3732 return 1048576 /* RUBY_BASE */; 3733 case "ruby-text": 3734 return 2097152 /* RUBY_TEXT */; 3735 case "ruby-base-container": 3736 return 4194304 /* RUBY_BASE_CONTAINER */; 3737 case "ruby-text-container": 3738 return 8388608 /* RUBY_TEXT_CONTAINER */; 3739 case "contents": 3740 return 16777216 /* CONTENTS */; 3741 case "inline-block": 3742 return 33554432 /* INLINE_BLOCK */; 3743 case "inline-list-item": 3744 return 67108864 /* INLINE_LIST_ITEM */; 3745 case "inline-table": 3746 return 134217728 /* INLINE_TABLE */; 3747 case "inline-flex": 3748 return 268435456 /* INLINE_FLEX */; 3749 case "inline-grid": 3750 return 536870912 /* INLINE_GRID */; 3751 } 3752 return 0 /* NONE */; 3753 }; 3754 3755 var FLOAT; 3756 (function (FLOAT) { 3757 FLOAT[(FLOAT["NONE"] = 0)] = "NONE"; 3758 FLOAT[(FLOAT["LEFT"] = 1)] = "LEFT"; 3759 FLOAT[(FLOAT["RIGHT"] = 2)] = "RIGHT"; 3760 FLOAT[(FLOAT["INLINE_START"] = 3)] = "INLINE_START"; 3761 FLOAT[(FLOAT["INLINE_END"] = 4)] = "INLINE_END"; 3762 })(FLOAT || (FLOAT = {})); 3763 var float = { 3764 name: "float", 3765 initialValue: "none", 3766 prefix: false, 3767 type: PropertyDescriptorParsingType.IDENT_VALUE, 3768 parse: function (float) { 3769 switch (float) {
3770 case "left": 3771 return FLOAT.LEFT; 3772 case "right": 3773 return FLOAT.RIGHT; 3774 case "inline-start": 3775 return FLOAT.INLINE_START; 3776 case "inline-end": 3777 return FLOAT.INLINE_END; 3778 } 3779 return FLOAT.NONE; 3780 }, 3781 }; 3782 3783 var letterSpacing = { 3784 name: "letter-spacing", 3785 initialValue: "0", 3786 prefix: false, 3787 type: PropertyDescriptorParsingType.VALUE, 3788 parse: function (token) { 3789 if (token.type === TokenType.IDENT_TOKEN && token.value === "normal") { 3790 return 0; 3791 } 3792 if (token.type === TokenType.NUMBER_TOKEN) { 3793 return token.number; 3794 } 3795 if (token.type === TokenType.DIMENSION_TOKEN) { 3796 return token.number; 3797 } 3798 return 0; 3799 }, 3800 }; 3801 3802 var LINE_BREAK; 3803 (function (LINE_BREAK) { 3804 LINE_BREAK["NORMAL"] = "normal"; 3805 LINE_BREAK["STRICT"] = "strict"; 3806 })(LINE_BREAK || (LINE_BREAK = {})); 3807 var lineBreak = { 3808 name: "line-break", 3809 initialValue: "normal", 3810 prefix: false, 3811 type: PropertyDescriptorParsingType.IDENT_VALUE, 3812 parse: function (lineBreak) { 3813 switch (lineBreak) { 3814 case "strict": 3815 return LINE_BREAK.STRICT; 3816 case "normal": 3817 default: 3818 return LINE_BREAK.NORMAL; 3819 } 3820 }, 3821 }; 3822 3823 var lineHeight = { 3824 name: "line-height", 3825 initialValue: "normal", 3826 prefix: false, 3827 type: PropertyDescriptorParsingType.TOKEN_VALUE, 3828 }; 3829 var computeLineHeight = function (token, fontSize) { 3830 if (isIdentToken(token) && token.value === "normal") { 3831 return 1.2 * fontSize; 3832 } else if (token.type === TokenType.NUMBER_TOKEN) { 3833 return fontSize * token.number; 3834 } else if (isLengthPercentage(token)) { 3835 return getAbsoluteValue(token, fontSize); 3836 } 3837 return fontSize; 3838 }; 3839 3840 var listStyleImage = { 3841 name: "list-style-image", 3842 initialValue: "none", 3843 type: PropertyDescriptorParsingType.VALUE, 3844 prefix: false, 3845 parse: function (token) { 3846 if (token.type === TokenType.IDENT_TOKEN && token.value === "none") { 3847 return null; 3848 } 3849 return image.parse(token); 3850 }, 3851 }; 3852 3853 var LIST_STYLE_POSITION; 3854 (function (LIST_STYLE_POSITION) { 3855 LIST_STYLE_POSITION[(LIST_STYLE_POSITION["INSIDE"] = 0)] = "INSIDE"; 3856 LIST_STYLE_POSITION[(LIST_STYLE_POSITION["OUTSIDE"] = 1)] = "OUTSIDE"; 3857 })(LIST_STYLE_POSITION || (LIST_STYLE_POSITION = {})); 3858 var listStylePosition = { 3859 name: "list-style-position", 3860 initialValue: "outside", 3861 prefix: false, 3862 type: PropertyDescriptorParsingType.IDENT_VALUE, 3863 parse: function (position) { 3864 switch (position) { 3865 case "inside": 3866 return LIST_STYLE_POSITION.INSIDE; 3867 case "outside": 3868 default: 3869 return LIST_STYLE_POSITION.OUTSIDE; 3870 } 3871 }, 3872 }; 3873 3874 var LIST_STYLE_TYPE; 3875 (function (LIST_STYLE_TYPE) { 3876 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["NONE"] = -1)] = "NONE"; 3877 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["DISC"] = 0)] = "DISC"; 3878 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["CIRCLE"] = 1)] = "CIRCLE"; 3879 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["SQUARE"] = 2)] = "SQUARE"; 3880 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["DECIMAL"] = 3)] = "DECIMAL"; 3881 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["CJK_DECIMAL"] = 4)] = "CJK_DECIMAL"; 3882 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["DECIMAL_LEADING_ZERO"] = 5)] = 3883 "DECIMAL_LEADING_ZERO"; 3884 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["LOWER_ROMAN"] = 6)] = "LOWER_ROMAN"; 3885 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["UPPER_ROMAN"] = 7)] = "UPPER_ROMAN"; 3886 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["LOWER_GREEK"] = 8)] = "LOWER_GREEK"; 3887 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["LOWER_ALPHA"] = 9)] = "LOWER_ALPHA"; 3888 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["UPPER_ALPHA"] = 10)] = "UPPER_ALPHA"; 3889 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["ARABIC_INDIC"] = 11)] = "ARABIC_INDIC"; 3890 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["ARMENIAN"] = 12)] = "ARMENIAN"; 3891 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["BENGALI"] = 13)] = "BENGALI"; 3892 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["CAMBODIAN"] = 14)] = "CAMBODIAN"; 3893 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["CJK_EARTHLY_BRANCH"] = 15)] = 3894 "CJK_EARTHLY_BRANCH"; 3895 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["CJK_HEAVENLY_STEM"] = 16)] = 3896 "CJK_HEAVENLY_STEM"; 3897 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["CJK_IDEOGRAPHIC"] = 17)] = 3898 "CJK_IDEOGRAPHIC"; 3899 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["DEVANAGARI"] = 18)] = "DEVANAGARI"; 3900 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["ETHIOPIC_NUMERIC"] = 19)] = 3901 "ETHIOPIC_NUMERIC"; 3902 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["GEORGIAN"] = 20)] = "GEORGIAN"; 3903 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["GUJARATI"] = 21)] = "GUJARATI"; 3904 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["GURMUKHI"] = 22)] = "GURMUKHI"; 3905 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["HEBREW"] = 22)] = "HEBREW"; 3906 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["HIRAGANA"] = 23)] = "HIRAGANA"; 3907 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["HIRAGANA_IROHA"] = 24)] = 3908 "HIRAGANA_IROHA"; 3909 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["JAPANESE_FORMAL"] = 25)] = 3910 "JAPANESE_FORMAL"; 3911 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["JAPANESE_INFORMAL"] = 26)] = 3912 "JAPANESE_INFORMAL"; 3913 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["KANNADA"] = 27)] = "KANNADA"; 3914 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["KATAKANA"] = 28)] = "KATAKANA"; 3915 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["KATAKANA_IROHA"] = 29)] = 3916 "KATAKANA_IROHA"; 3917 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["KHMER"] = 30)] = "KHMER"; 3918 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["KOREAN_HANGUL_FORMAL"] = 31)] = 3919 "KOREAN_HANGUL_FORMAL"; 3920 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["KOREAN_HANJA_FORMAL"] = 32)] = 3921 "KOREAN_HANJA_FORMAL"; 3922 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["KOREAN_HANJA_INFORMAL"] = 33)] = 3923 "KOREAN_HANJA_INFORMAL"; 3924 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["LAO"] = 34)] = "LAO"; 3925 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["LOWER_ARMENIAN"] = 35)] = 3926 "LOWER_ARMENIAN"; 3927 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["MALAYALAM"] = 36)] = "MALAYALAM"; 3928 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["MONGOLIAN"] = 37)] = "MONGOLIAN"; 3929 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["MYANMAR"] = 38)] = "MYANMAR"; 3930 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["ORIYA"] = 39)] = "ORIYA"; 3931 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["PERSIAN"] = 40)] = "PERSIAN"; 3932 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["SIMP_CHINESE_FORMAL"] = 41)] = 3933 "SIMP_CHINESE_FORMAL"; 3934 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["SIMP_CHINESE_INFORMAL"] = 42)] = 3935 "SIMP_CHINESE_INFORMAL"; 3936 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["TAMIL"] = 43)] = "TAMIL"; 3937 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["TELUGU"] = 44)] = "TELUGU"; 3938 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["THAI"] = 45)] = "THAI"; 3939 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["TIBETAN"] = 46)] = "TIBETAN"; 3940 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["TRAD_CHINESE_FORMAL"] = 47)] = 3941 "TRAD_CHINESE_FORMAL"; 3942 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["TRAD_CHINESE_INFORMAL"] = 48)] = 3943 "TRAD_CHINESE_INFORMAL"; 3944 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["UPPER_ARMENIAN"] = 49)] = 3945 "UPPER_ARMENIAN"; 3946 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["DISCLOSURE_OPEN"] = 50)] = 3947 "DISCLOSURE_OPEN"; 3948 LIST_STYLE_TYPE[(LIST_STYLE_TYPE["DISCLOSURE_CLOSED"] = 51)] = 3949 "DISCLOSURE_CLOSED"; 3950 })(LIST_STYLE_TYPE || (LIST_STYLE_TYPE = {})); 3951 var listStyleType = { 3952 name: "list-style-type", 3953 initialValue: "none", 3954 prefix: false, 3955 type: PropertyDescriptorParsingType.IDENT_VALUE, 3956 parse: function (type) { 3957 switch (type) { 3958 case "disc": 3959 return LIST_STYLE_TYPE.DISC; 3960 case "circle": 3961 return LIST_STYLE_TYPE.CIRCLE; 3962 case "square": 3963 return LIST_STYLE_TYPE.SQUARE; 3964 case "decimal": 3965 return LIST_STYLE_TYPE.DECIMAL; 3966 case "cjk-decimal": 3967 return LIST_STYLE_TYPE.CJK_DECIMAL; 3968 case "decimal-leading-zero": 3969 return LIST_STYLE_TYPE.DECIMAL_LEADING_ZERO; 3970 case "lower-roman": 3971 return LIST_STYLE_TYPE.LOWER_ROMAN; 3972 case "upper-roman": 3973 return LIST_STYLE_TYPE.UPPER_ROMAN; 3974 case "lower-greek": 3975 return LIST_STYLE_TYPE.LOWER_GREEK; 3976 case "lower-alpha": 3977 return LIST_STYLE_TYPE.LOWER_ALPHA; 3978 case "upper-alpha": 3979 return LIST_STYLE_TYPE.UPPER_ALPHA; 3980 case "arabic-indic": 3981 return LIST_STYLE_TYPE.ARABIC_INDIC; 3982 case "armenian": 3983 return LIST_STYLE_TYPE.ARMENIAN; 3984 case "bengali": 3985 return LIST_STYLE_TYPE.BENGALI; 3986 case "cambodian": 3987 return LIST_STYLE_TYPE.CAMBODIAN; 3988 case "cjk-earthly-branch": 3989 return LIST_STYLE_TYPE.CJK_EARTHLY_BRANCH; 3990 case "cjk-heavenly-stem": 3991 return LIST_STYLE_TYPE.CJK_HEAVENLY_STEM; 3992 case "cjk-ideographic": 3993 return LIST_STYLE_TYPE.CJK_IDEOGRAPHIC; 3994 case "devanagari": 3995 return LIST_STYLE_TYPE.DEVANAGARI; 3996 case "ethiopic-numeric": 3997 return LIST_STYLE_TYPE.ETHIOPIC_NUMERIC; 3998 case "georgian": 3999 return LIST_STYLE_TYPE.GEORGIAN; 4000 case "gujarati": 4001 return LIST_STYLE_TYPE.GUJARATI; 4002 case "gurmukhi": 4003 return LIST_STYLE_TYPE.GURMUKHI; 4004 case "hebrew": 4005 return LIST_STYLE_TYPE.HEBREW; 4006 case "hiragana": 4007 return LIST_STYLE_TYPE.HIRAGANA; 4008 case "hiragana-iroha": 4009 return LIST_STYLE_TYPE.HIRAGANA_IROHA; 4010 case "japanese-formal": 4011 return LIST_STYLE_TYPE.JAPANESE_FORMAL; 4012 case "japanese-informal": 4013 return LIST_STYLE_TYPE.JAPANESE_INFORMAL; 4014 case "kannada": 4015 return LIST_STYLE_TYPE.KANNADA; 4016 case "katakana":
4017 return LIST_STYLE_TYPE.KATAKANA; 4018 case "katakana-iroha": 4019 return LIST_STYLE_TYPE.KATAKANA_IROHA; 4020 case "khmer": 4021 return LIST_STYLE_TYPE.KHMER; 4022 case "korean-hangul-formal": 4023 return LIST_STYLE_TYPE.KOREAN_HANGUL_FORMAL; 4024 case "korean-hanja-formal": 4025 return LIST_STYLE_TYPE.KOREAN_HANJA_FORMAL; 4026 case "korean-hanja-informal": 4027 return LIST_STYLE_TYPE.KOREAN_HANJA_INFORMAL; 4028 case "lao": 4029 return LIST_STYLE_TYPE.LAO; 4030 case "lower-armenian": 4031 return LIST_STYLE_TYPE.LOWER_ARMENIAN; 4032 case "malayalam": 4033 return LIST_STYLE_TYPE.MALAYALAM; 4034 case "mongolian": 4035 return LIST_STYLE_TYPE.MONGOLIAN; 4036 case "myanmar": 4037 return LIST_STYLE_TYPE.MYANMAR; 4038 case "oriya": 4039 return LIST_STYLE_TYPE.ORIYA; 4040 case "persian": 4041 return LIST_STYLE_TYPE.PERSIAN; 4042 case "simp-chinese-formal": 4043 return LIST_STYLE_TYPE.SIMP_CHINESE_FORMAL; 4044 case "simp-chinese-informal": 4045 return LIST_STYLE_TYPE.SIMP_CHINESE_INFORMAL; 4046 case "tamil": 4047 return LIST_STYLE_TYPE.TAMIL; 4048 case "telugu": 4049 return LIST_STYLE_TYPE.TELUGU; 4050 case "thai": 4051 return LIST_STYLE_TYPE.THAI; 4052 case "tibetan": 4053 return LIST_STYLE_TYPE.TIBETAN; 4054 case "trad-chinese-formal": 4055 return LIST_STYLE_TYPE.TRAD_CHINESE_FORMAL; 4056 case "trad-chinese-informal": 4057 return LIST_STYLE_TYPE.TRAD_CHINESE_INFORMAL; 4058 case "upper-armenian": 4059 return LIST_STYLE_TYPE.UPPER_ARMENIAN; 4060 case "disclosure-open": 4061 return LIST_STYLE_TYPE.DISCLOSURE_OPEN; 4062 case "disclosure-closed": 4063 return LIST_STYLE_TYPE.DISCLOSURE_CLOSED; 4064 case "none": 4065 default: 4066 return LIST_STYLE_TYPE.NONE; 4067 } 4068 }, 4069 }; 4070 4071 var marginForSide = function (side) { 4072 return { 4073 name: "margin-" + side, 4074 initialValue: "0", 4075 prefix: false, 4076 type: PropertyDescriptorParsingType.TOKEN_VALUE, 4077 }; 4078 }; 4079 var marginTop = marginForSide("top"); 4080 var marginRight = marginForSide("right"); 4081 var marginBottom = marginForSide("bottom"); 4082 var marginLeft = marginForSide("left"); 4083 4084 var OVERFLOW; 4085 (function (OVERFLOW) { 4086 OVERFLOW[(OVERFLOW["VISIBLE"] = 0)] = "VISIBLE"; 4087 OVERFLOW[(OVERFLOW["HIDDEN"] = 1)] = "HIDDEN"; 4088 OVERFLOW[(OVERFLOW["SCROLL"] = 2)] = "SCROLL"; 4089 OVERFLOW[(OVERFLOW["AUTO"] = 3)] = "AUTO"; 4090 })(OVERFLOW || (OVERFLOW = {})); 4091 var overflow = { 4092 name: "overflow", 4093 initialValue: "visible", 4094 prefix: false, 4095 type: PropertyDescriptorParsingType.LIST, 4096 parse: function (tokens) { 4097 return tokens.filter(isIdentToken).map(function (overflow) { 4098 switch (overflow.value) { 4099 case "hidden": 4100 return OVERFLOW.HIDDEN; 4101 case "scroll": 4102 return OVERFLOW.SCROLL; 4103 case "auto": 4104 return OVERFLOW.AUTO; 4105 case "visible": 4106 default: 4107 return OVERFLOW.VISIBLE; 4108 } 4109 }); 4110 }, 4111 }; 4112 4113 var OVERFLOW_WRAP; 4114 (function (OVERFLOW_WRAP) { 4115 OVERFLOW_WRAP["NORMAL"] = "normal"; 4116 OVERFLOW_WRAP["BREAK_WORD"] = "break-word"; 4117 })(OVERFLOW_WRAP || (OVERFLOW_WRAP = {})); 4118 var overflowWrap = { 4119 name: "overflow-wrap", 4120 initialValue: "normal", 4121 prefix: false, 4122 type: PropertyDescriptorParsingType.IDENT_VALUE, 4123 parse: function (overflow) { 4124 switch (overflow) { 4125 case "break-word": 4126 return OVERFLOW_WRAP.BREAK_WORD; 4127 case "normal": 4128 default: 4129 return OVERFLOW_WRAP.NORMAL; 4130 } 4131 }, 4132 }; 4133 4134 var paddingForSide = function (side) { 4135 return { 4136 name: "padding-" + side, 4137 initialValue: "0", 4138 prefix: false, 4139 type: PropertyDescriptorParsingType.TYPE_VALUE, 4140 format: "length-percentage", 4141 }; 4142 }; 4143 var paddingTop = paddingForSide("top"); 4144 var paddingRight = paddingForSide("right"); 4145 var paddingBottom = paddingForSide("bottom"); 4146 var paddingLeft = paddingForSide("left"); 4147 4148 var TEXT_ALIGN; 4149 (function (TEXT_ALIGN) { 4150 TEXT_ALIGN[(TEXT_ALIGN["LEFT"] = 0)] = "LEFT";
4151 TEXT_ALIGN[(TEXT_ALIGN["CENTER"] = 1)] = "CENTER"; 4152 TEXT_ALIGN[(TEXT_ALIGN["RIGHT"] = 2)] = "RIGHT"; 4153 })(TEXT_ALIGN || (TEXT_ALIGN = {})); 4154 var textAlign = { 4155 name: "text-align", 4156 initialValue: "left", 4157 prefix: false, 4158 type: PropertyDescriptorParsingType.IDENT_VALUE, 4159 parse: function (textAlign) { 4160 switch (textAlign) { 4161 case "right": 4162 return TEXT_ALIGN.RIGHT; 4163 case "center": 4164 case "justify": 4165 return TEXT_ALIGN.CENTER; 4166 case "left": 4167 default: 4168 return TEXT_ALIGN.LEFT; 4169 } 4170 }, 4171 }; 4172 4173 var POSITION; 4174 (function (POSITION) { 4175 POSITION[(POSITION["STATIC"] = 0)] = "STATIC"; 4176 POSITION[(POSITION["RELATIVE"] = 1)] = "RELATIVE"; 4177 POSITION[(POSITION["ABSOLUTE"] = 2)] = "ABSOLUTE"; 4178 POSITION[(POSITION["FIXED"] = 3)] = "FIXED"; 4179 POSITION[(POSITION["STICKY"] = 4)] = "STICKY"; 4180 })(POSITION || (POSITION = {})); 4181 var position = { 4182 name: "position", 4183 initialValue: "static", 4184 prefix: false, 4185 type: PropertyDescriptorParsingType.IDENT_VALUE, 4186 parse: function (position) { 4187 switch (position) { 4188 case "relative": 4189 return POSITION.RELATIVE; 4190 case "absolute": 4191 return POSITION.ABSOLUTE; 4192 case "fixed": 4193 return POSITION.FIXED; 4194 case "sticky": 4195 return POSITION.STICKY; 4196 } 4197 return POSITION.STATIC; 4198 }, 4199 }; 4200 4201 var textShadow = { 4202 name: "text-shadow", 4203 initialValue: "none", 4204 type: PropertyDescriptorParsingType.LIST, 4205 prefix: false, 4206 parse: function (tokens) { 4207 if (tokens.length === 1 && isIdentWithValue(tokens[0], "none")) { 4208 return []; 4209 } 4210 return parseFunctionArgs(tokens).map(function (values) { 4211 var shadow = { 4212 color: COLORS.TRANSPARENT, 4213 offsetX: ZERO_LENGTH, 4214 offsetY: ZERO_LENGTH, 4215 blur: ZERO_LENGTH, 4216 }; 4217 var c = 0; 4218 for (var i = 0; i < values.length; i++) { 4219 var token = values[i]; 4220 if (isLength(token)) { 4221 if (c === 0) { 4222 shadow.offsetX = token; 4223 } else if (c === 1) { 4224 shadow.offsetY = token; 4225 } else { 4226 shadow.blur = token; 4227 } 4228 c++; 4229 } else { 4230 shadow.color = color.parse(token); 4231 } 4232 } 4233 return shadow; 4234 }); 4235 }, 4236 }; 4237 4238 var TEXT_TRANSFORM; 4239 (function (TEXT_TRANSFORM) { 4240 TEXT_TRANSFORM[(TEXT_TRANSFORM["NONE"] = 0)] = "NONE"; 4241 TEXT_TRANSFORM[(TEXT_TRANSFORM["LOWERCASE"] = 1)] = "LOWERCASE"; 4242 TEXT_TRANSFORM[(TEXT_TRANSFORM["UPPERCASE"] = 2)] = "UPPERCASE"; 4243 TEXT_TRANSFORM[(TEXT_TRANSFORM["CAPITALIZE"] = 3)] = "CAPITALIZE"; 4244 })(TEXT_TRANSFORM || (TEXT_TRANSFORM = {})); 4245 var textTransform = { 4246 name: "text-transform", 4247 initialValue: "none", 4248 prefix: false, 4249 type: PropertyDescriptorParsingType.IDENT_VALUE, 4250 parse: function (textTransform) { 4251 switch (textTransform) { 4252 case "uppercase": 4253 return TEXT_TRANSFORM.UPPERCASE; 4254 case "lowercase": 4255 return TEXT_TRANSFORM.LOWERCASE; 4256 case "capitalize": 4257 return TEXT_TRANSFORM.CAPITALIZE; 4258 } 4259 return TEXT_TRANSFORM.NONE; 4260 }, 4261 }; 4262 4263 var transform = { 4264 name: "transform", 4265 initialValue: "none", 4266 prefix: true, 4267 type: PropertyDescriptorParsingType.VALUE, 4268 parse: function (token) { 4269 if (token.type === TokenType.IDENT_TOKEN && token.value === "none") { 4270 return null; 4271 } 4272 if (token.type === TokenType.FUNCTION) { 4273 var transformFunction = SUPPORTED_TRANSFORM_FUNCTIONS[token.name]; 4274 if (typeof transformFunction === "undefined") { 4275 throw new Error( 4276 'Attempting to parse an unsupported transform function "' + 4277 token.name + 4278 '"' 4279 ); 4280 } 4281 return transformFunction(token.values); 4282 } 4283 return null; 4284 }, 4285 }; 4286 var matrix = function (args) { 4287 var values = args 4288 .filter(function (arg) { 4289 return arg.type === TokenType.NUMBER_TOKEN; 4290 }) 4291 .map(function (arg) { 4292 return arg.number; 4293 }); 4294 return values.length === 6 ? values : null; 4295 }; 4296 // doesn't support 3D transforms at the moment 4297 var matrix3d = function (args) { 4298 var values = args 4299 .filter(function (arg) { 4300 return arg.type === TokenType.NUMBER_TOKEN; 4301 }) 4302 .map(function (arg) { 4303 return arg.number; 4304 }); 4305 var a1 = values[0], 4306 b1 = values[1], 4307 _a = values[2], 4308 _b = values[3], 4309 a2 = values[4], 4310 b2 = values[5], 4311 _c = values[6], 4312 _d = values[7], 4313 _e = values[8], 4314 _f = values[9], 4315 _g = values[10], 4316 _h = values[11], 4317 a4 = values[12], 4318 b4 = values[13], 4319 _j = values[14], 4320 _k = values[15]; 4321 return values.length === 16 ? [a1, b1, a2, b2, a4, b4] : null; 4322 }; 4323 var SUPPORTED_TRANSFORM_FUNCTIONS = { 4324 matrix: matrix, 4325 matrix3d: matrix3d, 4326 }; 4327 4328 var DEFAULT_VALUE = { 4329 type: TokenType.PERCENTAGE_TOKEN, 4330 number: 50, 4331 flags: FLAG_INTEGER, 4332 }; 4333 var DEFAULT = [DEFAULT_VALUE, DEFAULT_VALUE]; 4334 var transformOrigin = { 4335 name: "transform-origin", 4336 initialValue: "50% 50%", 4337 prefix: true, 4338 type: PropertyDescriptorParsingType.LIST, 4339 parse: function (tokens) { 4340 var origins = tokens.filter(isLengthPercentage); 4341 if (origins.length !== 2) { 4342 return DEFAULT; 4343 } 4344 return [origins[0], origins[1]]; 4345 }, 4346 }; 4347 4348 var VISIBILITY; 4349 (function (VISIBILITY) { 4350 VISIBILITY[(VISIBILITY["VISIBLE"] = 0)] = "VISIBLE"; 4351 VISIBILITY[(VISIBILITY["HIDDEN"] = 1)] = "HIDDEN"; 4352 VISIBILITY[(VISIBILITY["COLLAPSE"] = 2)] = "COLLAPSE"; 4353 })(VISIBILITY || (VISIBILITY = {})); 4354 var visibility = { 4355 name: "visible", 4356 initialValue: "none", 4357 prefix: false, 4358 type: PropertyDescriptorParsingType.IDENT_VALUE, 4359 parse: function (visibility) { 4360 switch (visibility) { 4361 case "hidden": 4362 return VISIBILITY.HIDDEN; 4363 case "collapse": 4364 return VISIBILITY.COLLAPSE; 4365 case "visible": 4366 default:
4367 return VISIBILITY.VISIBLE; 4368 } 4369 }, 4370 }; 4371 4372 var WORD_BREAK; 4373 (function (WORD_BREAK) { 4374 WORD_BREAK["NORMAL"] = "normal"; 4375 WORD_BREAK["BREAK_ALL"] = "break-all"; 4376 WORD_BREAK["KEEP_ALL"] = "keep-all"; 4377 })(WORD_BREAK || (WORD_BREAK = {})); 4378 var wordBreak = { 4379 name: "word-break", 4380 initialValue: "normal", 4381 prefix: false, 4382 type: PropertyDescriptorParsingType.IDENT_VALUE, 4383 parse: function (wordBreak) { 4384 switch (wordBreak) { 4385 case "break-all": 4386 return WORD_BREAK.BREAK_ALL; 4387 case "keep-all": 4388 return WORD_BREAK.KEEP_ALL; 4389 case "normal": 4390 default: 4391 return WORD_BREAK.NORMAL; 4392 } 4393 }, 4394 }; 4395 4396 var zIndex = { 4397 name: "z-index", 4398 initialValue: "auto", 4399 prefix: false, 4400 type: PropertyDescriptorParsingType.VALUE, 4401 parse: function (token) { 4402 if (token.type === TokenType.IDENT_TOKEN) { 4403 return { auto: true, order: 0 }; 4404 } 4405 if (isNumberToken(token)) { 4406 return { auto: false, order: token.number }; 4407 } 4408 throw new Error("Invalid z-index number parsed"); 4409 }, 4410 }; 4411 4412 var opacity = { 4413 name: "opacity", 4414 initialValue: "1", 4415 type: PropertyDescriptorParsingType.VALUE, 4416 prefix: false, 4417 parse: function (token) { 4418 if (isNumberToken(token)) { 4419 return token.number; 4420 } 4421 return 1; 4422 }, 4423 }; 4424 4425 var textDecorationColor = { 4426 name: "text-decoration-color", 4427 initialValue: "transparent", 4428 prefix: false, 4429 type: PropertyDescriptorParsingType.TYPE_VALUE, 4430 format: "color", 4431 }; 4432 4433 var textDecorationLine = { 4434 name: "text-decoration-line", 4435 initialValue: "none", 4436 prefix: false, 4437 type: PropertyDescriptorParsingType.LIST, 4438 parse: function (tokens) { 4439 return tokens 4440 .filter(isIdentToken) 4441 .map(function (token) { 4442 switch (token.value) { 4443 case "underline": 4444 return 1 /* UNDERLINE */; 4445 case "overline": 4446 return 2 /* OVERLINE */; 4447 case "line-through": 4448 return 3 /* LINE_THROUGH */; 4449 case "none": 4450 return 4 /* BLINK */; 4451 } 4452 return 0 /* NONE */; 4453 }) 4454 .filter(function (line) { 4455 return line !== 0 /* NONE */; 4456 }); 4457 }, 4458 }; 4459 4460 var fontFamily = { 4461 name: "font-family", 4462 initialValue: "", 4463 prefix: false, 4464 type: PropertyDescriptorParsingType.LIST, 4465 parse: function (tokens) { 4466 var accumulator = []; 4467 var results = []; 4468 tokens.forEach(function (token) { 4469 switch (token.type) { 4470 case TokenType.IDENT_TOKEN: 4471 case TokenType.STRING_TOKEN: 4472 accumulator.push(token.value); 4473 break; 4474 case TokenType.NUMBER_TOKEN: 4475 accumulator.push(token.number.toString()); 4476 break; 4477 case TokenType.COMMA_TOKEN: 4478 results.push(accumulator.join(" ")); 4479 accumulator.length = 0; 4480 break; 4481 } 4482 }); 4483 if (accumulator.length) { 4484 results.push(accumulator.join(" ")); 4485 } 4486 return results.map(function (result) { 4487 return result.indexOf(" ") === -1 ? result : "'" + result + "'"; 4488 }); 4489 }, 4490 }; 4491 4492 var fontSize = { 4493 name: "font-size", 4494 initialValue: "0", 4495 prefix: false, 4496 type: PropertyDescriptorParsingType.TYPE_VALUE, 4497 format: "length", 4498 }; 4499 4500 var fontWeight = { 4501 name: "font-weight", 4502 initialValue: "normal", 4503 type: PropertyDescriptorParsingType.VALUE, 4504 prefix: false, 4505 parse: function (token) { 4506 if (isNumberToken(token)) { 4507 return token.number; 4508 } 4509 if (isIdentToken(token)) { 4510 switch (token.value) { 4511 case "bold": 4512 return 700; 4513 case "normal": 4514 default: 4515 return 400; 4516 } 4517 } 4518 return 400; 4519 }, 4520 }; 4521 4522 var fontVariant = { 4523 name: "font-variant", 4524 initialValue: "none", 4525 type: PropertyDescriptorParsingType.LIST, 4526 prefix: false, 4527 parse: function (tokens) { 4528 return tokens.filter(isIdentToken).map(function (token) { 4529 return token.value; 4530 }); 4531 }, 4532 }; 4533 4534 var FONT_STYLE; 4535 (function (FONT_STYLE) { 4536 FONT_STYLE["NORMAL"] = "normal"; 4537 FONT_STYLE["ITALIC"] = "italic"; 4538 FONT_STYLE["OBLIQUE"] = "oblique"; 4539 })(FONT_STYLE || (FONT_STYLE = {})); 4540 var fontStyle = { 4541 name: "font-style",
4542 initialValue: "normal", 4543 prefix: false, 4544 type: PropertyDescriptorParsingType.IDENT_VALUE, 4545 parse: function (overflow) { 4546 switch (overflow) { 4547 case "oblique": 4548 return FONT_STYLE.OBLIQUE; 4549 case "italic": 4550 return FONT_STYLE.ITALIC; 4551 case "normal": 4552 default: 4553 return FONT_STYLE.NORMAL; 4554 } 4555 }, 4556 }; 4557 4558 var contains = function (bit, value) { 4559 return (bit & value) !== 0; 4560 }; 4561 4562 var content = { 4563 name: "content", 4564 initialValue: "none", 4565 type: PropertyDescriptorParsingType.LIST, 4566 prefix: false, 4567 parse: function (tokens) { 4568 if (tokens.length === 0) { 4569 return []; 4570 } 4571 var first = tokens[0]; 4572 if (first.type === TokenType.IDENT_TOKEN && first.value === "none") { 4573 return []; 4574 } 4575 return tokens; 4576 }, 4577 }; 4578 4579 var counterIncrement = { 4580 name: "counter-increment", 4581 initialValue: "none", 4582 prefix: true, 4583 type: PropertyDescriptorParsingType.LIST, 4584 parse: function (tokens) { 4585 if (tokens.length === 0) { 4586 return null; 4587 } 4588 var first = tokens[0]; 4589 if (first.type === TokenType.IDENT_TOKEN && first.value === "none") { 4590 return null; 4591 } 4592 var increments = []; 4593 var filtered = tokens.filter(nonWhiteSpace); 4594 for (var i = 0; i < filtered.length; i++) { 4595 var counter = filtered[i]; 4596 var next = filtered[i + 1]; 4597 if (counter.type === TokenType.IDENT_TOKEN) { 4598 var increment = next && isNumberToken(next) ? next.number : 1; 4599 increments.push({ counter: counter.value, increment: increment }); 4600 } 4601 } 4602 return increments; 4603 }, 4604 }; 4605 4606 var counterReset = { 4607 name: "counter-reset", 4608 initialValue: "none", 4609 prefix: true, 4610 type: PropertyDescriptorParsingType.LIST, 4611 parse: function (tokens) { 4612 if (tokens.length === 0) { 4613 return []; 4614 } 4615 var resets = []; 4616 var filtered = tokens.filter(nonWhiteSpace); 4617 for (var i = 0; i < filtered.length; i++) { 4618 var counter = filtered[i]; 4619 var next = filtered[i + 1]; 4620 if (isIdentToken(counter) && counter.value !== "none") { 4621 var reset = next && isNumberToken(next) ? next.number : 0; 4622 resets.push({ counter: counter.value, reset: reset }); 4623 } 4624 } 4625 return resets; 4626 }, 4627 }; 4628 4629 var quotes = { 4630 name: "quotes", 4631 initialValue: "none", 4632 prefix: true, 4633 type: PropertyDescriptorParsingType.LIST, 4634 parse: function (tokens) { 4635 if (tokens.length === 0) { 4636 return null; 4637 } 4638 var first = tokens[0]; 4639 if (first.type === TokenType.IDENT_TOKEN && first.value === "none") { 4640 return null; 4641 } 4642 var quotes = []; 4643 var filtered = tokens.filter(isStringToken); 4644 if (filtered.length % 2 !== 0) { 4645 return null; 4646 } 4647 for (var i = 0; i < filtered.length; i += 2) { 4648 var open_1 = filtered[i].value; 4649 var close_1 = filtered[i + 1].value; 4650 quotes.push({ open: open_1, close: close_1 }); 4651 } 4652 return quotes; 4653 }, 4654 }; 4655 var getQuote = function (quotes, depth, open) { 4656 if (!quotes) { 4657 return ""; 4658 } 4659 var quote = quotes[Math.min(depth, quotes.length - 1)]; 4660 if (!quote) { 4661 return ""; 4662 } 4663 return open ? quote.open : quote.close; 4664 }; 4665 4666 var boxShadow = { 4667 name: "box-shadow", 4668 initialValue: "none", 4669 type: PropertyDescriptorParsingType.LIST, 4670 prefix: false, 4671 parse: function (tokens) { 4672 if (tokens.length === 1 && isIdentWithValue(tokens[0], "none")) { 4673 return []; 4674 } 4675 return parseFunctionArgs(tokens).map(function (values) { 4676 var shadow = { 4677 color: 0x000000ff, 4678 offsetX: ZERO_LENGTH, 4679 offsetY: ZERO_LENGTH, 4680 blur: ZERO_LENGTH, 4681 spread: ZERO_LENGTH, 4682 inset: false, 4683 }; 4684 var c = 0; 4685 for (var i = 0; i < values.length; i++) { 4686 var token = values[i]; 4687 if (isIdentWithValue(token, "inset")) { 4688 shadow.inset = true; 4689 } else if (isLength(token)) { 4690 if (c === 0) { 4691 shadow.offsetX = token; 4692 } else if (c === 1) { 4693 shadow.offsetY = token; 4694 } else if (c === 2) { 4695 shadow.blur = token; 4696 } else { 4697 shadow.spread = token; 4698 } 4699 c++; 4700 } else { 4701 shadow.color = color.parse(token); 4702 } 4703 } 4704 return shadow; 4705 }); 4706 }, 4707 }; 4708 4709 var CSSParsedDeclaration = /** @class */ (function () { 4710 function CSSParsedDeclaration(declaration) { 4711 this.backgroundClip = parse(backgroundClip, declaration.backgroundClip); 4712 this.backgroundColor = parse( 4713 backgroundColor, 4714 declaration.backgroundColor 4715 ); 4716 this.backgroundImage = parse( 4717 backgroundImage, 4718 declaration.backgroundImage 4719 ); 4720 this.backgroundOrigin = parse( 4721 backgroundOrigin, 4722 declaration.backgroundOrigin 4723 ); 4724 this.backgroundPosition = parse( 4725 backgroundPosition, 4726 declaration.backgroundPosition 4727 ); 4728 this.backgroundRepeat = parse( 4729 backgroundRepeat, 4730 declaration.backgroundRepeat 4731 ); 4732 this.backgroundSize = parse(backgroundSize, declaration.backgroundSize); 4733 this.borderTopColor = parse(borderTopColor, declaration.borderTopColor); 4734 this.borderRightColor = parse( 4735 borderRightColor, 4736 declaration.borderRightColor 4737 ); 4738 this.borderBottomColor = parse( 4739 borderBottomColor, 4740 declaration.borderBottomColor 4741 ); 4742 this.borderLeftColor = parse( 4743 borderLeftColor, 4744 declaration.borderLeftColor 4745 ); 4746 this.borderTopLeftRadius = parse( 4747 borderTopLeftRadius, 4748 declaration.borderTopLeftRadius 4749 ); 4750 this.borderTopRightRadius = parse( 4751 borderTopRightRadius, 4752 declaration.borderTopRightRadius 4753 ); 4754 this.borderBottomRightRadius = parse( 4755 borderBottomRightRadius, 4756 declaration.borderBottomRightRadius 4757 ); 4758 this.borderBottomLeftRadius = parse( 4759 borderBottomLeftRadius, 4760 declaration.borderBottomLeftRadius 4761 ); 4762 this.borderTopStyle = parse(borderTopStyle, declaration.borderTopStyle); 4763 this.borderRightStyle = parse( 4764 borderRightStyle, 4765 declaration.borderRightStyle 4766 ); 4767 this.borderBottomStyle = parse( 4768 borderBottomStyle, 4769 declaration.borderBottomStyle 4770 ); 4771 this.borderLeftStyle = parse( 4772 borderLeftStyle, 4773 declaration.borderLeftStyle 4774 ); 4775 this.borderTopWidth = parse(borderTopWidth, declaration.borderTopWidth); 4776 this.borderRightWidth = parse( 4777 borderRightWidth, 4778 declaration.borderRightWidth 4779 ); 4780 this.borderBottomWidth = parse( 4781 borderBottomWidth, 4782 declaration.borderBottomWidth 4783 ); 4784 this.borderLeftWidth = parse( 4785 borderLeftWidth, 4786 declaration.borderLeftWidth 4787 ); 4788 this.boxShadow = parse(boxShadow, declaration.boxShadow); 4789 this.color = parse(color$1, declaration.color); 4790 this.display = parse(display, declaration.display); 4791 this.float = parse(float, declaration.cssFloat); 4792 this.fontFamily = parse(fontFamily, declaration.fontFamily); 4793 this.fontSize = parse(fontSize, declaration.fontSize); 4794 this.fontStyle = parse(fontStyle, declaration.fontStyle); 4795 this.fontVariant = parse(fontVariant, declaration.fontVariant); 4796 this.fontWeight = parse(fontWeight, declaration.fontWeight); 4797 this.letterSpacing = parse(letterSpacing, declaration.letterSpacing); 4798 this.lineBreak = parse(lineBreak, declaration.lineBreak); 4799 this.lineHeight = parse(lineHeight, declaration.lineHeight); 4800 this.listStyleImage = parse(listStyleImage, declaration.listStyleImage); 4801 this.listStylePosition = parse( 4802 listStylePosition, 4803 declaration.listStylePosition 4804 ); 4805 this.listStyleType = parse(listStyleType, declaration.listStyleType); 4806 this.marginTop = parse(marginTop, declaration.marginTop); 4807 this.marginRight = parse(marginRight, declaration.marginRight); 4808 this.marginBottom = parse(marginBottom, declaration.marginBottom); 4809 this.marginLeft = parse(marginLeft, declaration.marginLeft); 4810 this.opacity = parse(opacity, declaration.opacity); 4811 var overflowTuple = parse(overflow, declaration.overflow); 4812 this.overflowX = overflowTuple[0]; 4813 this.overflowY = overflowTuple[overflowTuple.length > 1 ? 1 : 0]; 4814 this.overflowWrap = parse(overflowWrap, declaration.overflowWrap); 4815 this.paddingTop = parse(paddingTop, declaration.paddingTop); 4816 this.paddingRight = parse(paddingRight, declaration.paddingRight); 4817 this.paddingBottom = parse(paddingBottom, declaration.paddingBottom); 4818 this.paddingLeft = parse(paddingLeft, declaration.paddingLeft); 4819 this.position = parse(position, declaration.position); 4820 this.textAlign = parse(textAlign, declaration.textAlign); 4821 this.textDecorationColor = parse( 4822 textDecorationColor, 4823 declaration.textDecorationColor || declaration.color 4824 ); 4825 this.textDecorationLine = parse( 4826 textDecorationLine, 4827 declaration.textDecorationLine 4828 ); 4829 this.textShadow = parse(textShadow, declaration.textShadow); 4830 this.textTransform = parse(textTransform, declaration.textTransform); 4831 this.transform = parse(transform, declaration.transform); 4832 this.transformOrigin = parse( 4833 transformOrigin, 4834 declaration.transformOrigin 4835 ); 4836 this.visibility = parse(visibility, declaration.visibility); 4837 this.wordBreak = parse(wordBreak, declaration.wordBreak); 4838 this.zIndex = parse(zIndex, declaration.zIndex); 4839 } 4840 CSSParsedDeclaration.prototype.isVisible = function () { 4841 return ( 4842 this.display > 0 && 4843 this.opacity > 0 &&
4844 this.visibility === VISIBILITY.VISIBLE 4845 ); 4846 }; 4847 CSSParsedDeclaration.prototype.isTransparent = function () { 4848 return isTransparent(this.backgroundColor); 4849 }; 4850 CSSParsedDeclaration.prototype.isTransformed = function () { 4851 return this.transform !== null; 4852 }; 4853 CSSParsedDeclaration.prototype.isPositioned = function () { 4854 return this.position !== POSITION.STATIC; 4855 }; 4856 CSSParsedDeclaration.prototype.isPositionedWithZIndex = function () { 4857 return this.isPositioned() && !this.zIndex.auto; 4858 }; 4859 CSSParsedDeclaration.prototype.isFloating = function () { 4860 return this.float !== FLOAT.NONE; 4861 }; 4862 CSSParsedDeclaration.prototype.isInlineLevel = function () { 4863 return ( 4864 contains(this.display, 4 /* INLINE */) || 4865 contains(this.display, 33554432 /* INLINE_BLOCK */) || 4866 contains(this.display, 268435456 /* INLINE_FLEX */) || 4867 contains(this.display, 536870912 /* INLINE_GRID */) || 4868 contains(this.display, 67108864 /* INLINE_LIST_ITEM */) || 4869 contains(this.display, 134217728 /* INLINE_TABLE */) 4870 ); 4871 }; 4872 return CSSParsedDeclaration; 4873 })(); 4874 var CSSParsedPseudoDeclaration = /** @class */ (function () { 4875 function CSSParsedPseudoDeclaration(declaration) { 4876 this.content = parse(content, declaration.content); 4877 this.quotes = parse(quotes, declaration.quotes); 4878 } 4879 return CSSParsedPseudoDeclaration; 4880 })(); 4881 var CSSParsedCounterDeclaration = /** @class */ (function () { 4882 function CSSParsedCounterDeclaration(declaration) { 4883 this.counterIncrement = parse( 4884 counterIncrement, 4885 declaration.counterIncrement 4886 ); 4887 this.counterReset = parse(counterReset, declaration.counterReset); 4888 } 4889 return CSSParsedCounterDeclaration; 4890 })(); 4891 // eslint-disable-next-line @typescript-eslint/no-explicit-any 4892 var parse = function (descriptor, style) { 4893 var tokenizer = new Tokenizer(); 4894 var value = 4895 style !== null && typeof style !== "undefined" 4896 ? style.toString() 4897 : descriptor.initialValue; 4898 tokenizer.write(value); 4899 var parser = new Parser(tokenizer.read()); 4900 switch (descriptor.type) { 4901 case PropertyDescriptorParsingType.IDENT_VALUE: 4902 var token = parser.parseComponentValue(); 4903 return descriptor.parse( 4904 isIdentToken(token) ? token.value : descriptor.initialValue 4905 ); 4906 case PropertyDescriptorParsingType.VALUE: 4907 return descriptor.parse(parser.parseComponentValue()); 4908 case PropertyDescriptorParsingType.LIST: 4909 return descriptor.parse(parser.parseComponentValues()); 4910 case PropertyDescriptorParsingType.TOKEN_VALUE: 4911 return parser.parseComponentValue(); 4912 case PropertyDescriptorParsingType.TYPE_VALUE: 4913 switch (descriptor.format) { 4914 case "angle": 4915 return angle.parse(parser.parseComponentValue()); 4916 case "color": 4917 return color.parse(parser.parseComponentValue()); 4918 case "image": 4919 return image.parse(parser.parseComponentValue()); 4920 case "length": 4921 var length_1 = parser.parseComponentValue(); 4922 return isLength(length_1) ? length_1 : ZERO_LENGTH; 4923 case "length-percentage": 4924 var value_1 = parser.parseComponentValue(); 4925 return isLengthPercentage(value_1) ? value_1 : ZERO_LENGTH; 4926 } 4927 } 4928 throw new Error( 4929 "Attempting to parse unsupported css format type " + descriptor.format 4930 ); 4931 }; 4932 4933 var ElementContainer = /** @class */ (function () { 4934 function ElementContainer(element) { 4935 this.styles = new CSSParsedDeclaration( 4936 window.getComputedStyle(element, null) 4937 ); 4938 this.textNodes = []; 4939 this.elements = []; 4940 if (this.styles.transform !== null && isHTMLElementNode(element)) { 4941 // getBoundingClientRect takes transforms into account 4942 element.style.transform = "none"; 4943 } 4944 this.bounds = parseBounds(element); 4945 this.flags = 0; 4946 } 4947 return ElementContainer; 4948 })();
4949 4950 var TextBounds = /** @class */ (function () { 4951 function TextBounds(text, bounds) { 4952 this.text = text; 4953 this.bounds = bounds; 4954 } 4955 return TextBounds; 4956 })(); 4957 var parseTextBounds = function (value, styles, node) { 4958 var textList = breakText(value, styles); 4959 var textBounds = []; 4960 var offset = 0; 4961 textList.forEach(function (text) { 4962 if (styles.textDecorationLine.length || text.trim().length > 0) { 4963 if (FEATURES.SUPPORT_RANGE_BOUNDS) { 4964 textBounds.push( 4965 new TextBounds(text, getRangeBounds(node, offset, text.length)) 4966 ); 4967 } else { 4968 var replacementNode = node.splitText(text.length); 4969 textBounds.push(new TextBounds(text, getWrapperBounds(node))); 4970 node = replacementNode; 4971 } 4972 } else if (!FEATURES.SUPPORT_RANGE_BOUNDS) { 4973 node = node.splitText(text.length); 4974 } 4975 offset += text.length; 4976 }); 4977 return textBounds; 4978 }; 4979 var getWrapperBounds = function (node) { 4980 var ownerDocument = node.ownerDocument; 4981 if (ownerDocument) { 4982 var wrapper = ownerDocument.createElement("html2canvaswrapper"); 4983 wrapper.appendChild(node.cloneNode(true)); 4984 var parentNode = node.parentNode; 4985 if (parentNode) { 4986 parentNode.replaceChild(wrapper, node); 4987 var bounds = parseBounds(wrapper); 4988 if (wrapper.firstChild) { 4989 parentNode.replaceChild(wrapper.firstChild, wrapper); 4990 } 4991 return bounds; 4992 } 4993 } 4994 return new Bounds(0, 0, 0, 0); 4995 }; 4996 var getRangeBounds = function (node, offset, length) { 4997 var ownerDocument = node.ownerDocument; 4998 if (!ownerDocument) { 4999 throw new Error("Node has no owner document"); 5000 } 5001 var range = ownerDocument.createRange(); 5002 range.setStart(node, offset); 5003 range.setEnd(node, offset + length); 5004 return Bounds.fromClientRect(range.getBoundingClientRect()); 5005 }; 5006 var breakText = function (value, styles) { 5007 return styles.letterSpacing !== 0 5008 ? toCodePoints(value).map(function (i) { 5009 return fromCodePoint(i); 5010 }) 5011 : breakWords(value, styles); 5012 }; 5013 var breakWords = function (str, styles) { 5014 var breaker = LineBreaker(str, { 5015 lineBreak: styles.lineBreak, 5016 wordBreak: 5017 styles.overflowWrap === OVERFLOW_WRAP.BREAK_WORD 5018 ? "break-word" 5019 : styles.wordBreak, 5020 }); 5021 var words = []; 5022 var bk; 5023 while (!(bk = breaker.next()).done) { 5024 if (bk.value) { 5025 words.push(bk.value.slice()); 5026 } 5027 } 5028 return words; 5029 }; 5030 5031 var TextContainer = /** @class */ (function () { 5032 function TextContainer(node, styles) { 5033 this.text = transform$1(node.data, styles.textTransform); 5034 this.textBounds = parseTextBounds(this.text, styles, node); 5035 } 5036 return TextContainer; 5037 })();
5038 var transform$1 = function (text, transform) { 5039 switch (transform) { 5040 case TEXT_TRANSFORM.LOWERCASE: 5041 return text.toLowerCase(); 5042 case TEXT_TRANSFORM.CAPITALIZE: 5043 return text.replace(CAPITALIZE, capitalize); 5044 case TEXT_TRANSFORM.UPPERCASE: 5045 return text.toUpperCase(); 5046 default: 5047 return text; 5048 } 5049 }; 5050 var CAPITALIZE = /(^|\s|:|-|\(|\))([a-z])/g; 5051 var capitalize = function (m, p1, p2) { 5052 if (m.length > 0) { 5053 return p1 + p2.toUpperCase(); 5054 } 5055 return m; 5056 }; 5057 5058 var ImageElementContainer = /** @class */ (function (_super) { 5059 __extends(ImageElementContainer, _super); 5060 function ImageElementContainer(img) { 5061 var _this = _super.call(this, img) || this; 5062 _this.src = img.currentSrc || img.src; 5063 _this.intrinsicWidth = img.naturalWidth; 5064 _this.intrinsicHeight = img.naturalHeight; 5065 CacheStorage.getInstance().addImage(_this.src); 5066 return _this; 5067 } 5068 return ImageElementContainer; 5069 })(ElementContainer); 5070 5071 var CanvasElementContainer = /** @class */ (function (_super) { 5072 __extends(CanvasElementContainer, _super); 5073 function CanvasElementContainer(canvas) { 5074 var _this = _super.call(this, canvas) || this; 5075 _this.canvas = canvas; 5076 _this.intrinsicWidth = canvas.width; 5077 _this.intrinsicHeight = canvas.height; 5078 return _this; 5079 } 5080 return CanvasElementContainer; 5081 })(ElementContainer); 5082 5083 var SVGElementContainer = /** @class */ (function (_super) { 5084 __extends(SVGElementContainer, _super); 5085 function SVGElementContainer(img) { 5086 var _this = _super.call(this, img) || this; 5087 var s = new XMLSerializer(); 5088 _this.svg = 5089 "data:image/svg+xml," + encodeURIComponent(s.serializeToString(img)); 5090 _this.intrinsicWidth = img.width.baseVal.value; 5091 _this.intrinsicHeight = img.height.baseVal.value; 5092 CacheStorage.getInstance().addImage(_this.svg); 5093 return _this; 5094 } 5095 return SVGElementContainer; 5096 })(ElementContainer); 5097 5098 var LIElementContainer = /** @class */ (function (_super) { 5099 __extends(LIElementContainer, _super); 5100 function LIElementContainer(element) { 5101 var _this = _super.call(this, element) || this; 5102 _this.value = element.value; 5103 return _this; 5104 } 5105 return LIElementContainer; 5106 })(ElementContainer); 5107 5108 var OLElementContainer = /** @class */ (function (_super) { 5109 __extends(OLElementContainer, _super); 5110 function OLElementContainer(element) { 5111 var _this = _super.call(this, element) || this; 5112 _this.start = element.start; 5113 _this.reversed = 5114 typeof element.reversed === "boolean" && element.reversed === true; 5115 return _this; 5116 } 5117 return OLElementContainer; 5118 })(ElementContainer); 5119 5120 var CHECKBOX_BORDER_RADIUS = [ 5121 { 5122 type: TokenType.DIMENSION_TOKEN, 5123 flags: 0, 5124 unit: "px", 5125 number: 3, 5126 }, 5127 ]; 5128 var RADIO_BORDER_RADIUS = [ 5129 { 5130 type: TokenType.PERCENTAGE_TOKEN, 5131 flags: 0, 5132 number: 50, 5133 }, 5134 ]; 5135 var reformatInputBounds = function (bounds) { 5136 if (bounds.width > bounds.height) { 5137 return new Bounds( 5138 bounds.left + (bounds.width - bounds.height) / 2, 5139 bounds.top, 5140 bounds.height, 5141 bounds.height 5142 ); 5143 } else if (bounds.width < bounds.height) { 5144 return new Bounds( 5145 bounds.left, 5146 bounds.top + (bounds.height - bounds.width) / 2, 5147 bounds.width, 5148 bounds.width 5149 ); 5150 } 5151 return bounds; 5152 }; 5153 var getInputValue = function (node) { 5154 var value = 5155 node.type === PASSWORD 5156 ? new Array(node.value.length + 1).join("\u2022") 5157 : node.value; 5158 return value.length === 0 ? node.placeholder || "" : value; 5159 }; 5160 var CHECKBOX = "checkbox"; 5161 var RADIO = "radio"; 5162 var PASSWORD = "password"; 5163 var INPUT_COLOR = 0x2a2a2aff; 5164 var InputElementContainer = /** @class */ (function (_super) { 5165 __extends(InputElementContainer, _super); 5166 function InputElementContainer(input) { 5167 var _this = _super.call(this, input) || this; 5168 _this.type = input.type.toLowerCase(); 5169 _this.checked = input.checked; 5170 _this.value = getInputValue(input); 5171 if (_this.type === CHECKBOX || _this.type === RADIO) { 5172 _this.styles.backgroundColor = 0xdededeff; 5173 _this.styles.borderTopColor = 5174 _this.styles.borderRightColor = 5175 _this.styles.borderBottomColor = 5176 _this.styles.borderLeftColor = 5177 0xa5a5a5ff; 5178 _this.styles.borderTopWidth = 5179 _this.styles.borderRightWidth = 5180 _this.styles.borderBottomWidth = 5181 _this.styles.borderLeftWidth = 5182 1; 5183 _this.styles.borderTopStyle = 5184 _this.styles.borderRightStyle = 5185 _this.styles.borderBottomStyle = 5186 _this.styles.borderLeftStyle = 5187 BORDER_STYLE.SOLID; 5188 _this.styles.backgroundClip = [BACKGROUND_CLIP.BORDER_BOX]; 5189 _this.styles.backgroundOrigin = [0 /* BORDER_BOX */]; 5190 _this.bounds = reformatInputBounds(_this.bounds); 5191 } 5192 switch (_this.type) { 5193 case CHECKBOX: 5194 _this.styles.borderTopRightRadius = 5195 _this.styles.borderTopLeftRadius = 5196 _this.styles.borderBottomRightRadius = 5197 _this.styles.borderBottomLeftRadius = 5198 CHECKBOX_BORDER_RADIUS; 5199 break; 5200 case RADIO: 5201 _this.styles.borderTopRightRadius = 5202 _this.styles.borderTopLeftRadius = 5203 _this.styles.borderBottomRightRadius = 5204 _this.styles.borderBottomLeftRadius = 5205 RADIO_BORDER_RADIUS; 5206 break; 5207 } 5208 return _this; 5209 } 5210 return InputElementContainer; 5211 })(ElementContainer); 5212 5213 var SelectElementContainer = /** @class */ (function (_super) { 5214 __extends(SelectElementContainer, _super); 5215 function SelectElementContainer(element) { 5216 var _this = _super.call(this, element) || this; 5217 var option = element.options[element.selectedIndex || 0]; 5218 _this.value = option ? option.text || "" : ""; 5219 return _this; 5220 } 5221 return SelectElementContainer; 5222 })(ElementContainer); 5223 5224 var TextareaElementContainer = /** @class */ (function (_super) { 5225 __extends(TextareaElementContainer, _super); 5226 function TextareaElementContainer(element) { 5227 var _this = _super.call(this, element) || this; 5228 _this.value = element.value; 5229 return _this; 5230 } 5231 return TextareaElementContainer; 5232 })(ElementContainer); 5233 5234 var parseColor = function (value) { 5235 return color.parse(Parser.create(value).parseComponentValue()); 5236 }; 5237 var IFrameElementContainer = /** @class */ (function (_super) { 5238 __extends(IFrameElementContainer, _super); 5239 function IFrameElementContainer(iframe) { 5240 var _this = _super.call(this, iframe) || this;
5241 _this.src = iframe.src; 5242 _this.width = parseInt(iframe.width, 10) || 0; 5243 _this.height = parseInt(iframe.height, 10) || 0; 5244 _this.backgroundColor = _this.styles.backgroundColor; 5245 try { 5246 if ( 5247 iframe.contentWindow && 5248 iframe.contentWindow.document && 5249 iframe.contentWindow.document.documentElement 5250 ) { 5251 _this.tree = parseTree(iframe.contentWindow.document.documentElement); 5252 // http://www.w3.org/TR/css3-background/#special-backgrounds 5253 var documentBackgroundColor = iframe.contentWindow.document 5254 .documentElement 5255 ? parseColor( 5256 getComputedStyle(iframe.contentWindow.document.documentElement) 5257 .backgroundColor 5258 ) 5259 : COLORS.TRANSPARENT; 5260 var bodyBackgroundColor = iframe.contentWindow.document.body 5261 ? parseColor( 5262 getComputedStyle(iframe.contentWindow.document.body) 5263 .backgroundColor 5264 ) 5265 : COLORS.TRANSPARENT; 5266 _this.backgroundColor = isTransparent(documentBackgroundColor) 5267 ? isTransparent(bodyBackgroundColor) 5268 ? _this.styles.backgroundColor 5269 : bodyBackgroundColor 5270 : documentBackgroundColor; 5271 } 5272 } catch (e) {} 5273 return _this; 5274 } 5275 return IFrameElementContainer; 5276 })(ElementContainer); 5277 5278 var LIST_OWNERS = ["OL", "UL", "MENU"]; 5279 var parseNodeTree = function (node, parent, root) { 5280 for ( 5281 var childNode = node.firstChild, nextNode = void 0; 5282 childNode; 5283 childNode = nextNode 5284 ) { 5285 nextNode = childNode.nextSibling; 5286 if (isTextNode(childNode) && childNode.data.trim().length > 0) { 5287 parent.textNodes.push(new TextContainer(childNode, parent.styles)); 5288 } else if (isElementNode(childNode)) { 5289 var container = createContainer(childNode); 5290 if (container.styles.isVisible()) { 5291 if (createsRealStackingContext(childNode, container, root)) { 5292 container.flags |= 4 /* CREATES_REAL_STACKING_CONTEXT */; 5293 } else if (createsStackingContext(container.styles)) { 5294 container.flags |= 2 /* CREATES_STACKING_CONTEXT */; 5295 } 5296 if (LIST_OWNERS.indexOf(childNode.tagName) !== -1) { 5297 container.flags |= 8 /* IS_LIST_OWNER */; 5298 } 5299 parent.elements.push(container); 5300 if ( 5301 !isTextareaElement(childNode) && 5302 !isSVGElement(childNode) && 5303 !isSelectElement(childNode) 5304 ) { 5305 parseNodeTree(childNode, container, root); 5306 } 5307 } 5308 } 5309 } 5310 }; 5311 var createContainer = function (element) { 5312 if (isImageElement(element)) { 5313 return new ImageElementContainer(element); 5314 } 5315 if (isCanvasElement(element)) { 5316 return new CanvasElementContainer(element); 5317 } 5318 if (isSVGElement(element)) { 5319 return new SVGElementContainer(element); 5320 } 5321 if (isLIElement(element)) { 5322 return new LIElementContainer(element); 5323 } 5324 if (isOLElement(element)) { 5325 return new OLElementContainer(element); 5326 } 5327 if (isInputElement(element)) { 5328 return new InputElementContainer(element); 5329 } 5330 if (isSelectElement(element)) { 5331 return new SelectElementContainer(element); 5332 } 5333 if (isTextareaElement(element)) { 5334 return new TextareaElementContainer(element); 5335 } 5336 if (isIFrameElement(element)) { 5337 return new IFrameElementContainer(element); 5338 } 5339 return new ElementContainer(element); 5340 }; 5341 var parseTree = function (element) { 5342 var container = createContainer(element); 5343 container.flags |= 4 /* CREATES_REAL_STACKING_CONTEXT */; 5344 parseNodeTree(element, container, container); 5345 return container; 5346 }; 5347 var createsRealStackingContext = function (node, container, root) { 5348 return ( 5349 container.styles.isPositionedWithZIndex() || 5350 container.styles.opacity < 1 || 5351 container.styles.isTransformed() ||
vendor: 8,487 bytes, lines 5352-5716
5352 (isBodyElement(node) && root.styles.isTransparent()) 5353 ); 5354 }; 5355 var createsStackingContext = function (styles) { 5356 return styles.isPositioned() || styles.isFloating(); 5357 }; 5358 var isTextNode = function (node) { 5359 return node.nodeType === Node.TEXT_NODE; 5360 }; 5361 var isElementNode = function (node) { 5362 return node.nodeType === Node.ELEMENT_NODE; 5363 }; 5364 var isHTMLElementNode = function (node) { 5365 return ( 5366 isElementNode(node) && 5367 typeof node.style !== "undefined" && 5368 !isSVGElementNode(node) 5369 ); 5370 }; 5371 var isSVGElementNode = function (element) { 5372 return typeof element.className === "object"; 5373 }; 5374 var isLIElement = function (node) { 5375 return node.tagName === "LI"; 5376 }; 5377 var isOLElement = function (node) { 5378 return node.tagName === "OL"; 5379 }; 5380 var isInputElement = function (node) { 5381 return node.tagName === "INPUT"; 5382 }; 5383 var isHTMLElement = function (node) { 5384 return node.tagName === "HTML"; 5385 }; 5386 var isSVGElement = function (node) { 5387 return node.tagName === "svg"; 5388 }; 5389 var isBodyElement = function (node) { 5390 return node.tagName === "BODY"; 5391 }; 5392 var isCanvasElement = function (node) { 5393 return node.tagName === "CANVAS"; 5394 }; 5395 var isImageElement = function (node) { 5396 return node.tagName === "IMG"; 5397 }; 5398 var isIFrameElement = function (node) { 5399 return node.tagName === "IFRAME"; 5400 }; 5401 var isStyleElement = function (node) { 5402 return node.tagName === "STYLE"; 5403 }; 5404 var isScriptElement = function (node) { 5405 return node.tagName === "SCRIPT"; 5406 }; 5407 var isTextareaElement = function (node) { 5408 return node.tagName === "TEXTAREA"; 5409 }; 5410 var isSelectElement = function (node) { 5411 return node.tagName === "SELECT"; 5412 }; 5413 5414 var CounterState = /** @class */ (function () { 5415 function CounterState() { 5416 this.counters = {}; 5417 } 5418 CounterState.prototype.getCounterValue = function (name) { 5419 var counter = this.counters[name]; 5420 if (counter && counter.length) { 5421 return counter[counter.length - 1]; 5422 } 5423 return 1; 5424 }; 5425 CounterState.prototype.getCounterValues = function (name) { 5426 var counter = this.counters[name]; 5427 return counter ? counter : []; 5428 }; 5429 CounterState.prototype.pop = function (counters) { 5430 var _this = this; 5431 counters.forEach(function (counter) { 5432 return _this.counters[counter].pop(); 5433 }); 5434 }; 5435 CounterState.prototype.parse = function (style) { 5436 var _this = this; 5437 var counterIncrement = style.counterIncrement; 5438 var counterReset = style.counterReset; 5439 var canReset = true; 5440 if (counterIncrement !== null) { 5441 counterIncrement.forEach(function (entry) { 5442 var counter = _this.counters[entry.counter]; 5443 if (counter && entry.increment !== 0) { 5444 canReset = false; 5445 counter[Math.max(0, counter.length - 1)] += entry.increment; 5446 } 5447 }); 5448 } 5449 var counterNames = []; 5450 if (canReset) { 5451 counterReset.forEach(function (entry) { 5452 var counter = _this.counters[entry.counter]; 5453 counterNames.push(entry.counter); 5454 if (!counter) { 5455 counter = _this.counters[entry.counter] = []; 5456 } 5457 counter.push(entry.reset); 5458 }); 5459 } 5460 return counterNames; 5461 }; 5462 return CounterState; 5463 })(); 5464 var ROMAN_UPPER = { 5465 integers: [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1], 5466 values: [ 5467 "M", 5468 "CM", 5469 "D", 5470 "CD", 5471 "C", 5472 "XC", 5473 "L", 5474 "XL", 5475 "X", 5476 "IX", 5477 "V", 5478 "IV", 5479 "I", 5480 ], 5481 }; 5482 var ARMENIAN = { 5483 integers: [ 5484 9000, 8000, 7000, 6000, 5000, 4000, 3000, 2000, 1000, 900, 800, 700, 600, 5485 500, 400, 300, 200, 100, 90, 80, 70, 60, 50, 40, 30, 20, 10, 9, 8, 7, 6, 5486 5, 4, 3, 2, 1, 5487 ], 5488 values: [ 5489 "Õ", 5490 "Õ", 5491 "Õ", 5492 "Õ", 5493 "Õ", 5494 "Õ", 5495 "Õ", 5496 "Õ", 5497 "Õ", 5498 "Õ", 5499 "Õ", 5500 "Õ", 5501 "Õ", 5502 "Õ", 5503 "Õ", 5504 "Õ ", 5505 "Õ", 5506 "Õ", 5507 "Õ", 5508 "Õ", 5509 "Õ", 5510 "Ô¿", 5511 "Ô¾", 5512 "Ô½", 5513 "Ô¼", 5514 "Ô»", 5515 "Ôº", 5516 "Ô¹", 5517 "Ô¸", 5518 "Ô·", 5519 "Ô¶", 5520 "Ôµ", 5521 "Ô´", 5522 "Ô³", 5523 "Ô²", 5524 "Ô±", 5525 ], 5526 }; 5527 var HEBREW = { 5528 integers: [ 5529 10000, 9000, 8000, 7000, 6000, 5000, 4000, 3000, 2000, 1000, 400, 300, 5530 200, 100, 90, 80, 70, 60, 50, 40, 30, 20, 19, 18, 17, 16, 15, 10, 9, 8, 7, 5531 6, 5, 4, 3, 2, 1, 5532 ], 5533 values: [ 5534 "×׳", 5535 "×׳", 5536 "×׳", 5537 "×׳", 5538 "×׳", 5539 "×׳", 5540 "×׳", 5541 "×׳", 5542 "×׳", 5543 "×׳", 5544 "ת", 5545 "ש", 5546 "ר", 5547 "ק", 5548 "צ", 5549 "פ", 5550 "×¢", 5551 "ס", 5552 "× ", 5553 "×", 5554 "×", 5555 "×", 5556 "××", 5557 "××", 5558 "××", 5559 "××", 5560 "××", 5561 "×", 5562 "×", 5563 "×", 5564 "×", 5565 "×", 5566 "×", 5567 "×", 5568 "×", 5569 "×", 5570 "×", 5571 ], 5572 }; 5573 var GEORGIAN = { 5574 integers: [ 5575 10000, 9000, 8000, 7000, 6000, 5000, 4000, 3000, 2000, 1000, 900, 800, 5576 700, 600, 500, 400, 300, 200, 100, 90, 80, 70, 60, 50, 40, 30, 20, 10, 9, 5577 8, 7, 6, 5, 4, 3, 2, 1, 5578 ], 5579 values: [ 5580 "áµ", 5581 "á°", 5582 "á¯", 5583 "á´", 5584 "á®", 5585 "á", 5586 "á¬", 5587 "á«", 5588 "áª", 5589 "á©", 5590 "á¨", 5591 "á§", 5592 "á¦", 5593 "á¥", 5594 "á¤", 5595 "á³", 5596 "á¢", 5597 "á¡", 5598 "á ", 5599 "á", 5600 "á", 5601 "á", 5602 "á²", 5603 "á", 5604 "á", 5605 "á", 5606 "á", 5607 "á", 5608 "á", 5609 "á±", 5610 "á", 5611 "á", 5612 "á", 5613 "á", 5614 "á", 5615 "á", 5616 "á", 5617 ], 5618 }; 5619 var createAdditiveCounter = function ( 5620 value, 5621 min, 5622 max, 5623 symbols, 5624 fallback, 5625 suffix 5626 ) { 5627 if (value < min || value > max) { 5628 return createCounterText(value, fallback, suffix.length > 0); 5629 } 5630 return ( 5631 symbols.integers.reduce(function (string, integer, index) { 5632 while (value >= integer) { 5633 value -= integer; 5634 string += symbols.values[index]; 5635 } 5636 return string; 5637 }, "") + suffix 5638 ); 5639 }; 5640 var createCounterStyleWithSymbolResolver = function ( 5641 value, 5642 codePointRangeLength, 5643 isNumeric, 5644 resolver 5645 ) { 5646 var string = ""; 5647 do { 5648 if (!isNumeric) { 5649 value--; 5650 } 5651 string = resolver(value) + string; 5652 value /= codePointRangeLength; 5653 } while (value * codePointRangeLength >= codePointRangeLength); 5654 return string; 5655 }; 5656 var createCounterStyleFromRange = function ( 5657 value, 5658 codePointRangeStart, 5659 codePointRangeEnd, 5660 isNumeric, 5661 suffix 5662 ) { 5663 var codePointRangeLength = codePointRangeEnd - codePointRangeStart + 1; 5664 return ( 5665 (value < 0 ? "-" : "") + 5666 (createCounterStyleWithSymbolResolver( 5667 Math.abs(value), 5668 codePointRangeLength, 5669 isNumeric, 5670 function (codePoint) { 5671 return fromCodePoint( 5672 Math.floor(codePoint % codePointRangeLength) + codePointRangeStart 5673 ); 5674 } 5675 ) + 5676 suffix) 5677 ); 5678 }; 5679 var createCounterStyleFromSymbols = function (value, symbols, suffix) { 5680 if (suffix === void 0) { 5681 suffix = ". "; 5682 } 5683 var codePointRangeLength = symbols.length; 5684 return ( 5685 createCounterStyleWithSymbolResolver( 5686 Math.abs(value), 5687 codePointRangeLength, 5688 false, 5689 function (codePoint) { 5690 return symbols[Math.floor(codePoint % codePointRangeLength)]; 5691 } 5692 ) + suffix 5693 ); 5694 }; 5695 var CJK_ZEROS = 1 << 0; 5696 var CJK_TEN_COEFFICIENTS = 1 << 1; 5697 var CJK_TEN_HIGH_COEFFICIENTS = 1 << 2; 5698 var CJK_HUNDRED_COEFFICIENTS = 1 << 3; 5699 var createCJKCounter = function ( 5700 value, 5701 numbers, 5702 multipliers, 5703 negativeSign, 5704 suffix, 5705 flags 5706 ) { 5707 if (value < -9999 || value > 9999) { 5708 return createCounterText( 5709 value, 5710 LIST_STYLE_TYPE.CJK_DECIMAL, 5711 suffix.length > 0 5712 ); 5713 } 5714 var tmp = Math.abs(value); 5715 var string = suffix; 5716 if (tmp === 0) {
5717 return numbers[0] + string; 5718 } 5719 for (var digit = 0; tmp > 0 && digit <= 4; digit++) { 5720 var coefficient = tmp % 10; 5721 if (coefficient === 0 && contains(flags, CJK_ZEROS) && string !== "") { 5722 string = numbers[coefficient] + string; 5723 } else if ( 5724 coefficient > 1 || 5725 (coefficient === 1 && digit === 0) || 5726 (coefficient === 1 && 5727 digit === 1 && 5728 contains(flags, CJK_TEN_COEFFICIENTS)) || 5729 (coefficient === 1 && 5730 digit === 1 && 5731 contains(flags, CJK_TEN_HIGH_COEFFICIENTS) && 5732 value > 100) || 5733 (coefficient === 1 && 5734 digit > 1 && 5735 contains(flags, CJK_HUNDRED_COEFFICIENTS)) 5736 ) { 5737 string = 5738 numbers[coefficient] + 5739 (digit > 0 ? multipliers[digit - 1] : "") + 5740 string; 5741 } else if (coefficient === 1 && digit > 0) { 5742 string = multipliers[digit - 1] + string; 5743 } 5744 tmp = Math.floor(tmp / 10); 5745 } 5746 return (value < 0 ? negativeSign : "") + string; 5747 }; 5748 var CHINESE_INFORMAL_MULTIPLIERS = "åç¾åè¬"; 5749 var CHINESE_FORMAL_MULTIPLIERS = "æ¾ä½°ä»è¬"; 5750 var JAPANESE_NEGATIVE = "ãã¤ãã¹"; 5751 var KOREAN_NEGATIVE = "ë§ì´ëì¤"; 5752 var createCounterText = function (value, type, appendSuffix) { 5753 var defaultSuffix = appendSuffix ? ". " : ""; 5754 var cjkSuffix = appendSuffix ? "ã" : ""; 5755 var koreanSuffix = appendSuffix ? ", " : ""; 5756 var spaceSuffix = appendSuffix ? " " : ""; 5757 switch (type) { 5758 case LIST_STYLE_TYPE.DISC: 5759 return "â¢" + spaceSuffix; 5760 case LIST_STYLE_TYPE.CIRCLE: 5761 return "â¦" + spaceSuffix; 5762 case LIST_STYLE_TYPE.SQUARE: 5763 return "â¾" + spaceSuffix; 5764 case LIST_STYLE_TYPE.DECIMAL_LEADING_ZERO: 5765 var string = createCounterStyleFromRange( 5766 value, 5767 48, 5768 57, 5769 true, 5770 defaultSuffix 5771 ); 5772 return string.length < 4 ? "0" + string : string; 5773 case LIST_STYLE_TYPE.CJK_DECIMAL: 5774 return createCounterStyleFromSymbols( 5775 value, 5776 "ãä¸äºä¸åäºå ä¸å «ä¹", 5777 cjkSuffix 5778 ); 5779 case LIST_STYLE_TYPE.LOWER_ROMAN: 5780 return createAdditiveCounter( 5781 value, 5782 1, 5783 3999, 5784 ROMAN_UPPER, 5785 LIST_STYLE_TYPE.DECIMAL, 5786 defaultSuffix 5787 ).toLowerCase(); 5788 case LIST_STYLE_TYPE.UPPER_ROMAN: 5789 return createAdditiveCounter( 5790 value, 5791 1, 5792 3999, 5793 ROMAN_UPPER, 5794 LIST_STYLE_TYPE.DECIMAL, 5795 defaultSuffix 5796 ); 5797 case LIST_STYLE_TYPE.LOWER_GREEK: 5798 return createCounterStyleFromRange( 5799 value, 5800 945, 5801 969, 5802 false, 5803 defaultSuffix 5804 ); 5805 case LIST_STYLE_TYPE.LOWER_ALPHA: 5806 return createCounterStyleFromRange( 5807 value, 5808 97, 5809 122, 5810 false, 5811 defaultSuffix 5812 ); 5813 case LIST_STYLE_TYPE.UPPER_ALPHA: 5814 return createCounterStyleFromRange(value, 65, 90, false, defaultSuffix); 5815 case LIST_STYLE_TYPE.ARABIC_INDIC: 5816 return createCounterStyleFromRange( 5817 value, 5818 1632, 5819 1641, 5820 true, 5821 defaultSuffix 5822 ); 5823 case LIST_STYLE_TYPE.ARMENIAN: 5824 case LIST_STYLE_TYPE.UPPER_ARMENIAN: 5825 return createAdditiveCounter( 5826 value, 5827 1, 5828 9999, 5829 ARMENIAN, 5830 LIST_STYLE_TYPE.DECIMAL, 5831 defaultSuffix 5832 ); 5833 case LIST_STYLE_TYPE.LOWER_ARMENIAN: 5834 return createAdditiveCounter( 5835 value, 5836 1, 5837 9999, 5838 ARMENIAN, 5839 LIST_STYLE_TYPE.DECIMAL, 5840 defaultSuffix 5841 ).toLowerCase(); 5842 case LIST_STYLE_TYPE.BENGALI: 5843 return createCounterStyleFromRange( 5844 value, 5845 2534, 5846 2543, 5847 true, 5848 defaultSuffix 5849 ); 5850 case LIST_STYLE_TYPE.CAMBODIAN: 5851 case LIST_STYLE_TYPE.KHMER: 5852 return createCounterStyleFromRange( 5853 value, 5854 6112, 5855 6121, 5856 true, 5857 defaultSuffix 5858 ); 5859 case LIST_STYLE_TYPE.CJK_EARTHLY_BRANCH: 5860 return createCounterStyleFromSymbols( 5861 value, 5862 "åä¸å¯ å¯è¾°å·³åæªç³é æ亥", 5863 cjkSuffix 5864 ); 5865 case LIST_STYLE_TYPE.CJK_HEAVENLY_STEM: 5866 return createCounterStyleFromSymbols( 5867 value, 5868 "ç²ä¹ä¸ä¸æå·±åºè¾å£¬ç¸", 5869 cjkSuffix 5870 ); 5871 case LIST_STYLE_TYPE.CJK_IDEOGRAPHIC: 5872 case LIST_STYLE_TYPE.TRAD_CHINESE_INFORMAL: 5873 return createCJKCounter( 5874 value, 5875 "é¶ä¸äºä¸åäºå ä¸å «ä¹", 5876 CHINESE_INFORMAL_MULTIPLIERS, 5877 "è² ", 5878 cjkSuffix, 5879 CJK_TEN_COEFFICIENTS | 5880 CJK_TEN_HIGH_COEFFICIENTS | 5881 CJK_HUNDRED_COEFFICIENTS 5882 ); 5883 case LIST_STYLE_TYPE.TRAD_CHINESE_FORMAL: 5884 return createCJKCounter( 5885 value, 5886 "é¶å£¹è²³åèä¼é¸ææç", 5887 CHINESE_FORMAL_MULTIPLIERS, 5888 "è² ", 5889 cjkSuffix, 5890 CJK_ZEROS | 5891 CJK_TEN_COEFFICIENTS | 5892 CJK_TEN_HIGH_COEFFICIENTS | 5893 CJK_HUNDRED_COEFFICIENTS 5894 ); 5895 case LIST_STYLE_TYPE.SIMP_CHINESE_INFORMAL: 5896 return createCJKCounter( 5897 value, 5898 "é¶ä¸äºä¸åäºå ä¸å «ä¹", 5899 CHINESE_INFORMAL_MULTIPLIERS, 5900 "è´", 5901 cjkSuffix, 5902 CJK_TEN_COEFFICIENTS | 5903 CJK_TEN_HIGH_COEFFICIENTS | 5904 CJK_HUNDRED_COEFFICIENTS 5905 ); 5906 case LIST_STYLE_TYPE.SIMP_CHINESE_FORMAL: 5907 return createCJKCounter( 5908 value, 5909 "é¶å£¹è´°åèä¼éææç", 5910 CHINESE_FORMAL_MULTIPLIERS, 5911 "è´", 5912 cjkSuffix, 5913 CJK_ZEROS | 5914 CJK_TEN_COEFFICIENTS | 5915 CJK_TEN_HIGH_COEFFICIENTS | 5916 CJK_HUNDRED_COEFFICIENTS 5917 ); 5918 case LIST_STYLE_TYPE.JAPANESE_INFORMAL: 5919 return createCJKCounter( 5920 value, 5921 "ãä¸äºä¸åäºå ä¸å «ä¹", 5922 "åç¾åä¸", 5923 JAPANESE_NEGATIVE, 5924 cjkSuffix, 5925 0 5926 ); 5927 case LIST_STYLE_TYPE.JAPANESE_FORMAL: 5928 return createCJKCounter( 5929 value, 5930 "é¶å£±å¼ååä¼å ä¸å «ä¹", 5931 "æ¾ç¾åä¸", 5932 JAPANESE_NEGATIVE, 5933 cjkSuffix, 5934 CJK_ZEROS | CJK_TEN_COEFFICIENTS | CJK_TEN_HIGH_COEFFICIENTS 5935 ); 5936 case LIST_STYLE_TYPE.KOREAN_HANGUL_FORMAL: 5937 return createCJKCounter( 5938 value, 5939 "ìì¼ì´ì¼ì¬ì¤ì¡ì¹ í구", 5940 "ìë°±ì²ë§", 5941 KOREAN_NEGATIVE, 5942 koreanSuffix, 5943 CJK_ZEROS | CJK_TEN_COEFFICIENTS | CJK_TEN_HIGH_COEFFICIENTS 5944 ); 5945 case LIST_STYLE_TYPE.KOREAN_HANJA_INFORMAL: 5946 return createCJKCounter( 5947 value, 5948 "é¶ä¸äºä¸åäºå ä¸å «ä¹", 5949 "åç¾åè¬", 5950 KOREAN_NEGATIVE, 5951 koreanSuffix, 5952 0 5953 ); 5954 case LIST_STYLE_TYPE.KOREAN_HANJA_FORMAL: 5955 return createCJKCounter( 5956 value, 5957 "é¶å£¹è²³ååäºå ä¸å «ä¹", 5958 "æ¾ç¾å", 5959 KOREAN_NEGATIVE, 5960 koreanSuffix, 5961 CJK_ZEROS | CJK_TEN_COEFFICIENTS | CJK_TEN_HIGH_COEFFICIENTS 5962 ); 5963 case LIST_STYLE_TYPE.DEVANAGARI: 5964 return createCounterStyleFromRange( 5965 value, 5966 0x966, 5967 0x96f, 5968 true, 5969 defaultSuffix 5970 ); 5971 case LIST_STYLE_TYPE.GEORGIAN: 5972 return createAdditiveCounter( 5973 value, 5974 1, 5975 19999, 5976 GEORGIAN, 5977 LIST_STYLE_TYPE.DECIMAL, 5978 defaultSuffix 5979 ); 5980 case LIST_STYLE_TYPE.GUJARATI: 5981 return createCounterStyleFromRange( 5982 value, 5983 0xae6, 5984 0xaef, 5985 true, 5986 defaultSuffix 5987 ); 5988 case LIST_STYLE_TYPE.GURMUKHI: 5989 return createCounterStyleFromRange( 5990 value, 5991 0xa66, 5992 0xa6f, 5993 true, 5994 defaultSuffix 5995 ); 5996 case LIST_STYLE_TYPE.HEBREW: 5997 return createAdditiveCounter( 5998 value, 5999 1, 6000 10999, 6001 HEBREW, 6002 LIST_STYLE_TYPE.DECIMAL, 6003 defaultSuffix 6004 ); 6005 case LIST_STYLE_TYPE.HIRAGANA: 6006 return createCounterStyleFromSymbols( 6007 value, 6008 "ããããããããããããããããã¡ã¤ã¦ã¨ãªã«ã¬ãã®ã¯ã²ãµã¸ã»ã¾ã¿ãããããããããããããããã" 6009 ); 6010 case LIST_STYLE_TYPE.HIRAGANA_IROHA: 6011 return createCounterStyleFromSymbols( 6012 value, 6013 "ããã¯ã«ã»ã¸ã¨ã¡ãã¬ããããããããã¤ããªããããã®ãããã¾ããµããã¦ãããããã¿ããã²ããã" 6014 ); 6015 case LIST_STYLE_TYPE.KANNADA: 6016 return createCounterStyleFromRange( 6017 value, 6018 0xce6, 6019 0xcef, 6020 true, 6021 defaultSuffix 6022 );
6023 case LIST_STYLE_TYPE.KATAKANA: 6024 return createCounterStyleFromSymbols( 6025 value, 6026 "ã¢ã¤ã¦ã¨ãªã«ãã¯ã±ã³ãµã·ã¹ã»ã½ã¿ããããããããããããããããã ã¡ã¢ã¤ã¦ã¨ã©ãªã«ã¬ãã¯ã°ã±ã²ã³", 6027 cjkSuffix 6028 ); 6029 case LIST_STYLE_TYPE.KATAKANA_IROHA: 6030 return createCounterStyleFromSymbols( 6031 value, 6032 "ã¤ããããããããªãã«ã²ã¯ã«ã¨ã¿ã¬ã½ãããã©ã ã¦ã°ããªã¯ã¤ãã±ãã³ã¨ãã¢ãµãã¦ã¡ãã·ã±ãã¢ã»ã¹", 6033 cjkSuffix 6034 ); 6035 case LIST_STYLE_TYPE.LAO: 6036 return createCounterStyleFromRange( 6037 value, 6038 0xed0, 6039 0xed9, 6040 true, 6041 defaultSuffix 6042 ); 6043 case LIST_STYLE_TYPE.MONGOLIAN: 6044 return createCounterStyleFromRange( 6045 value, 6046 0x1810, 6047 0x1819, 6048 true, 6049 defaultSuffix 6050 ); 6051 case LIST_STYLE_TYPE.MYANMAR: 6052 return createCounterStyleFromRange( 6053 value, 6054 0x1040, 6055 0x1049, 6056 true, 6057 defaultSuffix 6058 ); 6059 case LIST_STYLE_TYPE.ORIYA: 6060 return createCounterStyleFromRange( 6061 value, 6062 0xb66, 6063 0xb6f, 6064 true, 6065 defaultSuffix 6066 ); 6067 case LIST_STYLE_TYPE.PERSIAN: 6068 return createCounterStyleFromRange( 6069 value, 6070 0x6f0, 6071 0x6f9, 6072 true, 6073 defaultSuffix 6074 ); 6075 case LIST_STYLE_TYPE.TAMIL: 6076 return createCounterStyleFromRange( 6077 value, 6078 0xbe6, 6079 0xbef, 6080 true, 6081 defaultSuffix 6082 ); 6083 case LIST_STYLE_TYPE.TELUGU: 6084 return createCounterStyleFromRange( 6085 value, 6086 0xc66, 6087 0xc6f, 6088 true, 6089 defaultSuffix 6090 ); 6091 case LIST_STYLE_TYPE.THAI: 6092 return createCounterStyleFromRange( 6093 value, 6094 0xe50, 6095 0xe59, 6096 true, 6097 defaultSuffix 6098 ); 6099 case LIST_STYLE_TYPE.TIBETAN: 6100 return createCounterStyleFromRange( 6101 value, 6102 0xf20, 6103 0xf29, 6104 true, 6105 defaultSuffix 6106 ); 6107 case LIST_STYLE_TYPE.DECIMAL: 6108 default: 6109 return createCounterStyleFromRange(value, 48, 57, true, defaultSuffix); 6110 } 6111 }; 6112 6113 var IGNORE_ATTRIBUTE = "data-html2canvas-ignore"; 6114 var DocumentCloner = /** @class */ (function () { 6115 function DocumentCloner(element, options) { 6116 this.options = options; 6117 this.scrolledElements = []; 6118 this.referenceElement = element; 6119 this.counters = new CounterState(); 6120 this.quoteDepth = 0; 6121 if (!element.ownerDocument) { 6122 throw new Error("Cloned element does not have an owner document"); 6123 } 6124 this.documentElement = this.cloneNode( 6125 element.ownerDocument.documentElement 6126 ); 6127 } 6128 DocumentCloner.prototype.toIFrame = function (ownerDocument, windowSize) { 6129 var _this = this; 6130 var iframe = createIFrameContainer(ownerDocument, windowSize); 6131 if (!iframe.contentWindow) { 6132 return Promise.reject("Unable to find iframe window"); 6133 } 6134 var scrollX = ownerDocument.defaultView.pageXOffset; 6135 var scrollY = ownerDocument.defaultView.pageYOffset; 6136 var cloneWindow = iframe.contentWindow; 6137 var documentClone = cloneWindow.document; 6138 /* Chrome doesn't detect relative background-images assigned in inline <style> sheets when fetched through getComputedStyle 6139 if window url is about:blank, we can assign the url to current by writing onto the document 6140 */ 6141 var iframeLoad = iframeLoader(iframe).then(function () { 6142 return __awaiter(_this, void 0, void 0, function () { 6143 var onclone; 6144 return __generator(this, function (_a) { 6145 switch (_a.label) { 6146 case 0: 6147 this.scrolledElements.forEach(restoreNodeScroll); 6148 if (cloneWindow) { 6149 cloneWindow.scrollTo(windowSize.left, windowSize.top); 6150 if ( 6151 /(iPad|iPhone|iPod)/g.test(navigator.userAgent) && 6152 (cloneWindow.scrollY !== windowSize.top || 6153 cloneWindow.scrollX !== windowSize.left) 6154 ) { 6155 documentClone.documentElement.style.top = 6156 -windowSize.top + "px"; 6157 documentClone.documentElement.style.left = 6158 -windowSize.left + "px"; 6159 documentClone.documentElement.style.position = "absolute"; 6160 } 6161 } 6162 onclone = this.options.onclone; 6163 if (typeof this.clonedReferenceElement === "undefined") { 6164 return [ 6165 2 /*return*/, 6166 Promise.reject( 6167 "Error finding the " + 6168 this.referenceElement.nodeName + 6169 " in the cloned document" 6170 ), 6171 ]; 6172 } 6173 if (!(documentClone.fonts && documentClone.fonts.ready)) 6174 return [3 /*break*/, 2]; 6175 return [4 /*yield*/, documentClone.fonts.ready]; 6176 case 1: 6177 _a.sent(); 6178 _a.label = 2; 6179 case 2: 6180 if (typeof onclone === "function") { 6181 return [ 6182 2 /*return*/, 6183 Promise.resolve() 6184 .then(function () { 6185 return onclone(documentClone); 6186 }) 6187 .then(function () { 6188 return iframe; 6189 }), 6190 ]; 6191 } 6192 return [2 /*return*/, iframe]; 6193 } 6194 }); 6195 }); 6196 }); 6197 documentClone.open(); 6198 documentClone.write(serializeDoctype(document.doctype) + "<html></html>"); 6199 // Chrome scrolls the parent document for some reason after the write to the cloned window??? 6200 restoreOwnerScroll(this.referenceElement.ownerDocument, scrollX, scrollY); 6201 documentClone.replaceChild( 6202 documentClone.adoptNode(this.documentElement), 6203 documentClone.documentElement 6204 ); 6205 documentClone.close(); 6206 return iframeLoad; 6207 }; 6208 DocumentCloner.prototype.createElementClone = function (node) { 6209 if (isCanvasElement(node)) { 6210 return this.createCanvasClone(node); 6211 } 6212 /* 6213 if (isIFrameElement(node)) { 6214 return this.createIFrameClone(node); 6215 } 6216 */ 6217 if (isStyleElement(node)) { 6218 return this.createStyleClone(node); 6219 } 6220 var clone = node.cloneNode(false); 6221 // @ts-ignore 6222 if (isImageElement(clone) && clone.loading === "lazy") { 6223 // @ts-ignore 6224 clone.loading = "eager"; 6225 } 6226 return clone; 6227 }; 6228 DocumentCloner.prototype.createStyleClone = function (node) {
vendor: 7,651 bytes, lines 6229-6418
6229 try { 6230 var sheet = node.sheet; 6231 if (sheet && sheet.cssRules) { 6232 var css = [].slice 6233 .call(sheet.cssRules, 0) 6234 .reduce(function (css, rule) { 6235 if (rule && typeof rule.cssText === "string") { 6236 return css + rule.cssText; 6237 } 6238 return css; 6239 }, ""); 6240 var style = node.cloneNode(false); 6241 style.textContent = css; 6242 return style; 6243 } 6244 } catch (e) { 6245 // accessing node.sheet.cssRules throws a DOMException 6246 Logger.getInstance(this.options.id).error( 6247 "Unable to access cssRules property", 6248 e 6249 ); 6250 if (e.name !== "SecurityError") { 6251 throw e; 6252 } 6253 } 6254 return node.cloneNode(false); 6255 }; 6256 DocumentCloner.prototype.createCanvasClone = function (canvas) { 6257 if (this.options.inlineImages && canvas.ownerDocument) { 6258 var img = canvas.ownerDocument.createElement("img"); 6259 try { 6260 img.src = canvas.toDataURL(); 6261 return img; 6262 } catch (e) { 6263 Logger.getInstance(this.options.id).info( 6264 "Unable to clone canvas contents, canvas is tainted" 6265 ); 6266 } 6267 } 6268 var clonedCanvas = canvas.cloneNode(false); 6269 try { 6270 clonedCanvas.width = canvas.width; 6271 clonedCanvas.height = canvas.height; 6272 var ctx = canvas.getContext("2d"); 6273 var clonedCtx = clonedCanvas.getContext("2d"); 6274 if (clonedCtx) { 6275 if (ctx) { 6276 clonedCtx.putImageData( 6277 ctx.getImageData(0, 0, canvas.width, canvas.height), 6278 0, 6279 0 6280 ); 6281 } else { 6282 clonedCtx.drawImage(canvas, 0, 0); 6283 } 6284 } 6285 return clonedCanvas; 6286 } catch (e) {} 6287 return clonedCanvas; 6288 }; 6289 /* 6290 createIFrameClone(iframe: HTMLIFrameElement) { 6291 const tempIframe = <HTMLIFrameElement>iframe.cloneNode(false); 6292 const iframeKey = generateIframeKey(); 6293 tempIframe.setAttribute('data-html2canvas-internal-iframe-key', iframeKey); 6294 6295 const {width, height} = parseBounds(iframe); 6296 6297 this.resourceLoader.cache[iframeKey] = getIframeDocumentElement(iframe, this.options) 6298 .then(documentElement => { 6299 return this.renderer( 6300 documentElement, 6301 { 6302 allowTaint: this.options.allowTaint, 6303 backgroundColor: '#ffffff', 6304 canvas: null, 6305 imageTimeout: this.options.imageTimeout, 6306 logging: this.options.logging, 6307 proxy: this.options.proxy, 6308 removeContainer: this.options.removeContainer, 6309 scale: this.options.scale, 6310 foreignObjectRendering: this.options.foreignObjectRendering, 6311 useCORS: this.options.useCORS, 6312 target: new CanvasRenderer(), 6313 width, 6314 height, 6315 x: 0, 6316 y: 0, 6317 windowWidth: documentElement.ownerDocument.defaultView.innerWidth, 6318 windowHeight: documentElement.ownerDocument.defaultView.innerHeight, 6319 scrollX: documentElement.ownerDocument.defaultView.pageXOffset, 6320 scrollY: documentElement.ownerDocument.defaultView.pageYOffset 6321 }, 6322 ); 6323 }) 6324 .then( 6325 (canvas: HTMLCanvasElement) => 6326 new Promise((resolve, reject) => { 6327 const iframeCanvas = document.createElement('img'); 6328 iframeCanvas.onload = () => resolve(canvas); 6329 iframeCanvas.onerror = (event) => { 6330 // Empty iframes may result in empty "data:," URLs, which are invalid from the <img>'s point of view 6331 // and instead of `onload` cause `onerror` and unhandled rejection warnings 6332 // https://github.com/niklasvh/html2canvas/issues/1502 6333 iframeCanvas.src == 'data:,' ? resolve(canvas) : reject(event); 6334 }; 6335 iframeCanvas.src = canvas.toDataURL(); 6336 if (tempIframe.parentNode && iframe.ownerDocument && iframe.ownerDocument.defaultView) { 6337 tempIframe.parentNode.replaceChild( 6338 copyCSSStyles( 6339 iframe.ownerDocument.defaultView.getComputedStyle(iframe), 6340 iframeCanvas 6341 ), 6342 tempIframe 6343 ); 6344 } 6345 }) 6346 ); 6347 return tempIframe; 6348 } 6349 */ 6350 DocumentCloner.prototype.cloneNode = function (node) { 6351 if (isTextNode(node)) { 6352 return document.createTextNode(node.data); 6353 } 6354 if (!node.ownerDocument) { 6355 return node.cloneNode(false); 6356 } 6357 var window = node.ownerDocument.defaultView; 6358 if ( 6359 window && 6360 isElementNode(node) && 6361 (isHTMLElementNode(node) || isSVGElementNode(node)) 6362 ) { 6363 var clone = this.createElementClone(node); 6364 var style = window.getComputedStyle(node); 6365 var styleBefore = window.getComputedStyle(node, ":before"); 6366 var styleAfter = window.getComputedStyle(node, ":after"); 6367 if (this.referenceElement === node && isHTMLElementNode(clone)) { 6368 this.clonedReferenceElement = clone; 6369 } 6370 if (isBodyElement(clone)) { 6371 createPseudoHideStyles(clone); 6372 } 6373 var counters = this.counters.parse( 6374 new CSSParsedCounterDeclaration(style) 6375 ); 6376 var before = this.resolvePseudoContent( 6377 node, 6378 clone, 6379 styleBefore, 6380 PseudoElementType.BEFORE 6381 ); 6382 for (var child = node.firstChild; child; child = child.nextSibling) { 6383 if ( 6384 !isElementNode(child) || 6385 (!isScriptElement(child) && 6386 !child.hasAttribute(IGNORE_ATTRIBUTE) && 6387 (typeof this.options.ignoreElements !== "function" || 6388 !this.options.ignoreElements(child))) 6389 ) { 6390 if ( 6391 !this.options.copyStyles || 6392 !isElementNode(child) || 6393 !isStyleElement(child) 6394 ) { 6395 clone.appendChild(this.cloneNode(child)); 6396 } 6397 } 6398 } 6399 if (before) { 6400 clone.insertBefore(before, clone.firstChild); 6401 } 6402 var after = this.resolvePseudoContent( 6403 node, 6404 clone, 6405 styleAfter, 6406 PseudoElementType.AFTER 6407 ); 6408 if (after) { 6409 clone.appendChild(after); 6410 } 6411 this.counters.pop(counters); 6412 if ( 6413 style && 6414 (this.options.copyStyles || isSVGElementNode(node)) && 6415 !isIFrameElement(node) 6416 ) { 6417 copyCSSStyles(style, clone); 6418 }
6419 //this.inlineAllImages(clone); 6420 if (node.scrollTop !== 0 || node.scrollLeft !== 0) { 6421 this.scrolledElements.push([clone, node.scrollLeft, node.scrollTop]); 6422 } 6423 if ( 6424 (isTextareaElement(node) || isSelectElement(node)) && 6425 (isTextareaElement(clone) || isSelectElement(clone)) 6426 ) { 6427 clone.value = node.value; 6428 } 6429 return clone; 6430 } 6431 return node.cloneNode(false); 6432 }; 6433 DocumentCloner.prototype.resolvePseudoContent = function ( 6434 node, 6435 clone, 6436 style, 6437 pseudoElt 6438 ) { 6439 var _this = this; 6440 if (!style) { 6441 return; 6442 } 6443 var value = style.content; 6444 var document = clone.ownerDocument; 6445 if ( 6446 !document || 6447 !value || 6448 value === "none" || 6449 value === "-moz-alt-content" || 6450 style.display === "none" 6451 ) { 6452 return; 6453 } 6454 this.counters.parse(new CSSParsedCounterDeclaration(style)); 6455 var declaration = new CSSParsedPseudoDeclaration(style); 6456 var anonymousReplacedElement = document.createElement( 6457 "html2canvaspseudoelement" 6458 ); 6459 copyCSSStyles(style, anonymousReplacedElement); 6460 declaration.content.forEach(function (token) { 6461 if (token.type === TokenType.STRING_TOKEN) { 6462 anonymousReplacedElement.appendChild( 6463 document.createTextNode(token.value) 6464 ); 6465 } else if (token.type === TokenType.URL_TOKEN) { 6466 var img = document.createElement("img"); 6467 img.src = token.value; 6468 img.style.opacity = "1"; 6469 anonymousReplacedElement.appendChild(img); 6470 } else if (token.type === TokenType.FUNCTION) { 6471 if (token.name === "attr") { 6472 var attr = token.values.filter(isIdentToken); 6473 if (attr.length) { 6474 anonymousReplacedElement.appendChild( 6475 document.createTextNode(node.getAttribute(attr[0].value) || "") 6476 ); 6477 } 6478 } else if (token.name === "counter") { 6479 var _a = token.values.filter(nonFunctionArgSeparator), 6480 counter = _a[0], 6481 counterStyle = _a[1]; 6482 if (counter && isIdentToken(counter)) { 6483 var counterState = _this.counters.getCounterValue(counter.value); 6484 var counterType = 6485 counterStyle && isIdentToken(counterStyle) 6486 ? listStyleType.parse(counterStyle.value) 6487 : LIST_STYLE_TYPE.DECIMAL; 6488 anonymousReplacedElement.appendChild( 6489 document.createTextNode( 6490 createCounterText(counterState, counterType, false) 6491 ) 6492 ); 6493 } 6494 } else if (token.name === "counters") { 6495 var _b = token.values.filter(nonFunctionArgSeparator), 6496 counter = _b[0], 6497 delim = _b[1], 6498 counterStyle = _b[2]; 6499 if (counter && isIdentToken(counter)) { 6500 var counterStates = _this.counters.getCounterValues( 6501 counter.value 6502 ); 6503 var counterType_1 = 6504 counterStyle && isIdentToken(counterStyle) 6505 ? listStyleType.parse(counterStyle.value) 6506 : LIST_STYLE_TYPE.DECIMAL; 6507 var separator = 6508 delim && delim.type === TokenType.STRING_TOKEN 6509 ? delim.value 6510 : ""; 6511 var text = counterStates 6512 .map(function (value) { 6513 return createCounterText(value, counterType_1, false); 6514 }) 6515 .join(separator); 6516 anonymousReplacedElement.appendChild( 6517 document.createTextNode(text) 6518 ); 6519 } 6520 } 6521 } else if (token.type === TokenType.IDENT_TOKEN) { 6522 switch (token.value) { 6523 case "open-quote": 6524 anonymousReplacedElement.appendChild( 6525 document.createTextNode( 6526 getQuote(declaration.quotes, _this.quoteDepth++, true) 6527 ) 6528 ); 6529 break; 6530 case "close-quote": 6531 anonymousReplacedElement.appendChild( 6532 document.createTextNode( 6533 getQuote(declaration.quotes, --_this.quoteDepth, false) 6534 ) 6535 ); 6536 break; 6537 default: 6538 // safari doesn't parse string tokens correctly because of lack of quotes 6539 anonymousReplacedElement.appendChild( 6540 document.createTextNode(token.value) 6541 ); 6542 } 6543 } 6544 }); 6545 anonymousReplacedElement.className = 6546 PSEUDO_HIDE_ELEMENT_CLASS_BEFORE + 6547 " " + 6548 PSEUDO_HIDE_ELEMENT_CLASS_AFTER; 6549 var newClassName = 6550 pseudoElt === PseudoElementType.BEFORE 6551 ? " " + PSEUDO_HIDE_ELEMENT_CLASS_BEFORE 6552 : " " + PSEUDO_HIDE_ELEMENT_CLASS_AFTER; 6553 if (isSVGElementNode(clone)) { 6554 clone.className.baseValue += newClassName; 6555 } else { 6556 clone.className += newClassName; 6557 } 6558 return anonymousReplacedElement; 6559 }; 6560 DocumentCloner.destroy = function (container) { 6561 if (container.parentNode) { 6562 container.parentNode.removeChild(container); 6563 return true; 6564 } 6565 return false; 6566 }; 6567 return DocumentCloner; 6568 })();
vendor: 4,298 bytes, lines 6569-6694
6569 var PseudoElementType; 6570 (function (PseudoElementType) { 6571 PseudoElementType[(PseudoElementType["BEFORE"] = 0)] = "BEFORE"; 6572 PseudoElementType[(PseudoElementType["AFTER"] = 1)] = "AFTER"; 6573 })(PseudoElementType || (PseudoElementType = {})); 6574 var createIFrameContainer = function (ownerDocument, bounds) { 6575 var cloneIframeContainer = ownerDocument.createElement("iframe"); 6576 cloneIframeContainer.className = "html2canvas-container"; 6577 cloneIframeContainer.style.visibility = "hidden"; 6578 cloneIframeContainer.style.position = "fixed"; 6579 cloneIframeContainer.style.left = "-10000px"; 6580 cloneIframeContainer.style.top = "0px"; 6581 cloneIframeContainer.style.border = "0"; 6582 cloneIframeContainer.width = bounds.width.toString(); 6583 cloneIframeContainer.height = bounds.height.toString(); 6584 cloneIframeContainer.scrolling = "no"; // ios won't scroll without it 6585 cloneIframeContainer.setAttribute(IGNORE_ATTRIBUTE, "true"); 6586 ownerDocument.body.appendChild(cloneIframeContainer); 6587 return cloneIframeContainer; 6588 }; 6589 var iframeLoader = function (iframe) { 6590 return new Promise(function (resolve, reject) { 6591 var cloneWindow = iframe.contentWindow; 6592 if (!cloneWindow) { 6593 return reject("No window assigned for iframe"); 6594 } 6595 var documentClone = cloneWindow.document; 6596 cloneWindow.onload = 6597 iframe.onload = 6598 documentClone.onreadystatechange = 6599 function () { 6600 cloneWindow.onload = 6601 iframe.onload = 6602 documentClone.onreadystatechange = 6603 null; 6604 var interval = setInterval(function () { 6605 if ( 6606 documentClone.body.childNodes.length > 0 && 6607 documentClone.readyState === "complete" 6608 ) { 6609 clearInterval(interval); 6610 resolve(iframe); 6611 } 6612 }, 50); 6613 }; 6614 }); 6615 }; 6616 var copyCSSStyles = function (style, target) { 6617 // Edge does not provide value for cssText 6618 for (var i = style.length - 1; i >= 0; i--) { 6619 var property = style.item(i); 6620 // Safari shows pseudoelements if content is set 6621 if (property !== "content") { 6622 target.style.setProperty(property, style.getPropertyValue(property)); 6623 } 6624 } 6625 return target; 6626 }; 6627 var serializeDoctype = function (doctype) { 6628 var str = ""; 6629 if (doctype) { 6630 str += "<!DOCTYPE "; 6631 if (doctype.name) { 6632 str += doctype.name; 6633 } 6634 if (doctype.internalSubset) { 6635 str += doctype.internalSubset; 6636 } 6637 if (doctype.publicId) { 6638 str += '"' + doctype.publicId + '"'; 6639 } 6640 if (doctype.systemId) { 6641 str += '"' + doctype.systemId + '"'; 6642 } 6643 str += ">"; 6644 } 6645 return str; 6646 }; 6647 var restoreOwnerScroll = function (ownerDocument, x, y) { 6648 if ( 6649 ownerDocument && 6650 ownerDocument.defaultView && 6651 (x !== ownerDocument.defaultView.pageXOffset || 6652 y !== ownerDocument.defaultView.pageYOffset) 6653 ) { 6654 ownerDocument.defaultView.scrollTo(x, y); 6655 } 6656 }; 6657 var restoreNodeScroll = function (_a) { 6658 var element = _a[0], 6659 x = _a[1], 6660 y = _a[2]; 6661 element.scrollLeft = x; 6662 element.scrollTop = y; 6663 }; 6664 var PSEUDO_BEFORE = ":before"; 6665 var PSEUDO_AFTER = ":after"; 6666 var PSEUDO_HIDE_ELEMENT_CLASS_BEFORE = 6667 "___html2canvas___pseudoelement_before"; 6668 var PSEUDO_HIDE_ELEMENT_CLASS_AFTER = "___html2canvas___pseudoelement_after"; 6669 var PSEUDO_HIDE_ELEMENT_STYLE = 6670 '{\n content: "" !important;\n display: none !important;\n}'; 6671 var createPseudoHideStyles = function (body) { 6672 createStyles( 6673 body, 6674 "." + 6675 PSEUDO_HIDE_ELEMENT_CLASS_BEFORE + 6676 PSEUDO_BEFORE + 6677 PSEUDO_HIDE_ELEMENT_STYLE + 6678 "\n ." + 6679 PSEUDO_HIDE_ELEMENT_CLASS_AFTER + 6680 PSEUDO_AFTER + 6681 PSEUDO_HIDE_ELEMENT_STYLE 6682 ); 6683 }; 6684 var createStyles = function (body, styles) { 6685 var document = body.ownerDocument; 6686 if (document) { 6687 var style = document.createElement("style"); 6688 style.textContent = styles; 6689 body.appendChild(style); 6690 } 6691 }; 6692 6693 var PathType; 6694 (function (PathType) {
vendor: 10,832 bytes, lines 6695-7008
6695 PathType[(PathType["VECTOR"] = 0)] = "VECTOR"; 6696 PathType[(PathType["BEZIER_CURVE"] = 1)] = "BEZIER_CURVE"; 6697 })(PathType || (PathType = {})); 6698 var equalPath = function (a, b) { 6699 if (a.length === b.length) { 6700 return a.some(function (v, i) { 6701 return v === b[i]; 6702 }); 6703 } 6704 return false; 6705 }; 6706 var transformPath = function (path, deltaX, deltaY, deltaW, deltaH) { 6707 return path.map(function (point, index) { 6708 switch (index) { 6709 case 0: 6710 return point.add(deltaX, deltaY); 6711 case 1: 6712 return point.add(deltaX + deltaW, deltaY); 6713 case 2: 6714 return point.add(deltaX + deltaW, deltaY + deltaH); 6715 case 3: 6716 return point.add(deltaX, deltaY + deltaH); 6717 } 6718 return point; 6719 }); 6720 }; 6721 6722 var Vector = /** @class */ (function () { 6723 function Vector(x, y) { 6724 this.type = PathType.VECTOR; 6725 this.x = x; 6726 this.y = y; 6727 } 6728 Vector.prototype.add = function (deltaX, deltaY) { 6729 return new Vector(this.x + deltaX, this.y + deltaY); 6730 }; 6731 return Vector; 6732 })(); 6733 6734 var lerp = function (a, b, t) { 6735 return new Vector(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t); 6736 }; 6737 var BezierCurve = /** @class */ (function () { 6738 function BezierCurve(start, startControl, endControl, end) { 6739 this.type = PathType.BEZIER_CURVE; 6740 this.start = start; 6741 this.startControl = startControl; 6742 this.endControl = endControl; 6743 this.end = end; 6744 } 6745 BezierCurve.prototype.subdivide = function (t, firstHalf) { 6746 var ab = lerp(this.start, this.startControl, t); 6747 var bc = lerp(this.startControl, this.endControl, t); 6748 var cd = lerp(this.endControl, this.end, t); 6749 var abbc = lerp(ab, bc, t); 6750 var bccd = lerp(bc, cd, t); 6751 var dest = lerp(abbc, bccd, t); 6752 return firstHalf 6753 ? new BezierCurve(this.start, ab, abbc, dest) 6754 : new BezierCurve(dest, bccd, cd, this.end); 6755 }; 6756 BezierCurve.prototype.add = function (deltaX, deltaY) { 6757 return new BezierCurve( 6758 this.start.add(deltaX, deltaY), 6759 this.startControl.add(deltaX, deltaY), 6760 this.endControl.add(deltaX, deltaY), 6761 this.end.add(deltaX, deltaY) 6762 ); 6763 }; 6764 BezierCurve.prototype.reverse = function () { 6765 return new BezierCurve( 6766 this.end, 6767 this.endControl, 6768 this.startControl, 6769 this.start 6770 ); 6771 }; 6772 return BezierCurve; 6773 })(); 6774 var isBezierCurve = function (path) { 6775 return path.type === PathType.BEZIER_CURVE; 6776 }; 6777 6778 var BoundCurves = /** @class */ (function () { 6779 function BoundCurves(element) { 6780 var styles = element.styles; 6781 var bounds = element.bounds; 6782 var _a = getAbsoluteValueForTuple( 6783 styles.borderTopLeftRadius, 6784 bounds.width, 6785 bounds.height 6786 ), 6787 tlh = _a[0], 6788 tlv = _a[1]; 6789 var _b = getAbsoluteValueForTuple( 6790 styles.borderTopRightRadius, 6791 bounds.width, 6792 bounds.height 6793 ), 6794 trh = _b[0], 6795 trv = _b[1]; 6796 var _c = getAbsoluteValueForTuple( 6797 styles.borderBottomRightRadius, 6798 bounds.width, 6799 bounds.height 6800 ), 6801 brh = _c[0], 6802 brv = _c[1]; 6803 var _d = getAbsoluteValueForTuple( 6804 styles.borderBottomLeftRadius, 6805 bounds.width, 6806 bounds.height 6807 ), 6808 blh = _d[0], 6809 blv = _d[1]; 6810 var factors = []; 6811 factors.push((tlh + trh) / bounds.width); 6812 factors.push((blh + brh) / bounds.width); 6813 factors.push((tlv + blv) / bounds.height); 6814 factors.push((trv + brv) / bounds.height); 6815 var maxFactor = Math.max.apply(Math, factors); 6816 if (maxFactor > 1) { 6817 tlh /= maxFactor; 6818 tlv /= maxFactor; 6819 trh /= maxFactor; 6820 trv /= maxFactor; 6821 brh /= maxFactor; 6822 brv /= maxFactor; 6823 blh /= maxFactor; 6824 blv /= maxFactor; 6825 } 6826 var topWidth = bounds.width - trh; 6827 var rightHeight = bounds.height - brv; 6828 var bottomWidth = bounds.width - brh; 6829 var leftHeight = bounds.height - blv; 6830 var borderTopWidth = styles.borderTopWidth; 6831 var borderRightWidth = styles.borderRightWidth; 6832 var borderBottomWidth = styles.borderBottomWidth; 6833 var borderLeftWidth = styles.borderLeftWidth; 6834 var paddingTop = getAbsoluteValue( 6835 styles.paddingTop, 6836 element.bounds.width 6837 ); 6838 var paddingRight = getAbsoluteValue( 6839 styles.paddingRight, 6840 element.bounds.width 6841 ); 6842 var paddingBottom = getAbsoluteValue( 6843 styles.paddingBottom, 6844 element.bounds.width 6845 ); 6846 var paddingLeft = getAbsoluteValue( 6847 styles.paddingLeft, 6848 element.bounds.width 6849 ); 6850 this.topLeftBorderBox = 6851 tlh > 0 || tlv > 0 6852 ? getCurvePoints(bounds.left, bounds.top, tlh, tlv, CORNER.TOP_LEFT) 6853 : new Vector(bounds.left, bounds.top); 6854 this.topRightBorderBox = 6855 trh > 0 || trv > 0 6856 ? getCurvePoints( 6857 bounds.left + topWidth, 6858 bounds.top, 6859 trh, 6860 trv, 6861 CORNER.TOP_RIGHT 6862 ) 6863 : new Vector(bounds.left + bounds.width, bounds.top); 6864 this.bottomRightBorderBox = 6865 brh > 0 || brv > 0 6866 ? getCurvePoints( 6867 bounds.left + bottomWidth, 6868 bounds.top + rightHeight, 6869 brh, 6870 brv, 6871 CORNER.BOTTOM_RIGHT 6872 ) 6873 : new Vector(bounds.left + bounds.width, bounds.top + bounds.height); 6874 this.bottomLeftBorderBox = 6875 blh > 0 || blv > 0 6876 ? getCurvePoints( 6877 bounds.left, 6878 bounds.top + leftHeight, 6879 blh, 6880 blv, 6881 CORNER.BOTTOM_LEFT 6882 ) 6883 : new Vector(bounds.left, bounds.top + bounds.height); 6884 this.topLeftPaddingBox = 6885 tlh > 0 || tlv > 0 6886 ? getCurvePoints( 6887 bounds.left + borderLeftWidth, 6888 bounds.top + borderTopWidth, 6889 Math.max(0, tlh - borderLeftWidth), 6890 Math.max(0, tlv - borderTopWidth), 6891 CORNER.TOP_LEFT 6892 ) 6893 : new Vector( 6894 bounds.left + borderLeftWidth, 6895 bounds.top + borderTopWidth 6896 ); 6897 this.topRightPaddingBox = 6898 trh > 0 || trv > 0 6899 ? getCurvePoints( 6900 bounds.left + Math.min(topWidth, bounds.width + borderLeftWidth), 6901 bounds.top + borderTopWidth, 6902 topWidth > bounds.width + borderLeftWidth 6903 ? 0 6904 : trh - borderLeftWidth, 6905 trv - borderTopWidth, 6906 CORNER.TOP_RIGHT 6907 ) 6908 : new Vector( 6909 bounds.left + bounds.width - borderRightWidth, 6910 bounds.top + borderTopWidth 6911 ); 6912 this.bottomRightPaddingBox = 6913 brh > 0 || brv > 0 6914 ? getCurvePoints( 6915 bounds.left + 6916 Math.min(bottomWidth, bounds.width - borderLeftWidth), 6917 bounds.top + 6918 Math.min(rightHeight, bounds.height + borderTopWidth), 6919 Math.max(0, brh - borderRightWidth), 6920 brv - borderBottomWidth, 6921 CORNER.BOTTOM_RIGHT 6922 ) 6923 : new Vector( 6924 bounds.left + bounds.width - borderRightWidth, 6925 bounds.top + bounds.height - borderBottomWidth 6926 ); 6927 this.bottomLeftPaddingBox = 6928 blh > 0 || blv > 0 6929 ? getCurvePoints( 6930 bounds.left + borderLeftWidth, 6931 bounds.top + leftHeight, 6932 Math.max(0, blh - borderLeftWidth), 6933 blv - borderBottomWidth, 6934 CORNER.BOTTOM_LEFT 6935 ) 6936 : new Vector( 6937 bounds.left + borderLeftWidth, 6938 bounds.top + bounds.height - borderBottomWidth 6939 ); 6940 this.topLeftContentBox = 6941 tlh > 0 || tlv > 0 6942 ? getCurvePoints( 6943 bounds.left + borderLeftWidth + paddingLeft, 6944 bounds.top + borderTopWidth + paddingTop, 6945 Math.max(0, tlh - (borderLeftWidth + paddingLeft)), 6946 Math.max(0, tlv - (borderTopWidth + paddingTop)), 6947 CORNER.TOP_LEFT 6948 ) 6949 : new Vector( 6950 bounds.left + borderLeftWidth + paddingLeft, 6951 bounds.top + borderTopWidth + paddingTop 6952 ); 6953 this.topRightContentBox = 6954 trh > 0 || trv > 0 6955 ? getCurvePoints( 6956 bounds.left + 6957 Math.min( 6958 topWidth, 6959 bounds.width + borderLeftWidth + paddingLeft 6960 ), 6961 bounds.top + borderTopWidth + paddingTop, 6962 topWidth > bounds.width + borderLeftWidth + paddingLeft 6963 ? 0 6964 : trh - borderLeftWidth + paddingLeft, 6965 trv - (borderTopWidth + paddingTop), 6966 CORNER.TOP_RIGHT 6967 ) 6968 : new Vector( 6969 bounds.left + bounds.width - (borderRightWidth + paddingRight), 6970 bounds.top + borderTopWidth + paddingTop 6971 ); 6972 this.bottomRightContentBox = 6973 brh > 0 || brv > 0 6974 ? getCurvePoints( 6975 bounds.left + 6976 Math.min( 6977 bottomWidth, 6978 bounds.width - (borderLeftWidth + paddingLeft) 6979 ), 6980 bounds.top + 6981 Math.min( 6982 rightHeight, 6983 bounds.height + borderTopWidth + paddingTop 6984 ), 6985 Math.max(0, brh - (borderRightWidth + paddingRight)), 6986 brv - (borderBottomWidth + paddingBottom), 6987 CORNER.BOTTOM_RIGHT 6988 ) 6989 : new Vector( 6990 bounds.left + bounds.width - (borderRightWidth + paddingRight), 6991 bounds.top + bounds.height - (borderBottomWidth + paddingBottom) 6992 ); 6993 this.bottomLeftContentBox = 6994 blh > 0 || blv > 0 6995 ? getCurvePoints( 6996 bounds.left + borderLeftWidth + paddingLeft, 6997 bounds.top + leftHeight, 6998 Math.max(0, blh - (borderLeftWidth + paddingLeft)), 6999 blv - (borderBottomWidth + paddingBottom), 7000 CORNER.BOTTOM_LEFT 7001 ) 7002 : new Vector( 7003 bounds.left + borderLeftWidth + paddingLeft, 7004 bounds.top + bounds.height - (borderBottomWidth + paddingBottom) 7005 ); 7006 } 7007 return BoundCurves; 7008 })();
7009 var CORNER; 7010 (function (CORNER) { 7011 CORNER[(CORNER["TOP_LEFT"] = 0)] = "TOP_LEFT"; 7012 CORNER[(CORNER["TOP_RIGHT"] = 1)] = "TOP_RIGHT"; 7013 CORNER[(CORNER["BOTTOM_RIGHT"] = 2)] = "BOTTOM_RIGHT"; 7014 CORNER[(CORNER["BOTTOM_LEFT"] = 3)] = "BOTTOM_LEFT"; 7015 })(CORNER || (CORNER = {})); 7016 var getCurvePoints = function (x, y, r1, r2, position) { 7017 var kappa = 4 * ((Math.sqrt(2) - 1) / 3); 7018 var ox = r1 * kappa; // control point offset horizontal 7019 var oy = r2 * kappa; // control point offset vertical 7020 var xm = x + r1; // x-middle 7021 var ym = y + r2; // y-middle 7022 switch (position) { 7023 case CORNER.TOP_LEFT: 7024 return new BezierCurve( 7025 new Vector(x, ym), 7026 new Vector(x, ym - oy), 7027 new Vector(xm - ox, y), 7028 new Vector(xm, y) 7029 ); 7030 case CORNER.TOP_RIGHT: 7031 return new BezierCurve( 7032 new Vector(x, y), 7033 new Vector(x + ox, y), 7034 new Vector(xm, ym - oy), 7035 new Vector(xm, ym) 7036 ); 7037 case CORNER.BOTTOM_RIGHT: 7038 return new BezierCurve( 7039 new Vector(xm, y), 7040 new Vector(xm, y + oy), 7041 new Vector(x + ox, ym), 7042 new Vector(x, ym) 7043 ); 7044 case CORNER.BOTTOM_LEFT: 7045 default: 7046 return new BezierCurve( 7047 new Vector(xm, ym), 7048 new Vector(xm - ox, ym), 7049 new Vector(x, y + oy), 7050 new Vector(x, y) 7051 ); 7052 } 7053 }; 7054 var calculateBorderBoxPath = function (curves) { 7055 return [ 7056 curves.topLeftBorderBox, 7057 curves.topRightBorderBox, 7058 curves.bottomRightBorderBox, 7059 curves.bottomLeftBorderBox, 7060 ]; 7061 }; 7062 var calculateContentBoxPath = function (curves) { 7063 return [ 7064 curves.topLeftContentBox, 7065 curves.topRightContentBox, 7066 curves.bottomRightContentBox, 7067 curves.bottomLeftContentBox, 7068 ]; 7069 }; 7070 var calculatePaddingBoxPath = function (curves) { 7071 return [ 7072 curves.topLeftPaddingBox, 7073 curves.topRightPaddingBox, 7074 curves.bottomRightPaddingBox, 7075 curves.bottomLeftPaddingBox, 7076 ]; 7077 }; 7078 7079 var TransformEffect = /** @class */ (function () { 7080 function TransformEffect(offsetX, offsetY, matrix) { 7081 this.type = 0 /* TRANSFORM */; 7082 this.offsetX = offsetX; 7083 this.offsetY = offsetY; 7084 this.matrix = matrix; 7085 this.target = 2 /* BACKGROUND_BORDERS */ | 4 /* CONTENT */; 7086 } 7087 return TransformEffect; 7088 })(); 7089 var ClipEffect = /** @class */ (function () { 7090 function ClipEffect(path, target) { 7091 this.type = 1 /* CLIP */; 7092 this.target = target; 7093 this.path = path; 7094 } 7095 return ClipEffect; 7096 })(); 7097 var isTransformEffect = function (effect) { 7098 return effect.type === 0 /* TRANSFORM */; 7099 }; 7100 var isClipEffect = function (effect) { 7101 return effect.type === 1 /* CLIP */; 7102 }; 7103 7104 var StackingContext = /** @class */ (function () { 7105 function StackingContext(container) { 7106 this.element = container; 7107 this.inlineLevel = []; 7108 this.nonInlineLevel = []; 7109 this.negativeZIndex = []; 7110 this.zeroOrAutoZIndexOrTransformedOrOpacity = []; 7111 this.positiveZIndex = []; 7112 this.nonPositionedFloats = []; 7113 this.nonPositionedInlineLevel = []; 7114 } 7115 return StackingContext; 7116 })(); 7117 var ElementPaint = /** @class */ (function () { 7118 function ElementPaint(element, parentStack) { 7119 this.container = element; 7120 this.effects = parentStack.slice(0); 7121 this.curves = new BoundCurves(element); 7122 if (element.styles.transform !== null) { 7123 var offsetX = 7124 element.bounds.left + element.styles.transformOrigin[0].number; 7125 var offsetY = 7126 element.bounds.top + element.styles.transformOrigin[1].number; 7127 var matrix = element.styles.transform; 7128 this.effects.push(new TransformEffect(offsetX, offsetY, matrix)); 7129 } 7130 if (element.styles.overflowX !== OVERFLOW.VISIBLE) { 7131 var borderBox = calculateBorderBoxPath(this.curves); 7132 var paddingBox = calculatePaddingBoxPath(this.curves); 7133 if (equalPath(borderBox, paddingBox)) { 7134 this.effects.push( 7135 new ClipEffect( 7136 borderBox, 7137 2 /* BACKGROUND_BORDERS */ | 4 /* CONTENT */ 7138 ) 7139 ); 7140 } else { 7141 this.effects.push( 7142 new ClipEffect(borderBox, 2 /* BACKGROUND_BORDERS */) 7143 ); 7144 this.effects.push(new ClipEffect(paddingBox, 4 /* CONTENT */)); 7145 } 7146 } 7147 } 7148 ElementPaint.prototype.getParentEffects = function () { 7149 var effects = this.effects.slice(0); 7150 if (this.container.styles.overflowX !== OVERFLOW.VISIBLE) { 7151 var borderBox = calculateBorderBoxPath(this.curves); 7152 var paddingBox = calculatePaddingBoxPath(this.curves); 7153 if (!equalPath(borderBox, paddingBox)) { 7154 effects.push( 7155 new ClipEffect( 7156 paddingBox, 7157 2 /* BACKGROUND_BORDERS */ | 4 /* CONTENT */ 7158 ) 7159 ); 7160 } 7161 } 7162 return effects; 7163 }; 7164 return ElementPaint; 7165 })();
vendor: 4,080 bytes, lines 7166-7281
7166 var parseStackTree = function ( 7167 parent, 7168 stackingContext, 7169 realStackingContext, 7170 listItems 7171 ) { 7172 parent.container.elements.forEach(function (child) { 7173 var treatAsRealStackingContext = contains( 7174 child.flags, 7175 4 /* CREATES_REAL_STACKING_CONTEXT */ 7176 ); 7177 var createsStackingContext = contains( 7178 child.flags, 7179 2 /* CREATES_STACKING_CONTEXT */ 7180 ); 7181 var paintContainer = new ElementPaint(child, parent.getParentEffects()); 7182 if (contains(child.styles.display, 2048 /* LIST_ITEM */)) { 7183 listItems.push(paintContainer); 7184 } 7185 var listOwnerItems = contains(child.flags, 8 /* IS_LIST_OWNER */) 7186 ? [] 7187 : listItems; 7188 if (treatAsRealStackingContext || createsStackingContext) { 7189 var parentStack = 7190 treatAsRealStackingContext || child.styles.isPositioned() 7191 ? realStackingContext 7192 : stackingContext; 7193 var stack = new StackingContext(paintContainer); 7194 if ( 7195 child.styles.isPositioned() || 7196 child.styles.opacity < 1 || 7197 child.styles.isTransformed() 7198 ) { 7199 var order_1 = child.styles.zIndex.order; 7200 if (order_1 < 0) { 7201 var index_1 = 0; 7202 parentStack.negativeZIndex.some(function (current, i) { 7203 if (order_1 > current.element.container.styles.zIndex.order) { 7204 index_1 = i; 7205 return false; 7206 } else if (index_1 > 0) { 7207 return true; 7208 } 7209 return false; 7210 }); 7211 parentStack.negativeZIndex.splice(index_1, 0, stack); 7212 } else if (order_1 > 0) { 7213 var index_2 = 0; 7214 parentStack.positiveZIndex.some(function (current, i) { 7215 if (order_1 >= current.element.container.styles.zIndex.order) { 7216 index_2 = i + 1; 7217 return false; 7218 } else if (index_2 > 0) { 7219 return true; 7220 } 7221 return false; 7222 }); 7223 parentStack.positiveZIndex.splice(index_2, 0, stack); 7224 } else { 7225 parentStack.zeroOrAutoZIndexOrTransformedOrOpacity.push(stack); 7226 } 7227 } else { 7228 if (child.styles.isFloating()) { 7229 parentStack.nonPositionedFloats.push(stack); 7230 } else { 7231 parentStack.nonPositionedInlineLevel.push(stack); 7232 } 7233 } 7234 parseStackTree( 7235 paintContainer, 7236 stack, 7237 treatAsRealStackingContext ? stack : realStackingContext, 7238 listOwnerItems 7239 ); 7240 } else { 7241 if (child.styles.isInlineLevel()) { 7242 stackingContext.inlineLevel.push(paintContainer); 7243 } else { 7244 stackingContext.nonInlineLevel.push(paintContainer); 7245 } 7246 parseStackTree( 7247 paintContainer, 7248 stackingContext, 7249 realStackingContext, 7250 listOwnerItems 7251 ); 7252 } 7253 if (contains(child.flags, 8 /* IS_LIST_OWNER */)) { 7254 processListItems(child, listOwnerItems); 7255 } 7256 }); 7257 }; 7258 var processListItems = function (owner, elements) { 7259 var numbering = owner instanceof OLElementContainer ? owner.start : 1; 7260 var reversed = owner instanceof OLElementContainer ? owner.reversed : false; 7261 for (var i = 0; i < elements.length; i++) { 7262 var item = elements[i]; 7263 if ( 7264 item.container instanceof LIElementContainer && 7265 typeof item.container.value === "number" && 7266 item.container.value !== 0 7267 ) { 7268 numbering = item.container.value; 7269 } 7270 item.listValue = createCounterText( 7271 numbering, 7272 item.container.styles.listStyleType, 7273 true 7274 ); 7275 numbering += reversed ? -1 : 1; 7276 } 7277 }; 7278 var parseStackingContexts = function (container) { 7279 var paintContainer = new ElementPaint(container, []); 7280 var root = new StackingContext(paintContainer); 7281 var listItems = [];
vendor: 15,860 bytes, lines 7282-7711
7282 parseStackTree(paintContainer, root, root, listItems); 7283 processListItems(paintContainer.container, listItems); 7284 return root; 7285 }; 7286 7287 var parsePathForBorder = function (curves, borderSide) { 7288 switch (borderSide) { 7289 case 0: 7290 return createPathFromCurves( 7291 curves.topLeftBorderBox, 7292 curves.topLeftPaddingBox, 7293 curves.topRightBorderBox, 7294 curves.topRightPaddingBox 7295 ); 7296 case 1: 7297 return createPathFromCurves( 7298 curves.topRightBorderBox, 7299 curves.topRightPaddingBox, 7300 curves.bottomRightBorderBox, 7301 curves.bottomRightPaddingBox 7302 ); 7303 case 2: 7304 return createPathFromCurves( 7305 curves.bottomRightBorderBox, 7306 curves.bottomRightPaddingBox, 7307 curves.bottomLeftBorderBox, 7308 curves.bottomLeftPaddingBox 7309 ); 7310 case 3: 7311 default: 7312 return createPathFromCurves( 7313 curves.bottomLeftBorderBox, 7314 curves.bottomLeftPaddingBox, 7315 curves.topLeftBorderBox, 7316 curves.topLeftPaddingBox 7317 ); 7318 } 7319 }; 7320 var createPathFromCurves = function (outer1, inner1, outer2, inner2) { 7321 var path = []; 7322 if (isBezierCurve(outer1)) { 7323 path.push(outer1.subdivide(0.5, false)); 7324 } else { 7325 path.push(outer1); 7326 } 7327 if (isBezierCurve(outer2)) { 7328 path.push(outer2.subdivide(0.5, true)); 7329 } else { 7330 path.push(outer2); 7331 } 7332 if (isBezierCurve(inner2)) { 7333 path.push(inner2.subdivide(0.5, true).reverse()); 7334 } else { 7335 path.push(inner2); 7336 } 7337 if (isBezierCurve(inner1)) { 7338 path.push(inner1.subdivide(0.5, false).reverse()); 7339 } else { 7340 path.push(inner1); 7341 } 7342 return path; 7343 }; 7344 7345 var paddingBox = function (element) { 7346 var bounds = element.bounds; 7347 var styles = element.styles; 7348 return bounds.add( 7349 styles.borderLeftWidth, 7350 styles.borderTopWidth, 7351 -(styles.borderRightWidth + styles.borderLeftWidth), 7352 -(styles.borderTopWidth + styles.borderBottomWidth) 7353 ); 7354 }; 7355 var contentBox = function (element) { 7356 var styles = element.styles; 7357 var bounds = element.bounds; 7358 var paddingLeft = getAbsoluteValue(styles.paddingLeft, bounds.width); 7359 var paddingRight = getAbsoluteValue(styles.paddingRight, bounds.width); 7360 var paddingTop = getAbsoluteValue(styles.paddingTop, bounds.width); 7361 var paddingBottom = getAbsoluteValue(styles.paddingBottom, bounds.width); 7362 return bounds.add( 7363 paddingLeft + styles.borderLeftWidth, 7364 paddingTop + styles.borderTopWidth, 7365 -( 7366 styles.borderRightWidth + 7367 styles.borderLeftWidth + 7368 paddingLeft + 7369 paddingRight 7370 ), 7371 -( 7372 styles.borderTopWidth + 7373 styles.borderBottomWidth + 7374 paddingTop + 7375 paddingBottom 7376 ) 7377 ); 7378 }; 7379 7380 var calculateBackgroundPositioningArea = function ( 7381 backgroundOrigin, 7382 element 7383 ) { 7384 if (backgroundOrigin === 0 /* BORDER_BOX */) { 7385 return element.bounds; 7386 } 7387 if (backgroundOrigin === 2 /* CONTENT_BOX */) { 7388 return contentBox(element); 7389 } 7390 return paddingBox(element); 7391 }; 7392 var calculateBackgroundPaintingArea = function (backgroundClip, element) { 7393 if (backgroundClip === BACKGROUND_CLIP.BORDER_BOX) { 7394 return element.bounds; 7395 } 7396 if (backgroundClip === BACKGROUND_CLIP.CONTENT_BOX) { 7397 return contentBox(element); 7398 } 7399 return paddingBox(element); 7400 }; 7401 var calculateBackgroundRendering = function ( 7402 container, 7403 index, 7404 intrinsicSize 7405 ) { 7406 var backgroundPositioningArea = calculateBackgroundPositioningArea( 7407 getBackgroundValueForIndex(container.styles.backgroundOrigin, index), 7408 container 7409 ); 7410 var backgroundPaintingArea = calculateBackgroundPaintingArea( 7411 getBackgroundValueForIndex(container.styles.backgroundClip, index), 7412 container 7413 ); 7414 var backgroundImageSize = calculateBackgroundSize( 7415 getBackgroundValueForIndex(container.styles.backgroundSize, index), 7416 intrinsicSize, 7417 backgroundPositioningArea 7418 ); 7419 var sizeWidth = backgroundImageSize[0], 7420 sizeHeight = backgroundImageSize[1]; 7421 var position = getAbsoluteValueForTuple( 7422 getBackgroundValueForIndex(container.styles.backgroundPosition, index), 7423 backgroundPositioningArea.width - sizeWidth, 7424 backgroundPositioningArea.height - sizeHeight 7425 ); 7426 var path = calculateBackgroundRepeatPath( 7427 getBackgroundValueForIndex(container.styles.backgroundRepeat, index), 7428 position, 7429 backgroundImageSize, 7430 backgroundPositioningArea, 7431 backgroundPaintingArea 7432 ); 7433 var offsetX = Math.round(backgroundPositioningArea.left + position[0]); 7434 var offsetY = Math.round(backgroundPositioningArea.top + position[1]); 7435 return [path, offsetX, offsetY, sizeWidth, sizeHeight]; 7436 }; 7437 var isAuto = function (token) { 7438 return isIdentToken(token) && token.value === BACKGROUND_SIZE.AUTO; 7439 }; 7440 var hasIntrinsicValue = function (value) { 7441 return typeof value === "number"; 7442 }; 7443 var calculateBackgroundSize = function (size, _a, bounds) { 7444 var intrinsicWidth = _a[0], 7445 intrinsicHeight = _a[1], 7446 intrinsicProportion = _a[2]; 7447 var first = size[0], 7448 second = size[1]; 7449 if (isLengthPercentage(first) && second && isLengthPercentage(second)) { 7450 return [ 7451 getAbsoluteValue(first, bounds.width), 7452 getAbsoluteValue(second, bounds.height), 7453 ]; 7454 } 7455 var hasIntrinsicProportion = hasIntrinsicValue(intrinsicProportion); 7456 if ( 7457 isIdentToken(first) && 7458 (first.value === BACKGROUND_SIZE.CONTAIN || 7459 first.value === BACKGROUND_SIZE.COVER) 7460 ) { 7461 if (hasIntrinsicValue(intrinsicProportion)) { 7462 var targetRatio = bounds.width / bounds.height; 7463 return targetRatio < intrinsicProportion !== 7464 (first.value === BACKGROUND_SIZE.COVER) 7465 ? [bounds.width, bounds.width / intrinsicProportion] 7466 : [bounds.height * intrinsicProportion, bounds.height]; 7467 } 7468 return [bounds.width, bounds.height]; 7469 } 7470 var hasIntrinsicWidth = hasIntrinsicValue(intrinsicWidth); 7471 var hasIntrinsicHeight = hasIntrinsicValue(intrinsicHeight); 7472 var hasIntrinsicDimensions = hasIntrinsicWidth || hasIntrinsicHeight; 7473 // If the background-size is auto or auto auto: 7474 if (isAuto(first) && (!second || isAuto(second))) { 7475 // If the image has both horizontal and vertical intrinsic dimensions, it's rendered at that size. 7476 if (hasIntrinsicWidth && hasIntrinsicHeight) { 7477 return [intrinsicWidth, intrinsicHeight]; 7478 } 7479 // If the image has no intrinsic dimensions and has no intrinsic proportions, 7480 // it's rendered at the size of the background positioning area. 7481 if (!hasIntrinsicProportion && !hasIntrinsicDimensions) { 7482 return [bounds.width, bounds.height]; 7483 } 7484 // TODO If the image has no intrinsic dimensions but has intrinsic proportions, it's rendered as if contain had been specified instead. 7485 // If the image has only one intrinsic dimension and has intrinsic proportions, it's rendered at the size corresponding to that one dimension. 7486 // The other dimension is computed using the specified dimension and the intrinsic proportions. 7487 if (hasIntrinsicDimensions && hasIntrinsicProportion) { 7488 var width_1 = hasIntrinsicWidth 7489 ? intrinsicWidth 7490 : intrinsicHeight * intrinsicProportion; 7491 var height_1 = hasIntrinsicHeight 7492 ? intrinsicHeight 7493 : intrinsicWidth / intrinsicProportion; 7494 return [width_1, height_1]; 7495 } 7496 // If the image has only one intrinsic dimension but has no intrinsic proportions, 7497 // it's rendered using the specified dimension and the other dimension of the background positioning area. 7498 var width_2 = hasIntrinsicWidth ? intrinsicWidth : bounds.width; 7499 var height_2 = hasIntrinsicHeight ? intrinsicHeight : bounds.height; 7500 return [width_2, height_2]; 7501 } 7502 // If the image has intrinsic proportions, it's stretched to the specified dimension. 7503 // The unspecified dimension is computed using the specified dimension and the intrinsic proportions. 7504 if (hasIntrinsicProportion) { 7505 var width_3 = 0; 7506 var height_3 = 0; 7507 if (isLengthPercentage(first)) { 7508 width_3 = getAbsoluteValue(first, bounds.width); 7509 } else if (isLengthPercentage(second)) { 7510 height_3 = getAbsoluteValue(second, bounds.height); 7511 } 7512 if (isAuto(first)) { 7513 width_3 = height_3 * intrinsicProportion; 7514 } else if (!second || isAuto(second)) { 7515 height_3 = width_3 / intrinsicProportion; 7516 } 7517 return [width_3, height_3]; 7518 } 7519 // If the image has no intrinsic proportions, it's stretched to the specified dimension. 7520 // The unspecified dimension is computed using the image's corresponding intrinsic dimension, 7521 // if there is one. If there is no such intrinsic dimension, 7522 // it becomes the corresponding dimension of the background positioning area. 7523 var width = null; 7524 var height = null; 7525 if (isLengthPercentage(first)) { 7526 width = getAbsoluteValue(first, bounds.width); 7527 } else if (second && isLengthPercentage(second)) { 7528 height = getAbsoluteValue(second, bounds.height); 7529 } 7530 if (width !== null && (!second || isAuto(second))) { 7531 height = 7532 hasIntrinsicWidth && hasIntrinsicHeight 7533 ? (width / intrinsicWidth) * intrinsicHeight 7534 : bounds.height; 7535 } 7536 if (height !== null && isAuto(first)) { 7537 width = 7538 hasIntrinsicWidth && hasIntrinsicHeight 7539 ? (height / intrinsicHeight) * intrinsicWidth 7540 : bounds.width; 7541 } 7542 if (width !== null && height !== null) { 7543 return [width, height]; 7544 } 7545 throw new Error("Unable to calculate background-size for element"); 7546 }; 7547 var getBackgroundValueForIndex = function (values, index) { 7548 var value = values[index]; 7549 if (typeof value === "undefined") { 7550 return values[0]; 7551 } 7552 return value; 7553 }; 7554 var calculateBackgroundRepeatPath = function ( 7555 repeat, 7556 _a, 7557 _b, 7558 backgroundPositioningArea, 7559 backgroundPaintingArea 7560 ) { 7561 var x = _a[0], 7562 y = _a[1]; 7563 var width = _b[0], 7564 height = _b[1]; 7565 switch (repeat) { 7566 case BACKGROUND_REPEAT.REPEAT_X: 7567 return [ 7568 new Vector( 7569 Math.round(backgroundPositioningArea.left), 7570 Math.round(backgroundPositioningArea.top + y) 7571 ), 7572 new Vector( 7573 Math.round( 7574 backgroundPositioningArea.left + backgroundPositioningArea.width 7575 ), 7576 Math.round(backgroundPositioningArea.top + y) 7577 ), 7578 new Vector( 7579 Math.round( 7580 backgroundPositioningArea.left + backgroundPositioningArea.width 7581 ), 7582 Math.round(height + backgroundPositioningArea.top + y) 7583 ), 7584 new Vector( 7585 Math.round(backgroundPositioningArea.left), 7586 Math.round(height + backgroundPositioningArea.top + y) 7587 ), 7588 ]; 7589 case BACKGROUND_REPEAT.REPEAT_Y: 7590 return [ 7591 new Vector( 7592 Math.round(backgroundPositioningArea.left + x), 7593 Math.round(backgroundPositioningArea.top) 7594 ), 7595 new Vector( 7596 Math.round(backgroundPositioningArea.left + x + width), 7597 Math.round(backgroundPositioningArea.top) 7598 ), 7599 new Vector( 7600 Math.round(backgroundPositioningArea.left + x + width), 7601 Math.round( 7602 backgroundPositioningArea.height + backgroundPositioningArea.top 7603 ) 7604 ), 7605 new Vector( 7606 Math.round(backgroundPositioningArea.left + x), 7607 Math.round( 7608 backgroundPositioningArea.height + backgroundPositioningArea.top 7609 ) 7610 ), 7611 ]; 7612 case BACKGROUND_REPEAT.NO_REPEAT: 7613 return [ 7614 new Vector( 7615 Math.round(backgroundPositioningArea.left + x), 7616 Math.round(backgroundPositioningArea.top + y) 7617 ), 7618 new Vector( 7619 Math.round(backgroundPositioningArea.left + x + width), 7620 Math.round(backgroundPositioningArea.top + y) 7621 ), 7622 new Vector( 7623 Math.round(backgroundPositioningArea.left + x + width), 7624 Math.round(backgroundPositioningArea.top + y + height) 7625 ), 7626 new Vector( 7627 Math.round(backgroundPositioningArea.left + x), 7628 Math.round(backgroundPositioningArea.top + y + height) 7629 ), 7630 ]; 7631 default: 7632 return [ 7633 new Vector( 7634 Math.round(backgroundPaintingArea.left), 7635 Math.round(backgroundPaintingArea.top) 7636 ), 7637 new Vector( 7638 Math.round( 7639 backgroundPaintingArea.left + backgroundPaintingArea.width 7640 ), 7641 Math.round(backgroundPaintingArea.top) 7642 ), 7643 new Vector( 7644 Math.round( 7645 backgroundPaintingArea.left + backgroundPaintingArea.width 7646 ), 7647 Math.round( 7648 backgroundPaintingArea.height + backgroundPaintingArea.top 7649 ) 7650 ), 7651 new Vector( 7652 Math.round(backgroundPaintingArea.left), 7653 Math.round( 7654 backgroundPaintingArea.height + backgroundPaintingArea.top 7655 ) 7656 ), 7657 ]; 7658 } 7659 }; 7660 7661 var SMALL_IMAGE = 7662 "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7"; 7663 7664 var SAMPLE_TEXT = "Hidden Text"; 7665 var FontMetrics = /** @class */ (function () { 7666 function FontMetrics(document) { 7667 this._data = {}; 7668 this._document = document; 7669 } 7670 FontMetrics.prototype.parseMetrics = function (fontFamily, fontSize) { 7671 var container = this._document.createElement("div"); 7672 var img = this._document.createElement("img"); 7673 var span = this._document.createElement("span"); 7674 var body = this._document.body; 7675 container.style.visibility = "hidden"; 7676 container.style.fontFamily = fontFamily; 7677 container.style.fontSize = fontSize; 7678 container.style.margin = "0"; 7679 container.style.padding = "0"; 7680 body.appendChild(container); 7681 img.src = SMALL_IMAGE; 7682 img.width = 1; 7683 img.height = 1; 7684 img.style.margin = "0"; 7685 img.style.padding = "0"; 7686 img.style.verticalAlign = "baseline"; 7687 span.style.fontFamily = fontFamily; 7688 span.style.fontSize = fontSize; 7689 span.style.margin = "0"; 7690 span.style.padding = "0"; 7691 span.appendChild(this._document.createTextNode(SAMPLE_TEXT)); 7692 container.appendChild(span); 7693 container.appendChild(img); 7694 var baseline = img.offsetTop - span.offsetTop + 2; 7695 container.removeChild(span); 7696 container.appendChild(this._document.createTextNode(SAMPLE_TEXT)); 7697 container.style.lineHeight = "normal"; 7698 img.style.verticalAlign = "super"; 7699 var middle = img.offsetTop - container.offsetTop + 2; 7700 body.removeChild(container); 7701 return { baseline: baseline, middle: middle }; 7702 }; 7703 FontMetrics.prototype.getMetrics = function (fontFamily, fontSize) { 7704 var key = fontFamily + " " + fontSize; 7705 if (typeof this._data[key] === "undefined") { 7706 this._data[key] = this.parseMetrics(fontFamily, fontSize); 7707 } 7708 return this._data[key]; 7709 }; 7710 return FontMetrics; 7711 })();
7712 7713 var MASK_OFFSET = 10000; 7714 var CanvasRenderer = /** @class */ (function () { 7715 function CanvasRenderer(options) { 7716 this._activeEffects = []; 7717 this.canvas = options.canvas 7718 ? options.canvas 7719 : document.createElement("canvas"); 7720 this.ctx = this.canvas.getContext("2d"); 7721 this.options = options; 7722 if (!options.canvas) { 7723 this.canvas.width = Math.floor(options.width * options.scale); 7724 this.canvas.height = Math.floor(options.height * options.scale); 7725 this.canvas.style.width = options.width + "px"; 7726 this.canvas.style.height = options.height + "px"; 7727 } 7728 this.fontMetrics = new FontMetrics(document); 7729 this.ctx.scale(this.options.scale, this.options.scale); 7730 this.ctx.translate( 7731 -options.x + options.scrollX, 7732 -options.y + options.scrollY 7733 ); 7734 this.ctx.textBaseline = "bottom"; 7735 this._activeEffects = []; 7736 Logger.getInstance(options.id).debug( 7737 "Canvas renderer initialized (" + 7738 options.width + 7739 "x" + 7740 options.height + 7741 " at " + 7742 options.x + 7743 "," + 7744 options.y + 7745 ") with scale " + 7746 options.scale 7747 ); 7748 } 7749 CanvasRenderer.prototype.applyEffects = function (effects, target) { 7750 var _this = this; 7751 while (this._activeEffects.length) { 7752 this.popEffect(); 7753 } 7754 effects 7755 .filter(function (effect) { 7756 return contains(effect.target, target); 7757 }) 7758 .forEach(function (effect) { 7759 return _this.applyEffect(effect); 7760 }); 7761 }; 7762 CanvasRenderer.prototype.applyEffect = function (effect) { 7763 this.ctx.save(); 7764 if (isTransformEffect(effect)) { 7765 this.ctx.translate(effect.offsetX, effect.offsetY); 7766 this.ctx.transform( 7767 effect.matrix[0], 7768 effect.matrix[1], 7769 effect.matrix[2], 7770 effect.matrix[3], 7771 effect.matrix[4], 7772 effect.matrix[5] 7773 ); 7774 this.ctx.translate(-effect.offsetX, -effect.offsetY); 7775 } 7776 if (isClipEffect(effect)) { 7777 this.path(effect.path); 7778 this.ctx.clip(); 7779 } 7780 this._activeEffects.push(effect); 7781 }; 7782 CanvasRenderer.prototype.popEffect = function () { 7783 this._activeEffects.pop(); 7784 this.ctx.restore(); 7785 }; 7786 CanvasRenderer.prototype.renderStack = function (stack) { 7787 return __awaiter(this, void 0, void 0, function () { 7788 var styles; 7789 return __generator(this, function (_a) { 7790 switch (_a.label) { 7791 case 0: 7792 styles = stack.element.container.styles; 7793 if (!styles.isVisible()) return [3 /*break*/, 2]; 7794 this.ctx.globalAlpha = styles.opacity; 7795 return [4 /*yield*/, this.renderStackContent(stack)]; 7796 case 1: 7797 _a.sent(); 7798 _a.label = 2; 7799 case 2: 7800 return [2 /*return*/]; 7801 } 7802 }); 7803 }); 7804 }; 7805 CanvasRenderer.prototype.renderNode = function (paint) { 7806 return __awaiter(this, void 0, void 0, function () { 7807 return __generator(this, function (_a) { 7808 switch (_a.label) { 7809 case 0: 7810 if (!paint.container.styles.isVisible()) return [3 /*break*/, 3]; 7811 return [4 /*yield*/, this.renderNodeBackgroundAndBorders(paint)]; 7812 case 1: 7813 _a.sent(); 7814 return [4 /*yield*/, this.renderNodeContent(paint)]; 7815 case 2: 7816 _a.sent(); 7817 _a.label = 3; 7818 case 3: 7819 return [2 /*return*/]; 7820 } 7821 }); 7822 }); 7823 }; 7824 CanvasRenderer.prototype.renderTextWithLetterSpacing = function ( 7825 text, 7826 letterSpacing 7827 ) { 7828 var _this = this; 7829 if (letterSpacing === 0) { 7830 this.ctx.fillText( 7831 text.text, 7832 text.bounds.left, 7833 text.bounds.top + text.bounds.height 7834 ); 7835 } else { 7836 var letters = toCodePoints(text.text).map(function (i) { 7837 return fromCodePoint(i); 7838 }); 7839 letters.reduce(function (left, letter) { 7840 _this.ctx.fillText( 7841 letter, 7842 left, 7843 text.bounds.top + text.bounds.height 7844 ); 7845 return left + _this.ctx.measureText(letter).width; 7846 }, text.bounds.left); 7847 } 7848 }; 7849 CanvasRenderer.prototype.createFontStyle = function (styles) { 7850 var fontVariant = styles.fontVariant 7851 .filter(function (variant) { 7852 return variant === "normal" || variant === "small-caps"; 7853 }) 7854 .join(""); 7855 var fontFamily = styles.fontFamily.join(", "); 7856 var fontSize = isDimensionToken(styles.fontSize) 7857 ? "" + styles.fontSize.number + styles.fontSize.unit 7858 : styles.fontSize.number + "px"; 7859 return [ 7860 [ 7861 styles.fontStyle, 7862 fontVariant, 7863 styles.fontWeight, 7864 fontSize, 7865 fontFamily, 7866 ].join(" "), 7867 fontFamily, 7868 fontSize, 7869 ]; 7870 }; 7871 CanvasRenderer.prototype.renderTextNode = function (text, styles) { 7872 return __awaiter(this, void 0, void 0, function () { 7873 var _a, font, fontFamily, fontSize; 7874 var _this = this; 7875 return __generator(this, function (_b) { 7876 (_a = this.createFontStyle(styles)), 7877 (font = _a[0]), 7878 (fontFamily = _a[1]), 7879 (fontSize = _a[2]); 7880 this.ctx.font = font; 7881 text.textBounds.forEach(function (text) { 7882 _this.ctx.fillStyle = asString(styles.color); 7883 _this.renderTextWithLetterSpacing(text, styles.letterSpacing); 7884 var textShadows = styles.textShadow; 7885 if (textShadows.length && text.text.trim().length) { 7886 textShadows 7887 .slice(0) 7888 .reverse() 7889 .forEach(function (textShadow) { 7890 _this.ctx.shadowColor = asString(textShadow.color); 7891 _this.ctx.shadowOffsetX = 7892 textShadow.offsetX.number * _this.options.scale; 7893 _this.ctx.shadowOffsetY = 7894 textShadow.offsetY.number * _this.options.scale; 7895 _this.ctx.shadowBlur = textShadow.blur.number; 7896 _this.ctx.fillText( 7897 text.text, 7898 text.bounds.left, 7899 text.bounds.top + text.bounds.height 7900 ); 7901 }); 7902 _this.ctx.shadowColor = ""; 7903 _this.ctx.shadowOffsetX = 0; 7904 _this.ctx.shadowOffsetY = 0; 7905 _this.ctx.shadowBlur = 0; 7906 } 7907 if (styles.textDecorationLine.length) { 7908 _this.ctx.fillStyle = asString( 7909 styles.textDecorationColor || styles.color 7910 ); 7911 styles.textDecorationLine.forEach(function (textDecorationLine) { 7912 switch (textDecorationLine) { 7913 case 1 /* UNDERLINE */: 7914 // Draws a line at the baseline of the font 7915 // TODO As some browsers display the line as more than 1px if the font-size is big, 7916 // need to take that into account both in position and size 7917 var baseline = _this.fontMetrics.getMetrics( 7918 fontFamily, 7919 fontSize 7920 ).baseline; 7921 _this.ctx.fillRect( 7922 text.bounds.left, 7923 Math.round(text.bounds.top + baseline), 7924 text.bounds.width, 7925 1 7926 ); 7927 break; 7928 case 2 /* OVERLINE */: 7929 _this.ctx.fillRect( 7930 text.bounds.left, 7931 Math.round(text.bounds.top), 7932 text.bounds.width, 7933 1 7934 ); 7935 break; 7936 case 3 /* LINE_THROUGH */: 7937 // TODO try and find exact position for line-through 7938 var middle = _this.fontMetrics.getMetrics( 7939 fontFamily, 7940 fontSize 7941 ).middle; 7942 _this.ctx.fillRect( 7943 text.bounds.left, 7944 Math.ceil(text.bounds.top + middle), 7945 text.bounds.width, 7946 1 7947 ); 7948 break; 7949 } 7950 }); 7951 } 7952 }); 7953 return [2 /*return*/]; 7954 }); 7955 }); 7956 }; 7957 CanvasRenderer.prototype.renderReplacedElement = function ( 7958 container, 7959 curves, 7960 image 7961 ) { 7962 if ( 7963 image && 7964 container.intrinsicWidth > 0 && 7965 container.intrinsicHeight > 0 7966 ) { 7967 var box = contentBox(container); 7968 var path = calculatePaddingBoxPath(curves); 7969 this.path(path);
7970 this.ctx.save(); 7971 this.ctx.clip(); 7972 this.ctx.drawImage( 7973 image, 7974 0, 7975 0, 7976 container.intrinsicWidth, 7977 container.intrinsicHeight, 7978 box.left, 7979 box.top, 7980 box.width, 7981 box.height 7982 ); 7983 this.ctx.restore(); 7984 } 7985 }; 7986 CanvasRenderer.prototype.renderNodeContent = function (paint) { 7987 return __awaiter(this, void 0, void 0, function () { 7988 var container, 7989 curves, 7990 styles, 7991 _i, 7992 _a, 7993 child, 7994 image, 7995 e_1, 7996 image, 7997 e_2, 7998 iframeRenderer, 7999 canvas, 8000 size, 8001 bounds, 8002 x, 8003 textBounds, 8004 img, 8005 image, 8006 url, 8007 e_3, 8008 bounds; 8009 return __generator(this, function (_b) { 8010 switch (_b.label) { 8011 case 0: 8012 this.applyEffects(paint.effects, 4 /* CONTENT */); 8013 container = paint.container; 8014 curves = paint.curves; 8015 styles = container.styles; 8016 (_i = 0), (_a = container.textNodes); 8017 _b.label = 1; 8018 case 1: 8019 if (!(_i < _a.length)) return [3 /*break*/, 4]; 8020 child = _a[_i]; 8021 return [4 /*yield*/, this.renderTextNode(child, styles)]; 8022 case 2: 8023 _b.sent(); 8024 _b.label = 3; 8025 case 3: 8026 _i++; 8027 return [3 /*break*/, 1]; 8028 case 4: 8029 if (!(container instanceof ImageElementContainer)) 8030 return [3 /*break*/, 8]; 8031 _b.label = 5; 8032 case 5: 8033 _b.trys.push([5, 7, , 8]); 8034 return [4 /*yield*/, this.options.cache.match(container.src)]; 8035 case 6: 8036 image = _b.sent(); 8037 this.renderReplacedElement(container, curves, image); 8038 return [3 /*break*/, 8]; 8039 case 7: 8040 e_1 = _b.sent(); 8041 Logger.getInstance(this.options.id).error( 8042 "Error loading image " + container.src 8043 ); 8044 return [3 /*break*/, 8]; 8045 case 8: 8046 if (container instanceof CanvasElementContainer) { 8047 this.renderReplacedElement(container, curves, container.canvas); 8048 } 8049 if (!(container instanceof SVGElementContainer)) 8050 return [3 /*break*/, 12]; 8051 _b.label = 9; 8052 case 9: 8053 _b.trys.push([9, 11, , 12]); 8054 return [4 /*yield*/, this.options.cache.match(container.svg)]; 8055 case 10: 8056 image = _b.sent(); 8057 this.renderReplacedElement(container, curves, image); 8058 return [3 /*break*/, 12]; 8059 case 11: 8060 e_2 = _b.sent(); 8061 Logger.getInstance(this.options.id).error( 8062 "Error loading svg " + container.svg.substring(0, 255) 8063 ); 8064 return [3 /*break*/, 12]; 8065 case 12: 8066 if ( 8067 !(container instanceof IFrameElementContainer && container.tree) 8068 ) 8069 return [3 /*break*/, 14]; 8070 iframeRenderer = new CanvasRenderer({ 8071 id: this.options.id, 8072 scale: this.options.scale, 8073 backgroundColor: container.backgroundColor, 8074 x: 0, 8075 y: 0, 8076 scrollX: 0, 8077 scrollY: 0, 8078 width: container.width, 8079 height: container.height, 8080 cache: this.options.cache, 8081 windowWidth: container.width, 8082 windowHeight: container.height, 8083 }); 8084 return [4 /*yield*/, iframeRenderer.render(container.tree)]; 8085 case 13: 8086 canvas = _b.sent(); 8087 if (container.width && container.height) { 8088 this.ctx.drawImage( 8089 canvas, 8090 0, 8091 0, 8092 container.width, 8093 container.height, 8094 container.bounds.left, 8095 container.bounds.top, 8096 container.bounds.width, 8097 container.bounds.height 8098 ); 8099 } 8100 _b.label = 14; 8101 case 14: 8102 if (container instanceof InputElementContainer) { 8103 size = Math.min( 8104 container.bounds.width, 8105 container.bounds.height 8106 ); 8107 if (container.type === CHECKBOX) { 8108 if (container.checked) { 8109 this.ctx.save(); 8110 this.path([ 8111 new Vector( 8112 container.bounds.left + size * 0.39363, 8113 container.bounds.top + size * 0.79 8114 ), 8115 new Vector( 8116 container.bounds.left + size * 0.16, 8117 container.bounds.top + size * 0.5549 8118 ), 8119 new Vector( 8120 container.bounds.left + size * 0.27347, 8121 container.bounds.top + size * 0.44071 8122 ), 8123 new Vector( 8124 container.bounds.left + size * 0.39694, 8125 container.bounds.top + size * 0.5649 8126 ), 8127 new Vector( 8128 container.bounds.left + size * 0.72983, 8129 container.bounds.top + size * 0.23 8130 ), 8131 new Vector( 8132 container.bounds.left + size * 0.84, 8133 container.bounds.top + size * 0.34085 8134 ), 8135 new Vector( 8136 container.bounds.left + size * 0.39363, 8137 container.bounds.top + size * 0.79 8138 ), 8139 ]); 8140 this.ctx.fillStyle = asString(INPUT_COLOR); 8141 this.ctx.fill();
8142 this.ctx.restore(); 8143 } 8144 } else if (container.type === RADIO) { 8145 if (container.checked) { 8146 this.ctx.save(); 8147 this.ctx.beginPath(); 8148 this.ctx.arc( 8149 container.bounds.left + size / 2, 8150 container.bounds.top + size / 2, 8151 size / 4, 8152 0, 8153 Math.PI * 2, 8154 true 8155 ); 8156 this.ctx.fillStyle = asString(INPUT_COLOR); 8157 this.ctx.fill(); 8158 this.ctx.restore(); 8159 } 8160 } 8161 } 8162 if (isTextInputElement(container) && container.value.length) { 8163 this.ctx.font = this.createFontStyle(styles)[0]; 8164 this.ctx.fillStyle = asString(styles.color); 8165 this.ctx.textBaseline = "middle"; 8166 this.ctx.textAlign = canvasTextAlign( 8167 container.styles.textAlign 8168 ); 8169 bounds = contentBox(container); 8170 x = 0; 8171 switch (container.styles.textAlign) { 8172 case TEXT_ALIGN.CENTER: 8173 x += bounds.width / 2; 8174 break; 8175 case TEXT_ALIGN.RIGHT: 8176 x += bounds.width; 8177 break; 8178 } 8179 textBounds = bounds.add(x, 0, 0, -bounds.height / 2 + 1); 8180 this.ctx.save(); 8181 this.path([ 8182 new Vector(bounds.left, bounds.top), 8183 new Vector(bounds.left + bounds.width, bounds.top), 8184 new Vector( 8185 bounds.left + bounds.width, 8186 bounds.top + bounds.height 8187 ), 8188 new Vector(bounds.left, bounds.top + bounds.height), 8189 ]); 8190 this.ctx.clip(); 8191 this.renderTextWithLetterSpacing( 8192 new TextBounds(container.value, textBounds), 8193 styles.letterSpacing 8194 ); 8195 this.ctx.restore(); 8196 this.ctx.textBaseline = "bottom"; 8197 this.ctx.textAlign = "left"; 8198 } 8199 if (!contains(container.styles.display, 2048 /* LIST_ITEM */)) 8200 return [3 /*break*/, 20]; 8201 if (!(container.styles.listStyleImage !== null)) 8202 return [3 /*break*/, 19]; 8203 img = container.styles.listStyleImage; 8204 if (!(img.type === CSSImageType.URL)) return [3 /*break*/, 18]; 8205 image = void 0; 8206 url = img.url; 8207 _b.label = 15; 8208 case 15: 8209 _b.trys.push([15, 17, , 18]); 8210 return [4 /*yield*/, this.options.cache.match(url)]; 8211 case 16: 8212 image = _b.sent(); 8213 this.ctx.drawImage( 8214 image, 8215 container.bounds.left - (image.width + 10), 8216 container.bounds.top 8217 ); 8218 return [3 /*break*/, 18]; 8219 case 17: 8220 e_3 = _b.sent(); 8221 Logger.getInstance(this.options.id).error( 8222 "Error loading list-style-image " + url 8223 ); 8224 return [3 /*break*/, 18]; 8225 case 18: 8226 return [3 /*break*/, 20]; 8227 case 19: 8228 if ( 8229 paint.listValue && 8230 container.styles.listStyleType !== LIST_STYLE_TYPE.NONE 8231 ) { 8232 this.ctx.font = this.createFontStyle(styles)[0]; 8233 this.ctx.fillStyle = asString(styles.color); 8234 this.ctx.textBaseline = "middle"; 8235 this.ctx.textAlign = "right"; 8236 bounds = new Bounds( 8237 container.bounds.left, 8238 container.bounds.top + 8239 getAbsoluteValue( 8240 container.styles.paddingTop, 8241 container.bounds.width 8242 ), 8243 container.bounds.width, 8244 computeLineHeight(styles.lineHeight, styles.fontSize.number) / 8245 2 + 8246 1 8247 ); 8248 this.renderTextWithLetterSpacing( 8249 new TextBounds(paint.listValue, bounds), 8250 styles.letterSpacing 8251 ); 8252 this.ctx.textBaseline = "bottom"; 8253 this.ctx.textAlign = "left"; 8254 } 8255 _b.label = 20; 8256 case 20: 8257 return [2 /*return*/]; 8258 } 8259 }); 8260 }); 8261 }; 8262 CanvasRenderer.prototype.renderStackContent = function (stack) { 8263 return __awaiter(this, void 0, void 0, function () { 8264 var _i, 8265 _a, 8266 child, 8267 _b, 8268 _c, 8269 child, 8270 _d, 8271 _e, 8272 child, 8273 _f, 8274 _g, 8275 child, 8276 _h, 8277 _j, 8278 child, 8279 _k, 8280 _l, 8281 child, 8282 _m, 8283 _o, 8284 child; 8285 return __generator(this, function (_p) { 8286 switch (_p.label) { 8287 case 0: 8288 // https://www.w3.org/TR/css-position-3/#painting-order 8289 // 1. the background and borders of the element forming the stacking context. 8290 return [ 8291 4 /*yield*/,
vendor: 5,191 bytes, lines 8292-8441
8292 this.renderNodeBackgroundAndBorders(stack.element), 8293 ]; 8294 case 1: 8295 // https://www.w3.org/TR/css-position-3/#painting-order 8296 // 1. the background and borders of the element forming the stacking context. 8297 _p.sent(); 8298 (_i = 0), (_a = stack.negativeZIndex); 8299 _p.label = 2; 8300 case 2: 8301 if (!(_i < _a.length)) return [3 /*break*/, 5]; 8302 child = _a[_i]; 8303 return [4 /*yield*/, this.renderStack(child)]; 8304 case 3: 8305 _p.sent(); 8306 _p.label = 4; 8307 case 4: 8308 _i++; 8309 return [3 /*break*/, 2]; 8310 case 5: 8311 // 3. For all its in-flow, non-positioned, block-level descendants in tree order: 8312 return [4 /*yield*/, this.renderNodeContent(stack.element)]; 8313 case 6: 8314 // 3. For all its in-flow, non-positioned, block-level descendants in tree order: 8315 _p.sent(); 8316 (_b = 0), (_c = stack.nonInlineLevel); 8317 _p.label = 7; 8318 case 7: 8319 if (!(_b < _c.length)) return [3 /*break*/, 10]; 8320 child = _c[_b]; 8321 return [4 /*yield*/, this.renderNode(child)]; 8322 case 8: 8323 _p.sent(); 8324 _p.label = 9; 8325 case 9: 8326 _b++; 8327 return [3 /*break*/, 7]; 8328 case 10: 8329 (_d = 0), (_e = stack.nonPositionedFloats); 8330 _p.label = 11; 8331 case 11: 8332 if (!(_d < _e.length)) return [3 /*break*/, 14]; 8333 child = _e[_d]; 8334 return [4 /*yield*/, this.renderStack(child)]; 8335 case 12: 8336 _p.sent(); 8337 _p.label = 13; 8338 case 13: 8339 _d++; 8340 return [3 /*break*/, 11]; 8341 case 14: 8342 (_f = 0), (_g = stack.nonPositionedInlineLevel); 8343 _p.label = 15; 8344 case 15: 8345 if (!(_f < _g.length)) return [3 /*break*/, 18]; 8346 child = _g[_f]; 8347 return [4 /*yield*/, this.renderStack(child)]; 8348 case 16: 8349 _p.sent(); 8350 _p.label = 17; 8351 case 17: 8352 _f++; 8353 return [3 /*break*/, 15]; 8354 case 18: 8355 (_h = 0), (_j = stack.inlineLevel); 8356 _p.label = 19; 8357 case 19: 8358 if (!(_h < _j.length)) return [3 /*break*/, 22]; 8359 child = _j[_h]; 8360 return [4 /*yield*/, this.renderNode(child)]; 8361 case 20: 8362 _p.sent(); 8363 _p.label = 21; 8364 case 21: 8365 _h++; 8366 return [3 /*break*/, 19]; 8367 case 22: 8368 (_k = 0), (_l = stack.zeroOrAutoZIndexOrTransformedOrOpacity); 8369 _p.label = 23; 8370 case 23: 8371 if (!(_k < _l.length)) return [3 /*break*/, 26]; 8372 child = _l[_k]; 8373 return [4 /*yield*/, this.renderStack(child)]; 8374 case 24: 8375 _p.sent(); 8376 _p.label = 25; 8377 case 25: 8378 _k++; 8379 return [3 /*break*/, 23]; 8380 case 26: 8381 (_m = 0), (_o = stack.positiveZIndex); 8382 _p.label = 27; 8383 case 27: 8384 if (!(_m < _o.length)) return [3 /*break*/, 30]; 8385 child = _o[_m]; 8386 return [4 /*yield*/, this.renderStack(child)]; 8387 case 28: 8388 _p.sent(); 8389 _p.label = 29; 8390 case 29: 8391 _m++; 8392 return [3 /*break*/, 27]; 8393 case 30: 8394 return [2 /*return*/]; 8395 } 8396 }); 8397 }); 8398 }; 8399 CanvasRenderer.prototype.mask = function (paths) { 8400 this.ctx.beginPath(); 8401 this.ctx.moveTo(0, 0); 8402 this.ctx.lineTo(this.canvas.width, 0); 8403 this.ctx.lineTo(this.canvas.width, this.canvas.height); 8404 this.ctx.lineTo(0, this.canvas.height); 8405 this.ctx.lineTo(0, 0); 8406 this.formatPath(paths.slice(0).reverse()); 8407 this.ctx.closePath(); 8408 }; 8409 CanvasRenderer.prototype.path = function (paths) { 8410 this.ctx.beginPath(); 8411 this.formatPath(paths); 8412 this.ctx.closePath(); 8413 }; 8414 CanvasRenderer.prototype.formatPath = function (paths) { 8415 var _this = this; 8416 paths.forEach(function (point, index) { 8417 var start = isBezierCurve(point) ? point.start : point; 8418 if (index === 0) { 8419 _this.ctx.moveTo(start.x, start.y); 8420 } else { 8421 _this.ctx.lineTo(start.x, start.y); 8422 } 8423 if (isBezierCurve(point)) { 8424 _this.ctx.bezierCurveTo( 8425 point.startControl.x, 8426 point.startControl.y, 8427 point.endControl.x, 8428 point.endControl.y, 8429 point.end.x, 8430 point.end.y 8431 ); 8432 } 8433 }); 8434 }; 8435 CanvasRenderer.prototype.renderRepeat = function ( 8436 path, 8437 pattern, 8438 offsetX, 8439 offsetY 8440 ) { 8441 this.path(path);
8442 this.ctx.fillStyle = pattern; 8443 this.ctx.translate(offsetX, offsetY); 8444 this.ctx.fill(); 8445 this.ctx.translate(-offsetX, -offsetY); 8446 }; 8447 CanvasRenderer.prototype.resizeImage = function (image, width, height) { 8448 if (image.width === width && image.height === height) { 8449 return image; 8450 } 8451 var canvas = this.canvas.ownerDocument.createElement("canvas"); 8452 canvas.width = width; 8453 canvas.height = height; 8454 var ctx = canvas.getContext("2d"); 8455 ctx.drawImage( 8456 image, 8457 0, 8458 0, 8459 image.width, 8460 image.height, 8461 0, 8462 0, 8463 width, 8464 height 8465 ); 8466 return canvas; 8467 }; 8468 CanvasRenderer.prototype.renderBackgroundImage = function (container) { 8469 return __awaiter(this, void 0, void 0, function () { 8470 var index, _loop_1, this_1, _i, _a, backgroundImage; 8471 return __generator(this, function (_b) { 8472 switch (_b.label) { 8473 case 0: 8474 index = container.styles.backgroundImage.length - 1; 8475 _loop_1 = function (backgroundImage) { 8476 var image, 8477 url, 8478 e_4, 8479 _a, 8480 path, 8481 x, 8482 y, 8483 width, 8484 height, 8485 pattern, 8486 _b, 8487 path, 8488 x, 8489 y, 8490 width, 8491 height, 8492 _c, 8493 lineLength, 8494 x0, 8495 x1, 8496 y0, 8497 y1, 8498 canvas, 8499 ctx, 8500 gradient_1, 8501 pattern, 8502 _d, 8503 path, 8504 left, 8505 top_1, 8506 width, 8507 height, 8508 position, 8509 x, 8510 y, 8511 _e, 8512 rx, 8513 ry, 8514 radialGradient_1, 8515 midX, 8516 midY, 8517 f, 8518 invF; 8519 return __generator(this, function (_f) { 8520 switch (_f.label) { 8521 case 0: 8522 if (!(backgroundImage.type === CSSImageType.URL)) 8523 return [3 /*break*/, 5]; 8524 image = void 0; 8525 url = backgroundImage.url; 8526 _f.label = 1; 8527 case 1: 8528 _f.trys.push([1, 3, , 4]); 8529 return [4 /*yield*/, this_1.options.cache.match(url)]; 8530 case 2: 8531 image = _f.sent(); 8532 return [3 /*break*/, 4]; 8533 case 3: 8534 e_4 = _f.sent(); 8535 Logger.getInstance(this_1.options.id).error( 8536 "Error loading background-image " + url 8537 ); 8538 return [3 /*break*/, 4]; 8539 case 4: 8540 if (image) { 8541 (_a = calculateBackgroundRendering(container, index, [ 8542 image.width, 8543 image.height, 8544 image.width / image.height, 8545 ])), 8546 (path = _a[0]), 8547 (x = _a[1]), 8548 (y = _a[2]), 8549 (width = _a[3]), 8550 (height = _a[4]); 8551 pattern = this_1.ctx.createPattern( 8552 this_1.resizeImage(image, width, height), 8553 "repeat" 8554 ); 8555 this_1.renderRepeat(path, pattern, x, y); 8556 } 8557 return [3 /*break*/, 6]; 8558 case 5: 8559 if (isLinearGradient(backgroundImage)) {
8560 (_b = calculateBackgroundRendering(container, index, [ 8561 null, 8562 null, 8563 null, 8564 ])), 8565 (path = _b[0]), 8566 (x = _b[1]), 8567 (y = _b[2]), 8568 (width = _b[3]), 8569 (height = _b[4]); 8570 (_c = calculateGradientDirection( 8571 backgroundImage.angle, 8572 width, 8573 height 8574 )), 8575 (lineLength = _c[0]), 8576 (x0 = _c[1]), 8577 (x1 = _c[2]), 8578 (y0 = _c[3]), 8579 (y1 = _c[4]); 8580 canvas = document.createElement("canvas"); 8581 canvas.width = width; 8582 canvas.height = height; 8583 ctx = canvas.getContext("2d"); 8584 gradient_1 = ctx.createLinearGradient(x0, y0, x1, y1); 8585 processColorStops( 8586 backgroundImage.stops, 8587 lineLength 8588 ).forEach(function (colorStop) { 8589 return gradient_1.addColorStop( 8590 colorStop.stop, 8591 asString(colorStop.color) 8592 ); 8593 }); 8594 ctx.fillStyle = gradient_1; 8595 ctx.fillRect(0, 0, width, height); 8596 if (width > 0 && height > 0) { 8597 pattern = this_1.ctx.createPattern(canvas, "repeat"); 8598 this_1.renderRepeat(path, pattern, x, y); 8599 } 8600 } else if (isRadialGradient(backgroundImage)) { 8601 (_d = calculateBackgroundRendering(container, index, [ 8602 null, 8603 null, 8604 null, 8605 ])), 8606 (path = _d[0]), 8607 (left = _d[1]), 8608 (top_1 = _d[2]), 8609 (width = _d[3]), 8610 (height = _d[4]); 8611 position = 8612 backgroundImage.position.length === 0 8613 ? [FIFTY_PERCENT] 8614 : backgroundImage.position; 8615 x = getAbsoluteValue(position[0], width); 8616 y = getAbsoluteValue( 8617 position[position.length - 1], 8618 height 8619 ); 8620 (_e = calculateRadius( 8621 backgroundImage, 8622 x, 8623 y, 8624 width, 8625 height 8626 )), 8627 (rx = _e[0]), 8628 (ry = _e[1]); 8629 if (rx > 0 && rx > 0) { 8630 radialGradient_1 = this_1.ctx.createRadialGradient( 8631 left + x, 8632 top_1 + y, 8633 0, 8634 left + x, 8635 top_1 + y, 8636 rx 8637 ); 8638 processColorStops( 8639 backgroundImage.stops, 8640 rx * 2 8641 ).forEach(function (colorStop) { 8642 return radialGradient_1.addColorStop( 8643 colorStop.stop, 8644 asString(colorStop.color) 8645 ); 8646 }); 8647 this_1.path(path); 8648 this_1.ctx.fillStyle = radialGradient_1; 8649 if (rx !== ry) { 8650 midX = 8651 container.bounds.left + 8652 0.5 * container.bounds.width; 8653 midY = 8654 container.bounds.top + 8655 0.5 * container.bounds.height; 8656 f = ry / rx; 8657 invF = 1 / f; 8658 this_1.ctx.save(); 8659 this_1.ctx.translate(midX, midY); 8660 this_1.ctx.transform(1, 0, 0, f, 0, 0); 8661 this_1.ctx.translate(-midX, -midY); 8662 this_1.ctx.fillRect( 8663 left, 8664 invF * (top_1 - midY) + midY, 8665 width, 8666 height * invF 8667 );
vendor: 5,048 bytes, lines 8668-8797
8668 this_1.ctx.restore(); 8669 } else { 8670 this_1.ctx.fill(); 8671 } 8672 } 8673 } 8674 _f.label = 6; 8675 case 6: 8676 index--; 8677 return [2 /*return*/]; 8678 } 8679 }); 8680 }; 8681 this_1 = this; 8682 (_i = 0), 8683 (_a = container.styles.backgroundImage.slice(0).reverse()); 8684 _b.label = 1; 8685 case 1: 8686 if (!(_i < _a.length)) return [3 /*break*/, 4]; 8687 backgroundImage = _a[_i]; 8688 return [5 /*yield**/, _loop_1(backgroundImage)]; 8689 case 2: 8690 _b.sent(); 8691 _b.label = 3; 8692 case 3: 8693 _i++; 8694 return [3 /*break*/, 1]; 8695 case 4: 8696 return [2 /*return*/]; 8697 } 8698 }); 8699 }); 8700 }; 8701 CanvasRenderer.prototype.renderBorder = function ( 8702 color, 8703 side, 8704 curvePoints 8705 ) { 8706 return __awaiter(this, void 0, void 0, function () { 8707 return __generator(this, function (_a) { 8708 this.path(parsePathForBorder(curvePoints, side)); 8709 this.ctx.fillStyle = asString(color); 8710 this.ctx.fill(); 8711 return [2 /*return*/]; 8712 }); 8713 }); 8714 }; 8715 CanvasRenderer.prototype.renderNodeBackgroundAndBorders = function (paint) { 8716 return __awaiter(this, void 0, void 0, function () { 8717 var styles, 8718 hasBackground, 8719 borders, 8720 backgroundPaintingArea, 8721 side, 8722 _i, 8723 borders_1, 8724 border; 8725 var _this = this; 8726 return __generator(this, function (_a) { 8727 switch (_a.label) { 8728 case 0: 8729 this.applyEffects(paint.effects, 2 /* BACKGROUND_BORDERS */); 8730 styles = paint.container.styles; 8731 hasBackground = 8732 !isTransparent(styles.backgroundColor) || 8733 styles.backgroundImage.length; 8734 borders = [ 8735 { style: styles.borderTopStyle, color: styles.borderTopColor }, 8736 { 8737 style: styles.borderRightStyle, 8738 color: styles.borderRightColor, 8739 }, 8740 { 8741 style: styles.borderBottomStyle, 8742 color: styles.borderBottomColor, 8743 }, 8744 { 8745 style: styles.borderLeftStyle, 8746 color: styles.borderLeftColor, 8747 }, 8748 ]; 8749 backgroundPaintingArea = calculateBackgroundCurvedPaintingArea( 8750 getBackgroundValueForIndex(styles.backgroundClip, 0), 8751 paint.curves 8752 ); 8753 if (!(hasBackground || styles.boxShadow.length)) 8754 return [3 /*break*/, 2]; 8755 this.ctx.save(); 8756 this.path(backgroundPaintingArea); 8757 this.ctx.clip(); 8758 if (!isTransparent(styles.backgroundColor)) { 8759 this.ctx.fillStyle = asString(styles.backgroundColor); 8760 this.ctx.fill(); 8761 } 8762 return [4 /*yield*/, this.renderBackgroundImage(paint.container)]; 8763 case 1: 8764 _a.sent(); 8765 this.ctx.restore(); 8766 styles.boxShadow 8767 .slice(0) 8768 .reverse() 8769 .forEach(function (shadow) { 8770 _this.ctx.save(); 8771 var borderBoxArea = calculateBorderBoxPath(paint.curves); 8772 var maskOffset = shadow.inset ? 0 : MASK_OFFSET; 8773 var shadowPaintingArea = transformPath( 8774 borderBoxArea, 8775 -maskOffset + 8776 (shadow.inset ? 1 : -1) * shadow.spread.number, 8777 (shadow.inset ? 1 : -1) * shadow.spread.number, 8778 shadow.spread.number * (shadow.inset ? -2 : 2), 8779 shadow.spread.number * (shadow.inset ? -2 : 2) 8780 ); 8781 if (shadow.inset) { 8782 _this.path(borderBoxArea); 8783 _this.ctx.clip(); 8784 _this.mask(shadowPaintingArea); 8785 } else { 8786 _this.mask(borderBoxArea); 8787 _this.ctx.clip(); 8788 _this.path(shadowPaintingArea); 8789 } 8790 _this.ctx.shadowOffsetX = shadow.offsetX.number + maskOffset; 8791 _this.ctx.shadowOffsetY = shadow.offsetY.number; 8792 _this.ctx.shadowColor = asString(shadow.color); 8793 _this.ctx.shadowBlur = shadow.blur.number; 8794 _this.ctx.fillStyle = shadow.inset 8795 ? asString(shadow.color) 8796 : "rgba(0,0,0,1)"; 8797 _this.ctx.fill();
8798 _this.ctx.restore(); 8799 }); 8800 _a.label = 2; 8801 case 2: 8802 side = 0; 8803 (_i = 0), (borders_1 = borders); 8804 _a.label = 3; 8805 case 3: 8806 if (!(_i < borders_1.length)) return [3 /*break*/, 7]; 8807 border = borders_1[_i]; 8808 if ( 8809 !( 8810 border.style !== BORDER_STYLE.NONE && 8811 !isTransparent(border.color) 8812 ) 8813 ) 8814 return [3 /*break*/, 5]; 8815 return [ 8816 4 /*yield*/, 8817 this.renderBorder(border.color, side, paint.curves), 8818 ]; 8819 case 4: 8820 _a.sent(); 8821 _a.label = 5; 8822 case 5: 8823 side++; 8824 _a.label = 6; 8825 case 6: 8826 _i++; 8827 return [3 /*break*/, 3]; 8828 case 7: 8829 return [2 /*return*/]; 8830 } 8831 }); 8832 }); 8833 }; 8834 CanvasRenderer.prototype.render = function (element) { 8835 return __awaiter(this, void 0, void 0, function () { 8836 var stack; 8837 return __generator(this, function (_a) { 8838 switch (_a.label) { 8839 case 0: 8840 if (this.options.backgroundColor) { 8841 this.ctx.fillStyle = asString(this.options.backgroundColor); 8842 this.ctx.fillRect( 8843 this.options.x - this.options.scrollX, 8844 this.options.y - this.options.scrollY, 8845 this.options.width, 8846 this.options.height 8847 ); 8848 } 8849 stack = parseStackingContexts(element); 8850 return [4 /*yield*/, this.renderStack(stack)]; 8851 case 1: 8852 _a.sent(); 8853 this.applyEffects([], 2 /* BACKGROUND_BORDERS */); 8854 return [2 /*return*/, this.canvas]; 8855 } 8856 }); 8857 }); 8858 }; 8859 return CanvasRenderer; 8860 })();
8861 var isTextInputElement = function (container) { 8862 if (container instanceof TextareaElementContainer) { 8863 return true; 8864 } else if (container instanceof SelectElementContainer) { 8865 return true; 8866 } else if ( 8867 container instanceof InputElementContainer && 8868 container.type !== RADIO && 8869 container.type !== CHECKBOX 8870 ) { 8871 return true; 8872 } 8873 return false; 8874 }; 8875 var calculateBackgroundCurvedPaintingArea = function (clip, curves) { 8876 switch (clip) { 8877 case BACKGROUND_CLIP.BORDER_BOX: 8878 return calculateBorderBoxPath(curves); 8879 case BACKGROUND_CLIP.CONTENT_BOX: 8880 return calculateContentBoxPath(curves); 8881 case BACKGROUND_CLIP.PADDING_BOX: 8882 default: 8883 return calculatePaddingBoxPath(curves); 8884 } 8885 }; 8886 var canvasTextAlign = function (textAlign) { 8887 switch (textAlign) { 8888 case TEXT_ALIGN.CENTER: 8889 return "center"; 8890 case TEXT_ALIGN.RIGHT: 8891 return "right"; 8892 case TEXT_ALIGN.LEFT: 8893 default: 8894 return "left"; 8895 } 8896 }; 8897 8898 var ForeignObjectRenderer = /** @class */ (function () { 8899 function ForeignObjectRenderer(options) { 8900 this.canvas = options.canvas 8901 ? options.canvas 8902 : document.createElement("canvas"); 8903 this.ctx = this.canvas.getContext("2d"); 8904 this.options = options; 8905 this.canvas.width = Math.floor(options.width * options.scale); 8906 this.canvas.height = Math.floor(options.height * options.scale); 8907 this.canvas.style.width = options.width + "px"; 8908 this.canvas.style.height = options.height + "px"; 8909 this.ctx.scale(this.options.scale, this.options.scale); 8910 this.ctx.translate( 8911 -options.x + options.scrollX, 8912 -options.y + options.scrollY 8913 ); 8914 Logger.getInstance(options.id).debug( 8915 "EXPERIMENTAL ForeignObject renderer initialized (" + 8916 options.width + 8917 "x" + 8918 options.height + 8919 " at " + 8920 options.x + 8921 "," + 8922 options.y + 8923 ") with scale " + 8924 options.scale 8925 ); 8926 } 8927 ForeignObjectRenderer.prototype.render = function (element) { 8928 return __awaiter(this, void 0, void 0, function () { 8929 var svg, img; 8930 return __generator(this, function (_a) { 8931 switch (_a.label) { 8932 case 0: 8933 svg = createForeignObjectSVG( 8934 Math.max(this.options.windowWidth, this.options.width) * 8935 this.options.scale, 8936 Math.max(this.options.windowHeight, this.options.height) * 8937 this.options.scale, 8938 this.options.scrollX * this.options.scale, 8939 this.options.scrollY * this.options.scale, 8940 element 8941 ); 8942 return [4 /*yield*/, loadSerializedSVG$1(svg)]; 8943 case 1: 8944 img = _a.sent(); 8945 if (this.options.backgroundColor) { 8946 this.ctx.fillStyle = asString(this.options.backgroundColor); 8947 this.ctx.fillRect( 8948 0, 8949 0, 8950 this.options.width * this.options.scale, 8951 this.options.height * this.options.scale 8952 ); 8953 } 8954 this.ctx.drawImage( 8955 img, 8956 -this.options.x * this.options.scale, 8957 -this.options.y * this.options.scale 8958 ); 8959 return [2 /*return*/, this.canvas]; 8960 } 8961 }); 8962 }); 8963 }; 8964 return ForeignObjectRenderer; 8965 })();
8966 var loadSerializedSVG$1 = function (svg) { 8967 return new Promise(function (resolve, reject) { 8968 var img = new Image(); 8969 img.onload = function () { 8970 resolve(img); 8971 }; 8972 img.onerror = reject; 8973 img.src = 8974 "data:image/svg+xml;charset=utf-8," + 8975 encodeURIComponent(new XMLSerializer().serializeToString(svg)); 8976 }); 8977 }; 8978 8979 var _this = undefined; 8980 var parseColor$1 = function (value) { 8981 return color.parse(Parser.create(value).parseComponentValue()); 8982 }; 8983 var html2canvas = function (element, options) { 8984 if (options === void 0) { 8985 options = {}; 8986 } 8987 return renderElement(element, options); 8988 }; 8989 if (typeof window !== "undefined") { 8990 CacheStorage.setContext(window); 8991 } 8992 var renderElement = function (element, opts) { 8993 return __awaiter(_this, void 0, void 0, function () { 8994 var ownerDocument, 8995 defaultView, 8996 instanceName, 8997 _a, 8998 width, 8999 height, 9000 left, 9001 top, 9002 defaultResourceOptions, 9003 resourceOptions, 9004 defaultOptions, 9005 options, 9006 windowBounds, 9007 documentCloner, 9008 clonedElement, 9009 container, 9010 documentBackgroundColor, 9011 bodyBackgroundColor, 9012 bgColor, 9013 defaultBackgroundColor, 9014 backgroundColor, 9015 renderOptions, 9016 canvas, 9017 renderer, 9018 root, 9019 renderer; 9020 return __generator(this, function (_b) { 9021 switch (_b.label) { 9022 case 0: 9023 ownerDocument = element.ownerDocument; 9024 if (!ownerDocument) { 9025 throw new Error("Element is not attached to a Document"); 9026 } 9027 defaultView = ownerDocument.defaultView; 9028 if (!defaultView) { 9029 throw new Error("Document is not attached to a Window"); 9030 } 9031 instanceName = ( 9032 Math.round(Math.random() * 1000) + Date.now() 9033 ).toString(16); 9034 (_a = 9035 isBodyElement(element) || isHTMLElement(element) 9036 ? parseDocumentSize(ownerDocument) 9037 : parseBounds(element)), 9038 (width = _a.width), 9039 (height = _a.height), 9040 (left = _a.left), 9041 (top = _a.top); 9042 defaultResourceOptions = { 9043 allowTaint: false, 9044 imageTimeout: 15000, 9045 proxy: undefined, 9046 useCORS: false, 9047 }; 9048 resourceOptions = __assign({}, defaultResourceOptions, opts); 9049 defaultOptions = { 9050 backgroundColor: "#ffffff", 9051 cache: opts.cache 9052 ? opts.cache 9053 : CacheStorage.create(instanceName, resourceOptions), 9054 logging: true, 9055 removeContainer: true, 9056 foreignObjectRendering: false, 9057 scale: defaultView.devicePixelRatio || 1, 9058 windowWidth: defaultView.innerWidth, 9059 windowHeight: defaultView.innerHeight, 9060 scrollX: defaultView.pageXOffset, 9061 scrollY: defaultView.pageYOffset, 9062 x: left, 9063 y: top, 9064 width: Math.ceil(width), 9065 height: Math.ceil(height), 9066 id: instanceName, 9067 }; 9068 options = __assign({}, defaultOptions, resourceOptions, opts); 9069 windowBounds = new Bounds( 9070 options.scrollX, 9071 options.scrollY, 9072 options.windowWidth, 9073 options.windowHeight 9074 ); 9075 Logger.create({ id: instanceName, enabled: options.logging }); 9076 Logger.getInstance(instanceName).debug("Starting document clone"); 9077 documentCloner = new DocumentCloner(element, { 9078 id: instanceName, 9079 onclone: options.onclone, 9080 ignoreElements: options.ignoreElements, 9081 inlineImages: options.foreignObjectRendering, 9082 copyStyles: options.foreignObjectRendering, 9083 }); 9084 clonedElement = documentCloner.clonedReferenceElement; 9085 if (!clonedElement) { 9086 return [ 9087 2 /*return*/, 9088 Promise.reject("Unable to find element in cloned iframe"), 9089 ]; 9090 } 9091 return [ 9092 4 /*yield*/, 9093 documentCloner.toIFrame(ownerDocument, windowBounds), 9094 ]; 9095 case 1: 9096 container = _b.sent();
9097 documentBackgroundColor = ownerDocument.documentElement 9098 ? parseColor$1( 9099 getComputedStyle(ownerDocument.documentElement) 9100 .backgroundColor 9101 ) 9102 : COLORS.TRANSPARENT; 9103 bodyBackgroundColor = ownerDocument.body 9104 ? parseColor$1( 9105 getComputedStyle(ownerDocument.body).backgroundColor 9106 ) 9107 : COLORS.TRANSPARENT; 9108 bgColor = opts.backgroundColor; 9109 defaultBackgroundColor = 9110 typeof bgColor === "string" 9111 ? parseColor$1(bgColor) 9112 : bgColor === null 9113 ? COLORS.TRANSPARENT 9114 : 0xffffffff; 9115 backgroundColor = 9116 element === ownerDocument.documentElement 9117 ? isTransparent(documentBackgroundColor) 9118 ? isTransparent(bodyBackgroundColor) 9119 ? defaultBackgroundColor 9120 : bodyBackgroundColor 9121 : documentBackgroundColor 9122 : defaultBackgroundColor; 9123 renderOptions = { 9124 id: instanceName, 9125 cache: options.cache, 9126 canvas: options.canvas, 9127 backgroundColor: backgroundColor, 9128 scale: options.scale, 9129 x: options.x, 9130 y: options.y, 9131 scrollX: options.scrollX, 9132 scrollY: options.scrollY, 9133 width: options.width, 9134 height: options.height, 9135 windowWidth: options.windowWidth, 9136 windowHeight: options.windowHeight, 9137 }; 9138 if (!options.foreignObjectRendering) return [3 /*break*/, 3]; 9139 Logger.getInstance(instanceName).debug( 9140 "Document cloned, using foreign object rendering" 9141 ); 9142 renderer = new ForeignObjectRenderer(renderOptions); 9143 return [4 /*yield*/, renderer.render(clonedElement)]; 9144 case 2: 9145 canvas = _b.sent(); 9146 return [3 /*break*/, 5]; 9147 case 3: 9148 Logger.getInstance(instanceName).debug( 9149 "Document cloned, using computed rendering" 9150 ); 9151 CacheStorage.attachInstance(options.cache); 9152 Logger.getInstance(instanceName).debug("Starting DOM parsing"); 9153 root = parseTree(clonedElement); 9154 CacheStorage.detachInstance(); 9155 if (backgroundColor === root.styles.backgroundColor) { 9156 root.styles.backgroundColor = COLORS.TRANSPARENT; 9157 } 9158 Logger.getInstance(instanceName).debug("Starting renderer"); 9159 renderer = new CanvasRenderer(renderOptions); 9160 return [4 /*yield*/, renderer.render(root)]; 9161 case 4: 9162 canvas = _b.sent(); 9163 _b.label = 5; 9164 case 5: 9165 if (options.removeContainer === true) { 9166 if (!DocumentCloner.destroy(container)) { 9167 Logger.getInstance(instanceName).error( 9168 "Cannot detach cloned iframe as it is not in the DOM anymore" 9169 ); 9170 } 9171 } 9172 Logger.getInstance(instanceName).debug("Finished rendering"); 9173 Logger.destroy(instanceName); 9174 CacheStorage.destroy(instanceName); 9175 return [2 /*return*/, canvas]; 9176 } 9177 }); 9178 }); 9179 }; 9180 9181 return html2canvas; 9182}); 9183//# sourceMappingURL=html2canvas.js.map
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.