vendor: 3,595 bytes, lines 1-88
1/******/ (function(modules) { // webpackBootstrap 2/******/ // The module cache 3/******/ var installedModules = {}; 4/******/ 5/******/ // The require function 6/******/ function __webpack_require__(moduleId) { 7/******/ 8/******/ // Check if module is in cache 9/******/ if(installedModules[moduleId]) { 10/******/ return installedModules[moduleId].exports; 11/******/ } 12/******/ // Create a new module (and put it into the cache) 13/******/ var module = installedModules[moduleId] = { 14/******/ i: moduleId, 15/******/ l: false, 16/******/ exports: {} 17/******/ }; 18/******/ 19/******/ // Execute the module function 20/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); 21/******/ 22/******/ // Flag the module as loaded 23/******/ module.l = true; 24/******/ 25/******/ // Return the exports of the module 26/******/ return module.exports; 27/******/ } 28/******/ 29/******/ 30/******/ // expose the modules object (__webpack_modules__) 31/******/ __webpack_require__.m = modules; 32/******/ 33/******/ // expose the module cache 34/******/ __webpack_require__.c = installedModules; 35/******/ 36/******/ // define getter function for harmony exports 37/******/ __webpack_require__.d = function(exports, name, getter) { 38/******/ if(!__webpack_require__.o(exports, name)) { 39/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter }); 40/******/ } 41/******/ }; 42/******/ 43/******/ // define __esModule on exports 44/******/ __webpack_require__.r = function(exports) { 45/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { 46/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); 47/******/ } 48/******/ Object.defineProperty(exports, '__esModule', { value: true }); 49/******/ }; 50/******/ 51/******/ // create a fake namespace object 52/******/ // mode & 1: value is a module id, require it 53/******/ // mode & 2: merge all properties of value into the ns 54/******/ // mode & 4: return value when already ns object 55/******/ // mode & 8|1: behave like require 56/******/ __webpack_require__.t = function(value, mode) { 57/******/ if(mode & 1) value = __webpack_require__(value); 58/******/ if(mode & 8) return value; 59/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value; 60/******/ var ns = Object.create(null); 61/******/ __webpack_require__.r(ns); 62/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value }); 63/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key)); 64/******/ return ns; 65/******/ }; 66/******/ 67/******/ // getDefaultExport function for compatibility with non-harmony modules 68/******/ __webpack_require__.n = function(module) { 69/******/ var getter = module && module.__esModule ? 70/******/ function getDefault() { return module['default']; } : 71/******/ function getModuleExports() { return module; }; 72/******/ __webpack_require__.d(getter, 'a', getter); 73/******/ return getter; 74/******/ }; 75/******/ 76/******/ // Object.prototype.hasOwnProperty.call 77/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; 78/******/ 79/******/ // __webpack_public_path__ 80/******/ __webpack_require__.p = "/"; 81/******/ 82/******/ 83/******/ // Load entry module and return exports 84/******/ return __webpack_require__(__webpack_require__.s = 0); 85/******/ }) 86/************************************************************************/ 87/******/ ({ 88
89/***/ "./assets/css/app.css": 90/*!****************************!*\ 91 !*** ./assets/css/app.css ***! 92 \****************************/ 93/*! no static exports found */ 94/***/ (function(module, exports) { 95 96// removed by extract-text-webpack-plugin 97 98/***/ }), 99
vendor: 4,218 bytes, lines 100-261
100/***/ "./node_modules/base64-js/index.js": 101/*!*****************************************!*\ 102 !*** ./node_modules/base64-js/index.js ***! 103 \*****************************************/ 104/*! no static exports found */ 105/***/ (function(module, exports, __webpack_require__) { 106 107"use strict"; 108 109 110exports.byteLength = byteLength 111exports.toByteArray = toByteArray 112exports.fromByteArray = fromByteArray 113 114var lookup = [] 115var revLookup = [] 116var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array 117 118var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/' 119for (var i = 0, len = code.length; i < len; ++i) { 120 lookup[i] = code[i] 121 revLookup[code.charCodeAt(i)] = i 122} 123 124// Support decoding URL-safe base64 strings, as Node.js does. 125// See: https://en.wikipedia.org/wiki/Base64#URL_applications 126revLookup['-'.charCodeAt(0)] = 62 127revLookup['_'.charCodeAt(0)] = 63 128 129function getLens (b64) { 130 var len = b64.length 131 132 if (len % 4 > 0) { 133 throw new Error('Invalid string. Length must be a multiple of 4') 134 } 135 136 // Trim off extra bytes after placeholder bytes are found 137 // See: https://github.com/beatgammit/base64-js/issues/42 138 var validLen = b64.indexOf('=') 139 if (validLen === -1) validLen = len 140 141 var placeHoldersLen = validLen === len 142 ? 0 143 : 4 - (validLen % 4) 144 145 return [validLen, placeHoldersLen] 146} 147 148// base64 is 4/3 + up to two characters of the original data 149function byteLength (b64) { 150 var lens = getLens(b64) 151 var validLen = lens[0] 152 var placeHoldersLen = lens[1] 153 return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen 154} 155 156function _byteLength (b64, validLen, placeHoldersLen) { 157 return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen 158} 159 160function toByteArray (b64) { 161 var tmp 162 var lens = getLens(b64) 163 var validLen = lens[0] 164 var placeHoldersLen = lens[1] 165 166 var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen)) 167 168 var curByte = 0 169 170 // if there are placeholders, only get up to the last complete 4 chars 171 var len = placeHoldersLen > 0 172 ? validLen - 4 173 : validLen 174 175 var i 176 for (i = 0; i < len; i += 4) { 177 tmp = 178 (revLookup[b64.charCodeAt(i)] << 18) | 179 (revLookup[b64.charCodeAt(i + 1)] << 12) | 180 (revLookup[b64.charCodeAt(i + 2)] << 6) | 181 revLookup[b64.charCodeAt(i + 3)] 182 arr[curByte++] = (tmp >> 16) & 0xFF 183 arr[curByte++] = (tmp >> 8) & 0xFF 184 arr[curByte++] = tmp & 0xFF 185 } 186 187 if (placeHoldersLen === 2) { 188 tmp = 189 (revLookup[b64.charCodeAt(i)] << 2) | 190 (revLookup[b64.charCodeAt(i + 1)] >> 4) 191 arr[curByte++] = tmp & 0xFF 192 } 193 194 if (placeHoldersLen === 1) { 195 tmp = 196 (revLookup[b64.charCodeAt(i)] << 10) | 197 (revLookup[b64.charCodeAt(i + 1)] << 4) | 198 (revLookup[b64.charCodeAt(i + 2)] >> 2) 199 arr[curByte++] = (tmp >> 8) & 0xFF 200 arr[curByte++] = tmp & 0xFF 201 } 202 203 return arr 204} 205 206function tripletToBase64 (num) { 207 return lookup[num >> 18 & 0x3F] + 208 lookup[num >> 12 & 0x3F] + 209 lookup[num >> 6 & 0x3F] + 210 lookup[num & 0x3F] 211} 212 213function encodeChunk (uint8, start, end) { 214 var tmp 215 var output = [] 216 for (var i = start; i < end; i += 3) { 217 tmp = 218 ((uint8[i] << 16) & 0xFF0000) + 219 ((uint8[i + 1] << 8) & 0xFF00) + 220 (uint8[i + 2] & 0xFF) 221 output.push(tripletToBase64(tmp)) 222 } 223 return output.join('') 224} 225 226function fromByteArray (uint8) { 227 var tmp 228 var len = uint8.length 229 var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes 230 var parts = [] 231 var maxChunkLength = 16383 // must be multiple of 3 232 233 // go through the array every three bytes, we'll deal with trailing stuff later 234 for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) { 235 parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength))) 236 } 237 238 // pad the end with zeros, but make sure to not forget the extra bytes 239 if (extraBytes === 1) { 240 tmp = uint8[len - 1] 241 parts.push( 242 lookup[tmp >> 2] + 243 lookup[(tmp << 4) & 0x3F] + 244 '==' 245 ) 246 } else if (extraBytes === 2) { 247 tmp = (uint8[len - 2] << 8) + uint8[len - 1] 248 parts.push( 249 lookup[tmp >> 10] + 250 lookup[(tmp >> 4) & 0x3F] + 251 lookup[(tmp << 2) & 0x3F] + 252 '=' 253 ) 254 } 255 256 return parts.join('') 257} 258 259 260/***/ }), 261
vendor: 49,209 bytes, lines 262-2063
262/***/ "./node_modules/buffer/index.js": 263/*!**************************************!*\ 264 !*** ./node_modules/buffer/index.js ***! 265 \**************************************/ 266/*! no static exports found */ 267/***/ (function(module, exports, __webpack_require__) { 268 269"use strict"; 270/* WEBPACK VAR INJECTION */(function(global) {/*! 271 * The buffer module from node.js, for the browser. 272 * 273 * @author Feross Aboukhadijeh <http://feross.org> 274 * @license MIT 275 */ 276/* eslint-disable no-proto */ 277 278 279 280var base64 = __webpack_require__(/*! base64-js */ "./node_modules/base64-js/index.js") 281var ieee754 = __webpack_require__(/*! ieee754 */ "./node_modules/ieee754/index.js") 282var isArray = __webpack_require__(/*! isarray */ "./node_modules/isarray/index.js") 283 284exports.Buffer = Buffer 285exports.SlowBuffer = SlowBuffer 286exports.INSPECT_MAX_BYTES = 50 287 288/** 289 * If `Buffer.TYPED_ARRAY_SUPPORT`: 290 * === true Use Uint8Array implementation (fastest) 291 * === false Use Object implementation (most compatible, even IE6) 292 * 293 * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+, 294 * Opera 11.6+, iOS 4.2+. 295 * 296 * Due to various browser bugs, sometimes the Object implementation will be used even 297 * when the browser supports typed arrays. 298 * 299 * Note: 300 * 301 * - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances, 302 * See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438. 303 * 304 * - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function. 305 * 306 * - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of 307 * incorrect length in some situations. 308 309 * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they 310 * get the Object implementation, which is slower but behaves correctly. 311 */ 312Buffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined 313 ? global.TYPED_ARRAY_SUPPORT 314 : typedArraySupport() 315 316/* 317 * Export kMaxLength after typed array support is determined. 318 */ 319exports.kMaxLength = kMaxLength() 320 321function typedArraySupport () { 322 try { 323 var arr = new Uint8Array(1) 324 arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }} 325 return arr.foo() === 42 && // typed array instances can be augmented 326 typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray` 327 arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray` 328 } catch (e) { 329 return false 330 } 331} 332 333function kMaxLength () { 334 return Buffer.TYPED_ARRAY_SUPPORT 335 ? 0x7fffffff 336 : 0x3fffffff 337} 338 339function createBuffer (that, length) { 340 if (kMaxLength() < length) { 341 throw new RangeError('Invalid typed array length') 342 } 343 if (Buffer.TYPED_ARRAY_SUPPORT) { 344 // Return an augmented `Uint8Array` instance, for best performance 345 that = new Uint8Array(length) 346 that.__proto__ = Buffer.prototype 347 } else { 348 // Fallback: Return an object instance of the Buffer class 349 if (that === null) { 350 that = new Buffer(length) 351 } 352 that.length = length 353 } 354 355 return that 356} 357 358/** 359 * The Buffer constructor returns instances of `Uint8Array` that have their 360 * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of 361 * `Uint8Array`, so the returned instances will have all the node `Buffer` methods 362 * and the `Uint8Array` methods. Square bracket notation works as expected -- it 363 * returns a single octet. 364 * 365 * The `Uint8Array` prototype remains unmodified. 366 */ 367 368function Buffer (arg, encodingOrOffset, length) { 369 if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) { 370 return new Buffer(arg, encodingOrOffset, length) 371 } 372 373 // Common case. 374 if (typeof arg === 'number') { 375 if (typeof encodingOrOffset === 'string') { 376 throw new Error( 377 'If encoding is specified then the first argument must be a string' 378 ) 379 } 380 return allocUnsafe(this, arg) 381 } 382 return from(this, arg, encodingOrOffset, length) 383} 384 385Buffer.poolSize = 8192 // not used by this implementation 386 387// TODO: Legacy, not needed anymore. Remove in next major version. 388Buffer._augment = function (arr) { 389 arr.__proto__ = Buffer.prototype 390 return arr 391} 392 393function from (that, value, encodingOrOffset, length) { 394 if (typeof value === 'number') { 395 throw new TypeError('"value" argument must not be a number') 396 } 397 398 if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) { 399 return fromArrayBuffer(that, value, encodingOrOffset, length) 400 } 401 402 if (typeof value === 'string') { 403 return fromString(that, value, encodingOrOffset) 404 } 405 406 return fromObject(that, value) 407} 408 409/** 410 * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError 411 * if value is a number. 412 * Buffer.from(str[, encoding]) 413 * Buffer.from(array) 414 * Buffer.from(buffer) 415 * Buffer.from(arrayBuffer[, byteOffset[, length]]) 416 **/ 417Buffer.from = function (value, encodingOrOffset, length) { 418 return from(null, value, encodingOrOffset, length) 419} 420 421if (Buffer.TYPED_ARRAY_SUPPORT) { 422 Buffer.prototype.__proto__ = Uint8Array.prototype 423 Buffer.__proto__ = Uint8Array 424 if (typeof Symbol !== 'undefined' && Symbol.species && 425 Buffer[Symbol.species] === Buffer) { 426 // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97 427 Object.defineProperty(Buffer, Symbol.species, { 428 value: null, 429 configurable: true 430 }) 431 } 432} 433 434function assertSize (size) { 435 if (typeof size !== 'number') { 436 throw new TypeError('"size" argument must be a number') 437 } else if (size < 0) { 438 throw new RangeError('"size" argument must not be negative') 439 } 440} 441 442function alloc (that, size, fill, encoding) { 443 assertSize(size) 444 if (size <= 0) { 445 return createBuffer(that, size) 446 } 447 if (fill !== undefined) { 448 // Only pay attention to encoding if it's a string. This 449 // prevents accidentally sending in a number that would 450 // be interpretted as a start offset. 451 return typeof encoding === 'string' 452 ? createBuffer(that, size).fill(fill, encoding) 453 : createBuffer(that, size).fill(fill) 454 } 455 return createBuffer(that, size) 456} 457 458/** 459 * Creates a new filled Buffer instance. 460 * alloc(size[, fill[, encoding]]) 461 **/ 462Buffer.alloc = function (size, fill, encoding) { 463 return alloc(null, size, fill, encoding) 464} 465 466function allocUnsafe (that, size) { 467 assertSize(size) 468 that = createBuffer(that, size < 0 ? 0 : checked(size) | 0) 469 if (!Buffer.TYPED_ARRAY_SUPPORT) { 470 for (var i = 0; i < size; ++i) { 471 that[i] = 0 472 } 473 } 474 return that 475} 476 477/** 478 * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance. 479 * */ 480Buffer.allocUnsafe = function (size) { 481 return allocUnsafe(null, size) 482} 483/** 484 * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance. 485 */ 486Buffer.allocUnsafeSlow = function (size) { 487 return allocUnsafe(null, size) 488} 489 490function fromString (that, string, encoding) { 491 if (typeof encoding !== 'string' || encoding === '') { 492 encoding = 'utf8' 493 } 494 495 if (!Buffer.isEncoding(encoding)) { 496 throw new TypeError('"encoding" must be a valid string encoding') 497 } 498 499 var length = byteLength(string, encoding) | 0 500 that = createBuffer(that, length) 501 502 var actual = that.write(string, encoding) 503 504 if (actual !== length) { 505 // Writing a hex string, for example, that contains invalid characters will 506 // cause everything after the first invalid character to be ignored. (e.g. 507 // 'abxxcd' will be treated as 'ab') 508 that = that.slice(0, actual) 509 } 510 511 return that 512} 513 514function fromArrayLike (that, array) { 515 var length = array.length < 0 ? 0 : checked(array.length) | 0 516 that = createBuffer(that, length) 517 for (var i = 0; i < length; i += 1) { 518 that[i] = array[i] & 255 519 } 520 return that 521} 522 523function fromArrayBuffer (that, array, byteOffset, length) { 524 array.byteLength // this throws if `array` is not a valid ArrayBuffer 525 526 if (byteOffset < 0 || array.byteLength < byteOffset) { 527 throw new RangeError('\'offset\' is out of bounds') 528 } 529 530 if (array.byteLength < byteOffset + (length || 0)) { 531 throw new RangeError('\'length\' is out of bounds') 532 } 533 534 if (byteOffset === undefined && length === undefined) { 535 array = new Uint8Array(array) 536 } else if (length === undefined) { 537 array = new Uint8Array(array, byteOffset) 538 } else { 539 array = new Uint8Array(array, byteOffset, length) 540 } 541 542 if (Buffer.TYPED_ARRAY_SUPPORT) { 543 // Return an augmented `Uint8Array` instance, for best performance 544 that = array 545 that.__proto__ = Buffer.prototype 546 } else { 547 // Fallback: Return an object instance of the Buffer class 548 that = fromArrayLike(that, array) 549 } 550 return that 551} 552 553function fromObject (that, obj) { 554 if (Buffer.isBuffer(obj)) { 555 var len = checked(obj.length) | 0 556 that = createBuffer(that, len) 557 558 if (that.length === 0) { 559 return that 560 } 561 562 obj.copy(that, 0, 0, len) 563 return that 564 } 565 566 if (obj) { 567 if ((typeof ArrayBuffer !== 'undefined' && 568 obj.buffer instanceof ArrayBuffer) || 'length' in obj) { 569 if (typeof obj.length !== 'number' || isnan(obj.length)) { 570 return createBuffer(that, 0) 571 } 572 return fromArrayLike(that, obj) 573 } 574 575 if (obj.type === 'Buffer' && isArray(obj.data)) { 576 return fromArrayLike(that, obj.data) 577 } 578 } 579 580 throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.') 581} 582 583function checked (length) { 584 // Note: cannot use `length < kMaxLength()` here because that fails when 585 // length is NaN (which is otherwise coerced to zero.) 586 if (length >= kMaxLength()) { 587 throw new RangeError('Attempt to allocate Buffer larger than maximum ' + 588 'size: 0x' + kMaxLength().toString(16) + ' bytes') 589 } 590 return length | 0 591} 592 593function SlowBuffer (length) { 594 if (+length != length) { // eslint-disable-line eqeqeq 595 length = 0 596 } 597 return Buffer.alloc(+length) 598} 599 600Buffer.isBuffer = function isBuffer (b) { 601 return !!(b != null && b._isBuffer) 602} 603 604Buffer.compare = function compare (a, b) { 605 if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) { 606 throw new TypeError('Arguments must be Buffers') 607 } 608 609 if (a === b) return 0 610 611 var x = a.length 612 var y = b.length 613 614 for (var i = 0, len = Math.min(x, y); i < len; ++i) { 615 if (a[i] !== b[i]) { 616 x = a[i] 617 y = b[i] 618 break 619 } 620 } 621 622 if (x < y) return -1 623 if (y < x) return 1 624 return 0 625} 626 627Buffer.isEncoding = function isEncoding (encoding) { 628 switch (String(encoding).toLowerCase()) { 629 case 'hex': 630 case 'utf8': 631 case 'utf-8': 632 case 'ascii': 633 case 'latin1': 634 case 'binary': 635 case 'base64': 636 case 'ucs2': 637 case 'ucs-2': 638 case 'utf16le': 639 case 'utf-16le': 640 return true 641 default: 642 return false 643 } 644} 645 646Buffer.concat = function concat (list, length) { 647 if (!isArray(list)) { 648 throw new TypeError('"list" argument must be an Array of Buffers') 649 } 650 651 if (list.length === 0) { 652 return Buffer.alloc(0) 653 } 654 655 var i 656 if (length === undefined) { 657 length = 0 658 for (i = 0; i < list.length; ++i) { 659 length += list[i].length 660 } 661 } 662 663 var buffer = Buffer.allocUnsafe(length) 664 var pos = 0 665 for (i = 0; i < list.length; ++i) { 666 var buf = list[i] 667 if (!Buffer.isBuffer(buf)) { 668 throw new TypeError('"list" argument must be an Array of Buffers') 669 } 670 buf.copy(buffer, pos) 671 pos += buf.length 672 } 673 return buffer 674} 675 676function byteLength (string, encoding) { 677 if (Buffer.isBuffer(string)) { 678 return string.length 679 } 680 if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' && 681 (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) { 682 return string.byteLength 683 } 684 if (typeof string !== 'string') { 685 string = '' + string 686 } 687 688 var len = string.length 689 if (len === 0) return 0 690 691 // Use a for loop to avoid recursion 692 var loweredCase = false 693 for (;;) { 694 switch (encoding) { 695 case 'ascii': 696 case 'latin1': 697 case 'binary': 698 return len 699 case 'utf8': 700 case 'utf-8': 701 case undefined: 702 return utf8ToBytes(string).length 703 case 'ucs2': 704 case 'ucs-2': 705 case 'utf16le': 706 case 'utf-16le': 707 return len * 2 708 case 'hex': 709 return len >>> 1 710 case 'base64': 711 return base64ToBytes(string).length 712 default: 713 if (loweredCase) return utf8ToBytes(string).length // assume utf8 714 encoding = ('' + encoding).toLowerCase() 715 loweredCase = true 716 } 717 } 718} 719Buffer.byteLength = byteLength 720 721function slowToString (encoding, start, end) { 722 var loweredCase = false 723 724 // No need to verify that "this.length <= MAX_UINT32" since it's a read-only 725 // property of a typed array. 726 727 // This behaves neither like String nor Uint8Array in that we set start/end 728 // to their upper/lower bounds if the value passed is out of range. 729 // undefined is handled specially as per ECMA-262 6th Edition, 730 // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization. 731 if (start === undefined || start < 0) { 732 start = 0 733 } 734 // Return early if start > this.length. Done here to prevent potential uint32 735 // coercion fail below. 736 if (start > this.length) { 737 return '' 738 } 739 740 if (end === undefined || end > this.length) { 741 end = this.length 742 } 743 744 if (end <= 0) { 745 return '' 746 } 747 748 // Force coersion to uint32. This will also coerce falsey/NaN values to 0. 749 end >>>= 0 750 start >>>= 0 751 752 if (end <= start) { 753 return '' 754 } 755 756 if (!encoding) encoding = 'utf8' 757 758 while (true) { 759 switch (encoding) { 760 case 'hex': 761 return hexSlice(this, start, end) 762 763 case 'utf8': 764 case 'utf-8': 765 return utf8Slice(this, start, end) 766 767 case 'ascii': 768 return asciiSlice(this, start, end) 769 770 case 'latin1': 771 case 'binary': 772 return latin1Slice(this, start, end) 773 774 case 'base64': 775 return base64Slice(this, start, end) 776 777 case 'ucs2': 778 case 'ucs-2': 779 case 'utf16le': 780 case 'utf-16le': 781 return utf16leSlice(this, start, end) 782 783 default: 784 if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) 785 encoding = (encoding + '').toLowerCase() 786 loweredCase = true 787 } 788 } 789} 790 791// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect 792// Buffer instances. 793Buffer.prototype._isBuffer = true 794 795function swap (b, n, m) { 796 var i = b[n] 797 b[n] = b[m] 798 b[m] = i 799} 800 801Buffer.prototype.swap16 = function swap16 () { 802 var len = this.length 803 if (len % 2 !== 0) { 804 throw new RangeError('Buffer size must be a multiple of 16-bits') 805 } 806 for (var i = 0; i < len; i += 2) { 807 swap(this, i, i + 1) 808 } 809 return this 810} 811 812Buffer.prototype.swap32 = function swap32 () { 813 var len = this.length 814 if (len % 4 !== 0) { 815 throw new RangeError('Buffer size must be a multiple of 32-bits') 816 } 817 for (var i = 0; i < len; i += 4) { 818 swap(this, i, i + 3) 819 swap(this, i + 1, i + 2) 820 } 821 return this 822} 823 824Buffer.prototype.swap64 = function swap64 () { 825 var len = this.length 826 if (len % 8 !== 0) { 827 throw new RangeError('Buffer size must be a multiple of 64-bits') 828 } 829 for (var i = 0; i < len; i += 8) { 830 swap(this, i, i + 7) 831 swap(this, i + 1, i + 6) 832 swap(this, i + 2, i + 5) 833 swap(this, i + 3, i + 4) 834 } 835 return this 836} 837 838Buffer.prototype.toString = function toString () { 839 var length = this.length | 0 840 if (length === 0) return '' 841 if (arguments.length === 0) return utf8Slice(this, 0, length) 842 return slowToString.apply(this, arguments) 843} 844 845Buffer.prototype.equals = function equals (b) { 846 if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer') 847 if (this === b) return true 848 return Buffer.compare(this, b) === 0 849} 850 851Buffer.prototype.inspect = function inspect () { 852 var str = '' 853 var max = exports.INSPECT_MAX_BYTES 854 if (this.length > 0) { 855 str = this.toString('hex', 0, max).match(/.{2}/g).join(' ') 856 if (this.length > max) str += ' ... ' 857 } 858 return '<Buffer ' + str + '>' 859} 860 861Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) { 862 if (!Buffer.isBuffer(target)) { 863 throw new TypeError('Argument must be a Buffer') 864 } 865 866 if (start === undefined) { 867 start = 0 868 } 869 if (end === undefined) { 870 end = target ? target.length : 0 871 } 872 if (thisStart === undefined) { 873 thisStart = 0 874 } 875 if (thisEnd === undefined) { 876 thisEnd = this.length 877 } 878 879 if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) { 880 throw new RangeError('out of range index') 881 } 882 883 if (thisStart >= thisEnd && start >= end) { 884 return 0 885 } 886 if (thisStart >= thisEnd) { 887 return -1 888 } 889 if (start >= end) { 890 return 1 891 } 892 893 start >>>= 0 894 end >>>= 0 895 thisStart >>>= 0 896 thisEnd >>>= 0 897 898 if (this === target) return 0 899 900 var x = thisEnd - thisStart 901 var y = end - start 902 var len = Math.min(x, y) 903 904 var thisCopy = this.slice(thisStart, thisEnd) 905 var targetCopy = target.slice(start, end) 906 907 for (var i = 0; i < len; ++i) { 908 if (thisCopy[i] !== targetCopy[i]) { 909 x = thisCopy[i] 910 y = targetCopy[i] 911 break 912 } 913 } 914 915 if (x < y) return -1 916 if (y < x) return 1 917 return 0 918} 919 920// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`, 921// OR the last index of `val` in `buffer` at offset <= `byteOffset`. 922// 923// Arguments: 924// - buffer - a Buffer to search 925// - val - a string, Buffer, or number 926// - byteOffset - an index into `buffer`; will be clamped to an int32 927// - encoding - an optional encoding, relevant is val is a string 928// - dir - true for indexOf, false for lastIndexOf 929function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) { 930 // Empty buffer means no match 931 if (buffer.length === 0) return -1 932 933 // Normalize byteOffset 934 if (typeof byteOffset === 'string') { 935 encoding = byteOffset 936 byteOffset = 0 937 } else if (byteOffset > 0x7fffffff) { 938 byteOffset = 0x7fffffff 939 } else if (byteOffset < -0x80000000) { 940 byteOffset = -0x80000000 941 } 942 byteOffset = +byteOffset // Coerce to Number. 943 if (isNaN(byteOffset)) { 944 // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer 945 byteOffset = dir ? 0 : (buffer.length - 1) 946 } 947 948 // Normalize byteOffset: negative offsets start from the end of the buffer 949 if (byteOffset < 0) byteOffset = buffer.length + byteOffset 950 if (byteOffset >= buffer.length) { 951 if (dir) return -1 952 else byteOffset = buffer.length - 1 953 } else if (byteOffset < 0) { 954 if (dir) byteOffset = 0 955 else return -1 956 } 957 958 // Normalize val 959 if (typeof val === 'string') { 960 val = Buffer.from(val, encoding) 961 } 962 963 // Finally, search either indexOf (if dir is true) or lastIndexOf 964 if (Buffer.isBuffer(val)) { 965 // Special case: looking for empty string/buffer always fails 966 if (val.length === 0) { 967 return -1 968 } 969 return arrayIndexOf(buffer, val, byteOffset, encoding, dir) 970 } else if (typeof val === 'number') { 971 val = val & 0xFF // Search for a byte value [0-255] 972 if (Buffer.TYPED_ARRAY_SUPPORT && 973 typeof Uint8Array.prototype.indexOf === 'function') { 974 if (dir) { 975 return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset) 976 } else { 977 return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset) 978 } 979 } 980 return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir) 981 } 982 983 throw new TypeError('val must be string, number or Buffer') 984} 985 986function arrayIndexOf (arr, val, byteOffset, encoding, dir) { 987 var indexSize = 1 988 var arrLength = arr.length 989 var valLength = val.length 990 991 if (encoding !== undefined) { 992 encoding = String(encoding).toLowerCase() 993 if (encoding === 'ucs2' || encoding === 'ucs-2' || 994 encoding === 'utf16le' || encoding === 'utf-16le') { 995 if (arr.length < 2 || val.length < 2) { 996 return -1 997 } 998 indexSize = 2 999 arrLength /= 2 1000 valLength /= 2 1001 byteOffset /= 2 1002 } 1003 } 1004 1005 function read (buf, i) { 1006 if (indexSize === 1) { 1007 return buf[i] 1008 } else { 1009 return buf.readUInt16BE(i * indexSize) 1010 } 1011 } 1012 1013 var i 1014 if (dir) { 1015 var foundIndex = -1 1016 for (i = byteOffset; i < arrLength; i++) { 1017 if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) { 1018 if (foundIndex === -1) foundIndex = i 1019 if (i - foundIndex + 1 === valLength) return foundIndex * indexSize 1020 } else { 1021 if (foundIndex !== -1) i -= i - foundIndex 1022 foundIndex = -1 1023 } 1024 } 1025 } else { 1026 if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength 1027 for (i = byteOffset; i >= 0; i--) { 1028 var found = true 1029 for (var j = 0; j < valLength; j++) { 1030 if (read(arr, i + j) !== read(val, j)) { 1031 found = false 1032 break 1033 } 1034 } 1035 if (found) return i 1036 } 1037 } 1038 1039 return -1 1040} 1041 1042Buffer.prototype.includes = function includes (val, byteOffset, encoding) { 1043 return this.indexOf(val, byteOffset, encoding) !== -1 1044} 1045 1046Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) { 1047 return bidirectionalIndexOf(this, val, byteOffset, encoding, true) 1048} 1049 1050Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) { 1051 return bidirectionalIndexOf(this, val, byteOffset, encoding, false) 1052} 1053 1054function hexWrite (buf, string, offset, length) { 1055 offset = Number(offset) || 0 1056 var remaining = buf.length - offset 1057 if (!length) { 1058 length = remaining 1059 } else { 1060 length = Number(length) 1061 if (length > remaining) { 1062 length = remaining 1063 } 1064 } 1065 1066 // must be an even number of digits 1067 var strLen = string.length 1068 if (strLen % 2 !== 0) throw new TypeError('Invalid hex string') 1069 1070 if (length > strLen / 2) { 1071 length = strLen / 2 1072 } 1073 for (var i = 0; i < length; ++i) { 1074 var parsed = parseInt(string.substr(i * 2, 2), 16) 1075 if (isNaN(parsed)) return i 1076 buf[offset + i] = parsed 1077 } 1078 return i 1079} 1080 1081function utf8Write (buf, string, offset, length) { 1082 return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length) 1083} 1084 1085function asciiWrite (buf, string, offset, length) { 1086 return blitBuffer(asciiToBytes(string), buf, offset, length) 1087} 1088 1089function latin1Write (buf, string, offset, length) { 1090 return asciiWrite(buf, string, offset, length) 1091} 1092 1093function base64Write (buf, string, offset, length) { 1094 return blitBuffer(base64ToBytes(string), buf, offset, length) 1095} 1096 1097function ucs2Write (buf, string, offset, length) { 1098 return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length) 1099} 1100 1101Buffer.prototype.write = function write (string, offset, length, encoding) { 1102 // Buffer#write(string) 1103 if (offset === undefined) { 1104 encoding = 'utf8' 1105 length = this.length 1106 offset = 0 1107 // Buffer#write(string, encoding) 1108 } else if (length === undefined && typeof offset === 'string') { 1109 encoding = offset 1110 length = this.length 1111 offset = 0 1112 // Buffer#write(string, offset[, length][, encoding]) 1113 } else if (isFinite(offset)) { 1114 offset = offset | 0 1115 if (isFinite(length)) { 1116 length = length | 0 1117 if (encoding === undefined) encoding = 'utf8' 1118 } else { 1119 encoding = length 1120 length = undefined 1121 } 1122 // legacy write(string, encoding, offset, length) - remove in v0.13 1123 } else { 1124 throw new Error( 1125 'Buffer.write(string, encoding, offset[, length]) is no longer supported' 1126 ) 1127 } 1128 1129 var remaining = this.length - offset 1130 if (length === undefined || length > remaining) length = remaining 1131 1132 if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) { 1133 throw new RangeError('Attempt to write outside buffer bounds') 1134 } 1135 1136 if (!encoding) encoding = 'utf8' 1137 1138 var loweredCase = false 1139 for (;;) { 1140 switch (encoding) { 1141 case 'hex': 1142 return hexWrite(this, string, offset, length) 1143 1144 case 'utf8': 1145 case 'utf-8': 1146 return utf8Write(this, string, offset, length) 1147 1148 case 'ascii': 1149 return asciiWrite(this, string, offset, length) 1150 1151 case 'latin1': 1152 case 'binary': 1153 return latin1Write(this, string, offset, length) 1154 1155 case 'base64': 1156 // Warning: maxLength not taken into account in base64Write 1157 return base64Write(this, string, offset, length) 1158 1159 case 'ucs2': 1160 case 'ucs-2': 1161 case 'utf16le': 1162 case 'utf-16le': 1163 return ucs2Write(this, string, offset, length) 1164 1165 default: 1166 if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) 1167 encoding = ('' + encoding).toLowerCase() 1168 loweredCase = true 1169 } 1170 } 1171} 1172 1173Buffer.prototype.toJSON = function toJSON () { 1174 return { 1175 type: 'Buffer', 1176 data: Array.prototype.slice.call(this._arr || this, 0) 1177 } 1178} 1179 1180function base64Slice (buf, start, end) { 1181 if (start === 0 && end === buf.length) { 1182 return base64.fromByteArray(buf) 1183 } else { 1184 return base64.fromByteArray(buf.slice(start, end)) 1185 } 1186} 1187 1188function utf8Slice (buf, start, end) { 1189 end = Math.min(buf.length, end) 1190 var res = [] 1191 1192 var i = start 1193 while (i < end) { 1194 var firstByte = buf[i] 1195 var codePoint = null 1196 var bytesPerSequence = (firstByte > 0xEF) ? 4 1197 : (firstByte > 0xDF) ? 3 1198 : (firstByte > 0xBF) ? 2 1199 : 1 1200 1201 if (i + bytesPerSequence <= end) { 1202 var secondByte, thirdByte, fourthByte, tempCodePoint 1203 1204 switch (bytesPerSequence) { 1205 case 1: 1206 if (firstByte < 0x80) { 1207 codePoint = firstByte 1208 } 1209 break 1210 case 2: 1211 secondByte = buf[i + 1] 1212 if ((secondByte & 0xC0) === 0x80) { 1213 tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F) 1214 if (tempCodePoint > 0x7F) { 1215 codePoint = tempCodePoint 1216 } 1217 } 1218 break 1219 case 3: 1220 secondByte = buf[i + 1] 1221 thirdByte = buf[i + 2] 1222 if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) { 1223 tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F) 1224 if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) { 1225 codePoint = tempCodePoint 1226 } 1227 } 1228 break 1229 case 4: 1230 secondByte = buf[i + 1] 1231 thirdByte = buf[i + 2] 1232 fourthByte = buf[i + 3] 1233 if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) { 1234 tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F) 1235 if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) { 1236 codePoint = tempCodePoint 1237 } 1238 } 1239 } 1240 } 1241 1242 if (codePoint === null) { 1243 // we did not generate a valid codePoint so insert a 1244 // replacement char (U+FFFD) and advance only 1 byte 1245 codePoint = 0xFFFD 1246 bytesPerSequence = 1 1247 } else if (codePoint > 0xFFFF) { 1248 // encode to utf16 (surrogate pair dance) 1249 codePoint -= 0x10000 1250 res.push(codePoint >>> 10 & 0x3FF | 0xD800) 1251 codePoint = 0xDC00 | codePoint & 0x3FF 1252 } 1253 1254 res.push(codePoint) 1255 i += bytesPerSequence 1256 } 1257 1258 return decodeCodePointsArray(res) 1259} 1260 1261// Based on http://stackoverflow.com/a/22747272/680742, the browser with 1262// the lowest limit is Chrome, with 0x10000 args. 1263// We go 1 magnitude less, for safety 1264var MAX_ARGUMENTS_LENGTH = 0x1000 1265 1266function decodeCodePointsArray (codePoints) { 1267 var len = codePoints.length 1268 if (len <= MAX_ARGUMENTS_LENGTH) { 1269 return String.fromCharCode.apply(String, codePoints) // avoid extra slice() 1270 } 1271 1272 // Decode in chunks to avoid "call stack size exceeded". 1273 var res = '' 1274 var i = 0 1275 while (i < len) { 1276 res += String.fromCharCode.apply( 1277 String, 1278 codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH) 1279 ) 1280 } 1281 return res 1282} 1283 1284function asciiSlice (buf, start, end) { 1285 var ret = '' 1286 end = Math.min(buf.length, end) 1287 1288 for (var i = start; i < end; ++i) { 1289 ret += String.fromCharCode(buf[i] & 0x7F) 1290 } 1291 return ret 1292} 1293 1294function latin1Slice (buf, start, end) { 1295 var ret = '' 1296 end = Math.min(buf.length, end) 1297 1298 for (var i = start; i < end; ++i) { 1299 ret += String.fromCharCode(buf[i]) 1300 } 1301 return ret 1302} 1303 1304function hexSlice (buf, start, end) { 1305 var len = buf.length 1306 1307 if (!start || start < 0) start = 0 1308 if (!end || end < 0 || end > len) end = len 1309 1310 var out = '' 1311 for (var i = start; i < end; ++i) { 1312 out += toHex(buf[i]) 1313 } 1314 return out 1315} 1316 1317function utf16leSlice (buf, start, end) { 1318 var bytes = buf.slice(start, end) 1319 var res = '' 1320 for (var i = 0; i < bytes.length; i += 2) { 1321 res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256) 1322 } 1323 return res 1324} 1325 1326Buffer.prototype.slice = function slice (start, end) { 1327 var len = this.length 1328 start = ~~start 1329 end = end === undefined ? len : ~~end 1330 1331 if (start < 0) { 1332 start += len 1333 if (start < 0) start = 0 1334 } else if (start > len) { 1335 start = len 1336 } 1337 1338 if (end < 0) { 1339 end += len 1340 if (end < 0) end = 0 1341 } else if (end > len) { 1342 end = len 1343 } 1344 1345 if (end < start) end = start 1346 1347 var newBuf 1348 if (Buffer.TYPED_ARRAY_SUPPORT) { 1349 newBuf = this.subarray(start, end) 1350 newBuf.__proto__ = Buffer.prototype 1351 } else { 1352 var sliceLen = end - start 1353 newBuf = new Buffer(sliceLen, undefined) 1354 for (var i = 0; i < sliceLen; ++i) { 1355 newBuf[i] = this[i + start] 1356 } 1357 } 1358 1359 return newBuf 1360} 1361 1362/* 1363 * Need to make sure that buffer isn't trying to write out of bounds. 1364 */ 1365function checkOffset (offset, ext, length) { 1366 if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint') 1367 if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length') 1368} 1369 1370Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) { 1371 offset = offset | 0 1372 byteLength = byteLength | 0 1373 if (!noAssert) checkOffset(offset, byteLength, this.length) 1374 1375 var val = this[offset] 1376 var mul = 1 1377 var i = 0 1378 while (++i < byteLength && (mul *= 0x100)) { 1379 val += this[offset + i] * mul 1380 } 1381 1382 return val 1383} 1384 1385Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) { 1386 offset = offset | 0 1387 byteLength = byteLength | 0 1388 if (!noAssert) { 1389 checkOffset(offset, byteLength, this.length) 1390 } 1391 1392 var val = this[offset + --byteLength] 1393 var mul = 1 1394 while (byteLength > 0 && (mul *= 0x100)) { 1395 val += this[offset + --byteLength] * mul 1396 } 1397 1398 return val 1399} 1400 1401Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) { 1402 if (!noAssert) checkOffset(offset, 1, this.length) 1403 return this[offset] 1404} 1405 1406Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) { 1407 if (!noAssert) checkOffset(offset, 2, this.length) 1408 return this[offset] | (this[offset + 1] << 8) 1409} 1410 1411Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) { 1412 if (!noAssert) checkOffset(offset, 2, this.length) 1413 return (this[offset] << 8) | this[offset + 1] 1414} 1415 1416Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) { 1417 if (!noAssert) checkOffset(offset, 4, this.length) 1418 1419 return ((this[offset]) | 1420 (this[offset + 1] << 8) | 1421 (this[offset + 2] << 16)) + 1422 (this[offset + 3] * 0x1000000) 1423} 1424 1425Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) { 1426 if (!noAssert) checkOffset(offset, 4, this.length) 1427 1428 return (this[offset] * 0x1000000) + 1429 ((this[offset + 1] << 16) | 1430 (this[offset + 2] << 8) | 1431 this[offset + 3]) 1432} 1433 1434Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) { 1435 offset = offset | 0 1436 byteLength = byteLength | 0 1437 if (!noAssert) checkOffset(offset, byteLength, this.length) 1438 1439 var val = this[offset] 1440 var mul = 1 1441 var i = 0 1442 while (++i < byteLength && (mul *= 0x100)) { 1443 val += this[offset + i] * mul 1444 } 1445 mul *= 0x80 1446 1447 if (val >= mul) val -= Math.pow(2, 8 * byteLength) 1448 1449 return val 1450} 1451 1452Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) { 1453 offset = offset | 0 1454 byteLength = byteLength | 0 1455 if (!noAssert) checkOffset(offset, byteLength, this.length) 1456 1457 var i = byteLength 1458 var mul = 1 1459 var val = this[offset + --i] 1460 while (i > 0 && (mul *= 0x100)) { 1461 val += this[offset + --i] * mul 1462 } 1463 mul *= 0x80 1464 1465 if (val >= mul) val -= Math.pow(2, 8 * byteLength) 1466 1467 return val 1468} 1469 1470Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) { 1471 if (!noAssert) checkOffset(offset, 1, this.length) 1472 if (!(this[offset] & 0x80)) return (this[offset]) 1473 return ((0xff - this[offset] + 1) * -1) 1474} 1475 1476Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) { 1477 if (!noAssert) checkOffset(offset, 2, this.length) 1478 var val = this[offset] | (this[offset + 1] << 8) 1479 return (val & 0x8000) ? val | 0xFFFF0000 : val 1480} 1481 1482Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) { 1483 if (!noAssert) checkOffset(offset, 2, this.length) 1484 var val = this[offset + 1] | (this[offset] << 8) 1485 return (val & 0x8000) ? val | 0xFFFF0000 : val 1486} 1487 1488Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) { 1489 if (!noAssert) checkOffset(offset, 4, this.length) 1490 1491 return (this[offset]) | 1492 (this[offset + 1] << 8) | 1493 (this[offset + 2] << 16) | 1494 (this[offset + 3] << 24) 1495} 1496 1497Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) { 1498 if (!noAssert) checkOffset(offset, 4, this.length) 1499 1500 return (this[offset] << 24) | 1501 (this[offset + 1] << 16) | 1502 (this[offset + 2] << 8) | 1503 (this[offset + 3]) 1504} 1505 1506Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) { 1507 if (!noAssert) checkOffset(offset, 4, this.length) 1508 return ieee754.read(this, offset, true, 23, 4) 1509} 1510 1511Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) { 1512 if (!noAssert) checkOffset(offset, 4, this.length) 1513 return ieee754.read(this, offset, false, 23, 4) 1514} 1515 1516Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) { 1517 if (!noAssert) checkOffset(offset, 8, this.length) 1518 return ieee754.read(this, offset, true, 52, 8) 1519} 1520 1521Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) { 1522 if (!noAssert) checkOffset(offset, 8, this.length) 1523 return ieee754.read(this, offset, false, 52, 8) 1524} 1525 1526function checkInt (buf, value, offset, ext, max, min) { 1527 if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance') 1528 if (value > max || value < min) throw new RangeError('"value" argument is out of bounds') 1529 if (offset + ext > buf.length) throw new RangeError('Index out of range') 1530} 1531 1532Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) { 1533 value = +value 1534 offset = offset | 0 1535 byteLength = byteLength | 0 1536 if (!noAssert) { 1537 var maxBytes = Math.pow(2, 8 * byteLength) - 1 1538 checkInt(this, value, offset, byteLength, maxBytes, 0) 1539 } 1540 1541 var mul = 1 1542 var i = 0 1543 this[offset] = value & 0xFF 1544 while (++i < byteLength && (mul *= 0x100)) { 1545 this[offset + i] = (value / mul) & 0xFF 1546 } 1547 1548 return offset + byteLength 1549} 1550 1551Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) { 1552 value = +value 1553 offset = offset | 0 1554 byteLength = byteLength | 0 1555 if (!noAssert) { 1556 var maxBytes = Math.pow(2, 8 * byteLength) - 1 1557 checkInt(this, value, offset, byteLength, maxBytes, 0) 1558 } 1559 1560 var i = byteLength - 1 1561 var mul = 1 1562 this[offset + i] = value & 0xFF 1563 while (--i >= 0 && (mul *= 0x100)) { 1564 this[offset + i] = (value / mul) & 0xFF 1565 } 1566 1567 return offset + byteLength 1568} 1569 1570Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) { 1571 value = +value 1572 offset = offset | 0 1573 if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0) 1574 if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value) 1575 this[offset] = (value & 0xff) 1576 return offset + 1 1577} 1578 1579function objectWriteUInt16 (buf, value, offset, littleEndian) { 1580 if (value < 0) value = 0xffff + value + 1 1581 for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) { 1582 buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>> 1583 (littleEndian ? i : 1 - i) * 8 1584 } 1585} 1586 1587Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) { 1588 value = +value 1589 offset = offset | 0 1590 if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0) 1591 if (Buffer.TYPED_ARRAY_SUPPORT) { 1592 this[offset] = (value & 0xff) 1593 this[offset + 1] = (value >>> 8) 1594 } else { 1595 objectWriteUInt16(this, value, offset, true) 1596 } 1597 return offset + 2 1598} 1599 1600Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) { 1601 value = +value 1602 offset = offset | 0 1603 if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0) 1604 if (Buffer.TYPED_ARRAY_SUPPORT) { 1605 this[offset] = (value >>> 8) 1606 this[offset + 1] = (value & 0xff) 1607 } else { 1608 objectWriteUInt16(this, value, offset, false) 1609 } 1610 return offset + 2 1611} 1612 1613function objectWriteUInt32 (buf, value, offset, littleEndian) { 1614 if (value < 0) value = 0xffffffff + value + 1 1615 for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) { 1616 buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff 1617 } 1618} 1619 1620Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) { 1621 value = +value 1622 offset = offset | 0 1623 if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0) 1624 if (Buffer.TYPED_ARRAY_SUPPORT) { 1625 this[offset + 3] = (value >>> 24) 1626 this[offset + 2] = (value >>> 16) 1627 this[offset + 1] = (value >>> 8) 1628 this[offset] = (value & 0xff) 1629 } else { 1630 objectWriteUInt32(this, value, offset, true) 1631 } 1632 return offset + 4 1633} 1634 1635Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) { 1636 value = +value 1637 offset = offset | 0 1638 if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0) 1639 if (Buffer.TYPED_ARRAY_SUPPORT) { 1640 this[offset] = (value >>> 24) 1641 this[offset + 1] = (value >>> 16) 1642 this[offset + 2] = (value >>> 8) 1643 this[offset + 3] = (value & 0xff) 1644 } else { 1645 objectWriteUInt32(this, value, offset, false) 1646 } 1647 return offset + 4 1648} 1649 1650Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) { 1651 value = +value 1652 offset = offset | 0 1653 if (!noAssert) { 1654 var limit = Math.pow(2, 8 * byteLength - 1) 1655 1656 checkInt(this, value, offset, byteLength, limit - 1, -limit) 1657 } 1658 1659 var i = 0 1660 var mul = 1 1661 var sub = 0 1662 this[offset] = value & 0xFF 1663 while (++i < byteLength && (mul *= 0x100)) { 1664 if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) { 1665 sub = 1 1666 } 1667 this[offset + i] = ((value / mul) >> 0) - sub & 0xFF 1668 } 1669 1670 return offset + byteLength 1671} 1672 1673Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) { 1674 value = +value 1675 offset = offset | 0 1676 if (!noAssert) { 1677 var limit = Math.pow(2, 8 * byteLength - 1) 1678 1679 checkInt(this, value, offset, byteLength, limit - 1, -limit) 1680 } 1681 1682 var i = byteLength - 1 1683 var mul = 1 1684 var sub = 0 1685 this[offset + i] = value & 0xFF 1686 while (--i >= 0 && (mul *= 0x100)) { 1687 if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) { 1688 sub = 1 1689 } 1690 this[offset + i] = ((value / mul) >> 0) - sub & 0xFF 1691 } 1692 1693 return offset + byteLength 1694} 1695 1696Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) { 1697 value = +value 1698 offset = offset | 0 1699 if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80) 1700 if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value) 1701 if (value < 0) value = 0xff + value + 1 1702 this[offset] = (value & 0xff) 1703 return offset + 1 1704} 1705 1706Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) { 1707 value = +value 1708 offset = offset | 0 1709 if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000) 1710 if (Buffer.TYPED_ARRAY_SUPPORT) { 1711 this[offset] = (value & 0xff) 1712 this[offset + 1] = (value >>> 8) 1713 } else { 1714 objectWriteUInt16(this, value, offset, true) 1715 } 1716 return offset + 2 1717} 1718 1719Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) { 1720 value = +value 1721 offset = offset | 0 1722 if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000) 1723 if (Buffer.TYPED_ARRAY_SUPPORT) { 1724 this[offset] = (value >>> 8) 1725 this[offset + 1] = (value & 0xff) 1726 } else { 1727 objectWriteUInt16(this, value, offset, false) 1728 } 1729 return offset + 2 1730} 1731 1732Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) { 1733 value = +value 1734 offset = offset | 0 1735 if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000) 1736 if (Buffer.TYPED_ARRAY_SUPPORT) { 1737 this[offset] = (value & 0xff) 1738 this[offset + 1] = (value >>> 8) 1739 this[offset + 2] = (value >>> 16) 1740 this[offset + 3] = (value >>> 24) 1741 } else { 1742 objectWriteUInt32(this, value, offset, true) 1743 } 1744 return offset + 4 1745} 1746 1747Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) { 1748 value = +value 1749 offset = offset | 0 1750 if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000) 1751 if (value < 0) value = 0xffffffff + value + 1 1752 if (Buffer.TYPED_ARRAY_SUPPORT) { 1753 this[offset] = (value >>> 24) 1754 this[offset + 1] = (value >>> 16) 1755 this[offset + 2] = (value >>> 8) 1756 this[offset + 3] = (value & 0xff) 1757 } else { 1758 objectWriteUInt32(this, value, offset, false) 1759 } 1760 return offset + 4 1761} 1762 1763function checkIEEE754 (buf, value, offset, ext, max, min) { 1764 if (offset + ext > buf.length) throw new RangeError('Index out of range') 1765 if (offset < 0) throw new RangeError('Index out of range') 1766} 1767 1768function writeFloat (buf, value, offset, littleEndian, noAssert) { 1769 if (!noAssert) { 1770 checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38) 1771 } 1772 ieee754.write(buf, value, offset, littleEndian, 23, 4) 1773 return offset + 4 1774} 1775 1776Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) { 1777 return writeFloat(this, value, offset, true, noAssert) 1778} 1779 1780Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) { 1781 return writeFloat(this, value, offset, false, noAssert) 1782} 1783 1784function writeDouble (buf, value, offset, littleEndian, noAssert) { 1785 if (!noAssert) { 1786 checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308) 1787 } 1788 ieee754.write(buf, value, offset, littleEndian, 52, 8) 1789 return offset + 8 1790} 1791 1792Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) { 1793 return writeDouble(this, value, offset, true, noAssert) 1794} 1795 1796Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) { 1797 return writeDouble(this, value, offset, false, noAssert) 1798} 1799 1800// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length) 1801Buffer.prototype.copy = function copy (target, targetStart, start, end) { 1802 if (!start) start = 0 1803 if (!end && end !== 0) end = this.length 1804 if (targetStart >= target.length) targetStart = target.length 1805 if (!targetStart) targetStart = 0 1806 if (end > 0 && end < start) end = start 1807 1808 // Copy 0 bytes; we're done 1809 if (end === start) return 0 1810 if (target.length === 0 || this.length === 0) return 0 1811 1812 // Fatal error conditions 1813 if (targetStart < 0) { 1814 throw new RangeError('targetStart out of bounds') 1815 } 1816 if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds') 1817 if (end < 0) throw new RangeError('sourceEnd out of bounds') 1818 1819 // Are we oob? 1820 if (end > this.length) end = this.length 1821 if (target.length - targetStart < end - start) { 1822 end = target.length - targetStart + start 1823 } 1824 1825 var len = end - start 1826 var i 1827 1828 if (this === target && start < targetStart && targetStart < end) { 1829 // descending copy from end 1830 for (i = len - 1; i >= 0; --i) { 1831 target[i + targetStart] = this[i + start] 1832 } 1833 } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) { 1834 // ascending copy from start 1835 for (i = 0; i < len; ++i) { 1836 target[i + targetStart] = this[i + start] 1837 } 1838 } else { 1839 Uint8Array.prototype.set.call( 1840 target, 1841 this.subarray(start, start + len), 1842 targetStart 1843 ) 1844 } 1845 1846 return len 1847} 1848 1849// Usage: 1850// buffer.fill(number[, offset[, end]]) 1851// buffer.fill(buffer[, offset[, end]]) 1852// buffer.fill(string[, offset[, end]][, encoding]) 1853Buffer.prototype.fill = function fill (val, start, end, encoding) { 1854 // Handle string cases: 1855 if (typeof val === 'string') { 1856 if (typeof start === 'string') { 1857 encoding = start 1858 start = 0 1859 end = this.length 1860 } else if (typeof end === 'string') { 1861 encoding = end 1862 end = this.length 1863 } 1864 if (val.length === 1) { 1865 var code = val.charCodeAt(0) 1866 if (code < 256) { 1867 val = code 1868 } 1869 } 1870 if (encoding !== undefined && typeof encoding !== 'string') { 1871 throw new TypeError('encoding must be a string') 1872 } 1873 if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) { 1874 throw new TypeError('Unknown encoding: ' + encoding) 1875 } 1876 } else if (typeof val === 'number') { 1877 val = val & 255 1878 } 1879 1880 // Invalid ranges are not set to a default, so can range check early. 1881 if (start < 0 || this.length < start || this.length < end) { 1882 throw new RangeError('Out of range index') 1883 } 1884 1885 if (end <= start) { 1886 return this 1887 } 1888 1889 start = start >>> 0 1890 end = end === undefined ? this.length : end >>> 0 1891 1892 if (!val) val = 0 1893 1894 var i 1895 if (typeof val === 'number') { 1896 for (i = start; i < end; ++i) { 1897 this[i] = val 1898 } 1899 } else { 1900 var bytes = Buffer.isBuffer(val) 1901 ? val 1902 : utf8ToBytes(new Buffer(val, encoding).toString()) 1903 var len = bytes.length 1904 for (i = 0; i < end - start; ++i) { 1905 this[i + start] = bytes[i % len] 1906 } 1907 } 1908 1909 return this 1910} 1911 1912// HELPER FUNCTIONS 1913// ================ 1914 1915var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g 1916 1917function base64clean (str) { 1918 // Node strips out invalid characters like \n and \t from the string, base64-js does not 1919 str = stringtrim(str).replace(INVALID_BASE64_RE, '') 1920 // Node converts strings with length < 2 to '' 1921 if (str.length < 2) return '' 1922 // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not 1923 while (str.length % 4 !== 0) { 1924 str = str + '=' 1925 } 1926 return str 1927} 1928 1929function stringtrim (str) { 1930 if (str.trim) return str.trim() 1931 return str.replace(/^\s+|\s+$/g, '') 1932} 1933 1934function toHex (n) { 1935 if (n < 16) return '0' + n.toString(16) 1936 return n.toString(16) 1937} 1938 1939function utf8ToBytes (string, units) { 1940 units = units || Infinity 1941 var codePoint 1942 var length = string.length 1943 var leadSurrogate = null 1944 var bytes = [] 1945 1946 for (var i = 0; i < length; ++i) { 1947 codePoint = string.charCodeAt(i) 1948 1949 // is surrogate component 1950 if (codePoint > 0xD7FF && codePoint < 0xE000) { 1951 // last char was a lead 1952 if (!leadSurrogate) { 1953 // no lead yet 1954 if (codePoint > 0xDBFF) { 1955 // unexpected trail 1956 if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) 1957 continue 1958 } else if (i + 1 === length) { 1959 // unpaired lead 1960 if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) 1961 continue 1962 } 1963 1964 // valid lead 1965 leadSurrogate = codePoint 1966 1967 continue 1968 } 1969 1970 // 2 leads in a row 1971 if (codePoint < 0xDC00) { 1972 if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) 1973 leadSurrogate = codePoint 1974 continue 1975 } 1976 1977 // valid surrogate pair 1978 codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000 1979 } else if (leadSurrogate) { 1980 // valid bmp char, but last char was a lead 1981 if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) 1982 } 1983 1984 leadSurrogate = null 1985 1986 // encode utf8 1987 if (codePoint < 0x80) { 1988 if ((units -= 1) < 0) break 1989 bytes.push(codePoint) 1990 } else if (codePoint < 0x800) { 1991 if ((units -= 2) < 0) break 1992 bytes.push( 1993 codePoint >> 0x6 | 0xC0, 1994 codePoint & 0x3F | 0x80 1995 ) 1996 } else if (codePoint < 0x10000) { 1997 if ((units -= 3) < 0) break 1998 bytes.push( 1999 codePoint >> 0xC | 0xE0, 2000 codePoint >> 0x6 & 0x3F | 0x80, 2001 codePoint & 0x3F | 0x80 2002 ) 2003 } else if (codePoint < 0x110000) { 2004 if ((units -= 4) < 0) break 2005 bytes.push( 2006 codePoint >> 0x12 | 0xF0, 2007 codePoint >> 0xC & 0x3F | 0x80, 2008 codePoint >> 0x6 & 0x3F | 0x80, 2009 codePoint & 0x3F | 0x80 2010 ) 2011 } else { 2012 throw new Error('Invalid code point') 2013 } 2014 } 2015 2016 return bytes 2017} 2018 2019function asciiToBytes (str) { 2020 var byteArray = [] 2021 for (var i = 0; i < str.length; ++i) { 2022 // Node's code seems to be doing this and not & 0x7F.. 2023 byteArray.push(str.charCodeAt(i) & 0xFF) 2024 } 2025 return byteArray 2026} 2027 2028function utf16leToBytes (str, units) { 2029 var c, hi, lo 2030 var byteArray = [] 2031 for (var i = 0; i < str.length; ++i) { 2032 if ((units -= 2) < 0) break 2033 2034 c = str.charCodeAt(i) 2035 hi = c >> 8 2036 lo = c % 256 2037 byteArray.push(lo) 2038 byteArray.push(hi) 2039 } 2040 2041 return byteArray 2042} 2043 2044function base64ToBytes (str) { 2045 return base64.toByteArray(base64clean(str)) 2046} 2047 2048function blitBuffer (src, dst, offset, length) { 2049 for (var i = 0; i < length; ++i) { 2050 if ((i + offset >= dst.length) || (i >= src.length)) break 2051 dst[i + offset] = src[i] 2052 } 2053 return i 2054} 2055 2056function isnan (val) { 2057 return val !== val // eslint-disable-line no-self-compare 2058} 2059 2060/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../webpack/buildin/global.js */ "./node_modules/webpack/buildin/global.js"))) 2061 2062/***/ }), 2063
vendor: 2,409 bytes, lines 2064-2159
2064/***/ "./node_modules/ieee754/index.js": 2065/*!***************************************!*\ 2066 !*** ./node_modules/ieee754/index.js ***! 2067 \***************************************/ 2068/*! no static exports found */ 2069/***/ (function(module, exports) { 2070 2071/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */ 2072exports.read = function (buffer, offset, isLE, mLen, nBytes) { 2073 var e, m 2074 var eLen = (nBytes * 8) - mLen - 1 2075 var eMax = (1 << eLen) - 1 2076 var eBias = eMax >> 1 2077 var nBits = -7 2078 var i = isLE ? (nBytes - 1) : 0 2079 var d = isLE ? -1 : 1 2080 var s = buffer[offset + i] 2081 2082 i += d 2083 2084 e = s & ((1 << (-nBits)) - 1) 2085 s >>= (-nBits) 2086 nBits += eLen 2087 for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {} 2088 2089 m = e & ((1 << (-nBits)) - 1) 2090 e >>= (-nBits) 2091 nBits += mLen 2092 for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {} 2093 2094 if (e === 0) { 2095 e = 1 - eBias 2096 } else if (e === eMax) { 2097 return m ? NaN : ((s ? -1 : 1) * Infinity) 2098 } else { 2099 m = m + Math.pow(2, mLen) 2100 e = e - eBias 2101 } 2102 return (s ? -1 : 1) * m * Math.pow(2, e - mLen) 2103} 2104 2105exports.write = function (buffer, value, offset, isLE, mLen, nBytes) { 2106 var e, m, c 2107 var eLen = (nBytes * 8) - mLen - 1 2108 var eMax = (1 << eLen) - 1 2109 var eBias = eMax >> 1 2110 var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0) 2111 var i = isLE ? 0 : (nBytes - 1) 2112 var d = isLE ? 1 : -1 2113 var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0 2114 2115 value = Math.abs(value) 2116 2117 if (isNaN(value) || value === Infinity) { 2118 m = isNaN(value) ? 1 : 0 2119 e = eMax 2120 } else { 2121 e = Math.floor(Math.log(value) / Math.LN2) 2122 if (value * (c = Math.pow(2, -e)) < 1) { 2123 e-- 2124 c *= 2 2125 } 2126 if (e + eBias >= 1) { 2127 value += rt / c 2128 } else { 2129 value += rt * Math.pow(2, 1 - eBias) 2130 } 2131 if (value * c >= 2) { 2132 e++ 2133 c /= 2 2134 } 2135 2136 if (e + eBias >= eMax) { 2137 m = 0 2138 e = eMax 2139 } else if (e + eBias >= 1) { 2140 m = ((value * c) - 1) * Math.pow(2, mLen) 2141 e = e + eBias 2142 } else { 2143 m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen) 2144 e = 0 2145 } 2146 } 2147 2148 for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {} 2149 2150 e = (e << mLen) | m 2151 eLen += mLen 2152 for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {} 2153 2154 buffer[offset + i - d] |= s * 128 2155} 2156 2157 2158/***/ }), 2159
vendor: 387 bytes, lines 2160-2175
2160/***/ "./node_modules/isarray/index.js": 2161/*!***************************************!*\ 2162 !*** ./node_modules/isarray/index.js ***! 2163 \***************************************/ 2164/*! no static exports found */ 2165/***/ (function(module, exports) { 2166 2167var toString = {}.toString; 2168 2169module.exports = Array.isArray || function (arr) { 2170 return toString.call(arr) == '[object Array]'; 2171}; 2172 2173 2174/***/ }), 2175
vendor: 1,107 bytes, lines 2176-2211
2176/***/ "./node_modules/nanoid/non-secure/index.js": 2177/*!*************************************************!*\ 2178 !*** ./node_modules/nanoid/non-secure/index.js ***! 2179 \*************************************************/ 2180/*! exports provided: nanoid, customAlphabet */ 2181/***/ (function(module, __webpack_exports__, __webpack_require__) { 2182 2183"use strict"; 2184__webpack_require__.r(__webpack_exports__); 2185/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "nanoid", function() { return nanoid; }); 2186/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "customAlphabet", function() { return customAlphabet; }); 2187let urlAlphabet = 2188 'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict' 2189let customAlphabet = (alphabet, defaultSize = 21) => { 2190 return (size = defaultSize) => { 2191 let id = '' 2192 let i = size 2193 while (i--) { 2194 id += alphabet[(Math.random() * alphabet.length) | 0] 2195 } 2196 return id 2197 } 2198} 2199let nanoid = (size = 21) => { 2200 let id = '' 2201 let i = size 2202 while (i--) { 2203 id += urlAlphabet[(Math.random() * 64) | 0] 2204 } 2205 return id 2206} 2207 2208 2209 2210/***/ }), 2211
vendor: 679 bytes, lines 2212-2226
2212/***/ "./node_modules/picocolors/picocolors.browser.js": 2213/*!*******************************************************!*\ 2214 !*** ./node_modules/picocolors/picocolors.browser.js ***! 2215 \*******************************************************/ 2216/*! no static exports found */ 2217/***/ (function(module, exports) { 2218 2219var x=String; 2220var create=function() {return {isColorSupported:false,reset:x,bold:x,dim:x,italic:x,underline:x,inverse:x,hidden:x,strikethrough:x,black:x,red:x,green:x,yellow:x,blue:x,magenta:x,cyan:x,white:x,gray:x,bgBlack:x,bgRed:x,bgGreen:x,bgYellow:x,bgBlue:x,bgMagenta:x,bgCyan:x,bgWhite:x}}; 2221module.exports=create(); 2222module.exports.createColors = create; 2223 2224 2225/***/ }), 2226
vendor: 832 bytes, lines 2227-2263
2227/***/ "./node_modules/postcss/lib/at-rule.js": 2228/*!*********************************************!*\ 2229 !*** ./node_modules/postcss/lib/at-rule.js ***! 2230 \*********************************************/ 2231/*! no static exports found */ 2232/***/ (function(module, exports, __webpack_require__) { 2233 2234"use strict"; 2235 2236 2237let Container = __webpack_require__(/*! ./container */ "./node_modules/postcss/lib/container.js") 2238 2239class AtRule extends Container { 2240 constructor(defaults) { 2241 super(defaults) 2242 this.type = 'atrule' 2243 } 2244 2245 append(...children) { 2246 if (!this.proxyOf.nodes) this.nodes = [] 2247 return super.append(...children) 2248 } 2249 2250 prepend(...children) { 2251 if (!this.proxyOf.nodes) this.nodes = [] 2252 return super.prepend(...children) 2253 } 2254} 2255 2256module.exports = AtRule 2257AtRule.default = AtRule 2258 2259Container.registerAtRule(AtRule) 2260 2261 2262/***/ }), 2263
vendor: 559 bytes, lines 2264-2288
2264/***/ "./node_modules/postcss/lib/comment.js": 2265/*!*********************************************!*\ 2266 !*** ./node_modules/postcss/lib/comment.js ***! 2267 \*********************************************/ 2268/*! no static exports found */ 2269/***/ (function(module, exports, __webpack_require__) { 2270 2271"use strict"; 2272 2273 2274let Node = __webpack_require__(/*! ./node */ "./node_modules/postcss/lib/node.js") 2275 2276class Comment extends Node { 2277 constructor(defaults) { 2278 super(defaults) 2279 this.type = 'comment' 2280 } 2281} 2282 2283module.exports = Comment 2284Comment.default = Comment 2285 2286 2287/***/ }), 2288
vendor: 10,759 bytes, lines 2289-2733
2289/***/ "./node_modules/postcss/lib/container.js": 2290/*!***********************************************!*\ 2291 !*** ./node_modules/postcss/lib/container.js ***! 2292 \***********************************************/ 2293/*! no static exports found */ 2294/***/ (function(module, exports, __webpack_require__) { 2295 2296"use strict"; 2297 2298 2299let { isClean, my } = __webpack_require__(/*! ./symbols */ "./node_modules/postcss/lib/symbols.js") 2300let Declaration = __webpack_require__(/*! ./declaration */ "./node_modules/postcss/lib/declaration.js") 2301let Comment = __webpack_require__(/*! ./comment */ "./node_modules/postcss/lib/comment.js") 2302let Node = __webpack_require__(/*! ./node */ "./node_modules/postcss/lib/node.js") 2303 2304let parse, Rule, AtRule 2305 2306function cleanSource(nodes) { 2307 return nodes.map(i => { 2308 if (i.nodes) i.nodes = cleanSource(i.nodes) 2309 delete i.source 2310 return i 2311 }) 2312} 2313 2314function markDirtyUp(node) { 2315 node[isClean] = false 2316 if (node.proxyOf.nodes) { 2317 for (let i of node.proxyOf.nodes) { 2318 markDirtyUp(i) 2319 } 2320 } 2321} 2322 2323class Container extends Node { 2324 push(child) { 2325 child.parent = this 2326 this.proxyOf.nodes.push(child) 2327 return this 2328 } 2329 2330 each(callback) { 2331 if (!this.proxyOf.nodes) return undefined 2332 let iterator = this.getIterator() 2333 2334 let index, result 2335 while (this.indexes[iterator] < this.proxyOf.nodes.length) { 2336 index = this.indexes[iterator] 2337 result = callback(this.proxyOf.nodes[index], index) 2338 if (result === false) break 2339 2340 this.indexes[iterator] += 1 2341 } 2342 2343 delete this.indexes[iterator] 2344 return result 2345 } 2346 2347 walk(callback) { 2348 return this.each((child, i) => { 2349 let result 2350 try { 2351 result = callback(child, i) 2352 } catch (e) { 2353 throw child.addToError(e) 2354 } 2355 if (result !== false && child.walk) { 2356 result = child.walk(callback) 2357 } 2358 2359 return result 2360 }) 2361 } 2362 2363 walkDecls(prop, callback) { 2364 if (!callback) { 2365 callback = prop 2366 return this.walk((child, i) => { 2367 if (child.type === 'decl') { 2368 return callback(child, i) 2369 } 2370 }) 2371 } 2372 if (prop instanceof RegExp) { 2373 return this.walk((child, i) => { 2374 if (child.type === 'decl' && prop.test(child.prop)) { 2375 return callback(child, i) 2376 } 2377 }) 2378 } 2379 return this.walk((child, i) => { 2380 if (child.type === 'decl' && child.prop === prop) { 2381 return callback(child, i) 2382 } 2383 }) 2384 } 2385 2386 walkRules(selector, callback) { 2387 if (!callback) { 2388 callback = selector 2389 2390 return this.walk((child, i) => { 2391 if (child.type === 'rule') { 2392 return callback(child, i) 2393 } 2394 }) 2395 } 2396 if (selector instanceof RegExp) { 2397 return this.walk((child, i) => { 2398 if (child.type === 'rule' && selector.test(child.selector)) { 2399 return callback(child, i) 2400 } 2401 }) 2402 } 2403 return this.walk((child, i) => { 2404 if (child.type === 'rule' && child.selector === selector) { 2405 return callback(child, i) 2406 } 2407 }) 2408 } 2409 2410 walkAtRules(name, callback) { 2411 if (!callback) { 2412 callback = name 2413 return this.walk((child, i) => { 2414 if (child.type === 'atrule') { 2415 return callback(child, i) 2416 } 2417 }) 2418 } 2419 if (name instanceof RegExp) { 2420 return this.walk((child, i) => { 2421 if (child.type === 'atrule' && name.test(child.name)) { 2422 return callback(child, i) 2423 } 2424 }) 2425 } 2426 return this.walk((child, i) => { 2427 if (child.type === 'atrule' && child.name === name) { 2428 return callback(child, i) 2429 } 2430 }) 2431 } 2432 2433 walkComments(callback) { 2434 return this.walk((child, i) => { 2435 if (child.type === 'comment') { 2436 return callback(child, i) 2437 } 2438 }) 2439 } 2440 2441 append(...children) { 2442 for (let child of children) { 2443 let nodes = this.normalize(child, this.last) 2444 for (let node of nodes) this.proxyOf.nodes.push(node) 2445 } 2446 2447 this.markDirty() 2448 2449 return this 2450 } 2451 2452 prepend(...children) { 2453 children = children.reverse() 2454 for (let child of children) { 2455 let nodes = this.normalize(child, this.first, 'prepend').reverse() 2456 for (let node of nodes) this.proxyOf.nodes.unshift(node) 2457 for (let id in this.indexes) { 2458 this.indexes[id] = this.indexes[id] + nodes.length 2459 } 2460 } 2461 2462 this.markDirty() 2463 2464 return this 2465 } 2466 2467 cleanRaws(keepBetween) { 2468 super.cleanRaws(keepBetween) 2469 if (this.nodes) { 2470 for (let node of this.nodes) node.cleanRaws(keepBetween) 2471 } 2472 } 2473 2474 insertBefore(exist, add) { 2475 exist = this.index(exist) 2476 2477 let type = exist === 0 ? 'prepend' : false 2478 let nodes = this.normalize(add, this.proxyOf.nodes[exist], type).reverse() 2479 for (let node of nodes) this.proxyOf.nodes.splice(exist, 0, node) 2480 2481 let index 2482 for (let id in this.indexes) { 2483 index = this.indexes[id] 2484 if (exist <= index) { 2485 this.indexes[id] = index + nodes.length 2486 } 2487 } 2488 2489 this.markDirty() 2490 2491 return this 2492 } 2493 2494 insertAfter(exist, add) { 2495 exist = this.index(exist) 2496 2497 let nodes = this.normalize(add, this.proxyOf.nodes[exist]).reverse() 2498 for (let node of nodes) this.proxyOf.nodes.splice(exist + 1, 0, node) 2499 2500 let index 2501 for (let id in this.indexes) { 2502 index = this.indexes[id] 2503 if (exist < index) { 2504 this.indexes[id] = index + nodes.length 2505 } 2506 } 2507 2508 this.markDirty() 2509 2510 return this 2511 } 2512 2513 removeChild(child) { 2514 child = this.index(child) 2515 this.proxyOf.nodes[child].parent = undefined 2516 this.proxyOf.nodes.splice(child, 1) 2517 2518 let index 2519 for (let id in this.indexes) { 2520 index = this.indexes[id] 2521 if (index >= child) { 2522 this.indexes[id] = index - 1 2523 } 2524 } 2525 2526 this.markDirty() 2527 2528 return this 2529 } 2530 2531 removeAll() { 2532 for (let node of this.proxyOf.nodes) node.parent = undefined 2533 this.proxyOf.nodes = [] 2534 2535 this.markDirty() 2536 2537 return this 2538 } 2539 2540 replaceValues(pattern, opts, callback) { 2541 if (!callback) { 2542 callback = opts 2543 opts = {} 2544 } 2545 2546 this.walkDecls(decl => { 2547 if (opts.props && !opts.props.includes(decl.prop)) return 2548 if (opts.fast && !decl.value.includes(opts.fast)) return 2549 2550 decl.value = decl.value.replace(pattern, callback) 2551 }) 2552 2553 this.markDirty() 2554 2555 return this 2556 } 2557 2558 every(condition) { 2559 return this.nodes.every(condition) 2560 } 2561 2562 some(condition) { 2563 return this.nodes.some(condition) 2564 } 2565 2566 index(child) { 2567 if (typeof child === 'number') return child 2568 if (child.proxyOf) child = child.proxyOf 2569 return this.proxyOf.nodes.indexOf(child) 2570 } 2571 2572 get first() { 2573 if (!this.proxyOf.nodes) return undefined 2574 return this.proxyOf.nodes[0] 2575 } 2576 2577 get last() { 2578 if (!this.proxyOf.nodes) return undefined 2579 return this.proxyOf.nodes[this.proxyOf.nodes.length - 1] 2580 } 2581 2582 normalize(nodes, sample) { 2583 if (typeof nodes === 'string') { 2584 nodes = cleanSource(parse(nodes).nodes) 2585 } else if (Array.isArray(nodes)) { 2586 nodes = nodes.slice(0) 2587 for (let i of nodes) { 2588 if (i.parent) i.parent.removeChild(i, 'ignore') 2589 } 2590 } else if (nodes.type === 'root' && this.type !== 'document') { 2591 nodes = nodes.nodes.slice(0) 2592 for (let i of nodes) { 2593 if (i.parent) i.parent.removeChild(i, 'ignore') 2594 } 2595 } else if (nodes.type) { 2596 nodes = [nodes] 2597 } else if (nodes.prop) { 2598 if (typeof nodes.value === 'undefined') { 2599 throw new Error('Value field is missed in node creation') 2600 } else if (typeof nodes.value !== 'string') { 2601 nodes.value = String(nodes.value) 2602 } 2603 nodes = [new Declaration(nodes)] 2604 } else if (nodes.selector) { 2605 nodes = [new Rule(nodes)] 2606 } else if (nodes.name) { 2607 nodes = [new AtRule(nodes)] 2608 } else if (nodes.text) { 2609 nodes = [new Comment(nodes)] 2610 } else { 2611 throw new Error('Unknown node type in node creation') 2612 } 2613 2614 let processed = nodes.map(i => { 2615 /* c8 ignore next */ 2616 if (!i[my]) Container.rebuild(i) 2617 i = i.proxyOf 2618 if (i.parent) i.parent.removeChild(i) 2619 if (i[isClean]) markDirtyUp(i) 2620 if (typeof i.raws.before === 'undefined') { 2621 if (sample && typeof sample.raws.before !== 'undefined') { 2622 i.raws.before = sample.raws.before.replace(/\S/g, '') 2623 } 2624 } 2625 i.parent = this 2626 return i 2627 }) 2628 2629 return processed 2630 } 2631 2632 getProxyProcessor() { 2633 return { 2634 set(node, prop, value) { 2635 if (node[prop] === value) return true 2636 node[prop] = value 2637 if (prop === 'name' || prop === 'params' || prop === 'selector') { 2638 node.markDirty() 2639 } 2640 return true 2641 }, 2642 2643 get(node, prop) { 2644 if (prop === 'proxyOf') { 2645 return node 2646 } else if (!node[prop]) { 2647 return node[prop] 2648 } else if ( 2649 prop === 'each' || 2650 (typeof prop === 'string' && prop.startsWith('walk')) 2651 ) { 2652 return (...args) => { 2653 return node[prop]( 2654 ...args.map(i => { 2655 if (typeof i === 'function') { 2656 return (child, index) => i(child.toProxy(), index) 2657 } else { 2658 return i 2659 } 2660 }) 2661 ) 2662 } 2663 } else if (prop === 'every' || prop === 'some') { 2664 return cb => { 2665 return node[prop]((child, ...other) => 2666 cb(child.toProxy(), ...other) 2667 ) 2668 } 2669 } else if (prop === 'root') { 2670 return () => node.root().toProxy() 2671 } else if (prop === 'nodes') { 2672 return node.nodes.map(i => i.toProxy()) 2673 } else if (prop === 'first' || prop === 'last') { 2674 return node[prop].toProxy() 2675 } else { 2676 return node[prop] 2677 } 2678 } 2679 } 2680 } 2681 2682 getIterator() { 2683 if (!this.lastEach) this.lastEach = 0 2684 if (!this.indexes) this.indexes = {} 2685 2686 this.lastEach += 1 2687 let iterator = this.lastEach 2688 this.indexes[iterator] = 0 2689 2690 return iterator 2691 } 2692} 2693 2694Container.registerParse = dependant => { 2695 parse = dependant 2696} 2697 2698Container.registerRule = dependant => { 2699 Rule = dependant 2700} 2701 2702Container.registerAtRule = dependant => { 2703 AtRule = dependant 2704} 2705 2706module.exports = Container 2707Container.default = Container 2708 2709/* c8 ignore start */ 2710Container.rebuild = node => { 2711 if (node.type === 'atrule') { 2712 Object.setPrototypeOf(node, AtRule.prototype) 2713 } else if (node.type === 'rule') { 2714 Object.setPrototypeOf(node, Rule.prototype) 2715 } else if (node.type === 'decl') { 2716 Object.setPrototypeOf(node, Declaration.prototype) 2717 } else if (node.type === 'comment') { 2718 Object.setPrototypeOf(node, Comment.prototype) 2719 } 2720 2721 node[my] = true 2722 2723 if (node.nodes) { 2724 node.nodes.forEach(child => { 2725 Container.rebuild(child) 2726 }) 2727 } 2728} 2729/* c8 ignore stop */ 2730 2731 2732/***/ }), 2733
vendor: 2,948 bytes, lines 2734-2845
2734/***/ "./node_modules/postcss/lib/css-syntax-error.js": 2735/*!******************************************************!*\ 2736 !*** ./node_modules/postcss/lib/css-syntax-error.js ***! 2737 \******************************************************/ 2738/*! no static exports found */ 2739/***/ (function(module, exports, __webpack_require__) { 2740 2741"use strict"; 2742 2743 2744let pico = __webpack_require__(/*! picocolors */ "./node_modules/picocolors/picocolors.browser.js") 2745 2746let terminalHighlight = __webpack_require__(/*! ./terminal-highlight */ 1) 2747 2748class CssSyntaxError extends Error { 2749 constructor(message, line, column, source, file, plugin) { 2750 super(message) 2751 this.name = 'CssSyntaxError' 2752 this.reason = message 2753 2754 if (file) { 2755 this.file = file 2756 } 2757 if (source) { 2758 this.source = source 2759 } 2760 if (plugin) { 2761 this.plugin = plugin 2762 } 2763 if (typeof line !== 'undefined' && typeof column !== 'undefined') { 2764 if (typeof line === 'number') { 2765 this.line = line 2766 this.column = column 2767 } else { 2768 this.line = line.line 2769 this.column = line.column 2770 this.endLine = column.line 2771 this.endColumn = column.column 2772 } 2773 } 2774 2775 this.setMessage() 2776 2777 if (Error.captureStackTrace) { 2778 Error.captureStackTrace(this, CssSyntaxError) 2779 } 2780 } 2781 2782 setMessage() { 2783 this.message = this.plugin ? this.plugin + ': ' : '' 2784 this.message += this.file ? this.file : '<css input>' 2785 if (typeof this.line !== 'undefined') { 2786 this.message += ':' + this.line + ':' + this.column 2787 } 2788 this.message += ': ' + this.reason 2789 } 2790 2791 showSourceCode(color) { 2792 if (!this.source) return '' 2793 2794 let css = this.source 2795 if (color == null) color = pico.isColorSupported 2796 if (terminalHighlight) { 2797 if (color) css = terminalHighlight(css) 2798 } 2799 2800 let lines = css.split(/\r?\n/) 2801 let start = Math.max(this.line - 3, 0) 2802 let end = Math.min(this.line + 2, lines.length) 2803 2804 let maxWidth = String(end).length 2805 2806 let mark, aside 2807 if (color) { 2808 let { bold, red, gray } = pico.createColors(true) 2809 mark = text => bold(red(text)) 2810 aside = text => gray(text) 2811 } else { 2812 mark = aside = str => str 2813 } 2814 2815 return lines 2816 .slice(start, end) 2817 .map((line, index) => { 2818 let number = start + 1 + index 2819 let gutter = ' ' + (' ' + number).slice(-maxWidth) + ' | ' 2820 if (number === this.line) { 2821 let spacing = 2822 aside(gutter.replace(/\d/g, ' ')) + 2823 line.slice(0, this.column - 1).replace(/[^\t]/g, ' ') 2824 return mark('>') + aside(gutter) + line + '\n ' + spacing + mark('^') 2825 } 2826 return ' ' + aside(gutter) + line 2827 }) 2828 .join('\n') 2829 } 2830 2831 toString() { 2832 let code = this.showSourceCode() 2833 if (code) { 2834 code = '\n\n' + code + '\n' 2835 } 2836 return this.name + ': ' + this.message + code 2837 } 2838} 2839 2840module.exports = CssSyntaxError 2841CssSyntaxError.default = CssSyntaxError 2842 2843 2844/***/ }), 2845
vendor: 867 bytes, lines 2846-2881
2846/***/ "./node_modules/postcss/lib/declaration.js": 2847/*!*************************************************!*\ 2848 !*** ./node_modules/postcss/lib/declaration.js ***! 2849 \*************************************************/ 2850/*! no static exports found */ 2851/***/ (function(module, exports, __webpack_require__) { 2852 2853"use strict"; 2854 2855 2856let Node = __webpack_require__(/*! ./node */ "./node_modules/postcss/lib/node.js") 2857 2858class Declaration extends Node { 2859 constructor(defaults) { 2860 if ( 2861 defaults && 2862 typeof defaults.value !== 'undefined' && 2863 typeof defaults.value !== 'string' 2864 ) { 2865 defaults = { ...defaults, value: String(defaults.value) } 2866 } 2867 super(defaults) 2868 this.type = 'decl' 2869 } 2870 2871 get variable() { 2872 return this.prop.startsWith('--') || this.prop[0] === '$' 2873 } 2874} 2875 2876module.exports = Declaration 2877Declaration.default = Declaration 2878 2879 2880/***/ }), 2881
vendor: 1,019 bytes, lines 2882-2926
2882/***/ "./node_modules/postcss/lib/document.js": 2883/*!**********************************************!*\ 2884 !*** ./node_modules/postcss/lib/document.js ***! 2885 \**********************************************/ 2886/*! no static exports found */ 2887/***/ (function(module, exports, __webpack_require__) { 2888 2889"use strict"; 2890 2891 2892let Container = __webpack_require__(/*! ./container */ "./node_modules/postcss/lib/container.js") 2893 2894let LazyResult, Processor 2895 2896class Document extends Container { 2897 constructor(defaults) { 2898 // type needs to be passed to super, otherwise child roots won't be normalized correctly 2899 super({ type: 'document', ...defaults }) 2900 2901 if (!this.nodes) { 2902 this.nodes = [] 2903 } 2904 } 2905 2906 toResult(opts = {}) { 2907 let lazy = new LazyResult(new Processor(), this, opts) 2908 2909 return lazy.stringify() 2910 } 2911} 2912 2913Document.registerLazyResult = dependant => { 2914 LazyResult = dependant 2915} 2916 2917Document.registerProcessor = dependant => { 2918 Processor = dependant 2919} 2920 2921module.exports = Document 2922Document.default = Document 2923 2924 2925/***/ }), 2926
vendor: 2,212 bytes, lines 2927-2992
2927/***/ "./node_modules/postcss/lib/fromJSON.js": 2928/*!**********************************************!*\ 2929 !*** ./node_modules/postcss/lib/fromJSON.js ***! 2930 \**********************************************/ 2931/*! no static exports found */ 2932/***/ (function(module, exports, __webpack_require__) { 2933 2934"use strict"; 2935 2936 2937let Declaration = __webpack_require__(/*! ./declaration */ "./node_modules/postcss/lib/declaration.js") 2938let PreviousMap = __webpack_require__(/*! ./previous-map */ "./node_modules/postcss/lib/previous-map.js") 2939let Comment = __webpack_require__(/*! ./comment */ "./node_modules/postcss/lib/comment.js") 2940let AtRule = __webpack_require__(/*! ./at-rule */ "./node_modules/postcss/lib/at-rule.js") 2941let Input = __webpack_require__(/*! ./input */ "./node_modules/postcss/lib/input.js") 2942let Root = __webpack_require__(/*! ./root */ "./node_modules/postcss/lib/root.js") 2943let Rule = __webpack_require__(/*! ./rule */ "./node_modules/postcss/lib/rule.js") 2944 2945function fromJSON(json, inputs) { 2946 if (Array.isArray(json)) return json.map(n => fromJSON(n)) 2947 2948 let { inputs: ownInputs, ...defaults } = json 2949 if (ownInputs) { 2950 inputs = [] 2951 for (let input of ownInputs) { 2952 let inputHydrated = { ...input, __proto__: Input.prototype } 2953 if (inputHydrated.map) { 2954 inputHydrated.map = { 2955 ...inputHydrated.map, 2956 __proto__: PreviousMap.prototype 2957 } 2958 } 2959 inputs.push(inputHydrated) 2960 } 2961 } 2962 if (defaults.nodes) { 2963 defaults.nodes = json.nodes.map(n => fromJSON(n, inputs)) 2964 } 2965 if (defaults.source) { 2966 let { inputId, ...source } = defaults.source 2967 defaults.source = source 2968 if (inputId != null) { 2969 defaults.source.input = inputs[inputId] 2970 } 2971 } 2972 if (defaults.type === 'root') { 2973 return new Root(defaults) 2974 } else if (defaults.type === 'decl') { 2975 return new Declaration(defaults) 2976 } else if (defaults.type === 'rule') { 2977 return new Rule(defaults) 2978 } else if (defaults.type === 'comment') { 2979 return new Comment(defaults) 2980 } else if (defaults.type === 'atrule') { 2981 return new AtRule(defaults) 2982 } else { 2983 throw new Error('Unknown node type: ' + json.type) 2984 } 2985} 2986 2987module.exports = fromJSON 2988fromJSON.default = fromJSON 2989 2990 2991/***/ }), 2992
vendor: 6,748 bytes, lines 2993-3252
2993/***/ "./node_modules/postcss/lib/input.js": 2994/*!*******************************************!*\ 2995 !*** ./node_modules/postcss/lib/input.js ***! 2996 \*******************************************/ 2997/*! no static exports found */ 2998/***/ (function(module, exports, __webpack_require__) { 2999 3000"use strict"; 3001 3002 3003let { SourceMapConsumer, SourceMapGenerator } = __webpack_require__(/*! source-map-js */ 2) 3004let { fileURLToPath, pathToFileURL } = __webpack_require__(/*! url */ 4) 3005let { resolve, isAbsolute } = __webpack_require__(/*! path */ 3) 3006let { nanoid } = __webpack_require__(/*! nanoid/non-secure */ "./node_modules/nanoid/non-secure/index.js") 3007 3008let terminalHighlight = __webpack_require__(/*! ./terminal-highlight */ 1) 3009let CssSyntaxError = __webpack_require__(/*! ./css-syntax-error */ "./node_modules/postcss/lib/css-syntax-error.js") 3010let PreviousMap = __webpack_require__(/*! ./previous-map */ "./node_modules/postcss/lib/previous-map.js") 3011 3012let fromOffsetCache = Symbol('fromOffsetCache') 3013 3014let sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator) 3015let pathAvailable = Boolean(resolve && isAbsolute) 3016 3017class Input { 3018 constructor(css, opts = {}) { 3019 if ( 3020 css === null || 3021 typeof css === 'undefined' || 3022 (typeof css === 'object' && !css.toString) 3023 ) { 3024 throw new Error(`PostCSS received ${css} instead of CSS string`) 3025 } 3026 3027 this.css = css.toString() 3028 3029 if (this.css[0] === '\uFEFF' || this.css[0] === '\uFFFE') { 3030 this.hasBOM = true 3031 this.css = this.css.slice(1) 3032 } else { 3033 this.hasBOM = false 3034 } 3035 3036 if (opts.from) { 3037 if ( 3038 !pathAvailable || 3039 /^\w+:\/\//.test(opts.from) || 3040 isAbsolute(opts.from) 3041 ) { 3042 this.file = opts.from 3043 } else { 3044 this.file = resolve(opts.from) 3045 } 3046 } 3047 3048 if (pathAvailable && sourceMapAvailable) { 3049 let map = new PreviousMap(this.css, opts) 3050 if (map.text) { 3051 this.map = map 3052 let file = map.consumer().file 3053 if (!this.file && file) this.file = this.mapResolve(file) 3054 } 3055 } 3056 3057 if (!this.file) { 3058 this.id = '<input css ' + nanoid(6) + '>' 3059 } 3060 if (this.map) this.map.file = this.from 3061 } 3062 3063 fromOffset(offset) { 3064 let lastLine, lineToIndex 3065 if (!this[fromOffsetCache]) { 3066 let lines = this.css.split('\n') 3067 lineToIndex = new Array(lines.length) 3068 let prevIndex = 0 3069 3070 for (let i = 0, l = lines.length; i < l; i++) { 3071 lineToIndex[i] = prevIndex 3072 prevIndex += lines[i].length + 1 3073 } 3074 3075 this[fromOffsetCache] = lineToIndex 3076 } else { 3077 lineToIndex = this[fromOffsetCache] 3078 } 3079 lastLine = lineToIndex[lineToIndex.length - 1] 3080 3081 let min = 0 3082 if (offset >= lastLine) { 3083 min = lineToIndex.length - 1 3084 } else { 3085 let max = lineToIndex.length - 2 3086 let mid 3087 while (min < max) { 3088 mid = min + ((max - min) >> 1) 3089 if (offset < lineToIndex[mid]) { 3090 max = mid - 1 3091 } else if (offset >= lineToIndex[mid + 1]) { 3092 min = mid + 1 3093 } else { 3094 min = mid 3095 break 3096 } 3097 } 3098 } 3099 return { 3100 line: min + 1, 3101 col: offset - lineToIndex[min] + 1 3102 } 3103 } 3104 3105 error(message, line, column, opts = {}) { 3106 let result, endLine, endColumn 3107 3108 if (line && typeof line === 'object') { 3109 let start = line 3110 let end = column 3111 if (typeof line.offset === 'number') { 3112 let pos = this.fromOffset(start.offset) 3113 line = pos.line 3114 column = pos.col 3115 } else { 3116 line = start.line 3117 column = start.column 3118 } 3119 if (typeof end.offset === 'number') { 3120 let pos = this.fromOffset(end.offset) 3121 endLine = pos.line 3122 endColumn = pos.col 3123 } else { 3124 endLine = end.line 3125 endColumn = end.column 3126 } 3127 } else if (!column) { 3128 let pos = this.fromOffset(line) 3129 line = pos.line 3130 column = pos.col 3131 } 3132 3133 let origin = this.origin(line, column, endLine, endColumn) 3134 if (origin) { 3135 result = new CssSyntaxError( 3136 message, 3137 origin.endLine === undefined 3138 ? origin.line 3139 : { line: origin.line, column: origin.column }, 3140 origin.endLine === undefined 3141 ? origin.column 3142 : { line: origin.endLine, column: origin.endColumn }, 3143 origin.source, 3144 origin.file, 3145 opts.plugin 3146 ) 3147 } else { 3148 result = new CssSyntaxError( 3149 message, 3150 endLine === undefined ? line : { line, column }, 3151 endLine === undefined ? column : { line: endLine, column: endColumn }, 3152 this.css, 3153 this.file, 3154 opts.plugin 3155 ) 3156 } 3157 3158 result.input = { line, column, endLine, endColumn, source: this.css } 3159 if (this.file) { 3160 if (pathToFileURL) { 3161 result.input.url = pathToFileURL(this.file).toString() 3162 } 3163 result.input.file = this.file 3164 } 3165 3166 return result 3167 } 3168 3169 origin(line, column, endLine, endColumn) { 3170 if (!this.map) return false 3171 let consumer = this.map.consumer() 3172 3173 let from = consumer.originalPositionFor({ line, column }) 3174 if (!from.source) return false 3175 3176 let to 3177 if (typeof endLine === 'number') { 3178 to = consumer.originalPositionFor({ line: endLine, column: endColumn }) 3179 } 3180 3181 let fromUrl 3182 3183 if (isAbsolute(from.source)) { 3184 fromUrl = pathToFileURL(from.source) 3185 } else { 3186 fromUrl = new URL( 3187 from.source, 3188 this.map.consumer().sourceRoot || pathToFileURL(this.map.mapFile) 3189 ) 3190 } 3191 3192 let result = { 3193 url: fromUrl.toString(), 3194 line: from.line, 3195 column: from.column, 3196 endLine: to && to.line, 3197 endColumn: to && to.column 3198 } 3199 3200 if (fromUrl.protocol === 'file:') { 3201 if (fileURLToPath) { 3202 result.file = fileURLToPath(fromUrl) 3203 } else { 3204 /* c8 ignore next 2 */ 3205 throw new Error(`file: protocol is not available in this PostCSS build`) 3206 } 3207 } 3208 3209 let source = consumer.sourceContentFor(from.source) 3210 if (source) result.source = source 3211 3212 return result 3213 } 3214 3215 mapResolve(file) { 3216 if (/^\w+:\/\//.test(file)) { 3217 return file 3218 } 3219 return resolve(this.map.consumer().sourceRoot || this.map.root || '.', file) 3220 } 3221 3222 get from() { 3223 return this.file || this.id 3224 } 3225 3226 toJSON() { 3227 let json = {} 3228 for (let name of ['hasBOM', 'css', 'file', 'id']) { 3229 if (this[name] != null) { 3230 json[name] = this[name] 3231 } 3232 } 3233 if (this.map) { 3234 json.map = { ...this.map } 3235 if (json.map.consumerCache) { 3236 json.map.consumerCache = undefined 3237 } 3238 } 3239 return json 3240 } 3241} 3242 3243module.exports = Input 3244Input.default = Input 3245 3246if (terminalHighlight && terminalHighlight.registerInput) { 3247 terminalHighlight.registerInput(Input) 3248} 3249 3250 3251/***/ }), 3252
vendor: 14,334 bytes, lines 3253-3814
3253/***/ "./node_modules/postcss/lib/lazy-result.js": 3254/*!*************************************************!*\ 3255 !*** ./node_modules/postcss/lib/lazy-result.js ***! 3256 \*************************************************/ 3257/*! no static exports found */ 3258/***/ (function(module, exports, __webpack_require__) { 3259 3260"use strict"; 3261 3262 3263let { isClean, my } = __webpack_require__(/*! ./symbols */ "./node_modules/postcss/lib/symbols.js") 3264let MapGenerator = __webpack_require__(/*! ./map-generator */ "./node_modules/postcss/lib/map-generator.js") 3265let stringify = __webpack_require__(/*! ./stringify */ "./node_modules/postcss/lib/stringify.js") 3266let Container = __webpack_require__(/*! ./container */ "./node_modules/postcss/lib/container.js") 3267let Document = __webpack_require__(/*! ./document */ "./node_modules/postcss/lib/document.js") 3268let warnOnce = __webpack_require__(/*! ./warn-once */ "./node_modules/postcss/lib/warn-once.js") 3269let Result = __webpack_require__(/*! ./result */ "./node_modules/postcss/lib/result.js") 3270let parse = __webpack_require__(/*! ./parse */ "./node_modules/postcss/lib/parse.js") 3271let Root = __webpack_require__(/*! ./root */ "./node_modules/postcss/lib/root.js") 3272 3273const TYPE_TO_CLASS_NAME = { 3274 document: 'Document', 3275 root: 'Root', 3276 atrule: 'AtRule', 3277 rule: 'Rule', 3278 decl: 'Declaration', 3279 comment: 'Comment' 3280} 3281 3282const PLUGIN_PROPS = { 3283 postcssPlugin: true, 3284 prepare: true, 3285 Once: true, 3286 Document: true, 3287 Root: true, 3288 Declaration: true, 3289 Rule: true, 3290 AtRule: true, 3291 Comment: true, 3292 DeclarationExit: true, 3293 RuleExit: true, 3294 AtRuleExit: true, 3295 CommentExit: true, 3296 RootExit: true, 3297 DocumentExit: true, 3298 OnceExit: true 3299} 3300 3301const NOT_VISITORS = { 3302 postcssPlugin: true, 3303 prepare: true, 3304 Once: true 3305} 3306 3307const CHILDREN = 0 3308 3309function isPromise(obj) { 3310 return typeof obj === 'object' && typeof obj.then === 'function' 3311} 3312 3313function getEvents(node) { 3314 let key = false 3315 let type = TYPE_TO_CLASS_NAME[node.type] 3316 if (node.type === 'decl') { 3317 key = node.prop.toLowerCase() 3318 } else if (node.type === 'atrule') { 3319 key = node.name.toLowerCase() 3320 } 3321 3322 if (key && node.append) { 3323 return [ 3324 type, 3325 type + '-' + key, 3326 CHILDREN, 3327 type + 'Exit', 3328 type + 'Exit-' + key 3329 ] 3330 } else if (key) { 3331 return [type, type + '-' + key, type + 'Exit', type + 'Exit-' + key] 3332 } else if (node.append) { 3333 return [type, CHILDREN, type + 'Exit'] 3334 } else { 3335 return [type, type + 'Exit'] 3336 } 3337} 3338 3339function toStack(node) { 3340 let events 3341 if (node.type === 'document') { 3342 events = ['Document', CHILDREN, 'DocumentExit'] 3343 } else if (node.type === 'root') { 3344 events = ['Root', CHILDREN, 'RootExit'] 3345 } else { 3346 events = getEvents(node) 3347 } 3348 3349 return { 3350 node, 3351 events, 3352 eventIndex: 0, 3353 visitors: [], 3354 visitorIndex: 0, 3355 iterator: 0 3356 } 3357} 3358 3359function cleanMarks(node) { 3360 node[isClean] = false 3361 if (node.nodes) node.nodes.forEach(i => cleanMarks(i)) 3362 return node 3363} 3364 3365let postcss = {} 3366 3367class LazyResult { 3368 constructor(processor, css, opts) { 3369 this.stringified = false 3370 this.processed = false 3371 3372 let root 3373 if ( 3374 typeof css === 'object' && 3375 css !== null && 3376 (css.type === 'root' || css.type === 'document') 3377 ) { 3378 root = cleanMarks(css) 3379 } else if (css instanceof LazyResult || css instanceof Result) { 3380 root = cleanMarks(css.root) 3381 if (css.map) { 3382 if (typeof opts.map === 'undefined') opts.map = {} 3383 if (!opts.map.inline) opts.map.inline = false 3384 opts.map.prev = css.map 3385 } 3386 } else { 3387 let parser = parse 3388 if (opts.syntax) parser = opts.syntax.parse 3389 if (opts.parser) parser = opts.parser 3390 if (parser.parse) parser = parser.parse 3391 3392 try { 3393 root = parser(css, opts) 3394 } catch (error) { 3395 this.processed = true 3396 this.error = error 3397 } 3398 3399 if (root && !root[my]) { 3400 /* c8 ignore next 2 */ 3401 Container.rebuild(root) 3402 } 3403 } 3404 3405 this.result = new Result(processor, root, opts) 3406 this.helpers = { ...postcss, result: this.result, postcss } 3407 this.plugins = this.processor.plugins.map(plugin => { 3408 if (typeof plugin === 'object' && plugin.prepare) { 3409 return { ...plugin, ...plugin.prepare(this.result) } 3410 } else { 3411 return plugin 3412 } 3413 }) 3414 } 3415 3416 get [Symbol.toStringTag]() { 3417 return 'LazyResult' 3418 } 3419 3420 get processor() { 3421 return this.result.processor 3422 } 3423 3424 get opts() { 3425 return this.result.opts 3426 } 3427 3428 get css() { 3429 return this.stringify().css 3430 } 3431 3432 get content() { 3433 return this.stringify().content 3434 } 3435 3436 get map() { 3437 return this.stringify().map 3438 } 3439 3440 get root() { 3441 return this.sync().root 3442 } 3443 3444 get messages() { 3445 return this.sync().messages 3446 } 3447 3448 warnings() { 3449 return this.sync().warnings() 3450 } 3451 3452 toString() { 3453 return this.css 3454 } 3455 3456 then(onFulfilled, onRejected) { 3457 if (true) { 3458 if (!('from' in this.opts)) { 3459 warnOnce( 3460 'Without `from` option PostCSS could generate wrong source map ' + 3461 'and will not find Browserslist config. Set it to CSS file path ' + 3462 'or to `undefined` to prevent this warning.' 3463 ) 3464 } 3465 } 3466 return this.async().then(onFulfilled, onRejected) 3467 } 3468 3469 catch(onRejected) { 3470 return this.async().catch(onRejected) 3471 } 3472 3473 finally(onFinally) { 3474 return this.async().then(onFinally, onFinally) 3475 } 3476 3477 async() { 3478 if (this.error) return Promise.reject(this.error) 3479 if (this.processed) return Promise.resolve(this.result) 3480 if (!this.processing) { 3481 this.processing = this.runAsync() 3482 } 3483 return this.processing 3484 } 3485 3486 sync() { 3487 if (this.error) throw this.error 3488 if (this.processed) return this.result 3489 this.processed = true 3490 3491 if (this.processing) { 3492 throw this.getAsyncError() 3493 } 3494 3495 for (let plugin of this.plugins) { 3496 let promise = this.runOnRoot(plugin) 3497 if (isPromise(promise)) { 3498 throw this.getAsyncError() 3499 } 3500 } 3501 3502 this.prepareVisitors() 3503 if (this.hasListener) { 3504 let root = this.result.root 3505 while (!root[isClean]) { 3506 root[isClean] = true 3507 this.walkSync(root) 3508 } 3509 if (this.listeners.OnceExit) { 3510 if (root.type === 'document') { 3511 for (let subRoot of root.nodes) { 3512 this.visitSync(this.listeners.OnceExit, subRoot) 3513 } 3514 } else { 3515 this.visitSync(this.listeners.OnceExit, root) 3516 } 3517 } 3518 } 3519 3520 return this.result 3521 } 3522 3523 stringify() { 3524 if (this.error) throw this.error 3525 if (this.stringified) return this.result 3526 this.stringified = true 3527 3528 this.sync() 3529 3530 let opts = this.result.opts 3531 let str = stringify 3532 if (opts.syntax) str = opts.syntax.stringify 3533 if (opts.stringifier) str = opts.stringifier 3534 if (str.stringify) str = str.stringify 3535 3536 let map = new MapGenerator(str, this.result.root, this.result.opts) 3537 let data = map.generate() 3538 this.result.css = data[0] 3539 this.result.map = data[1] 3540 3541 return this.result 3542 } 3543 3544 walkSync(node) { 3545 node[isClean] = true 3546 let events = getEvents(node) 3547 for (let event of events) { 3548 if (event === CHILDREN) { 3549 if (node.nodes) { 3550 node.each(child => { 3551 if (!child[isClean]) this.walkSync(child) 3552 }) 3553 } 3554 } else { 3555 let visitors = this.listeners[event] 3556 if (visitors) { 3557 if (this.visitSync(visitors, node.toProxy())) return 3558 } 3559 } 3560 } 3561 } 3562 3563 visitSync(visitors, node) { 3564 for (let [plugin, visitor] of visitors) { 3565 this.result.lastPlugin = plugin 3566 let promise 3567 try { 3568 promise = visitor(node, this.helpers) 3569 } catch (e) { 3570 throw this.handleError(e, node.proxyOf) 3571 } 3572 if (node.type !== 'root' && node.type !== 'document' && !node.parent) { 3573 return true 3574 } 3575 if (isPromise(promise)) { 3576 throw this.getAsyncError() 3577 } 3578 } 3579 } 3580 3581 runOnRoot(plugin) { 3582 this.result.lastPlugin = plugin 3583 try { 3584 if (typeof plugin === 'object' && plugin.Once) { 3585 if (this.result.root.type === 'document') { 3586 let roots = this.result.root.nodes.map(root => 3587 plugin.Once(root, this.helpers) 3588 ) 3589 3590 if (isPromise(roots[0])) { 3591 return Promise.all(roots) 3592 } 3593 3594 return roots 3595 } 3596 3597 return plugin.Once(this.result.root, this.helpers) 3598 } else if (typeof plugin === 'function') { 3599 return plugin(this.result.root, this.result) 3600 } 3601 } catch (error) { 3602 throw this.handleError(error) 3603 } 3604 } 3605 3606 getAsyncError() { 3607 throw new Error('Use process(css).then(cb) to work with async plugins') 3608 } 3609 3610 handleError(error, node) { 3611 let plugin = this.result.lastPlugin 3612 try { 3613 if (node) node.addToError(error) 3614 this.error = error 3615 if (error.name === 'CssSyntaxError' && !error.plugin) { 3616 error.plugin = plugin.postcssPlugin 3617 error.setMessage() 3618 } else if (plugin.postcssVersion) { 3619 if (true) { 3620 let pluginName = plugin.postcssPlugin 3621 let pluginVer = plugin.postcssVersion 3622 let runtimeVer = this.result.processor.version 3623 let a = pluginVer.split('.') 3624 let b = runtimeVer.split('.') 3625 3626 if (a[0] !== b[0] || parseInt(a[1]) > parseInt(b[1])) { 3627 // eslint-disable-next-line no-console 3628 console.error( 3629 'Unknown error from PostCSS plugin. Your current PostCSS ' + 3630 'version is ' + 3631 runtimeVer + 3632 ', but ' + 3633 pluginName + 3634 ' uses ' + 3635 pluginVer + 3636 '. Perhaps this is the source of the error below.' 3637 ) 3638 } 3639 } 3640 } 3641 } catch (err) { 3642 /* c8 ignore next 3 */ 3643 // eslint-disable-next-line no-console 3644 if (console && console.error) console.error(err) 3645 } 3646 return error 3647 } 3648 3649 async runAsync() { 3650 this.plugin = 0 3651 for (let i = 0; i < this.plugins.length; i++) { 3652 let plugin = this.plugins[i] 3653 let promise = this.runOnRoot(plugin) 3654 if (isPromise(promise)) { 3655 try { 3656 await promise 3657 } catch (error) { 3658 throw this.handleError(error) 3659 } 3660 } 3661 } 3662 3663 this.prepareVisitors() 3664 if (this.hasListener) { 3665 let root = this.result.root 3666 while (!root[isClean]) { 3667 root[isClean] = true 3668 let stack = [toStack(root)] 3669 while (stack.length > 0) { 3670 let promise = this.visitTick(stack) 3671 if (isPromise(promise)) { 3672 try { 3673 await promise 3674 } catch (e) { 3675 let node = stack[stack.length - 1].node 3676 throw this.handleError(e, node) 3677 } 3678 } 3679 } 3680 } 3681 3682 if (this.listeners.OnceExit) { 3683 for (let [plugin, visitor] of this.listeners.OnceExit) { 3684 this.result.lastPlugin = plugin 3685 try { 3686 if (root.type === 'document') { 3687 let roots = root.nodes.map(subRoot => 3688 visitor(subRoot, this.helpers) 3689 ) 3690 3691 await Promise.all(roots) 3692 } else { 3693 await visitor(root, this.helpers) 3694 } 3695 } catch (e) { 3696 throw this.handleError(e) 3697 } 3698 } 3699 } 3700 } 3701 3702 this.processed = true 3703 return this.stringify() 3704 } 3705 3706 prepareVisitors() { 3707 this.listeners = {} 3708 let add = (plugin, type, cb) => { 3709 if (!this.listeners[type]) this.listeners[type] = [] 3710 this.listeners[type].push([plugin, cb]) 3711 } 3712 for (let plugin of this.plugins) { 3713 if (typeof plugin === 'object') { 3714 for (let event in plugin) { 3715 if (!PLUGIN_PROPS[event] && /^[A-Z]/.test(event)) { 3716 throw new Error( 3717 `Unknown event ${event} in ${plugin.postcssPlugin}. ` + 3718 `Try to update PostCSS (${this.processor.version} now).` 3719 ) 3720 } 3721 if (!NOT_VISITORS[event]) { 3722 if (typeof plugin[event] === 'object') { 3723 for (let filter in plugin[event]) { 3724 if (filter === '*') { 3725 add(plugin, event, plugin[event][filter]) 3726 } else { 3727 add( 3728 plugin, 3729 event + '-' + filter.toLowerCase(), 3730 plugin[event][filter] 3731 ) 3732 } 3733 } 3734 } else if (typeof plugin[event] === 'function') { 3735 add(plugin, event, plugin[event]) 3736 } 3737 } 3738 } 3739 } 3740 } 3741 this.hasListener = Object.keys(this.listeners).length > 0 3742 } 3743 3744 visitTick(stack) { 3745 let visit = stack[stack.length - 1] 3746 let { node, visitors } = visit 3747 3748 if (node.type !== 'root' && node.type !== 'document' && !node.parent) { 3749 stack.pop() 3750 return 3751 } 3752 3753 if (visitors.length > 0 && visit.visitorIndex < visitors.length) { 3754 let [plugin, visitor] = visitors[visit.visitorIndex] 3755 visit.visitorIndex += 1 3756 if (visit.visitorIndex === visitors.length) { 3757 visit.visitors = [] 3758 visit.visitorIndex = 0 3759 } 3760 this.result.lastPlugin = plugin 3761 try { 3762 return visitor(node.toProxy(), this.helpers) 3763 } catch (e) { 3764 throw this.handleError(e, node) 3765 } 3766 } 3767 3768 if (visit.iterator !== 0) { 3769 let iterator = visit.iterator 3770 let child 3771 while ((child = node.nodes[node.indexes[iterator]])) { 3772 node.indexes[iterator] += 1 3773 if (!child[isClean]) { 3774 child[isClean] = true 3775 stack.push(toStack(child)) 3776 return 3777 } 3778 } 3779 visit.iterator = 0 3780 delete node.indexes[iterator] 3781 } 3782 3783 let events = visit.events 3784 while (visit.eventIndex < events.length) { 3785 let event = events[visit.eventIndex] 3786 visit.eventIndex += 1 3787 if (event === CHILDREN) { 3788 if (node.nodes && node.nodes.length) { 3789 node[isClean] = true 3790 visit.iterator = node.getIterator() 3791 } 3792 return 3793 } else if (this.listeners[event]) { 3794 visit.visitors = this.listeners[event] 3795 return 3796 } 3797 } 3798 stack.pop() 3799 } 3800} 3801 3802LazyResult.registerPostcss = dependant => { 3803 postcss = dependant 3804} 3805 3806module.exports = LazyResult 3807LazyResult.default = LazyResult 3808 3809Root.registerLazyResult(LazyResult) 3810Document.registerLazyResult(LazyResult) 3811 3812 3813/***/ }), 3814
vendor: 1,457 bytes, lines 3815-3882
3815/***/ "./node_modules/postcss/lib/list.js": 3816/*!******************************************!*\ 3817 !*** ./node_modules/postcss/lib/list.js ***! 3818 \******************************************/ 3819/*! no static exports found */ 3820/***/ (function(module, exports, __webpack_require__) { 3821 3822"use strict"; 3823 3824 3825let list = { 3826 split(string, separators, last) { 3827 let array = [] 3828 let current = '' 3829 let split = false 3830 3831 let func = 0 3832 let quote = false 3833 let escape = false 3834 3835 for (let letter of string) { 3836 if (escape) { 3837 escape = false 3838 } else if (letter === '\\') { 3839 escape = true 3840 } else if (quote) { 3841 if (letter === quote) { 3842 quote = false 3843 } 3844 } else if (letter === '"' || letter === "'") { 3845 quote = letter 3846 } else if (letter === '(') { 3847 func += 1 3848 } else if (letter === ')') { 3849 if (func > 0) func -= 1 3850 } else if (func === 0) { 3851 if (separators.includes(letter)) split = true 3852 } 3853 3854 if (split) { 3855 if (current !== '') array.push(current.trim()) 3856 current = '' 3857 split = false 3858 } else { 3859 current += letter 3860 } 3861 } 3862 3863 if (last || current !== '') array.push(current.trim()) 3864 return array 3865 }, 3866 3867 space(string) { 3868 let spaces = [' ', '\n', '\t'] 3869 return list.split(string, spaces) 3870 }, 3871 3872 comma(string) { 3873 return list.split(string, [','], true) 3874 } 3875} 3876 3877module.exports = list 3878list.default = list 3879 3880 3881/***/ }), 3882
vendor: 9,404 bytes, lines 3883-4226
3883/***/ "./node_modules/postcss/lib/map-generator.js": 3884/*!***************************************************!*\ 3885 !*** ./node_modules/postcss/lib/map-generator.js ***! 3886 \***************************************************/ 3887/*! no static exports found */ 3888/***/ (function(module, exports, __webpack_require__) { 3889 3890"use strict"; 3891/* WEBPACK VAR INJECTION */(function(Buffer) { 3892 3893let { SourceMapConsumer, SourceMapGenerator } = __webpack_require__(/*! source-map-js */ 2) 3894let { dirname, resolve, relative, sep } = __webpack_require__(/*! path */ 3) 3895let { pathToFileURL } = __webpack_require__(/*! url */ 4) 3896 3897let Input = __webpack_require__(/*! ./input */ "./node_modules/postcss/lib/input.js") 3898 3899let sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator) 3900let pathAvailable = Boolean(dirname && resolve && relative && sep) 3901 3902class MapGenerator { 3903 constructor(stringify, root, opts, cssString) { 3904 this.stringify = stringify 3905 this.mapOpts = opts.map || {} 3906 this.root = root 3907 this.opts = opts 3908 this.css = cssString 3909 } 3910 3911 isMap() { 3912 if (typeof this.opts.map !== 'undefined') { 3913 return !!this.opts.map 3914 } 3915 return this.previous().length > 0 3916 } 3917 3918 previous() { 3919 if (!this.previousMaps) { 3920 this.previousMaps = [] 3921 if (this.root) { 3922 this.root.walk(node => { 3923 if (node.source && node.source.input.map) { 3924 let map = node.source.input.map 3925 if (!this.previousMaps.includes(map)) { 3926 this.previousMaps.push(map) 3927 } 3928 } 3929 }) 3930 } else { 3931 let input = new Input(this.css, this.opts) 3932 if (input.map) this.previousMaps.push(input.map) 3933 } 3934 } 3935 3936 return this.previousMaps 3937 } 3938 3939 isInline() { 3940 if (typeof this.mapOpts.inline !== 'undefined') { 3941 return this.mapOpts.inline 3942 } 3943 3944 let annotation = this.mapOpts.annotation 3945 if (typeof annotation !== 'undefined' && annotation !== true) { 3946 return false 3947 } 3948 3949 if (this.previous().length) { 3950 return this.previous().some(i => i.inline) 3951 } 3952 return true 3953 } 3954 3955 isSourcesContent() { 3956 if (typeof this.mapOpts.sourcesContent !== 'undefined') { 3957 return this.mapOpts.sourcesContent 3958 } 3959 if (this.previous().length) { 3960 return this.previous().some(i => i.withContent()) 3961 } 3962 return true 3963 } 3964 3965 clearAnnotation() { 3966 if (this.mapOpts.annotation === false) return 3967 3968 if (this.root) { 3969 let node 3970 for (let i = this.root.nodes.length - 1; i >= 0; i--) { 3971 node = this.root.nodes[i] 3972 if (node.type !== 'comment') continue 3973 if (node.text.indexOf('# sourceMappingURL=') === 0) { 3974 this.root.removeChild(i) 3975 } 3976 } 3977 } else if (this.css) { 3978 this.css = this.css.replace(/(\n)?\/\*#[\S\s]*?\*\/$/gm, '') 3979 } 3980 } 3981 3982 setSourcesContent() { 3983 let already = {} 3984 if (this.root) { 3985 this.root.walk(node => { 3986 if (node.source) { 3987 let from = node.source.input.from 3988 if (from && !already[from]) { 3989 already[from] = true 3990 this.map.setSourceContent( 3991 this.toUrl(this.path(from)), 3992 node.source.input.css 3993 ) 3994 } 3995 } 3996 }) 3997 } else if (this.css) { 3998 let from = this.opts.from 3999 ? this.toUrl(this.path(this.opts.from)) 4000 : '<no source>' 4001 this.map.setSourceContent(from, this.css) 4002 } 4003 } 4004 4005 applyPrevMaps() { 4006 for (let prev of this.previous()) { 4007 let from = this.toUrl(this.path(prev.file)) 4008 let root = prev.root || dirname(prev.file) 4009 let map 4010 4011 if (this.mapOpts.sourcesContent === false) { 4012 map = new SourceMapConsumer(prev.text) 4013 if (map.sourcesContent) { 4014 map.sourcesContent = map.sourcesContent.map(() => null) 4015 } 4016 } else { 4017 map = prev.consumer() 4018 } 4019 4020 this.map.applySourceMap(map, from, this.toUrl(this.path(root))) 4021 } 4022 } 4023 4024 isAnnotation() { 4025 if (this.isInline()) { 4026 return true 4027 } 4028 if (typeof this.mapOpts.annotation !== 'undefined') { 4029 return this.mapOpts.annotation 4030 } 4031 if (this.previous().length) { 4032 return this.previous().some(i => i.annotation) 4033 } 4034 return true 4035 } 4036 4037 toBase64(str) { 4038 if (Buffer) { 4039 return Buffer.from(str).toString('base64') 4040 } else { 4041 return window.btoa(unescape(encodeURIComponent(str))) 4042 } 4043 } 4044 4045 addAnnotation() { 4046 let content 4047 4048 if (this.isInline()) { 4049 content = 4050 'data:application/json;base64,' + this.toBase64(this.map.toString()) 4051 } else if (typeof this.mapOpts.annotation === 'string') { 4052 content = this.mapOpts.annotation 4053 } else if (typeof this.mapOpts.annotation === 'function') { 4054 content = this.mapOpts.annotation(this.opts.to, this.root) 4055 } else { 4056 content = this.outputFile() + '.map' 4057 } 4058 let eol = '\n' 4059 if (this.css.includes('\r\n')) eol = '\r\n' 4060 4061 this.css += eol + '/*# sourceMappingURL=' + content + ' */' 4062 } 4063 4064 outputFile() { 4065 if (this.opts.to) { 4066 return this.path(this.opts.to) 4067 } else if (this.opts.from) { 4068 return this.path(this.opts.from) 4069 } else { 4070 return 'to.css' 4071 } 4072 } 4073 4074 generateMap() { 4075 if (this.root) { 4076 this.generateString() 4077 } else if (this.previous().length === 1) { 4078 let prev = this.previous()[0].consumer() 4079 prev.file = this.outputFile() 4080 this.map = SourceMapGenerator.fromSourceMap(prev) 4081 } else { 4082 this.map = new SourceMapGenerator({ file: this.outputFile() }) 4083 this.map.addMapping({ 4084 source: this.opts.from 4085 ? this.toUrl(this.path(this.opts.from)) 4086 : '<no source>', 4087 generated: { line: 1, column: 0 }, 4088 original: { line: 1, column: 0 } 4089 }) 4090 } 4091 4092 if (this.isSourcesContent()) this.setSourcesContent() 4093 if (this.root && this.previous().length > 0) this.applyPrevMaps() 4094 if (this.isAnnotation()) this.addAnnotation() 4095 4096 if (this.isInline()) { 4097 return [this.css] 4098 } else { 4099 return [this.css, this.map] 4100 } 4101 } 4102 4103 path(file) { 4104 if (file.indexOf('<') === 0) return file 4105 if (/^\w+:\/\//.test(file)) return file 4106 if (this.mapOpts.absolute) return file 4107 4108 let from = this.opts.to ? dirname(this.opts.to) : '.' 4109 4110 if (typeof this.mapOpts.annotation === 'string') { 4111 from = dirname(resolve(from, this.mapOpts.annotation)) 4112 } 4113 4114 file = relative(from, file) 4115 return file 4116 } 4117 4118 toUrl(path) { 4119 if (sep === '\\') { 4120 path = path.replace(/\\/g, '/') 4121 } 4122 return encodeURI(path).replace(/[#?]/g, encodeURIComponent) 4123 } 4124 4125 sourcePath(node) { 4126 if (this.mapOpts.from) { 4127 return this.toUrl(this.mapOpts.from) 4128 } else if (this.mapOpts.absolute) { 4129 if (pathToFileURL) { 4130 return pathToFileURL(node.source.input.from).toString() 4131 } else { 4132 throw new Error( 4133 '`map.absolute` option is not available in this PostCSS build' 4134 ) 4135 } 4136 } else { 4137 return this.toUrl(this.path(node.source.input.from)) 4138 } 4139 } 4140 4141 generateString() { 4142 this.css = '' 4143 this.map = new SourceMapGenerator({ file: this.outputFile() }) 4144 4145 let line = 1 4146 let column = 1 4147 4148 let noSource = '<no source>' 4149 let mapping = { 4150 source: '', 4151 generated: { line: 0, column: 0 }, 4152 original: { line: 0, column: 0 } 4153 } 4154 4155 let lines, last 4156 this.stringify(this.root, (str, node, type) => { 4157 this.css += str 4158 4159 if (node && type !== 'end') { 4160 mapping.generated.line = line 4161 mapping.generated.column = column - 1 4162 if (node.source && node.source.start) { 4163 mapping.source = this.sourcePath(node) 4164 mapping.original.line = node.source.start.line 4165 mapping.original.column = node.source.start.column - 1 4166 this.map.addMapping(mapping) 4167 } else { 4168 mapping.source = noSource 4169 mapping.original.line = 1 4170 mapping.original.column = 0 4171 this.map.addMapping(mapping) 4172 } 4173 } 4174 4175 lines = str.match(/\n/g) 4176 if (lines) { 4177 line += lines.length 4178 last = str.lastIndexOf('\n') 4179 column = str.length - last 4180 } else { 4181 column += str.length 4182 } 4183 4184 if (node && type !== 'start') { 4185 let p = node.parent || { raws: {} } 4186 if (node.type !== 'decl' || node !== p.last || p.raws.semicolon) { 4187 if (node.source && node.source.end) { 4188 mapping.source = this.sourcePath(node) 4189 mapping.original.line = node.source.end.line 4190 mapping.original.column = node.source.end.column - 1 4191 mapping.generated.line = line 4192 mapping.generated.column = column - 2 4193 this.map.addMapping(mapping) 4194 } else { 4195 mapping.source = noSource 4196 mapping.original.line = 1 4197 mapping.original.column = 0 4198 mapping.generated.line = line 4199 mapping.generated.column = column - 1 4200 this.map.addMapping(mapping) 4201 } 4202 } 4203 } 4204 }) 4205 } 4206 4207 generate() { 4208 this.clearAnnotation() 4209 if (pathAvailable && sourceMapAvailable && this.isMap()) { 4210 return this.generateMap() 4211 } else { 4212 let result = '' 4213 this.stringify(this.root, i => { 4214 result += i 4215 }) 4216 return [result] 4217 } 4218 } 4219} 4220 4221module.exports = MapGenerator 4222 4223/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../buffer/index.js */ "./node_modules/buffer/index.js").Buffer)) 4224 4225/***/ }), 4226
vendor: 3,140 bytes, lines 4227-4373
4227/***/ "./node_modules/postcss/lib/no-work-result.js": 4228/*!****************************************************!*\ 4229 !*** ./node_modules/postcss/lib/no-work-result.js ***! 4230 \****************************************************/ 4231/*! no static exports found */ 4232/***/ (function(module, exports, __webpack_require__) { 4233 4234"use strict"; 4235 4236 4237let MapGenerator = __webpack_require__(/*! ./map-generator */ "./node_modules/postcss/lib/map-generator.js") 4238let stringify = __webpack_require__(/*! ./stringify */ "./node_modules/postcss/lib/stringify.js") 4239let warnOnce = __webpack_require__(/*! ./warn-once */ "./node_modules/postcss/lib/warn-once.js") 4240let parse = __webpack_require__(/*! ./parse */ "./node_modules/postcss/lib/parse.js") 4241const Result = __webpack_require__(/*! ./result */ "./node_modules/postcss/lib/result.js") 4242 4243class NoWorkResult { 4244 constructor(processor, css, opts) { 4245 css = css.toString() 4246 this.stringified = false 4247 4248 this._processor = processor 4249 this._css = css 4250 this._opts = opts 4251 this._map = undefined 4252 let root 4253 4254 let str = stringify 4255 this.result = new Result(this._processor, root, this._opts) 4256 this.result.css = css 4257 4258 let self = this 4259 Object.defineProperty(this.result, 'root', { 4260 get() { 4261 return self.root 4262 } 4263 }) 4264 4265 let map = new MapGenerator(str, root, this._opts, css) 4266 if (map.isMap()) { 4267 let [generatedCSS, generatedMap] = map.generate() 4268 if (generatedCSS) { 4269 this.result.css = generatedCSS 4270 } 4271 if (generatedMap) { 4272 this.result.map = generatedMap 4273 } 4274 } 4275 } 4276 4277 get [Symbol.toStringTag]() { 4278 return 'NoWorkResult' 4279 } 4280 4281 get processor() { 4282 return this.result.processor 4283 } 4284 4285 get opts() { 4286 return this.result.opts 4287 } 4288 4289 get css() { 4290 return this.result.css 4291 } 4292 4293 get content() { 4294 return this.result.css 4295 } 4296 4297 get map() { 4298 return this.result.map 4299 } 4300 4301 get root() { 4302 if (this._root) { 4303 return this._root 4304 } 4305 4306 let root 4307 let parser = parse 4308 4309 try { 4310 root = parser(this._css, this._opts) 4311 } catch (error) { 4312 this.error = error 4313 } 4314 4315 if (this.error) { 4316 throw this.error 4317 } else { 4318 this._root = root 4319 return root 4320 } 4321 } 4322 4323 get messages() { 4324 return [] 4325 } 4326 4327 warnings() { 4328 return [] 4329 } 4330 4331 toString() { 4332 return this._css 4333 } 4334 4335 then(onFulfilled, onRejected) { 4336 if (true) { 4337 if (!('from' in this._opts)) { 4338 warnOnce( 4339 'Without `from` option PostCSS could generate wrong source map ' + 4340 'and will not find Browserslist config. Set it to CSS file path ' + 4341 'or to `undefined` to prevent this warning.' 4342 ) 4343 } 4344 } 4345 4346 return this.async().then(onFulfilled, onRejected) 4347 } 4348 4349 catch(onRejected) { 4350 return this.async().catch(onRejected) 4351 } 4352 4353 finally(onFinally) { 4354 return this.async().then(onFinally, onFinally) 4355 } 4356 4357 async() { 4358 if (this.error) return Promise.reject(this.error) 4359 return Promise.resolve(this.result) 4360 } 4361 4362 sync() { 4363 if (this.error) throw this.error 4364 return this.result 4365 } 4366} 4367 4368module.exports = NoWorkResult 4369NoWorkResult.default = NoWorkResult 4370 4371 4372/***/ }), 4373
vendor: 9,018 bytes, lines 4374-4764
4374/***/ "./node_modules/postcss/lib/node.js": 4375/*!******************************************!*\ 4376 !*** ./node_modules/postcss/lib/node.js ***! 4377 \******************************************/ 4378/*! no static exports found */ 4379/***/ (function(module, exports, __webpack_require__) { 4380 4381"use strict"; 4382 4383 4384let { isClean, my } = __webpack_require__(/*! ./symbols */ "./node_modules/postcss/lib/symbols.js") 4385let CssSyntaxError = __webpack_require__(/*! ./css-syntax-error */ "./node_modules/postcss/lib/css-syntax-error.js") 4386let Stringifier = __webpack_require__(/*! ./stringifier */ "./node_modules/postcss/lib/stringifier.js") 4387let stringify = __webpack_require__(/*! ./stringify */ "./node_modules/postcss/lib/stringify.js") 4388 4389function cloneNode(obj, parent) { 4390 let cloned = new obj.constructor() 4391 4392 for (let i in obj) { 4393 if (!Object.prototype.hasOwnProperty.call(obj, i)) { 4394 /* c8 ignore next 2 */ 4395 continue 4396 } 4397 if (i === 'proxyCache') continue 4398 let value = obj[i] 4399 let type = typeof value 4400 4401 if (i === 'parent' && type === 'object') { 4402 if (parent) cloned[i] = parent 4403 } else if (i === 'source') { 4404 cloned[i] = value 4405 } else if (Array.isArray(value)) { 4406 cloned[i] = value.map(j => cloneNode(j, cloned)) 4407 } else { 4408 if (type === 'object' && value !== null) value = cloneNode(value) 4409 cloned[i] = value 4410 } 4411 } 4412 4413 return cloned 4414} 4415 4416class Node { 4417 constructor(defaults = {}) { 4418 this.raws = {} 4419 this[isClean] = false 4420 this[my] = true 4421 4422 for (let name in defaults) { 4423 if (name === 'nodes') { 4424 this.nodes = [] 4425 for (let node of defaults[name]) { 4426 if (typeof node.clone === 'function') { 4427 this.append(node.clone()) 4428 } else { 4429 this.append(node) 4430 } 4431 } 4432 } else { 4433 this[name] = defaults[name] 4434 } 4435 } 4436 } 4437 4438 error(message, opts = {}) { 4439 if (this.source) { 4440 let { start, end } = this.rangeBy(opts) 4441 return this.source.input.error( 4442 message, 4443 { line: start.line, column: start.column }, 4444 { line: end.line, column: end.column }, 4445 opts 4446 ) 4447 } 4448 return new CssSyntaxError(message) 4449 } 4450 4451 warn(result, text, opts) { 4452 let data = { node: this } 4453 for (let i in opts) data[i] = opts[i] 4454 return result.warn(text, data) 4455 } 4456 4457 remove() { 4458 if (this.parent) { 4459 this.parent.removeChild(this) 4460 } 4461 this.parent = undefined 4462 return this 4463 } 4464 4465 toString(stringifier = stringify) { 4466 if (stringifier.stringify) stringifier = stringifier.stringify 4467 let result = '' 4468 stringifier(this, i => { 4469 result += i 4470 }) 4471 return result 4472 } 4473 4474 assign(overrides = {}) { 4475 for (let name in overrides) { 4476 this[name] = overrides[name] 4477 } 4478 return this 4479 } 4480 4481 clone(overrides = {}) { 4482 let cloned = cloneNode(this) 4483 for (let name in overrides) { 4484 cloned[name] = overrides[name] 4485 } 4486 return cloned 4487 } 4488 4489 cloneBefore(overrides = {}) { 4490 let cloned = this.clone(overrides) 4491 this.parent.insertBefore(this, cloned) 4492 return cloned 4493 } 4494 4495 cloneAfter(overrides = {}) { 4496 let cloned = this.clone(overrides) 4497 this.parent.insertAfter(this, cloned) 4498 return cloned 4499 } 4500 4501 replaceWith(...nodes) { 4502 if (this.parent) { 4503 let bookmark = this 4504 let foundSelf = false 4505 for (let node of nodes) { 4506 if (node === this) { 4507 foundSelf = true 4508 } else if (foundSelf) { 4509 this.parent.insertAfter(bookmark, node) 4510 bookmark = node 4511 } else { 4512 this.parent.insertBefore(bookmark, node) 4513 } 4514 } 4515 4516 if (!foundSelf) { 4517 this.remove() 4518 } 4519 } 4520 4521 return this 4522 } 4523 4524 next() { 4525 if (!this.parent) return undefined 4526 let index = this.parent.index(this) 4527 return this.parent.nodes[index + 1] 4528 } 4529 4530 prev() { 4531 if (!this.parent) return undefined 4532 let index = this.parent.index(this) 4533 return this.parent.nodes[index - 1] 4534 } 4535 4536 before(add) { 4537 this.parent.insertBefore(this, add) 4538 return this 4539 } 4540 4541 after(add) { 4542 this.parent.insertAfter(this, add) 4543 return this 4544 } 4545 4546 root() { 4547 let result = this 4548 while (result.parent && result.parent.type !== 'document') { 4549 result = result.parent 4550 } 4551 return result 4552 } 4553 4554 raw(prop, defaultType) { 4555 let str = new Stringifier() 4556 return str.raw(this, prop, defaultType) 4557 } 4558 4559 cleanRaws(keepBetween) { 4560 delete this.raws.before 4561 delete this.raws.after 4562 if (!keepBetween) delete this.raws.between 4563 } 4564 4565 toJSON(_, inputs) { 4566 let fixed = {} 4567 let emitInputs = inputs == null 4568 inputs = inputs || new Map() 4569 let inputsNextIndex = 0 4570 4571 for (let name in this) { 4572 if (!Object.prototype.hasOwnProperty.call(this, name)) { 4573 /* c8 ignore next 2 */ 4574 continue 4575 } 4576 if (name === 'parent' || name === 'proxyCache') continue 4577 let value = this[name] 4578 4579 if (Array.isArray(value)) { 4580 fixed[name] = value.map(i => { 4581 if (typeof i === 'object' && i.toJSON) { 4582 return i.toJSON(null, inputs) 4583 } else { 4584 return i 4585 } 4586 }) 4587 } else if (typeof value === 'object' && value.toJSON) { 4588 fixed[name] = value.toJSON(null, inputs) 4589 } else if (name === 'source') { 4590 let inputId = inputs.get(value.input) 4591 if (inputId == null) { 4592 inputId = inputsNextIndex 4593 inputs.set(value.input, inputsNextIndex) 4594 inputsNextIndex++ 4595 } 4596 fixed[name] = { 4597 inputId, 4598 start: value.start, 4599 end: value.end 4600 } 4601 } else { 4602 fixed[name] = value 4603 } 4604 } 4605 4606 if (emitInputs) { 4607 fixed.inputs = [...inputs.keys()].map(input => input.toJSON()) 4608 } 4609 4610 return fixed 4611 } 4612 4613 positionInside(index) { 4614 let string = this.toString() 4615 let column = this.source.start.column 4616 let line = this.source.start.line 4617 4618 for (let i = 0; i < index; i++) { 4619 if (string[i] === '\n') { 4620 column = 1 4621 line += 1 4622 } else { 4623 column += 1 4624 } 4625 } 4626 4627 return { line, column } 4628 } 4629 4630 positionBy(opts) { 4631 let pos = this.source.start 4632 if (opts.index) { 4633 pos = this.positionInside(opts.index) 4634 } else if (opts.word) { 4635 let index = this.toString().indexOf(opts.word) 4636 if (index !== -1) pos = this.positionInside(index) 4637 } 4638 return pos 4639 } 4640 4641 rangeBy(opts) { 4642 let start = { 4643 line: this.source.start.line, 4644 column: this.source.start.column 4645 } 4646 let end = this.source.end 4647 ? { 4648 line: this.source.end.line, 4649 column: this.source.end.column + 1 4650 } 4651 : { 4652 line: start.line, 4653 column: start.column + 1 4654 } 4655 4656 if (opts.word) { 4657 let index = this.toString().indexOf(opts.word) 4658 if (index !== -1) { 4659 start = this.positionInside(index) 4660 end = this.positionInside(index + opts.word.length) 4661 } 4662 } else { 4663 if (opts.start) { 4664 start = { 4665 line: opts.start.line, 4666 column: opts.start.column 4667 } 4668 } else if (opts.index) { 4669 start = this.positionInside(opts.index) 4670 } 4671 4672 if (opts.end) { 4673 end = { 4674 line: opts.end.line, 4675 column: opts.end.column 4676 } 4677 } else if (opts.endIndex) { 4678 end = this.positionInside(opts.endIndex) 4679 } else if (opts.index) { 4680 end = this.positionInside(opts.index + 1) 4681 } 4682 } 4683 4684 if ( 4685 end.line < start.line || 4686 (end.line === start.line && end.column <= start.column) 4687 ) { 4688 end = { line: start.line, column: start.column + 1 } 4689 } 4690 4691 return { start, end } 4692 } 4693 4694 getProxyProcessor() { 4695 return { 4696 set(node, prop, value) { 4697 if (node[prop] === value) return true 4698 node[prop] = value 4699 if ( 4700 prop === 'prop' || 4701 prop === 'value' || 4702 prop === 'name' || 4703 prop === 'params' || 4704 prop === 'important' || 4705 /* c8 ignore next */ 4706 prop === 'text' 4707 ) { 4708 node.markDirty() 4709 } 4710 return true 4711 }, 4712 4713 get(node, prop) { 4714 if (prop === 'proxyOf') { 4715 return node 4716 } else if (prop === 'root') { 4717 return () => node.root().toProxy() 4718 } else { 4719 return node[prop] 4720 } 4721 } 4722 } 4723 } 4724 4725 toProxy() { 4726 if (!this.proxyCache) { 4727 this.proxyCache = new Proxy(this, this.getProxyProcessor()) 4728 } 4729 return this.proxyCache 4730 } 4731 4732 addToError(error) { 4733 error.postcssNode = this 4734 if (error.stack && this.source && /\n\s{4}at /.test(error.stack)) { 4735 let s = this.source 4736 error.stack = error.stack.replace( 4737 /\n\s{4}at /, 4738 `$&${s.input.from}:${s.start.line}:${s.start.column}$&` 4739 ) 4740 } 4741 return error 4742 } 4743 4744 markDirty() { 4745 if (this[isClean]) { 4746 this[isClean] = false 4747 let next = this 4748 while ((next = next.parent)) { 4749 next[isClean] = false 4750 } 4751 } 4752 } 4753 4754 get proxyOf() { 4755 return this 4756 } 4757} 4758 4759module.exports = Node 4760Node.default = Node 4761 4762 4763/***/ }), 4764
vendor: 1,578 bytes, lines 4765-4818
4765/***/ "./node_modules/postcss/lib/parse.js": 4766/*!*******************************************!*\ 4767 !*** ./node_modules/postcss/lib/parse.js ***! 4768 \*******************************************/ 4769/*! no static exports found */ 4770/***/ (function(module, exports, __webpack_require__) { 4771 4772"use strict"; 4773 4774 4775let Container = __webpack_require__(/*! ./container */ "./node_modules/postcss/lib/container.js") 4776let Parser = __webpack_require__(/*! ./parser */ "./node_modules/postcss/lib/parser.js") 4777let Input = __webpack_require__(/*! ./input */ "./node_modules/postcss/lib/input.js") 4778 4779function parse(css, opts) { 4780 let input = new Input(css, opts) 4781 let parser = new Parser(input) 4782 try { 4783 parser.parse() 4784 } catch (e) { 4785 if (true) { 4786 if (e.name === 'CssSyntaxError' && opts && opts.from) { 4787 if (/\.scss$/i.test(opts.from)) { 4788 e.message += 4789 '\nYou tried to parse SCSS with ' + 4790 'the standard CSS parser; ' + 4791 'try again with the postcss-scss parser' 4792 } else if (/\.sass/i.test(opts.from)) { 4793 e.message += 4794 '\nYou tried to parse Sass with ' + 4795 'the standard CSS parser; ' + 4796 'try again with the postcss-sass parser' 4797 } else if (/\.less$/i.test(opts.from)) { 4798 e.message += 4799 '\nYou tried to parse Less with ' + 4800 'the standard CSS parser; ' + 4801 'try again with the postcss-less parser' 4802 } 4803 } 4804 } 4805 throw e 4806 } 4807 4808 return parser.root 4809} 4810 4811module.exports = parse 4812parse.default = parse 4813 4814Container.registerParse(parse) 4815 4816 4817/***/ }), 4818
vendor: 15,121 bytes, lines 4819-5433
4819/***/ "./node_modules/postcss/lib/parser.js": 4820/*!********************************************!*\ 4821 !*** ./node_modules/postcss/lib/parser.js ***! 4822 \********************************************/ 4823/*! no static exports found */ 4824/***/ (function(module, exports, __webpack_require__) { 4825 4826"use strict"; 4827 4828 4829let Declaration = __webpack_require__(/*! ./declaration */ "./node_modules/postcss/lib/declaration.js") 4830let tokenizer = __webpack_require__(/*! ./tokenize */ "./node_modules/postcss/lib/tokenize.js") 4831let Comment = __webpack_require__(/*! ./comment */ "./node_modules/postcss/lib/comment.js") 4832let AtRule = __webpack_require__(/*! ./at-rule */ "./node_modules/postcss/lib/at-rule.js") 4833let Root = __webpack_require__(/*! ./root */ "./node_modules/postcss/lib/root.js") 4834let Rule = __webpack_require__(/*! ./rule */ "./node_modules/postcss/lib/rule.js") 4835 4836const SAFE_COMMENT_NEIGHBOR = { 4837 empty: true, 4838 space: true 4839} 4840 4841function findLastWithPosition(tokens) { 4842 for (let i = tokens.length - 1; i >= 0; i--) { 4843 let token = tokens[i] 4844 let pos = token[3] || token[2] 4845 if (pos) return pos 4846 } 4847} 4848 4849class Parser { 4850 constructor(input) { 4851 this.input = input 4852 4853 this.root = new Root() 4854 this.current = this.root 4855 this.spaces = '' 4856 this.semicolon = false 4857 this.customProperty = false 4858 4859 this.createTokenizer() 4860 this.root.source = { input, start: { offset: 0, line: 1, column: 1 } } 4861 } 4862 4863 createTokenizer() { 4864 this.tokenizer = tokenizer(this.input) 4865 } 4866 4867 parse() { 4868 let token 4869 while (!this.tokenizer.endOfFile()) { 4870 token = this.tokenizer.nextToken() 4871 4872 switch (token[0]) { 4873 case 'space': 4874 this.spaces += token[1] 4875 break 4876 4877 case ';': 4878 this.freeSemicolon(token) 4879 break 4880 4881 case '}': 4882 this.end(token) 4883 break 4884 4885 case 'comment': 4886 this.comment(token) 4887 break 4888 4889 case 'at-word': 4890 this.atrule(token) 4891 break 4892 4893 case '{': 4894 this.emptyRule(token) 4895 break 4896 4897 default: 4898 this.other(token) 4899 break 4900 } 4901 } 4902 this.endFile() 4903 } 4904 4905 comment(token) { 4906 let node = new Comment() 4907 this.init(node, token[2]) 4908 node.source.end = this.getPosition(token[3] || token[2]) 4909 4910 let text = token[1].slice(2, -2) 4911 if (/^\s*$/.test(text)) { 4912 node.text = '' 4913 node.raws.left = text 4914 node.raws.right = '' 4915 } else { 4916 let match = text.match(/^(\s*)([^]*\S)(\s*)$/) 4917 node.text = match[2] 4918 node.raws.left = match[1] 4919 node.raws.right = match[3] 4920 } 4921 } 4922 4923 emptyRule(token) { 4924 let node = new Rule() 4925 this.init(node, token[2]) 4926 node.selector = '' 4927 node.raws.between = '' 4928 this.current = node 4929 } 4930 4931 other(start) { 4932 let end = false 4933 let type = null 4934 let colon = false 4935 let bracket = null 4936 let brackets = [] 4937 let customProperty = start[1].startsWith('--') 4938 4939 let tokens = [] 4940 let token = start 4941 while (token) { 4942 type = token[0] 4943 tokens.push(token) 4944 4945 if (type === '(' || type === '[') { 4946 if (!bracket) bracket = token 4947 brackets.push(type === '(' ? ')' : ']') 4948 } else if (customProperty && colon && type === '{') { 4949 if (!bracket) bracket = token 4950 brackets.push('}') 4951 } else if (brackets.length === 0) { 4952 if (type === ';') { 4953 if (colon) { 4954 this.decl(tokens, customProperty) 4955 return 4956 } else { 4957 break 4958 } 4959 } else if (type === '{') { 4960 this.rule(tokens) 4961 return 4962 } else if (type === '}') { 4963 this.tokenizer.back(tokens.pop()) 4964 end = true 4965 break 4966 } else if (type === ':') { 4967 colon = true 4968 } 4969 } else if (type === brackets[brackets.length - 1]) { 4970 brackets.pop() 4971 if (brackets.length === 0) bracket = null 4972 } 4973 4974 token = this.tokenizer.nextToken() 4975 } 4976 4977 if (this.tokenizer.endOfFile()) end = true 4978 if (brackets.length > 0) this.unclosedBracket(bracket) 4979 4980 if (end && colon) { 4981 if (!customProperty) { 4982 while (tokens.length) { 4983 token = tokens[tokens.length - 1][0] 4984 if (token !== 'space' && token !== 'comment') break 4985 this.tokenizer.back(tokens.pop()) 4986 } 4987 } 4988 this.decl(tokens, customProperty) 4989 } else { 4990 this.unknownWord(tokens) 4991 } 4992 } 4993 4994 rule(tokens) { 4995 tokens.pop() 4996 4997 let node = new Rule() 4998 this.init(node, tokens[0][2]) 4999 5000 node.raws.between = this.spacesAndCommentsFromEnd(tokens) 5001 this.raw(node, 'selector', tokens) 5002 this.current = node 5003 } 5004 5005 decl(tokens, customProperty) { 5006 let node = new Declaration() 5007 this.init(node, tokens[0][2]) 5008 5009 let last = tokens[tokens.length - 1] 5010 if (last[0] === ';') { 5011 this.semicolon = true 5012 tokens.pop() 5013 } 5014 5015 node.source.end = this.getPosition( 5016 last[3] || last[2] || findLastWithPosition(tokens) 5017 ) 5018 5019 while (tokens[0][0] !== 'word') { 5020 if (tokens.length === 1) this.unknownWord(tokens) 5021 node.raws.before += tokens.shift()[1] 5022 } 5023 node.source.start = this.getPosition(tokens[0][2]) 5024 5025 node.prop = '' 5026 while (tokens.length) { 5027 let type = tokens[0][0] 5028 if (type === ':' || type === 'space' || type === 'comment') { 5029 break 5030 } 5031 node.prop += tokens.shift()[1] 5032 } 5033 5034 node.raws.between = '' 5035 5036 let token 5037 while (tokens.length) { 5038 token = tokens.shift() 5039 5040 if (token[0] === ':') { 5041 node.raws.between += token[1] 5042 break 5043 } else { 5044 if (token[0] === 'word' && /\w/.test(token[1])) { 5045 this.unknownWord([token]) 5046 } 5047 node.raws.between += token[1] 5048 } 5049 } 5050 5051 if (node.prop[0] === '_' || node.prop[0] === '*') { 5052 node.raws.before += node.prop[0] 5053 node.prop = node.prop.slice(1) 5054 } 5055 5056 let firstSpaces = [] 5057 let next 5058 while (tokens.length) { 5059 next = tokens[0][0] 5060 if (next !== 'space' && next !== 'comment') break 5061 firstSpaces.push(tokens.shift()) 5062 } 5063 5064 this.precheckMissedSemicolon(tokens) 5065 5066 for (let i = tokens.length - 1; i >= 0; i--) { 5067 token = tokens[i] 5068 if (token[1].toLowerCase() === '!important') { 5069 node.important = true 5070 let string = this.stringFrom(tokens, i) 5071 string = this.spacesFromEnd(tokens) + string 5072 if (string !== ' !important') node.raws.important = string 5073 break 5074 } else if (token[1].toLowerCase() === 'important') { 5075 let cache = tokens.slice(0) 5076 let str = '' 5077 for (let j = i; j > 0; j--) { 5078 let type = cache[j][0] 5079 if (str.trim().indexOf('!') === 0 && type !== 'space') { 5080 break 5081 } 5082 str = cache.pop()[1] + str 5083 } 5084 if (str.trim().indexOf('!') === 0) { 5085 node.important = true 5086 node.raws.important = str 5087 tokens = cache 5088 } 5089 } 5090 5091 if (token[0] !== 'space' && token[0] !== 'comment') { 5092 break 5093 } 5094 } 5095 5096 let hasWord = tokens.some(i => i[0] !== 'space' && i[0] !== 'comment') 5097 5098 if (hasWord) { 5099 node.raws.between += firstSpaces.map(i => i[1]).join('') 5100 firstSpaces = [] 5101 } 5102 this.raw(node, 'value', firstSpaces.concat(tokens), customProperty) 5103 5104 if (node.value.includes(':') && !customProperty) { 5105 this.checkMissedSemicolon(tokens) 5106 } 5107 } 5108 5109 atrule(token) { 5110 let node = new AtRule() 5111 node.name = token[1].slice(1) 5112 if (node.name === '') { 5113 this.unnamedAtrule(node, token) 5114 } 5115 this.init(node, token[2]) 5116 5117 let type 5118 let prev 5119 let shift 5120 let last = false 5121 let open = false 5122 let params = [] 5123 let brackets = [] 5124 5125 while (!this.tokenizer.endOfFile()) { 5126 token = this.tokenizer.nextToken() 5127 type = token[0] 5128 5129 if (type === '(' || type === '[') { 5130 brackets.push(type === '(' ? ')' : ']') 5131 } else if (type === '{' && brackets.length > 0) { 5132 brackets.push('}') 5133 } else if (type === brackets[brackets.length - 1]) { 5134 brackets.pop() 5135 } 5136 5137 if (brackets.length === 0) { 5138 if (type === ';') { 5139 node.source.end = this.getPosition(token[2]) 5140 this.semicolon = true 5141 break 5142 } else if (type === '{') { 5143 open = true 5144 break 5145 } else if (type === '}') { 5146 if (params.length > 0) { 5147 shift = params.length - 1 5148 prev = params[shift] 5149 while (prev && prev[0] === 'space') { 5150 prev = params[--shift] 5151 } 5152 if (prev) { 5153 node.source.end = this.getPosition(prev[3] || prev[2]) 5154 } 5155 } 5156 this.end(token) 5157 break 5158 } else { 5159 params.push(token) 5160 } 5161 } else { 5162 params.push(token) 5163 } 5164 5165 if (this.tokenizer.endOfFile()) { 5166 last = true 5167 break 5168 } 5169 } 5170 5171 node.raws.between = this.spacesAndCommentsFromEnd(params) 5172 if (params.length) { 5173 node.raws.afterName = this.spacesAndCommentsFromStart(params) 5174 this.raw(node, 'params', params) 5175 if (last) { 5176 token = params[params.length - 1] 5177 node.source.end = this.getPosition(token[3] || token[2]) 5178 this.spaces = node.raws.between 5179 node.raws.between = '' 5180 } 5181 } else { 5182 node.raws.afterName = '' 5183 node.params = '' 5184 } 5185 5186 if (open) { 5187 node.nodes = [] 5188 this.current = node 5189 } 5190 } 5191 5192 end(token) { 5193 if (this.current.nodes && this.current.nodes.length) { 5194 this.current.raws.semicolon = this.semicolon 5195 } 5196 this.semicolon = false 5197 5198 this.current.raws.after = (this.current.raws.after || '') + this.spaces 5199 this.spaces = '' 5200 5201 if (this.current.parent) { 5202 this.current.source.end = this.getPosition(token[2]) 5203 this.current = this.current.parent 5204 } else { 5205 this.unexpectedClose(token) 5206 } 5207 } 5208 5209 endFile() { 5210 if (this.current.parent) this.unclosedBlock() 5211 if (this.current.nodes && this.current.nodes.length) { 5212 this.current.raws.semicolon = this.semicolon 5213 } 5214 this.current.raws.after = (this.current.raws.after || '') + this.spaces 5215 } 5216 5217 freeSemicolon(token) { 5218 this.spaces += token[1] 5219 if (this.current.nodes) { 5220 let prev = this.current.nodes[this.current.nodes.length - 1] 5221 if (prev && prev.type === 'rule' && !prev.raws.ownSemicolon) { 5222 prev.raws.ownSemicolon = this.spaces 5223 this.spaces = '' 5224 } 5225 } 5226 } 5227 5228 // Helpers 5229 5230 getPosition(offset) { 5231 let pos = this.input.fromOffset(offset) 5232 return { 5233 offset, 5234 line: pos.line, 5235 column: pos.col 5236 } 5237 } 5238 5239 init(node, offset) { 5240 this.current.push(node) 5241 node.source = { 5242 start: this.getPosition(offset), 5243 input: this.input 5244 } 5245 node.raws.before = this.spaces 5246 this.spaces = '' 5247 if (node.type !== 'comment') this.semicolon = false 5248 } 5249 5250 raw(node, prop, tokens, customProperty) { 5251 let token, type 5252 let length = tokens.length 5253 let value = '' 5254 let clean = true 5255 let next, prev 5256 5257 for (let i = 0; i < length; i += 1) { 5258 token = tokens[i] 5259 type = token[0] 5260 if (type === 'space' && i === length - 1 && !customProperty) { 5261 clean = false 5262 } else if (type === 'comment') { 5263 prev = tokens[i - 1] ? tokens[i - 1][0] : 'empty' 5264 next = tokens[i + 1] ? tokens[i + 1][0] : 'empty' 5265 if (!SAFE_COMMENT_NEIGHBOR[prev] && !SAFE_COMMENT_NEIGHBOR[next]) { 5266 if (value.slice(-1) === ',') { 5267 clean = false 5268 } else { 5269 value += token[1] 5270 } 5271 } else { 5272 clean = false 5273 } 5274 } else { 5275 value += token[1] 5276 } 5277 } 5278 if (!clean) { 5279 let raw = tokens.reduce((all, i) => all + i[1], '') 5280 node.raws[prop] = { value, raw } 5281 } 5282 node[prop] = value 5283 } 5284 5285 spacesAndCommentsFromEnd(tokens) { 5286 let lastTokenType 5287 let spaces = '' 5288 while (tokens.length) { 5289 lastTokenType = tokens[tokens.length - 1][0] 5290 if (lastTokenType !== 'space' && lastTokenType !== 'comment') break 5291 spaces = tokens.pop()[1] + spaces 5292 } 5293 return spaces 5294 } 5295 5296 spacesAndCommentsFromStart(tokens) { 5297 let next 5298 let spaces = '' 5299 while (tokens.length) { 5300 next = tokens[0][0] 5301 if (next !== 'space' && next !== 'comment') break 5302 spaces += tokens.shift()[1] 5303 } 5304 return spaces 5305 } 5306 5307 spacesFromEnd(tokens) { 5308 let lastTokenType 5309 let spaces = '' 5310 while (tokens.length) { 5311 lastTokenType = tokens[tokens.length - 1][0] 5312 if (lastTokenType !== 'space') break 5313 spaces = tokens.pop()[1] + spaces 5314 } 5315 return spaces 5316 } 5317 5318 stringFrom(tokens, from) { 5319 let result = '' 5320 for (let i = from; i < tokens.length; i++) { 5321 result += tokens[i][1] 5322 } 5323 tokens.splice(from, tokens.length - from) 5324 return result 5325 } 5326 5327 colon(tokens) { 5328 let brackets = 0 5329 let token, type, prev 5330 for (let [i, element] of tokens.entries()) { 5331 token = element 5332 type = token[0] 5333 5334 if (type === '(') { 5335 brackets += 1 5336 } 5337 if (type === ')') { 5338 brackets -= 1 5339 } 5340 if (brackets === 0 && type === ':') { 5341 if (!prev) { 5342 this.doubleColon(token) 5343 } else if (prev[0] === 'word' && prev[1] === 'progid') { 5344 continue 5345 } else { 5346 return i 5347 } 5348 } 5349 5350 prev = token 5351 } 5352 return false 5353 } 5354 5355 // Errors 5356 5357 unclosedBracket(bracket) { 5358 throw this.input.error( 5359 'Unclosed bracket', 5360 { offset: bracket[2] }, 5361 { offset: bracket[2] + 1 } 5362 ) 5363 } 5364 5365 unknownWord(tokens) { 5366 throw this.input.error( 5367 'Unknown word', 5368 { offset: tokens[0][2] }, 5369 { offset: tokens[0][2] + tokens[0][1].length } 5370 ) 5371 } 5372 5373 unexpectedClose(token) { 5374 throw this.input.error( 5375 'Unexpected }', 5376 { offset: token[2] }, 5377 { offset: token[2] + 1 } 5378 ) 5379 } 5380 5381 unclosedBlock() { 5382 let pos = this.current.source.start 5383 throw this.input.error('Unclosed block', pos.line, pos.column) 5384 } 5385 5386 doubleColon(token) { 5387 throw this.input.error( 5388 'Double colon', 5389 { offset: token[2] }, 5390 { offset: token[2] + token[1].length } 5391 ) 5392 } 5393 5394 unnamedAtrule(node, token) { 5395 throw this.input.error( 5396 'At-rule without name', 5397 { offset: token[2] }, 5398 { offset: token[2] + token[1].length } 5399 ) 5400 } 5401 5402 precheckMissedSemicolon(/* tokens */) { 5403 // Hook for Safe Parser 5404 } 5405 5406 checkMissedSemicolon(tokens) { 5407 let colon = this.colon(tokens) 5408 if (colon === false) return 5409 5410 let founded = 0 5411 let token 5412 for (let j = colon - 1; j >= 0; j--) { 5413 token = tokens[j] 5414 if (token[0] !== 'space') { 5415 founded += 1 5416 if (founded === 2) break 5417 } 5418 } 5419 // If the token is a word, e.g. `!important`, `red` or any other valid property's value. 5420 // Then we need to return the colon after that word token. [3] is the "end" colon of that word. 5421 // And because we need it after that one we do +1 to get the next one. 5422 throw this.input.error( 5423 'Missed semicolon', 5424 token[0] === 'word' ? token[3] + 1 : token[2] 5425 ) 5426 } 5427} 5428 5429module.exports = Parser 5430 5431 5432/***/ }), 5433
vendor: 4,302 bytes, lines 5434-5545
5434/***/ "./node_modules/postcss/lib/postcss.js": 5435/*!*********************************************!*\ 5436 !*** ./node_modules/postcss/lib/postcss.js ***! 5437 \*********************************************/ 5438/*! no static exports found */ 5439/***/ (function(module, exports, __webpack_require__) { 5440 5441"use strict"; 5442/* WEBPACK VAR INJECTION */(function(process) { 5443 5444let CssSyntaxError = __webpack_require__(/*! ./css-syntax-error */ "./node_modules/postcss/lib/css-syntax-error.js") 5445let Declaration = __webpack_require__(/*! ./declaration */ "./node_modules/postcss/lib/declaration.js") 5446let LazyResult = __webpack_require__(/*! ./lazy-result */ "./node_modules/postcss/lib/lazy-result.js") 5447let Container = __webpack_require__(/*! ./container */ "./node_modules/postcss/lib/container.js") 5448let Processor = __webpack_require__(/*! ./processor */ "./node_modules/postcss/lib/processor.js") 5449let stringify = __webpack_require__(/*! ./stringify */ "./node_modules/postcss/lib/stringify.js") 5450let fromJSON = __webpack_require__(/*! ./fromJSON */ "./node_modules/postcss/lib/fromJSON.js") 5451let Document = __webpack_require__(/*! ./document */ "./node_modules/postcss/lib/document.js") 5452let Warning = __webpack_require__(/*! ./warning */ "./node_modules/postcss/lib/warning.js") 5453let Comment = __webpack_require__(/*! ./comment */ "./node_modules/postcss/lib/comment.js") 5454let AtRule = __webpack_require__(/*! ./at-rule */ "./node_modules/postcss/lib/at-rule.js") 5455let Result = __webpack_require__(/*! ./result.js */ "./node_modules/postcss/lib/result.js") 5456let Input = __webpack_require__(/*! ./input */ "./node_modules/postcss/lib/input.js") 5457let parse = __webpack_require__(/*! ./parse */ "./node_modules/postcss/lib/parse.js") 5458let list = __webpack_require__(/*! ./list */ "./node_modules/postcss/lib/list.js") 5459let Rule = __webpack_require__(/*! ./rule */ "./node_modules/postcss/lib/rule.js") 5460let Root = __webpack_require__(/*! ./root */ "./node_modules/postcss/lib/root.js") 5461let Node = __webpack_require__(/*! ./node */ "./node_modules/postcss/lib/node.js") 5462 5463function postcss(...plugins) { 5464 if (plugins.length === 1 && Array.isArray(plugins[0])) { 5465 plugins = plugins[0] 5466 } 5467 return new Processor(plugins) 5468} 5469 5470postcss.plugin = function plugin(name, initializer) { 5471 // eslint-disable-next-line no-console 5472 if (console && console.warn) { 5473 // eslint-disable-next-line no-console 5474 console.warn( 5475 name + 5476 ': postcss.plugin was deprecated. Migration guide:\n' + 5477 'https://evilmartians.com/chronicles/postcss-8-plugin-migration' 5478 ) 5479 if (process.env.LANG && process.env.LANG.startsWith('cn')) { 5480 /* c8 ignore next 7 */ 5481 // eslint-disable-next-line no-console 5482 console.warn( 5483 name + 5484 ': éé¢ postcss.plugin 被å¼ç¨. è¿ç§»æå:\n' + 5485 'https://www.w3ctech.com/topic/2226' 5486 ) 5487 } 5488 } 5489 function creator(...args) { 5490 let transformer = initializer(...args) 5491 transformer.postcssPlugin = name 5492 transformer.postcssVersion = new Processor().version 5493 return transformer 5494 } 5495 5496 let cache 5497 Object.defineProperty(creator, 'postcss', { 5498 get() { 5499 if (!cache) cache = creator() 5500 return cache 5501 } 5502 }) 5503 5504 creator.process = function (css, processOpts, pluginOpts) { 5505 return postcss([creator(pluginOpts)]).process(css, processOpts) 5506 } 5507 5508 return creator 5509} 5510 5511postcss.stringify = stringify 5512postcss.parse = parse 5513postcss.fromJSON = fromJSON 5514postcss.list = list 5515 5516postcss.comment = defaults => new Comment(defaults) 5517postcss.atRule = defaults => new AtRule(defaults) 5518postcss.decl = defaults => new Declaration(defaults) 5519postcss.rule = defaults => new Rule(defaults) 5520postcss.root = defaults => new Root(defaults) 5521postcss.document = defaults => new Document(defaults) 5522 5523postcss.CssSyntaxError = CssSyntaxError 5524postcss.Declaration = Declaration 5525postcss.Container = Container 5526postcss.Processor = Processor 5527postcss.Document = Document 5528postcss.Comment = Comment 5529postcss.Warning = Warning 5530postcss.AtRule = AtRule 5531postcss.Result = Result 5532postcss.Input = Input 5533postcss.Rule = Rule 5534postcss.Root = Root 5535postcss.Node = Node 5536 5537LazyResult.registerPostcss(postcss) 5538 5539module.exports = postcss 5540postcss.default = postcss 5541 5542/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../process/browser.js */ "./node_modules/process/browser.js"))) 5543 5544/***/ }), 5545
vendor: 4,482 bytes, lines 5546-5700
5546/***/ "./node_modules/postcss/lib/previous-map.js": 5547/*!**************************************************!*\ 5548 !*** ./node_modules/postcss/lib/previous-map.js ***! 5549 \**************************************************/ 5550/*! no static exports found */ 5551/***/ (function(module, exports, __webpack_require__) { 5552 5553"use strict"; 5554/* WEBPACK VAR INJECTION */(function(Buffer) { 5555 5556let { SourceMapConsumer, SourceMapGenerator } = __webpack_require__(/*! source-map-js */ 2) 5557let { existsSync, readFileSync } = __webpack_require__(/*! fs */ 5) 5558let { dirname, join } = __webpack_require__(/*! path */ 3) 5559 5560function fromBase64(str) { 5561 if (Buffer) { 5562 return Buffer.from(str, 'base64').toString() 5563 } else { 5564 /* c8 ignore next 2 */ 5565 return window.atob(str) 5566 } 5567} 5568 5569class PreviousMap { 5570 constructor(css, opts) { 5571 if (opts.map === false) return 5572 this.loadAnnotation(css) 5573 this.inline = this.startWith(this.annotation, 'data:') 5574 5575 let prev = opts.map ? opts.map.prev : undefined 5576 let text = this.loadMap(opts.from, prev) 5577 if (!this.mapFile && opts.from) { 5578 this.mapFile = opts.from 5579 } 5580 if (this.mapFile) this.root = dirname(this.mapFile) 5581 if (text) this.text = text 5582 } 5583 5584 consumer() { 5585 if (!this.consumerCache) { 5586 this.consumerCache = new SourceMapConsumer(this.text) 5587 } 5588 return this.consumerCache 5589 } 5590 5591 withContent() { 5592 return !!( 5593 this.consumer().sourcesContent && 5594 this.consumer().sourcesContent.length > 0 5595 ) 5596 } 5597 5598 startWith(string, start) { 5599 if (!string) return false 5600 return string.substr(0, start.length) === start 5601 } 5602 5603 getAnnotationURL(sourceMapString) { 5604 return sourceMapString.replace(/^\/\*\s*# sourceMappingURL=/, '').trim() 5605 } 5606 5607 loadAnnotation(css) { 5608 let comments = css.match(/\/\*\s*# sourceMappingURL=/gm) 5609 if (!comments) return 5610 5611 // sourceMappingURLs from comments, strings, etc. 5612 let start = css.lastIndexOf(comments.pop()) 5613 let end = css.indexOf('*/', start) 5614 5615 if (start > -1 && end > -1) { 5616 // Locate the last sourceMappingURL to avoid pickin 5617 this.annotation = this.getAnnotationURL(css.substring(start, end)) 5618 } 5619 } 5620 5621 decodeInline(text) { 5622 let baseCharsetUri = /^data:application\/json;charset=utf-?8;base64,/ 5623 let baseUri = /^data:application\/json;base64,/ 5624 let charsetUri = /^data:application\/json;charset=utf-?8,/ 5625 let uri = /^data:application\/json,/ 5626 5627 if (charsetUri.test(text) || uri.test(text)) { 5628 return decodeURIComponent(text.substr(RegExp.lastMatch.length)) 5629 } 5630 5631 if (baseCharsetUri.test(text) || baseUri.test(text)) { 5632 return fromBase64(text.substr(RegExp.lastMatch.length)) 5633 } 5634 5635 let encoding = text.match(/data:application\/json;([^,]+),/)[1] 5636 throw new Error('Unsupported source map encoding ' + encoding) 5637 } 5638 5639 loadFile(path) { 5640 this.root = dirname(path) 5641 if (existsSync(path)) { 5642 this.mapFile = path 5643 return readFileSync(path, 'utf-8').toString().trim() 5644 } 5645 } 5646 5647 loadMap(file, prev) { 5648 if (prev === false) return false 5649 5650 if (prev) { 5651 if (typeof prev === 'string') { 5652 return prev 5653 } else if (typeof prev === 'function') { 5654 let prevPath = prev(file) 5655 if (prevPath) { 5656 let map = this.loadFile(prevPath) 5657 if (!map) { 5658 throw new Error( 5659 'Unable to load previous source map: ' + prevPath.toString() 5660 ) 5661 } 5662 return map 5663 } 5664 } else if (prev instanceof SourceMapConsumer) { 5665 return SourceMapGenerator.fromSourceMap(prev).toString() 5666 } else if (prev instanceof SourceMapGenerator) { 5667 return prev.toString() 5668 } else if (this.isMap(prev)) { 5669 return JSON.stringify(prev) 5670 } else { 5671 throw new Error( 5672 'Unsupported previous source map format: ' + prev.toString() 5673 ) 5674 } 5675 } else if (this.inline) { 5676 return this.decodeInline(this.annotation) 5677 } else if (this.annotation) { 5678 let map = this.annotation 5679 if (file) map = join(dirname(file), map) 5680 return this.loadFile(map) 5681 } 5682 } 5683 5684 isMap(map) { 5685 if (typeof map !== 'object') return false 5686 return ( 5687 typeof map.mappings === 'string' || 5688 typeof map._mappings === 'string' || 5689 Array.isArray(map.sections) 5690 ) 5691 } 5692} 5693 5694module.exports = PreviousMap 5695PreviousMap.default = PreviousMap 5696 5697/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../buffer/index.js */ "./node_modules/buffer/index.js").Buffer)) 5698 5699/***/ }), 5700
vendor: 2,323 bytes, lines 5701-5779
5701/***/ "./node_modules/postcss/lib/processor.js": 5702/*!***********************************************!*\ 5703 !*** ./node_modules/postcss/lib/processor.js ***! 5704 \***********************************************/ 5705/*! no static exports found */ 5706/***/ (function(module, exports, __webpack_require__) { 5707 5708"use strict"; 5709 5710 5711let NoWorkResult = __webpack_require__(/*! ./no-work-result */ "./node_modules/postcss/lib/no-work-result.js") 5712let LazyResult = __webpack_require__(/*! ./lazy-result */ "./node_modules/postcss/lib/lazy-result.js") 5713let Document = __webpack_require__(/*! ./document */ "./node_modules/postcss/lib/document.js") 5714let Root = __webpack_require__(/*! ./root */ "./node_modules/postcss/lib/root.js") 5715 5716class Processor { 5717 constructor(plugins = []) { 5718 this.version = '8.4.8' 5719 this.plugins = this.normalize(plugins) 5720 } 5721 5722 use(plugin) { 5723 this.plugins = this.plugins.concat(this.normalize([plugin])) 5724 return this 5725 } 5726 5727 process(css, opts = {}) { 5728 if ( 5729 this.plugins.length === 0 && 5730 typeof opts.parser === 'undefined' && 5731 typeof opts.stringifier === 'undefined' && 5732 typeof opts.syntax === 'undefined' 5733 ) { 5734 return new NoWorkResult(this, css, opts) 5735 } else { 5736 return new LazyResult(this, css, opts) 5737 } 5738 } 5739 5740 normalize(plugins) { 5741 let normalized = [] 5742 for (let i of plugins) { 5743 if (i.postcss === true) { 5744 i = i() 5745 } else if (i.postcss) { 5746 i = i.postcss 5747 } 5748 5749 if (typeof i === 'object' && Array.isArray(i.plugins)) { 5750 normalized = normalized.concat(i.plugins) 5751 } else if (typeof i === 'object' && i.postcssPlugin) { 5752 normalized.push(i) 5753 } else if (typeof i === 'function') { 5754 normalized.push(i) 5755 } else if (typeof i === 'object' && (i.parse || i.stringify)) { 5756 if (true) { 5757 throw new Error( 5758 'PostCSS syntaxes cannot be used as plugins. Instead, please use ' + 5759 'one of the syntax/parser/stringifier options as outlined ' + 5760 'in your PostCSS runner documentation.' 5761 ) 5762 } 5763 } else { 5764 throw new Error(i + ' is not a PostCSS plugin') 5765 } 5766 } 5767 return normalized 5768 } 5769} 5770 5771module.exports = Processor 5772Processor.default = Processor 5773 5774Root.registerProcessor(Processor) 5775Document.registerProcessor(Processor) 5776 5777 5778/***/ }), 5779
vendor: 1,100 bytes, lines 5780-5833
5780/***/ "./node_modules/postcss/lib/result.js": 5781/*!********************************************!*\ 5782 !*** ./node_modules/postcss/lib/result.js ***! 5783 \********************************************/ 5784/*! no static exports found */ 5785/***/ (function(module, exports, __webpack_require__) { 5786 5787"use strict"; 5788 5789 5790let Warning = __webpack_require__(/*! ./warning */ "./node_modules/postcss/lib/warning.js") 5791 5792class Result { 5793 constructor(processor, root, opts) { 5794 this.processor = processor 5795 this.messages = [] 5796 this.root = root 5797 this.opts = opts 5798 this.css = undefined 5799 this.map = undefined 5800 } 5801 5802 toString() { 5803 return this.css 5804 } 5805 5806 warn(text, opts = {}) { 5807 if (!opts.plugin) { 5808 if (this.lastPlugin && this.lastPlugin.postcssPlugin) { 5809 opts.plugin = this.lastPlugin.postcssPlugin 5810 } 5811 } 5812 5813 let warning = new Warning(text, opts) 5814 this.messages.push(warning) 5815 5816 return warning 5817 } 5818 5819 warnings() { 5820 return this.messages.filter(i => i.type === 'warning') 5821 } 5822 5823 get content() { 5824 return this.css 5825 } 5826} 5827 5828module.exports = Result 5829Result.default = Result 5830 5831 5832/***/ }), 5833
vendor: 1,558 bytes, lines 5834-5904
5834/***/ "./node_modules/postcss/lib/root.js": 5835/*!******************************************!*\ 5836 !*** ./node_modules/postcss/lib/root.js ***! 5837 \******************************************/ 5838/*! no static exports found */ 5839/***/ (function(module, exports, __webpack_require__) { 5840 5841"use strict"; 5842 5843 5844let Container = __webpack_require__(/*! ./container */ "./node_modules/postcss/lib/container.js") 5845 5846let LazyResult, Processor 5847 5848class Root extends Container { 5849 constructor(defaults) { 5850 super(defaults) 5851 this.type = 'root' 5852 if (!this.nodes) this.nodes = [] 5853 } 5854 5855 removeChild(child, ignore) { 5856 let index = this.index(child) 5857 5858 if (!ignore && index === 0 && this.nodes.length > 1) { 5859 this.nodes[1].raws.before = this.nodes[index].raws.before 5860 } 5861 5862 return super.removeChild(child) 5863 } 5864 5865 normalize(child, sample, type) { 5866 let nodes = super.normalize(child) 5867 5868 if (sample) { 5869 if (type === 'prepend') { 5870 if (this.nodes.length > 1) { 5871 sample.raws.before = this.nodes[1].raws.before 5872 } else { 5873 delete sample.raws.before 5874 } 5875 } else if (this.first !== sample) { 5876 for (let node of nodes) { 5877 node.raws.before = sample.raws.before 5878 } 5879 } 5880 } 5881 5882 return nodes 5883 } 5884 5885 toResult(opts = {}) { 5886 let lazy = new LazyResult(new Processor(), this, opts) 5887 return lazy.stringify() 5888 } 5889} 5890 5891Root.registerLazyResult = dependant => { 5892 LazyResult = dependant 5893} 5894 5895Root.registerProcessor = dependant => { 5896 Processor = dependant 5897} 5898 5899module.exports = Root 5900Root.default = Root 5901 5902 5903/***/ }), 5904
vendor: 972 bytes, lines 5905-5943
5905/***/ "./node_modules/postcss/lib/rule.js": 5906/*!******************************************!*\ 5907 !*** ./node_modules/postcss/lib/rule.js ***! 5908 \******************************************/ 5909/*! no static exports found */ 5910/***/ (function(module, exports, __webpack_require__) { 5911 5912"use strict"; 5913 5914 5915let Container = __webpack_require__(/*! ./container */ "./node_modules/postcss/lib/container.js") 5916let list = __webpack_require__(/*! ./list */ "./node_modules/postcss/lib/list.js") 5917 5918class Rule extends Container { 5919 constructor(defaults) { 5920 super(defaults) 5921 this.type = 'rule' 5922 if (!this.nodes) this.nodes = [] 5923 } 5924 5925 get selectors() { 5926 return list.comma(this.selector) 5927 } 5928 5929 set selectors(values) { 5930 let match = this.selector ? this.selector.match(/,\s*/) : null 5931 let sep = match ? match[0] : ',' + this.raw('between', 'beforeOpen') 5932 this.selector = values.join(sep) 5933 } 5934} 5935 5936module.exports = Rule 5937Rule.default = Rule 5938 5939Container.registerRule(Rule) 5940 5941 5942/***/ }), 5943
vendor: 8,538 bytes, lines 5944-6308
5944/***/ "./node_modules/postcss/lib/stringifier.js": 5945/*!*************************************************!*\ 5946 !*** ./node_modules/postcss/lib/stringifier.js ***! 5947 \*************************************************/ 5948/*! no static exports found */ 5949/***/ (function(module, exports, __webpack_require__) { 5950 5951"use strict"; 5952 5953 5954const DEFAULT_RAW = { 5955 colon: ': ', 5956 indent: ' ', 5957 beforeDecl: '\n', 5958 beforeRule: '\n', 5959 beforeOpen: ' ', 5960 beforeClose: '\n', 5961 beforeComment: '\n', 5962 after: '\n', 5963 emptyBody: '', 5964 commentLeft: ' ', 5965 commentRight: ' ', 5966 semicolon: false 5967} 5968 5969function capitalize(str) { 5970 return str[0].toUpperCase() + str.slice(1) 5971} 5972 5973class Stringifier { 5974 constructor(builder) { 5975 this.builder = builder 5976 } 5977 5978 stringify(node, semicolon) { 5979 /* c8 ignore start */ 5980 if (!this[node.type]) { 5981 throw new Error( 5982 'Unknown AST node type ' + 5983 node.type + 5984 '. ' + 5985 'Maybe you need to change PostCSS stringifier.' 5986 ) 5987 } 5988 /* c8 ignore stop */ 5989 this[node.type](node, semicolon) 5990 } 5991 5992 document(node) { 5993 this.body(node) 5994 } 5995 5996 root(node) { 5997 this.body(node) 5998 if (node.raws.after) this.builder(node.raws.after) 5999 } 6000 6001 comment(node) { 6002 let left = this.raw(node, 'left', 'commentLeft') 6003 let right = this.raw(node, 'right', 'commentRight') 6004 this.builder('/*' + left + node.text + right + '*/', node) 6005 } 6006 6007 decl(node, semicolon) { 6008 let between = this.raw(node, 'between', 'colon') 6009 let string = node.prop + between + this.rawValue(node, 'value') 6010 6011 if (node.important) { 6012 string += node.raws.important || ' !important' 6013 } 6014 6015 if (semicolon) string += ';' 6016 this.builder(string, node) 6017 } 6018 6019 rule(node) { 6020 this.block(node, this.rawValue(node, 'selector')) 6021 if (node.raws.ownSemicolon) { 6022 this.builder(node.raws.ownSemicolon, node, 'end') 6023 } 6024 } 6025 6026 atrule(node, semicolon) { 6027 let name = '@' + node.name 6028 let params = node.params ? this.rawValue(node, 'params') : '' 6029 6030 if (typeof node.raws.afterName !== 'undefined') { 6031 name += node.raws.afterName 6032 } else if (params) { 6033 name += ' ' 6034 } 6035 6036 if (node.nodes) { 6037 this.block(node, name + params) 6038 } else { 6039 let end = (node.raws.between || '') + (semicolon ? ';' : '') 6040 this.builder(name + params + end, node) 6041 } 6042 } 6043 6044 body(node) { 6045 let last = node.nodes.length - 1 6046 while (last > 0) { 6047 if (node.nodes[last].type !== 'comment') break 6048 last -= 1 6049 } 6050 6051 let semicolon = this.raw(node, 'semicolon') 6052 for (let i = 0; i < node.nodes.length; i++) { 6053 let child = node.nodes[i] 6054 let before = this.raw(child, 'before') 6055 if (before) this.builder(before) 6056 this.stringify(child, last !== i || semicolon) 6057 } 6058 } 6059 6060 block(node, start) { 6061 let between = this.raw(node, 'between', 'beforeOpen') 6062 this.builder(start + between + '{', node, 'start') 6063 6064 let after 6065 if (node.nodes && node.nodes.length) { 6066 this.body(node) 6067 after = this.raw(node, 'after') 6068 } else { 6069 after = this.raw(node, 'after', 'emptyBody') 6070 } 6071 6072 if (after) this.builder(after) 6073 this.builder('}', node, 'end') 6074 } 6075 6076 raw(node, own, detect) { 6077 let value 6078 if (!detect) detect = own 6079 6080 // Already had 6081 if (own) { 6082 value = node.raws[own] 6083 if (typeof value !== 'undefined') return value 6084 } 6085 6086 let parent = node.parent 6087 6088 if (detect === 'before') { 6089 // Hack for first rule in CSS 6090 if (!parent || (parent.type === 'root' && parent.first === node)) { 6091 return '' 6092 } 6093 6094 // `root` nodes in `document` should use only their own raws 6095 if (parent && parent.type === 'document') { 6096 return '' 6097 } 6098 } 6099 6100 // Floating child without parent 6101 if (!parent) return DEFAULT_RAW[detect] 6102 6103 // Detect style by other nodes 6104 let root = node.root() 6105 if (!root.rawCache) root.rawCache = {} 6106 if (typeof root.rawCache[detect] !== 'undefined') { 6107 return root.rawCache[detect] 6108 } 6109 6110 if (detect === 'before' || detect === 'after') { 6111 return this.beforeAfter(node, detect) 6112 } else { 6113 let method = 'raw' + capitalize(detect) 6114 if (this[method]) { 6115 value = this[method](root, node) 6116 } else { 6117 root.walk(i => { 6118 value = i.raws[own] 6119 if (typeof value !== 'undefined') return false 6120 }) 6121 } 6122 } 6123 6124 if (typeof value === 'undefined') value = DEFAULT_RAW[detect] 6125 6126 root.rawCache[detect] = value 6127 return value 6128 } 6129 6130 rawSemicolon(root) { 6131 let value 6132 root.walk(i => { 6133 if (i.nodes && i.nodes.length && i.last.type === 'decl') { 6134 value = i.raws.semicolon 6135 if (typeof value !== 'undefined') return false 6136 } 6137 }) 6138 return value 6139 } 6140 6141 rawEmptyBody(root) { 6142 let value 6143 root.walk(i => { 6144 if (i.nodes && i.nodes.length === 0) { 6145 value = i.raws.after 6146 if (typeof value !== 'undefined') return false 6147 } 6148 }) 6149 return value 6150 } 6151 6152 rawIndent(root) { 6153 if (root.raws.indent) return root.raws.indent 6154 let value 6155 root.walk(i => { 6156 let p = i.parent 6157 if (p && p !== root && p.parent && p.parent === root) { 6158 if (typeof i.raws.before !== 'undefined') { 6159 let parts = i.raws.before.split('\n') 6160 value = parts[parts.length - 1] 6161 value = value.replace(/\S/g, '') 6162 return false 6163 } 6164 } 6165 }) 6166 return value 6167 } 6168 6169 rawBeforeComment(root, node) { 6170 let value 6171 root.walkComments(i => { 6172 if (typeof i.raws.before !== 'undefined') { 6173 value = i.raws.before 6174 if (value.includes('\n')) { 6175 value = value.replace(/[^\n]+$/, '') 6176 } 6177 return false 6178 } 6179 }) 6180 if (typeof value === 'undefined') { 6181 value = this.raw(node, null, 'beforeDecl') 6182 } else if (value) { 6183 value = value.replace(/\S/g, '') 6184 } 6185 return value 6186 } 6187 6188 rawBeforeDecl(root, node) { 6189 let value 6190 root.walkDecls(i => { 6191 if (typeof i.raws.before !== 'undefined') { 6192 value = i.raws.before 6193 if (value.includes('\n')) { 6194 value = value.replace(/[^\n]+$/, '') 6195 } 6196 return false 6197 } 6198 }) 6199 if (typeof value === 'undefined') { 6200 value = this.raw(node, null, 'beforeRule') 6201 } else if (value) { 6202 value = value.replace(/\S/g, '') 6203 } 6204 return value 6205 } 6206 6207 rawBeforeRule(root) { 6208 let value 6209 root.walk(i => { 6210 if (i.nodes && (i.parent !== root || root.first !== i)) { 6211 if (typeof i.raws.before !== 'undefined') { 6212 value = i.raws.before 6213 if (value.includes('\n')) { 6214 value = value.replace(/[^\n]+$/, '') 6215 } 6216 return false 6217 } 6218 } 6219 }) 6220 if (value) value = value.replace(/\S/g, '') 6221 return value 6222 } 6223 6224 rawBeforeClose(root) { 6225 let value 6226 root.walk(i => { 6227 if (i.nodes && i.nodes.length > 0) { 6228 if (typeof i.raws.after !== 'undefined') { 6229 value = i.raws.after 6230 if (value.includes('\n')) { 6231 value = value.replace(/[^\n]+$/, '') 6232 } 6233 return false 6234 } 6235 } 6236 }) 6237 if (value) value = value.replace(/\S/g, '') 6238 return value 6239 } 6240 6241 rawBeforeOpen(root) { 6242 let value 6243 root.walk(i => { 6244 if (i.type !== 'decl') { 6245 value = i.raws.between 6246 if (typeof value !== 'undefined') return false 6247 } 6248 }) 6249 return value 6250 } 6251 6252 rawColon(root) { 6253 let value 6254 root.walkDecls(i => { 6255 if (typeof i.raws.between !== 'undefined') { 6256 value = i.raws.between.replace(/[^\s:]/g, '') 6257 return false 6258 } 6259 }) 6260 return value 6261 } 6262 6263 beforeAfter(node, detect) { 6264 let value 6265 if (node.type === 'decl') { 6266 value = this.raw(node, null, 'beforeDecl') 6267 } else if (node.type === 'comment') { 6268 value = this.raw(node, null, 'beforeComment') 6269 } else if (detect === 'before') { 6270 value = this.raw(node, null, 'beforeRule') 6271 } else { 6272 value = this.raw(node, null, 'beforeClose') 6273 } 6274 6275 let buf = node.parent 6276 let depth = 0 6277 while (buf && buf.type !== 'root') { 6278 depth += 1 6279 buf = buf.parent 6280 } 6281 6282 if (value.includes('\n')) { 6283 let indent = this.raw(node, null, 'indent') 6284 if (indent.length) { 6285 for (let step = 0; step < depth; step++) value += indent 6286 } 6287 } 6288 6289 return value 6290 } 6291 6292 rawValue(node, prop) { 6293 let value = node[prop] 6294 let raw = node.raws[prop] 6295 if (raw && raw.value === value) { 6296 return raw.raw 6297 } 6298 6299 return value 6300 } 6301} 6302 6303module.exports = Stringifier 6304Stringifier.default = Stringifier 6305 6306 6307/***/ }), 6308
vendor: 584 bytes, lines 6309-6331
6309/***/ "./node_modules/postcss/lib/stringify.js": 6310/*!***********************************************!*\ 6311 !*** ./node_modules/postcss/lib/stringify.js ***! 6312 \***********************************************/ 6313/*! no static exports found */ 6314/***/ (function(module, exports, __webpack_require__) { 6315 6316"use strict"; 6317 6318 6319let Stringifier = __webpack_require__(/*! ./stringifier */ "./node_modules/postcss/lib/stringifier.js") 6320 6321function stringify(node, builder) { 6322 let str = new Stringifier(builder) 6323 str.stringify(node) 6324} 6325 6326module.exports = stringify 6327stringify.default = stringify 6328 6329 6330/***/ }), 6331
vendor: 393 bytes, lines 6332-6348
6332/***/ "./node_modules/postcss/lib/symbols.js": 6333/*!*********************************************!*\ 6334 !*** ./node_modules/postcss/lib/symbols.js ***! 6335 \*********************************************/ 6336/*! no static exports found */ 6337/***/ (function(module, exports, __webpack_require__) { 6338 6339"use strict"; 6340 6341 6342module.exports.isClean = Symbol('isClean') 6343 6344module.exports.my = Symbol('my') 6345 6346 6347/***/ }), 6348
vendor: 6,842 bytes, lines 6349-6626
6349/***/ "./node_modules/postcss/lib/tokenize.js": 6350/*!**********************************************!*\ 6351 !*** ./node_modules/postcss/lib/tokenize.js ***! 6352 \**********************************************/ 6353/*! no static exports found */ 6354/***/ (function(module, exports, __webpack_require__) { 6355 6356"use strict"; 6357 6358 6359const SINGLE_QUOTE = "'".charCodeAt(0) 6360const DOUBLE_QUOTE = '"'.charCodeAt(0) 6361const BACKSLASH = '\\'.charCodeAt(0) 6362const SLASH = '/'.charCodeAt(0) 6363const NEWLINE = '\n'.charCodeAt(0) 6364const SPACE = ' '.charCodeAt(0) 6365const FEED = '\f'.charCodeAt(0) 6366const TAB = '\t'.charCodeAt(0) 6367const CR = '\r'.charCodeAt(0) 6368const OPEN_SQUARE = '['.charCodeAt(0) 6369const CLOSE_SQUARE = ']'.charCodeAt(0) 6370const OPEN_PARENTHESES = '('.charCodeAt(0) 6371const CLOSE_PARENTHESES = ')'.charCodeAt(0) 6372const OPEN_CURLY = '{'.charCodeAt(0) 6373const CLOSE_CURLY = '}'.charCodeAt(0) 6374const SEMICOLON = ';'.charCodeAt(0) 6375const ASTERISK = '*'.charCodeAt(0) 6376const COLON = ':'.charCodeAt(0) 6377const AT = '@'.charCodeAt(0) 6378 6379const RE_AT_END = /[\t\n\f\r "#'()/;[\\\]{}]/g 6380const RE_WORD_END = /[\t\n\f\r !"#'():;@[\\\]{}]|\/(?=\*)/g 6381const RE_BAD_BRACKET = /.[\n"'(/\\]/ 6382const RE_HEX_ESCAPE = /[\da-f]/i 6383 6384module.exports = function tokenizer(input, options = {}) { 6385 let css = input.css.valueOf() 6386 let ignore = options.ignoreErrors 6387 6388 let code, next, quote, content, escape 6389 let escaped, escapePos, prev, n, currentToken 6390 6391 let length = css.length 6392 let pos = 0 6393 let buffer = [] 6394 let returned = [] 6395 6396 function position() { 6397 return pos 6398 } 6399 6400 function unclosed(what) { 6401 throw input.error('Unclosed ' + what, pos) 6402 } 6403 6404 function endOfFile() { 6405 return returned.length === 0 && pos >= length 6406 } 6407 6408 function nextToken(opts) { 6409 if (returned.length) return returned.pop() 6410 if (pos >= length) return 6411 6412 let ignoreUnclosed = opts ? opts.ignoreUnclosed : false 6413 6414 code = css.charCodeAt(pos) 6415 6416 switch (code) { 6417 case NEWLINE: 6418 case SPACE: 6419 case TAB: 6420 case CR: 6421 case FEED: { 6422 next = pos 6423 do { 6424 next += 1 6425 code = css.charCodeAt(next) 6426 } while ( 6427 code === SPACE || 6428 code === NEWLINE || 6429 code === TAB || 6430 code === CR || 6431 code === FEED 6432 ) 6433 6434 currentToken = ['space', css.slice(pos, next)] 6435 pos = next - 1 6436 break 6437 } 6438 6439 case OPEN_SQUARE: 6440 case CLOSE_SQUARE: 6441 case OPEN_CURLY: 6442 case CLOSE_CURLY: 6443 case COLON: 6444 case SEMICOLON: 6445 case CLOSE_PARENTHESES: { 6446 let controlChar = String.fromCharCode(code) 6447 currentToken = [controlChar, controlChar, pos] 6448 break 6449 } 6450 6451 case OPEN_PARENTHESES: { 6452 prev = buffer.length ? buffer.pop()[1] : '' 6453 n = css.charCodeAt(pos + 1) 6454 if ( 6455 prev === 'url' && 6456 n !== SINGLE_QUOTE && 6457 n !== DOUBLE_QUOTE && 6458 n !== SPACE && 6459 n !== NEWLINE && 6460 n !== TAB && 6461 n !== FEED && 6462 n !== CR 6463 ) { 6464 next = pos 6465 do { 6466 escaped = false 6467 next = css.indexOf(')', next + 1) 6468 if (next === -1) { 6469 if (ignore || ignoreUnclosed) { 6470 next = pos 6471 break 6472 } else { 6473 unclosed('bracket') 6474 } 6475 } 6476 escapePos = next 6477 while (css.charCodeAt(escapePos - 1) === BACKSLASH) { 6478 escapePos -= 1 6479 escaped = !escaped 6480 } 6481 } while (escaped) 6482 6483 currentToken = ['brackets', css.slice(pos, next + 1), pos, next] 6484 6485 pos = next 6486 } else { 6487 next = css.indexOf(')', pos + 1) 6488 content = css.slice(pos, next + 1) 6489 6490 if (next === -1 || RE_BAD_BRACKET.test(content)) { 6491 currentToken = ['(', '(', pos] 6492 } else { 6493 currentToken = ['brackets', content, pos, next] 6494 pos = next 6495 } 6496 } 6497 6498 break 6499 } 6500 6501 case SINGLE_QUOTE: 6502 case DOUBLE_QUOTE: { 6503 quote = code === SINGLE_QUOTE ? "'" : '"' 6504 next = pos 6505 do { 6506 escaped = false 6507 next = css.indexOf(quote, next + 1) 6508 if (next === -1) { 6509 if (ignore || ignoreUnclosed) { 6510 next = pos + 1 6511 break 6512 } else { 6513 unclosed('string') 6514 } 6515 } 6516 escapePos = next 6517 while (css.charCodeAt(escapePos - 1) === BACKSLASH) { 6518 escapePos -= 1 6519 escaped = !escaped 6520 } 6521 } while (escaped) 6522 6523 currentToken = ['string', css.slice(pos, next + 1), pos, next] 6524 pos = next 6525 break 6526 } 6527 6528 case AT: { 6529 RE_AT_END.lastIndex = pos + 1 6530 RE_AT_END.test(css) 6531 if (RE_AT_END.lastIndex === 0) { 6532 next = css.length - 1 6533 } else { 6534 next = RE_AT_END.lastIndex - 2 6535 } 6536 6537 currentToken = ['at-word', css.slice(pos, next + 1), pos, next] 6538 6539 pos = next 6540 break 6541 } 6542 6543 case BACKSLASH: { 6544 next = pos 6545 escape = true 6546 while (css.charCodeAt(next + 1) === BACKSLASH) { 6547 next += 1 6548 escape = !escape 6549 } 6550 code = css.charCodeAt(next + 1) 6551 if ( 6552 escape && 6553 code !== SLASH && 6554 code !== SPACE && 6555 code !== NEWLINE && 6556 code !== TAB && 6557 code !== CR && 6558 code !== FEED 6559 ) { 6560 next += 1 6561 if (RE_HEX_ESCAPE.test(css.charAt(next))) { 6562 while (RE_HEX_ESCAPE.test(css.charAt(next + 1))) { 6563 next += 1 6564 } 6565 if (css.charCodeAt(next + 1) === SPACE) { 6566 next += 1 6567 } 6568 } 6569 } 6570 6571 currentToken = ['word', css.slice(pos, next + 1), pos, next] 6572 6573 pos = next 6574 break 6575 } 6576 6577 default: { 6578 if (code === SLASH && css.charCodeAt(pos + 1) === ASTERISK) { 6579 next = css.indexOf('*/', pos + 2) + 1 6580 if (next === 0) { 6581 if (ignore || ignoreUnclosed) { 6582 next = css.length 6583 } else { 6584 unclosed('comment') 6585 } 6586 } 6587 6588 currentToken = ['comment', css.slice(pos, next + 1), pos, next] 6589 pos = next 6590 } else { 6591 RE_WORD_END.lastIndex = pos + 1 6592 RE_WORD_END.test(css) 6593 if (RE_WORD_END.lastIndex === 0) { 6594 next = css.length - 1 6595 } else { 6596 next = RE_WORD_END.lastIndex - 2 6597 } 6598 6599 currentToken = ['word', css.slice(pos, next + 1), pos, next] 6600 buffer.push(currentToken) 6601 pos = next 6602 } 6603 6604 break 6605 } 6606 } 6607 6608 pos++ 6609 return currentToken 6610 } 6611 6612 function back(token) { 6613 returned.push(token) 6614 } 6615 6616 return { 6617 back, 6618 nextToken, 6619 endOfFile, 6620 position 6621 } 6622} 6623 6624 6625/***/ }), 6626
vendor: 566 bytes, lines 6627-6651
6627/***/ "./node_modules/postcss/lib/warn-once.js": 6628/*!***********************************************!*\ 6629 !*** ./node_modules/postcss/lib/warn-once.js ***! 6630 \***********************************************/ 6631/*! no static exports found */ 6632/***/ (function(module, exports, __webpack_require__) { 6633 6634"use strict"; 6635/* eslint-disable no-console */ 6636 6637 6638let printed = {} 6639 6640module.exports = function warnOnce(message) { 6641 if (printed[message]) return 6642 printed[message] = true 6643 6644 if (typeof console !== 'undefined' && console.warn) { 6645 console.warn(message) 6646 } 6647} 6648 6649 6650/***/ }), 6651
vendor: 1,041 bytes, lines 6652-6700
6652/***/ "./node_modules/postcss/lib/warning.js": 6653/*!*********************************************!*\ 6654 !*** ./node_modules/postcss/lib/warning.js ***! 6655 \*********************************************/ 6656/*! no static exports found */ 6657/***/ (function(module, exports, __webpack_require__) { 6658 6659"use strict"; 6660 6661 6662class Warning { 6663 constructor(text, opts = {}) { 6664 this.type = 'warning' 6665 this.text = text 6666 6667 if (opts.node && opts.node.source) { 6668 let range = opts.node.rangeBy(opts) 6669 this.line = range.start.line 6670 this.column = range.start.column 6671 this.endLine = range.end.line 6672 this.endColumn = range.end.column 6673 } 6674 6675 for (let opt in opts) this[opt] = opts[opt] 6676 } 6677 6678 toString() { 6679 if (this.node) { 6680 return this.node.error(this.text, { 6681 plugin: this.plugin, 6682 index: this.index, 6683 word: this.word 6684 }).message 6685 } 6686 6687 if (this.plugin) { 6688 return this.plugin + ': ' + this.text 6689 } 6690 6691 return this.text 6692 } 6693} 6694 6695module.exports = Warning 6696Warning.default = Warning 6697 6698 6699/***/ }), 6700
vendor: 5,681 bytes, lines 6701-6895
6701/***/ "./node_modules/process/browser.js": 6702/*!*****************************************!*\ 6703 !*** ./node_modules/process/browser.js ***! 6704 \*****************************************/ 6705/*! no static exports found */ 6706/***/ (function(module, exports) { 6707 6708// shim for using process in browser 6709var process = module.exports = {}; 6710 6711// cached from whatever global is present so that test runners that stub it 6712// don't break things. But we need to wrap it in a try catch in case it is 6713// wrapped in strict mode code which doesn't define any globals. It's inside a 6714// function because try/catches deoptimize in certain engines. 6715 6716var cachedSetTimeout; 6717var cachedClearTimeout; 6718 6719function defaultSetTimout() { 6720 throw new Error('setTimeout has not been defined'); 6721} 6722function defaultClearTimeout () { 6723 throw new Error('clearTimeout has not been defined'); 6724} 6725(function () { 6726 try { 6727 if (typeof setTimeout === 'function') { 6728 cachedSetTimeout = setTimeout; 6729 } else { 6730 cachedSetTimeout = defaultSetTimout; 6731 } 6732 } catch (e) { 6733 cachedSetTimeout = defaultSetTimout; 6734 } 6735 try { 6736 if (typeof clearTimeout === 'function') { 6737 cachedClearTimeout = clearTimeout; 6738 } else { 6739 cachedClearTimeout = defaultClearTimeout; 6740 } 6741 } catch (e) { 6742 cachedClearTimeout = defaultClearTimeout; 6743 } 6744} ()) 6745function runTimeout(fun) { 6746 if (cachedSetTimeout === setTimeout) { 6747 //normal enviroments in sane situations 6748 return setTimeout(fun, 0); 6749 } 6750 // if setTimeout wasn't available but was latter defined 6751 if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) { 6752 cachedSetTimeout = setTimeout; 6753 return setTimeout(fun, 0); 6754 } 6755 try { 6756 // when when somebody has screwed with setTimeout but no I.E. maddness 6757 return cachedSetTimeout(fun, 0); 6758 } catch(e){ 6759 try { 6760 // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally 6761 return cachedSetTimeout.call(null, fun, 0); 6762 } catch(e){ 6763 // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error 6764 return cachedSetTimeout.call(this, fun, 0); 6765 } 6766 } 6767 6768 6769} 6770function runClearTimeout(marker) { 6771 if (cachedClearTimeout === clearTimeout) { 6772 //normal enviroments in sane situations 6773 return clearTimeout(marker); 6774 } 6775 // if clearTimeout wasn't available but was latter defined 6776 if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) { 6777 cachedClearTimeout = clearTimeout; 6778 return clearTimeout(marker); 6779 } 6780 try { 6781 // when when somebody has screwed with setTimeout but no I.E. maddness 6782 return cachedClearTimeout(marker); 6783 } catch (e){ 6784 try { 6785 // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally 6786 return cachedClearTimeout.call(null, marker); 6787 } catch (e){ 6788 // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error. 6789 // Some versions of I.E. have different rules for clearTimeout vs setTimeout 6790 return cachedClearTimeout.call(this, marker); 6791 } 6792 } 6793 6794 6795 6796} 6797var queue = []; 6798var draining = false; 6799var currentQueue; 6800var queueIndex = -1; 6801 6802function cleanUpNextTick() { 6803 if (!draining || !currentQueue) { 6804 return; 6805 } 6806 draining = false; 6807 if (currentQueue.length) { 6808 queue = currentQueue.concat(queue); 6809 } else { 6810 queueIndex = -1; 6811 } 6812 if (queue.length) { 6813 drainQueue(); 6814 } 6815} 6816 6817function drainQueue() { 6818 if (draining) { 6819 return; 6820 } 6821 var timeout = runTimeout(cleanUpNextTick); 6822 draining = true; 6823 6824 var len = queue.length; 6825 while(len) { 6826 currentQueue = queue; 6827 queue = []; 6828 while (++queueIndex < len) { 6829 if (currentQueue) { 6830 currentQueue[queueIndex].run(); 6831 } 6832 } 6833 queueIndex = -1; 6834 len = queue.length; 6835 } 6836 currentQueue = null; 6837 draining = false; 6838 runClearTimeout(timeout); 6839} 6840 6841process.nextTick = function (fun) { 6842 var args = new Array(arguments.length - 1); 6843 if (arguments.length > 1) { 6844 for (var i = 1; i < arguments.length; i++) { 6845 args[i - 1] = arguments[i]; 6846 } 6847 } 6848 queue.push(new Item(fun, args)); 6849 if (queue.length === 1 && !draining) { 6850 runTimeout(drainQueue); 6851 } 6852}; 6853 6854// v8 likes predictible objects 6855function Item(fun, array) { 6856 this.fun = fun; 6857 this.array = array; 6858} 6859Item.prototype.run = function () { 6860 this.fun.apply(null, this.array); 6861}; 6862process.title = 'browser'; 6863process.browser = true; 6864process.env = {}; 6865process.argv = []; 6866process.version = ''; // empty string to avoid regexp issues 6867process.versions = {}; 6868 6869function noop() {} 6870 6871process.on = noop; 6872process.addListener = noop; 6873process.once = noop; 6874process.off = noop; 6875process.removeListener = noop; 6876process.removeAllListeners = noop; 6877process.emit = noop; 6878process.prependListener = noop; 6879process.prependOnceListener = noop; 6880 6881process.listeners = function (name) { return [] } 6882 6883process.binding = function (name) { 6884 throw new Error('process.binding is not supported'); 6885}; 6886 6887process.cwd = function () { return '/' }; 6888process.chdir = function (dir) { 6889 throw new Error('process.chdir is not supported'); 6890}; 6891process.umask = function() { return 0; }; 6892 6893 6894/***/ }), 6895
vendor: 923 bytes, lines 6896-6931
6896/***/ "./node_modules/tailwindcss/lib/lib/formatCSS.js": 6897/*!*******************************************************!*\ 6898 !*** ./node_modules/tailwindcss/lib/lib/formatCSS.js ***! 6899 \*******************************************************/ 6900/*! no static exports found */ 6901/***/ (function(module, exports, __webpack_require__) { 6902 6903"use strict"; 6904 6905 6906Object.defineProperty(exports, "__esModule", { 6907 value: true 6908}); 6909exports.default = formatNodes; 6910 6911function indentRecursive(node, indent = 0) { 6912 node.each && node.each((child, i) => { 6913 if (!child.raws.before || child.raws.before.includes('\n')) { 6914 child.raws.before = `\n${node.type !== 'rule' && i > 0 ? '\n' : ''}${' '.repeat(indent)}`; 6915 } 6916 6917 child.raws.after = `\n${' '.repeat(indent)}`; 6918 indentRecursive(child, indent + 1); 6919 }); 6920} 6921 6922function formatNodes(root) { 6923 indentRecursive(root); 6924 6925 if (root.first) { 6926 root.first.raws.before = ''; 6927 } 6928} 6929 6930/***/ }), 6931
vendor: 724 bytes, lines 6932-6962
6932/***/ "./node_modules/webpack/buildin/global.js": 6933/*!***********************************!*\ 6934 !*** (webpack)/buildin/global.js ***! 6935 \***********************************/ 6936/*! no static exports found */ 6937/***/ (function(module, exports) { 6938 6939var g; 6940 6941// This works in non-strict mode 6942g = (function() { 6943 return this; 6944})(); 6945 6946try { 6947 // This works if eval is allowed (see CSP) 6948 g = g || new Function("return this")(); 6949} catch (e) { 6950 // This works if the window reference is available 6951 if (typeof window === "object") g = window; 6952} 6953 6954// g can still be undefined, but nothing to do about it... 6955// We return undefined, instead of nothing here, so it's 6956// easier to handle this case. if(!global) { ...} 6957 6958module.exports = g; 6959 6960 6961/***/ }), 6962
6963/***/ "./public/js/ll-before-after-gallery-public.js": 6964/*!*****************************************************!*\ 6965 !*** ./public/js/ll-before-after-gallery-public.js ***! 6966 \*****************************************************/ 6967/*! no static exports found */ 6968/***/ (function(module, exports, __webpack_require__) { 6969 6970var _require = __webpack_require__(/*! postcss */ "./node_modules/postcss/lib/postcss.js"), 6971 fromJSON = _require.fromJSON; 6972 6973var _require2 = __webpack_require__(/*! tailwindcss/lib/lib/formatCSS */ "./node_modules/tailwindcss/lib/lib/formatCSS.js"), 6974 formatCSS = _require2["default"]; 6975 6976(function ($) { 6977 'use strict'; // slider for multiple images 6978 6979 $('.slider-for').slick({ 6980 slidesToShow: 1, 6981 slidesToScroll: 1, 6982 fade: true, 6983 draggable: false, 6984 asNavFor: '.slider-nav', 6985 arrows: false, 6986 infinite: false, 6987 accessibility: true, 6988 focusOnChange: true 6989 }); 6990 $('.slider-nav').slick({ 6991 slidesToShow: 3, 6992 slidesToScroll: 1, 6993 asNavFor: '.slider-for', 6994 vertical: true, 6995 arrows: true, 6996 draggable: false, 6997 focusOnSelect: true, 6998 nextArrow: '<button class="next"></button>', 6999 prevArrow: '<button class="prev"></button>', 7000 infinite: false, 7001 accessibility: true, 7002 responsive: [{ 7003 breakpoint: 768, 7004 settings: { 7005 vertical: false, 7006 arrows: false, 7007 draggable: true, 7008 variableWidth: true 7009 } 7010 }] 7011 }); 7012 $('.slider').on('input change', function (e) { 7013 var sliderPosition = e.target.value; // Update the width of the foreground image 7014 7015 $('.foreground').css('width', "calc(".concat(sliderPosition, "% - 4px)")); // Update the position of the slider button 7016 7017 $('.slider-button').css('left', "calc(".concat(sliderPosition, "% - 36px)")); 7018 }); 7019 $('.bag_gallery-image').on('click', function () { 7020 // Reset the width of the foreground image 7021 $('.foreground').css('width', "calc(50% - 4px)"); // Reset the position of the slider button 7022 7023 $('.slider-button').css('left', "calc(50% - 36px)"); // Reset the position of the slider bar 7024 7025 $('.slider').val('50'); 7026 }); // mobile filter toggles 7027 7028 $('.bag_mobile-filter-toggle').on('click', function () { 7029 $('.bag_mobile-filter').toggleClass('bag_active'); 7030 }); 7031 $('.bag_mobile-filter-exit').on('click', function () { 7032 $('.bag_mobile-filter').toggleClass('bag_active'); 7033 }); // iframe popup functionality 7034 7035 $('.bag_init-popup').magnificPopup({ 7036 disableOn: 700, 7037 type: 'iframe', 7038 mainClass: 'mfp-fade', 7039 removalDelay: 160, 7040 preloader: false, 7041 fixedContentPos: false 7042 }); 7043 7044 if ($('.single-ll_bag').length > 0) { 7045 // if user arrived at this page by a filtered result, update back link to go back to the filtered result 7046 var backUrl = localStorage.getItem('backToBag'); 7047 7048 if (backUrl === null) { 7049 backUrl = '/before-and-after/'; 7050 } 7051 7052 $('.bag_sidebar-back-btn a').attr('href', backUrl); // if the result is nsfw, show the nsfw popup warning 7053 7054 if ($('.bag_single-page-section').hasClass('is-nsfw') && localStorage.getItem('bag-nsfw-safe') !== 'true') { 7055 $.magnificPopup.open({ 7056 items: { 7057 src: '#ll-bag-nsfw-popup', 7058 type: 'inline' 7059 } 7060 }); 7061 } 7062 } 7063 7064 if ($('.bag_archive-section').length > 0 && !window.location.search) { 7065 // if the results are nsfw, show the nsfw popup warning 7066 if ($('.is-nsfw').length > 0 && localStorage.getItem('bag-nsfw-safe') !== 'true') { 7067 $.magnificPopup.open({ 7068 items: { 7069 src: '#ll-bag-nsfw-popup', 7070 type: 'inline' 7071 } 7072 }); 7073 } 7074 } // custom close button functionality for bag modal, because it wasn't working normally 7075 7076 7077 $('.ll-bag-modal__close').on('click', function () { 7078 if ($(this).closest('.ll-bag-modal').hasClass('ll-bag-nsfw-popup')) { 7079 localStorage.setItem('bag-nsfw-safe', 'true'); 7080 } 7081 7082 $('.mfp-close').trigger('click'); 7083 }); // if url has parameters, filter the results 7084 7085 if (window.location.search) { 7086 filterBag(new URLSearchParams(window.location.search).toString()); 7087 } else { 7088 $('#bag_results-container').addClass('is-loaded'); 7089 } // if the window is mobile, add aria-hidden to the filter form to make it more accessible with the dropdown trigger 7090 7091 7092 if (window.innerWidth < 1024) { 7093 $('#bag_filter-form').attr('aria-hidden', true); 7094 } // if the window is mobile, add aria-hidden to the filter form to make it more accessible with the dropdown trigger 7095 7096 7097 $(window).on('resize', function () { 7098 if (window.innerWidth < 1024) { 7099 $('#bag_filter-form').attr('aria-hidden', true); 7100 } else { 7101 $('#bag_filter-form').removeAttr('aria-hidden'); 7102 } 7103 }); // if a checkbox is changed, update the form and add a pill button showing the new filter 7104 7105 document.querySelectorAll('.bag_filter-form input[type="checkbox"]').forEach(function (el) { 7106 el.addEventListener('change', function () { 7107 // check to see if changed checkbox has a pill 7108 // if it does click the pill to remove the item, 7109 // else create the pill and then submit the form 7110 var checkboxes = document.querySelectorAll('.bag_filter-form input[value="' + el.value + '"]'); 7111 var currentButton = document.querySelector('button[value="' + el.value + '"]'); 7112 7113 if ($(el).closest('.add-to-banner').length) { 7114 console.log('.bar_archive-banner label[for="' + $(el).attr('id') + '"]'); 7115 $('.bar_archive-banner label[for="' + $(el).attr('id') + '"], .bag_archive-banner label[for="' + $(el).attr('id') + '"]').toggleClass('is-checked'); 7116 } 7117 7118 if (currentButton) { 7119 currentButton.parentElement.remove(); 7120 7121 if (!$('.bag_pill-btn').length) { 7122 $('.bag_selected-filters').removeClass('active'); 7123 } 7124 7125 form.trigger('submit'); 7126 } else { 7127 $('.bag_selected-filters').addClass('active'); 7128 var label = document.querySelector('[for="' + el.id + '"]'); 7129 var newContent = "<li class=\"bag-mx-2 bag-mb-3\"><button type=\"button\" class=\"bag_pill-btn bag-inline-flex bag-items-center bag-p-2 bag-text-xs bag-font-medium bag-leading-tight bag-bg-opacity-50 bag-rounded bag-text-brand-charcoal bag-bg-brand-light-gray\" name=\"".concat(el.name.replace('[]', ''), "\" value=\"").concat(el.value, "\">
7129\n <span class=\"sr-only\">Remove filter for </span>\n ").concat(label.textContent, "\n <svg class=\"bag-ml-3 bag-w-3 bag-h-3 bag-pointer-events-none bag-text-brand-graphite icon icon-cross-small\"><use xlink:href=\"#icon-cross-small\"></use></svg>\n </button></li>"); 7130 document.querySelector('.bag_selected-filters ul').insertAdjacentHTML('beforeend', newContent); 7131 } 7132 7133 form.trigger('submit'); 7134 }); 7135 }); // AJAX 7136 7137 var form = $('#bag_filter-form'); 7138 var inputs = $('.bag_filter-form input'); // when the form is submitted, update browser history and get new results 7139 7140 form.on('submit', function (event) { 7141 event.preventDefault(); 7142 var formData = new FormData(event.target); 7143 var urlQuery = new URLSearchParams(formData).toString(); 7144 history.replaceState('', '', '?' + decodeURIComponent(urlQuery)); 7145 filterBag(urlQuery); 7146 var fromUrl = window.location.href; 7147 localStorage.setItem('backToBag', fromUrl); 7148 }); // set up pagination with history 7149 7150 document.body.addEventListener('click', function (event) { 7151 var target = event.target; 7152 7153 if (target.classList.contains('page-numbers', 'nav-button', 'bag_filter-tag')) { 7154 var page = target; 7155 var urlQuery = new URLSearchParams(window.location.search); 7156 urlQuery.set('page', page.dataset.value); 7157 history.replaceState('', '', '?' + decodeURIComponent(urlQuery.toString())); 7158 filterBag(urlQuery.toString()); 7159 location.href = '#bag_results-container'; 7160 } 7161 }); // When clear all filters is clicked, unset all of the checkboxes, and resubmit the form 7162 7163 $('.bag_clear-filter').on('click', function (e) { 7164 e.preventDefault(); 7165 document.querySelectorAll('.bag_filter-form input[type="checkbox"]').forEach(function (el) { 7166 el.checked = false; 7167 }); 7168 document.querySelectorAll('.bag_selected-filters .bag_pill-btn').forEach(function (el) { 7169 el.remove(); 7170 }); 7171 $('.bag_selected-filters').removeClass('active'); 7172 form.trigger('submit'); 7173 }); // If there are no pill buttons (i.e. no filters), remove the Clear All Filters button 7174 7175 if ($('.bag_pill-btn').length >= 1) { 7176 $('.bag_clear-filter').removeClass('hidden'); 7177 } else { 7178 $('.bag_clear-filter').addClass('hidden'); 7179 } // remove pills when clicked and resubmit form 7180 7181 7182 $('.bag_selected-filters').on('click', '.bag_pill-btn', function (el) { 7183 if (this.classList.contains('bag_pill-btn')) { 7184 var uncheckedInput = document.querySelectorAll('input[name="' + this.name + '[]"][value="' + this.value + '"]'); 7185 $(uncheckedInput).each(function () { 7186 $(this)[0].checked = false; 7187 }); 7188 var termButton = document.querySelector('button[value="' + this.value + '"]'); 7189 7190 if (termButton) { 7191 termButton.parentElement.remove(); 7192 } 7193 7194 form.trigger('submit'); 7195 } 7196 7197 if (!$('.bag_pill-btn').length) { 7198 $('.bag_selected-filters').removeClass('active'); 7199 } 7200 }); // Filter the results with ajax 7201 7202 function filterBag(query) { 7203 $('#bag_results-container').addClass('is-filtering'); 7204 $.ajax({ 7205 type: 'POST', 7206 url: '/wp-admin/admin-ajax.php', 7207 dataType: 'html', 7208 data: { 7209 action: 'll_bag_filter', 7210 query: query 7211 }, 7212 success: function success(res) { 7213 var data = $.parseJSON(res); 7214 7215 if (data.grid) { 7216 document.querySelector('#bag_results-container').innerHTML = data.grid; 7217 document.querySelector('#bag_results-container').insertAdjacentHTML('afterBegin', '<h2 class="sr-only">Filtered Results:</h2>'); 7218 7219 if (data.paging) { 7220 document.querySelector('.bag_pagination').outerHTML = data.paging; 7221 } else { 7222 document.querySelector('.bag_pagination').innerHTML = data.paging; 7223 } 7224 7225 if (data.filter) {// document.querySelector( '.bag_selected-filters' ).innerHTML = data.filter; 7226 } 7227 7228 if ($('.bag_pill-btn').length >= 1) { 7229 $('.bag_clear-filter').removeClass('hidden'); 7230 } else { 7231 $('.bag_clear-filter').addClass('hidden'); 7232 } 7233 } else { 7234 document.querySelector('#bag_results-container').innerHTML = '<p class="ll-filter-result-notice mb-12">No results found, please adjust your search</p>'; 7235 document.querySelector('.bag_pagination').innerHTML = ''; 7236 } 7237 7238 $('#bag_results-container').addClass('is-loaded').removeClass('is-filtering'); // if the results are nsfw, show the nsfw popup warning 7239 7240 if ($('.is-nsfw').length > 0 && localStorage.getItem('bag-nsfw-safe') !== 'true') { 7241 $.magnificPopup.open({ 7242 items: { 7243 src: '#ll-bag-nsfw-popup', 7244 type: 'inline' 7245 } 7246 }); 7247 } 7248 }, 7249 error: function error(err) { 7250 console.log(err); 7251 } 7252 }); 7253 } 7254})(jQuery); 7255 7256/***/ })
7256, 7257 7258/***/ 0: 7259/*!********************************************************************************!*\ 7260 !*** multi ./public/js/ll-before-after-gallery-public.js ./assets/css/app.css ***! 7261 \********************************************************************************/ 7262/*! no static exports found */ 7263/***/ (function(module, exports, __webpack_require__) { 7264 7265__webpack_require__(/*! /Users/aaroncochran/Documents/Clients/mothership/app/public/wp-content/plugins/ll-bag-v2/public/js/ll-before-after-gallery-public.js */"./public/js/ll-before-after-gallery-public.js"); 7266module.exports = __webpack_require__(/*! /Users/aaroncochran/Documents/Clients/mothership/app/public/wp-content/plugins/ll-bag-v2/assets/css/app.css */"./assets/css/app.css"); 7267 7268 7269/***/ }), 7270 7271/***/ 1: 7272/*!**************************************!*\ 7273 !*** ./terminal-highlight (ignored) ***! 7274 \**************************************/ 7275/*! no static exports found */ 7276/***/ (function(module, exports) { 7277 7278/* (ignored) */ 7279 7280/***/ }), 7281 7282/***/ 2: 7283/*!*******************************!*\ 7284 !*** source-map-js (ignored) ***! 7285 \*******************************/ 7286/*! no static exports found */ 7287/***/ (function(module, exports) { 7288 7289/* (ignored) */ 7290 7291/***/ }), 7292 7293/***/ 3: 7294/*!**********************!*\ 7295 !*** path (ignored) ***! 7296 \**********************/ 7297/*! no static exports found */ 7298/***/ (function(module, exports) { 7299 7300/* (ignored) */ 7301 7302/***/ }), 7303 7304/***/ 4: 7305/*!*********************!*\ 7306 !*** url (ignored) ***! 7307 \*********************/ 7308/*! no static exports found */ 7309/***/ (function(module, exports) { 7310 7311/* (ignored) */ 7312 7313/***/ }), 7314 7315/***/ 5: 7316/*!********************!*\ 7317 !*** fs (ignored) ***! 7318 \********************/ 7319/*! no static exports found */ 7320/***/ (function(module, exports) { 7321 7322/* (ignored) */ 7323 7324/***/ }) 7325 7326/******/ }); 7327//# sourceMappingURL=ll-bag.min.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.