| [ Index ] |
PHP Cross Reference of WordPress Trunk (Updated Daily) |
[Summary view] [Print] [Text view]
1 /******/ (() => { // webpackBootstrap 2 /******/ var __webpack_modules__ = ({ 3 4 /***/ 4306: 5 /***/ (function(module, exports) { 6 7 var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*! 8 autosize 4.0.4 9 license: MIT 10 http://www.jacklmoore.com/autosize 11 */ 12 (function (global, factory) { 13 if (true) { 14 !(__WEBPACK_AMD_DEFINE_ARRAY__ = [module, exports], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), 15 __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? 16 (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), 17 __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); 18 } else { var mod; } 19 })(this, function (module, exports) { 20 'use strict'; 21 22 var map = typeof Map === "function" ? new Map() : function () { 23 var keys = []; 24 var values = []; 25 26 return { 27 has: function has(key) { 28 return keys.indexOf(key) > -1; 29 }, 30 get: function get(key) { 31 return values[keys.indexOf(key)]; 32 }, 33 set: function set(key, value) { 34 if (keys.indexOf(key) === -1) { 35 keys.push(key); 36 values.push(value); 37 } 38 }, 39 delete: function _delete(key) { 40 var index = keys.indexOf(key); 41 if (index > -1) { 42 keys.splice(index, 1); 43 values.splice(index, 1); 44 } 45 } 46 }; 47 }(); 48 49 var createEvent = function createEvent(name) { 50 return new Event(name, { bubbles: true }); 51 }; 52 try { 53 new Event('test'); 54 } catch (e) { 55 // IE does not support `new Event()` 56 createEvent = function createEvent(name) { 57 var evt = document.createEvent('Event'); 58 evt.initEvent(name, true, false); 59 return evt; 60 }; 61 } 62 63 function assign(ta) { 64 if (!ta || !ta.nodeName || ta.nodeName !== 'TEXTAREA' || map.has(ta)) return; 65 66 var heightOffset = null; 67 var clientWidth = null; 68 var cachedHeight = null; 69 70 function init() { 71 var style = window.getComputedStyle(ta, null); 72 73 if (style.resize === 'vertical') { 74 ta.style.resize = 'none'; 75 } else if (style.resize === 'both') { 76 ta.style.resize = 'horizontal'; 77 } 78 79 if (style.boxSizing === 'content-box') { 80 heightOffset = -(parseFloat(style.paddingTop) + parseFloat(style.paddingBottom)); 81 } else { 82 heightOffset = parseFloat(style.borderTopWidth) + parseFloat(style.borderBottomWidth); 83 } 84 // Fix when a textarea is not on document body and heightOffset is Not a Number 85 if (isNaN(heightOffset)) { 86 heightOffset = 0; 87 } 88 89 update(); 90 } 91 92 function changeOverflow(value) { 93 { 94 // Chrome/Safari-specific fix: 95 // When the textarea y-overflow is hidden, Chrome/Safari do not reflow the text to account for the space 96 // made available by removing the scrollbar. The following forces the necessary text reflow. 97 var width = ta.style.width; 98 ta.style.width = '0px'; 99 // Force reflow: 100 /* jshint ignore:start */ 101 ta.offsetWidth; 102 /* jshint ignore:end */ 103 ta.style.width = width; 104 } 105 106 ta.style.overflowY = value; 107 } 108 109 function getParentOverflows(el) { 110 var arr = []; 111 112 while (el && el.parentNode && el.parentNode instanceof Element) { 113 if (el.parentNode.scrollTop) { 114 arr.push({ 115 node: el.parentNode, 116 scrollTop: el.parentNode.scrollTop 117 }); 118 } 119 el = el.parentNode; 120 } 121 122 return arr; 123 } 124 125 function resize() { 126 if (ta.scrollHeight === 0) { 127 // If the scrollHeight is 0, then the element probably has display:none or is detached from the DOM. 128 return; 129 } 130 131 var overflows = getParentOverflows(ta); 132 var docTop = document.documentElement && document.documentElement.scrollTop; // Needed for Mobile IE (ticket #240) 133 134 ta.style.height = ''; 135 ta.style.height = ta.scrollHeight + heightOffset + 'px'; 136 137 // used to check if an update is actually necessary on window.resize 138 clientWidth = ta.clientWidth; 139 140 // prevents scroll-position jumping 141 overflows.forEach(function (el) { 142 el.node.scrollTop = el.scrollTop; 143 }); 144 145 if (docTop) { 146 document.documentElement.scrollTop = docTop; 147 } 148 } 149 150 function update() { 151 resize(); 152 153 var styleHeight = Math.round(parseFloat(ta.style.height)); 154 var computed = window.getComputedStyle(ta, null); 155 156 // Using offsetHeight as a replacement for computed.height in IE, because IE does not account use of border-box 157 var actualHeight = computed.boxSizing === 'content-box' ? Math.round(parseFloat(computed.height)) : ta.offsetHeight; 158 159 // The actual height not matching the style height (set via the resize method) indicates that 160 // the max-height has been exceeded, in which case the overflow should be allowed. 161 if (actualHeight < styleHeight) { 162 if (computed.overflowY === 'hidden') { 163 changeOverflow('scroll'); 164 resize(); 165 actualHeight = computed.boxSizing === 'content-box' ? Math.round(parseFloat(window.getComputedStyle(ta, null).height)) : ta.offsetHeight; 166 } 167 } else { 168 // Normally keep overflow set to hidden, to avoid flash of scrollbar as the textarea expands. 169 if (computed.overflowY !== 'hidden') { 170 changeOverflow('hidden'); 171 resize(); 172 actualHeight = computed.boxSizing === 'content-box' ? Math.round(parseFloat(window.getComputedStyle(ta, null).height)) : ta.offsetHeight; 173 } 174 } 175 176 if (cachedHeight !== actualHeight) { 177 cachedHeight = actualHeight; 178 var evt = createEvent('autosize:resized'); 179 try { 180 ta.dispatchEvent(evt); 181 } catch (err) { 182 // Firefox will throw an error on dispatchEvent for a detached element 183 // https://bugzilla.mozilla.org/show_bug.cgi?id=889376 184 } 185 } 186 } 187 188 var pageResize = function pageResize() { 189 if (ta.clientWidth !== clientWidth) { 190 update(); 191 } 192 }; 193 194 var destroy = function (style) { 195 window.removeEventListener('resize', pageResize, false); 196 ta.removeEventListener('input', update, false); 197 ta.removeEventListener('keyup', update, false); 198 ta.removeEventListener('autosize:destroy', destroy, false); 199 ta.removeEventListener('autosize:update', update, false); 200 201 Object.keys(style).forEach(function (key) { 202 ta.style[key] = style[key]; 203 }); 204 205 map.delete(ta); 206 }.bind(ta, { 207 height: ta.style.height, 208 resize: ta.style.resize, 209 overflowY: ta.style.overflowY, 210 overflowX: ta.style.overflowX, 211 wordWrap: ta.style.wordWrap 212 }); 213 214 ta.addEventListener('autosize:destroy', destroy, false); 215 216 // IE9 does not fire onpropertychange or oninput for deletions, 217 // so binding to onkeyup to catch most of those events. 218 // There is no way that I know of to detect something like 'cut' in IE9. 219 if ('onpropertychange' in ta && 'oninput' in ta) { 220 ta.addEventListener('keyup', update, false); 221 } 222 223 window.addEventListener('resize', pageResize, false); 224 ta.addEventListener('input', update, false); 225 ta.addEventListener('autosize:update', update, false); 226 ta.style.overflowX = 'hidden'; 227 ta.style.wordWrap = 'break-word'; 228 229 map.set(ta, { 230 destroy: destroy, 231 update: update 232 }); 233 234 init(); 235 } 236 237 function destroy(ta) { 238 var methods = map.get(ta); 239 if (methods) { 240 methods.destroy(); 241 } 242 } 243 244 function update(ta) { 245 var methods = map.get(ta); 246 if (methods) { 247 methods.update(); 248 } 249 } 250 251 var autosize = null; 252 253 // Do nothing in Node.js environment and IE8 (or lower) 254 if (typeof window === 'undefined' || typeof window.getComputedStyle !== 'function') { 255 autosize = function autosize(el) { 256 return el; 257 }; 258 autosize.destroy = function (el) { 259 return el; 260 }; 261 autosize.update = function (el) { 262 return el; 263 }; 264 } else { 265 autosize = function autosize(el, options) { 266 if (el) { 267 Array.prototype.forEach.call(el.length ? el : [el], function (x) { 268 return assign(x, options); 269 }); 270 } 271 return el; 272 }; 273 autosize.destroy = function (el) { 274 if (el) { 275 Array.prototype.forEach.call(el.length ? el : [el], destroy); 276 } 277 return el; 278 }; 279 autosize.update = function (el) { 280 if (el) { 281 Array.prototype.forEach.call(el.length ? el : [el], update); 282 } 283 return el; 284 }; 285 } 286 287 exports.default = autosize; 288 module.exports = exports['default']; 289 }); 290 291 /***/ }), 292 293 /***/ 6109: 294 /***/ ((module) => { 295 296 // This code has been refactored for 140 bytes 297 // You can see the original here: https://github.com/twolfson/computedStyle/blob/04cd1da2e30fa45844f95f5cb1ac898e9b9ef050/lib/computedStyle.js 298 var computedStyle = function (el, prop, getComputedStyle) { 299 getComputedStyle = window.getComputedStyle; 300 301 // In one fell swoop 302 return ( 303 // If we have getComputedStyle 304 getComputedStyle ? 305 // Query it 306 // TODO: From CSS-Query notes, we might need (node, null) for FF 307 getComputedStyle(el) : 308 309 // Otherwise, we are in IE and use currentStyle 310 el.currentStyle 311 )[ 312 // Switch to camelCase for CSSOM 313 // DEV: Grabbed from jQuery 314 // https://github.com/jquery/jquery/blob/1.9-stable/src/css.js#L191-L194 315 // https://github.com/jquery/jquery/blob/1.9-stable/src/core.js#L593-L597 316 prop.replace(/-(\w)/gi, function (word, letter) { 317 return letter.toUpperCase(); 318 }) 319 ]; 320 }; 321 322 module.exports = computedStyle; 323 324 325 /***/ }), 326 327 /***/ 5417: 328 /***/ ((__unused_webpack_module, exports) => { 329 330 "use strict"; 331 /*istanbul ignore start*/ 332 333 334 Object.defineProperty(exports, "__esModule", ({ 335 value: true 336 })); 337 exports["default"] = Diff; 338 339 /*istanbul ignore end*/ 340 function Diff() {} 341 342 Diff.prototype = { 343 /*istanbul ignore start*/ 344 345 /*istanbul ignore end*/ 346 diff: function diff(oldString, newString) { 347 /*istanbul ignore start*/ 348 var 349 /*istanbul ignore end*/ 350 options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; 351 var callback = options.callback; 352 353 if (typeof options === 'function') { 354 callback = options; 355 options = {}; 356 } 357 358 this.options = options; 359 var self = this; 360 361 function done(value) { 362 if (callback) { 363 setTimeout(function () { 364 callback(undefined, value); 365 }, 0); 366 return true; 367 } else { 368 return value; 369 } 370 } // Allow subclasses to massage the input prior to running 371 372 373 oldString = this.castInput(oldString); 374 newString = this.castInput(newString); 375 oldString = this.removeEmpty(this.tokenize(oldString)); 376 newString = this.removeEmpty(this.tokenize(newString)); 377 var newLen = newString.length, 378 oldLen = oldString.length; 379 var editLength = 1; 380 var maxEditLength = newLen + oldLen; 381 var bestPath = [{ 382 newPos: -1, 383 components: [] 384 }]; // Seed editLength = 0, i.e. the content starts with the same values 385 386 var oldPos = this.extractCommon(bestPath[0], newString, oldString, 0); 387 388 if (bestPath[0].newPos + 1 >= newLen && oldPos + 1 >= oldLen) { 389 // Identity per the equality and tokenizer 390 return done([{ 391 value: this.join(newString), 392 count: newString.length 393 }]); 394 } // Main worker method. checks all permutations of a given edit length for acceptance. 395 396 397 function execEditLength() { 398 for (var diagonalPath = -1 * editLength; diagonalPath <= editLength; diagonalPath += 2) { 399 var basePath = 400 /*istanbul ignore start*/ 401 void 0 402 /*istanbul ignore end*/ 403 ; 404 405 var addPath = bestPath[diagonalPath - 1], 406 removePath = bestPath[diagonalPath + 1], 407 _oldPos = (removePath ? removePath.newPos : 0) - diagonalPath; 408 409 if (addPath) { 410 // No one else is going to attempt to use this value, clear it 411 bestPath[diagonalPath - 1] = undefined; 412 } 413 414 var canAdd = addPath && addPath.newPos + 1 < newLen, 415 canRemove = removePath && 0 <= _oldPos && _oldPos < oldLen; 416 417 if (!canAdd && !canRemove) { 418 // If this path is a terminal then prune 419 bestPath[diagonalPath] = undefined; 420 continue; 421 } // Select the diagonal that we want to branch from. We select the prior 422 // path whose position in the new string is the farthest from the origin 423 // and does not pass the bounds of the diff graph 424 425 426 if (!canAdd || canRemove && addPath.newPos < removePath.newPos) { 427 basePath = clonePath(removePath); 428 self.pushComponent(basePath.components, undefined, true); 429 } else { 430 basePath = addPath; // No need to clone, we've pulled it from the list 431 432 basePath.newPos++; 433 self.pushComponent(basePath.components, true, undefined); 434 } 435 436 _oldPos = self.extractCommon(basePath, newString, oldString, diagonalPath); // If we have hit the end of both strings, then we are done 437 438 if (basePath.newPos + 1 >= newLen && _oldPos + 1 >= oldLen) { 439 return done(buildValues(self, basePath.components, newString, oldString, self.useLongestToken)); 440 } else { 441 // Otherwise track this path as a potential candidate and continue. 442 bestPath[diagonalPath] = basePath; 443 } 444 } 445 446 editLength++; 447 } // Performs the length of edit iteration. Is a bit fugly as this has to support the 448 // sync and async mode which is never fun. Loops over execEditLength until a value 449 // is produced. 450 451 452 if (callback) { 453 (function exec() { 454 setTimeout(function () { 455 // This should not happen, but we want to be safe. 456 457 /* istanbul ignore next */ 458 if (editLength > maxEditLength) { 459 return callback(); 460 } 461 462 if (!execEditLength()) { 463 exec(); 464 } 465 }, 0); 466 })(); 467 } else { 468 while (editLength <= maxEditLength) { 469 var ret = execEditLength(); 470 471 if (ret) { 472 return ret; 473 } 474 } 475 } 476 }, 477 478 /*istanbul ignore start*/ 479 480 /*istanbul ignore end*/ 481 pushComponent: function pushComponent(components, added, removed) { 482 var last = components[components.length - 1]; 483 484 if (last && last.added === added && last.removed === removed) { 485 // We need to clone here as the component clone operation is just 486 // as shallow array clone 487 components[components.length - 1] = { 488 count: last.count + 1, 489 added: added, 490 removed: removed 491 }; 492 } else { 493 components.push({ 494 count: 1, 495 added: added, 496 removed: removed 497 }); 498 } 499 }, 500 501 /*istanbul ignore start*/ 502 503 /*istanbul ignore end*/ 504 extractCommon: function extractCommon(basePath, newString, oldString, diagonalPath) { 505 var newLen = newString.length, 506 oldLen = oldString.length, 507 newPos = basePath.newPos, 508 oldPos = newPos - diagonalPath, 509 commonCount = 0; 510 511 while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(newString[newPos + 1], oldString[oldPos + 1])) { 512 newPos++; 513 oldPos++; 514 commonCount++; 515 } 516 517 if (commonCount) { 518 basePath.components.push({ 519 count: commonCount 520 }); 521 } 522 523 basePath.newPos = newPos; 524 return oldPos; 525 }, 526 527 /*istanbul ignore start*/ 528 529 /*istanbul ignore end*/ 530 equals: function equals(left, right) { 531 if (this.options.comparator) { 532 return this.options.comparator(left, right); 533 } else { 534 return left === right || this.options.ignoreCase && left.toLowerCase() === right.toLowerCase(); 535 } 536 }, 537 538 /*istanbul ignore start*/ 539 540 /*istanbul ignore end*/ 541 removeEmpty: function removeEmpty(array) { 542 var ret = []; 543 544 for (var i = 0; i < array.length; i++) { 545 if (array[i]) { 546 ret.push(array[i]); 547 } 548 } 549 550 return ret; 551 }, 552 553 /*istanbul ignore start*/ 554 555 /*istanbul ignore end*/ 556 castInput: function castInput(value) { 557 return value; 558 }, 559 560 /*istanbul ignore start*/ 561 562 /*istanbul ignore end*/ 563 tokenize: function tokenize(value) { 564 return value.split(''); 565 }, 566 567 /*istanbul ignore start*/ 568 569 /*istanbul ignore end*/ 570 join: function join(chars) { 571 return chars.join(''); 572 } 573 }; 574 575 function buildValues(diff, components, newString, oldString, useLongestToken) { 576 var componentPos = 0, 577 componentLen = components.length, 578 newPos = 0, 579 oldPos = 0; 580 581 for (; componentPos < componentLen; componentPos++) { 582 var component = components[componentPos]; 583 584 if (!component.removed) { 585 if (!component.added && useLongestToken) { 586 var value = newString.slice(newPos, newPos + component.count); 587 value = value.map(function (value, i) { 588 var oldValue = oldString[oldPos + i]; 589 return oldValue.length > value.length ? oldValue : value; 590 }); 591 component.value = diff.join(value); 592 } else { 593 component.value = diff.join(newString.slice(newPos, newPos + component.count)); 594 } 595 596 newPos += component.count; // Common case 597 598 if (!component.added) { 599 oldPos += component.count; 600 } 601 } else { 602 component.value = diff.join(oldString.slice(oldPos, oldPos + component.count)); 603 oldPos += component.count; // Reverse add and remove so removes are output first to match common convention 604 // The diffing algorithm is tied to add then remove output and this is the simplest 605 // route to get the desired output with minimal overhead. 606 607 if (componentPos && components[componentPos - 1].added) { 608 var tmp = components[componentPos - 1]; 609 components[componentPos - 1] = components[componentPos]; 610 components[componentPos] = tmp; 611 } 612 } 613 } // Special case handle for when one terminal is ignored (i.e. whitespace). 614 // For this case we merge the terminal into the prior string and drop the change. 615 // This is only available for string mode. 616 617 618 var lastComponent = components[componentLen - 1]; 619 620 if (componentLen > 1 && typeof lastComponent.value === 'string' && (lastComponent.added || lastComponent.removed) && diff.equals('', lastComponent.value)) { 621 components[componentLen - 2].value += lastComponent.value; 622 components.pop(); 623 } 624 625 return components; 626 } 627 628 function clonePath(path) { 629 return { 630 newPos: path.newPos, 631 components: path.components.slice(0) 632 }; 633 } 634 635 636 /***/ }), 637 638 /***/ 8021: 639 /***/ ((__unused_webpack_module, exports, __webpack_require__) => { 640 641 "use strict"; 642 var __webpack_unused_export__; 643 /*istanbul ignore start*/ 644 645 646 __webpack_unused_export__ = ({ 647 value: true 648 }); 649 exports.JJ = diffChars; 650 __webpack_unused_export__ = void 0; 651 652 /*istanbul ignore end*/ 653 var 654 /*istanbul ignore start*/ 655 _base = _interopRequireDefault(__webpack_require__(5417)) 656 /*istanbul ignore end*/ 657 ; 658 659 /*istanbul ignore start*/ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 660 661 /*istanbul ignore end*/ 662 var characterDiff = new 663 /*istanbul ignore start*/ 664 _base 665 /*istanbul ignore end*/ 666 . 667 /*istanbul ignore start*/ 668 default 669 /*istanbul ignore end*/ 670 (); 671 672 /*istanbul ignore start*/ 673 __webpack_unused_export__ = characterDiff; 674 675 /*istanbul ignore end*/ 676 function diffChars(oldStr, newStr, options) { 677 return characterDiff.diff(oldStr, newStr, options); 678 } 679 680 681 /***/ }), 682 683 /***/ 7734: 684 /***/ ((module) => { 685 686 "use strict"; 687 688 689 // do not edit .js files directly - edit src/index.jst 690 691 692 var envHasBigInt64Array = typeof BigInt64Array !== 'undefined'; 693 694 695 module.exports = function equal(a, b) { 696 if (a === b) return true; 697 698 if (a && b && typeof a == 'object' && typeof b == 'object') { 699 if (a.constructor !== b.constructor) return false; 700 701 var length, i, keys; 702 if (Array.isArray(a)) { 703 length = a.length; 704 if (length != b.length) return false; 705 for (i = length; i-- !== 0;) 706 if (!equal(a[i], b[i])) return false; 707 return true; 708 } 709 710 711 if ((a instanceof Map) && (b instanceof Map)) { 712 if (a.size !== b.size) return false; 713 for (i of a.entries()) 714 if (!b.has(i[0])) return false; 715 for (i of a.entries()) 716 if (!equal(i[1], b.get(i[0]))) return false; 717 return true; 718 } 719 720 if ((a instanceof Set) && (b instanceof Set)) { 721 if (a.size !== b.size) return false; 722 for (i of a.entries()) 723 if (!b.has(i[0])) return false; 724 return true; 725 } 726 727 if (ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) { 728 length = a.length; 729 if (length != b.length) return false; 730 for (i = length; i-- !== 0;) 731 if (a[i] !== b[i]) return false; 732 return true; 733 } 734 735 736 if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags; 737 if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf(); 738 if (a.toString !== Object.prototype.toString) return a.toString() === b.toString(); 739 740 keys = Object.keys(a); 741 length = keys.length; 742 if (length !== Object.keys(b).length) return false; 743 744 for (i = length; i-- !== 0;) 745 if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false; 746 747 for (i = length; i-- !== 0;) { 748 var key = keys[i]; 749 750 if (!equal(a[key], b[key])) return false; 751 } 752 753 return true; 754 } 755 756 // true if both NaN, false otherwise 757 return a!==a && b!==b; 758 }; 759 760 761 /***/ }), 762 763 /***/ 5215: 764 /***/ ((module) => { 765 766 "use strict"; 767 768 769 // do not edit .js files directly - edit src/index.jst 770 771 772 773 module.exports = function equal(a, b) { 774 if (a === b) return true; 775 776 if (a && b && typeof a == 'object' && typeof b == 'object') { 777 if (a.constructor !== b.constructor) return false; 778 779 var length, i, keys; 780 if (Array.isArray(a)) { 781 length = a.length; 782 if (length != b.length) return false; 783 for (i = length; i-- !== 0;) 784 if (!equal(a[i], b[i])) return false; 785 return true; 786 } 787 788 789 790 if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags; 791 if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf(); 792 if (a.toString !== Object.prototype.toString) return a.toString() === b.toString(); 793 794 keys = Object.keys(a); 795 length = keys.length; 796 if (length !== Object.keys(b).length) return false; 797 798 for (i = length; i-- !== 0;) 799 if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false; 800 801 for (i = length; i-- !== 0;) { 802 var key = keys[i]; 803 804 if (!equal(a[key], b[key])) return false; 805 } 806 807 return true; 808 } 809 810 // true if both NaN, false otherwise 811 return a!==a && b!==b; 812 }; 813 814 815 /***/ }), 816 817 /***/ 461: 818 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 819 820 // Load in dependencies 821 var computedStyle = __webpack_require__(6109); 822 823 /** 824 * Calculate the `line-height` of a given node 825 * @param {HTMLElement} node Element to calculate line height of. Must be in the DOM. 826 * @returns {Number} `line-height` of the element in pixels 827 */ 828 function lineHeight(node) { 829 // Grab the line-height via style 830 var lnHeightStr = computedStyle(node, 'line-height'); 831 var lnHeight = parseFloat(lnHeightStr, 10); 832 833 // If the lineHeight did not contain a unit (i.e. it was numeric), convert it to ems (e.g. '2.3' === '2.3em') 834 if (lnHeightStr === lnHeight + '') { 835 // Save the old lineHeight style and update the em unit to the element 836 var _lnHeightStyle = node.style.lineHeight; 837 node.style.lineHeight = lnHeightStr + 'em'; 838 839 // Calculate the em based height 840 lnHeightStr = computedStyle(node, 'line-height'); 841 lnHeight = parseFloat(lnHeightStr, 10); 842 843 // Revert the lineHeight style 844 if (_lnHeightStyle) { 845 node.style.lineHeight = _lnHeightStyle; 846 } else { 847 delete node.style.lineHeight; 848 } 849 } 850 851 // If the lineHeight is in `pt`, convert it to pixels (4px for 3pt) 852 // DEV: `em` units are converted to `pt` in IE6 853 // Conversion ratio from https://developer.mozilla.org/en-US/docs/Web/CSS/length 854 if (lnHeightStr.indexOf('pt') !== -1) { 855 lnHeight *= 4; 856 lnHeight /= 3; 857 // Otherwise, if the lineHeight is in `mm`, convert it to pixels (96px for 25.4mm) 858 } else if (lnHeightStr.indexOf('mm') !== -1) { 859 lnHeight *= 96; 860 lnHeight /= 25.4; 861 // Otherwise, if the lineHeight is in `cm`, convert it to pixels (96px for 2.54cm) 862 } else if (lnHeightStr.indexOf('cm') !== -1) { 863 lnHeight *= 96; 864 lnHeight /= 2.54; 865 // Otherwise, if the lineHeight is in `in`, convert it to pixels (96px for 1in) 866 } else if (lnHeightStr.indexOf('in') !== -1) { 867 lnHeight *= 96; 868 // Otherwise, if the lineHeight is in `pc`, convert it to pixels (12pt for 1pc) 869 } else if (lnHeightStr.indexOf('pc') !== -1) { 870 lnHeight *= 16; 871 } 872 873 // Continue our computation 874 lnHeight = Math.round(lnHeight); 875 876 // If the line-height is "normal", calculate by font-size 877 if (lnHeightStr === 'normal') { 878 // Create a temporary node 879 var nodeName = node.nodeName; 880 var _node = document.createElement(nodeName); 881 _node.innerHTML = ' '; 882 883 // If we have a text area, reset it to only 1 row 884 // https://github.com/twolfson/line-height/issues/4 885 if (nodeName.toUpperCase() === 'TEXTAREA') { 886 _node.setAttribute('rows', '1'); 887 } 888 889 // Set the font-size of the element 890 var fontSizeStr = computedStyle(node, 'font-size'); 891 _node.style.fontSize = fontSizeStr; 892 893 // Remove default padding/border which can affect offset height 894 // https://github.com/twolfson/line-height/issues/4 895 // https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/offsetHeight 896 _node.style.padding = '0px'; 897 _node.style.border = '0px'; 898 899 // Append it to the body 900 var body = document.body; 901 body.appendChild(_node); 902 903 // Assume the line height of the element is the height 904 var height = _node.offsetHeight; 905 lnHeight = height; 906 907 // Remove our child from the DOM 908 body.removeChild(_node); 909 } 910 911 // Return the calculated height 912 return lnHeight; 913 } 914 915 // Export lineHeight 916 module.exports = lineHeight; 917 918 919 /***/ }), 920 921 /***/ 7520: 922 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 923 924 module.exports = __webpack_require__(7191); 925 926 927 /***/ }), 928 929 /***/ 8202: 930 /***/ ((module) => { 931 932 "use strict"; 933 /** 934 * Copyright (c) 2015, Facebook, Inc. 935 * All rights reserved. 936 * 937 * This source code is licensed under the BSD-style license found in the 938 * LICENSE file in the root directory of this source tree. An additional grant 939 * of patent rights can be found in the PATENTS file in the same directory. 940 * 941 * @providesModule ExecutionEnvironment 942 */ 943 944 /*jslint evil: true */ 945 946 947 948 var canUseDOM = !!( 949 typeof window !== 'undefined' && 950 window.document && 951 window.document.createElement 952 ); 953 954 /** 955 * Simple, lightweight module assisting with the detection and context of 956 * Worker. Helps avoid circular dependencies and allows code to reason about 957 * whether or not they are in a Worker, even if they never include the main 958 * `ReactWorker` dependency. 959 */ 960 var ExecutionEnvironment = { 961 962 canUseDOM: canUseDOM, 963 964 canUseWorkers: typeof Worker !== 'undefined', 965 966 canUseEventListeners: 967 canUseDOM && !!(window.addEventListener || window.attachEvent), 968 969 canUseViewport: canUseDOM && !!window.screen, 970 971 isInWorker: !canUseDOM // For now, this is true - might change in the future. 972 973 }; 974 975 module.exports = ExecutionEnvironment; 976 977 978 /***/ }), 979 980 /***/ 2213: 981 /***/ ((module) => { 982 983 /** 984 * Copyright 2004-present Facebook. All Rights Reserved. 985 * 986 * @providesModule UserAgent_DEPRECATED 987 */ 988 989 /** 990 * Provides entirely client-side User Agent and OS detection. You should prefer 991 * the non-deprecated UserAgent module when possible, which exposes our 992 * authoritative server-side PHP-based detection to the client. 993 * 994 * Usage is straightforward: 995 * 996 * if (UserAgent_DEPRECATED.ie()) { 997 * // IE 998 * } 999 * 1000 * You can also do version checks: 1001 * 1002 * if (UserAgent_DEPRECATED.ie() >= 7) { 1003 * // IE7 or better 1004 * } 1005 * 1006 * The browser functions will return NaN if the browser does not match, so 1007 * you can also do version compares the other way: 1008 * 1009 * if (UserAgent_DEPRECATED.ie() < 7) { 1010 * // IE6 or worse 1011 * } 1012 * 1013 * Note that the version is a float and may include a minor version number, 1014 * so you should always use range operators to perform comparisons, not 1015 * strict equality. 1016 * 1017 * **Note:** You should **strongly** prefer capability detection to browser 1018 * version detection where it's reasonable: 1019 * 1020 * http://www.quirksmode.org/js/support.html 1021 * 1022 * Further, we have a large number of mature wrapper functions and classes 1023 * which abstract away many browser irregularities. Check the documentation, 1024 * grep for things, or ask on javascript@lists.facebook.com before writing yet 1025 * another copy of "event || window.event". 1026 * 1027 */ 1028 1029 var _populated = false; 1030 1031 // Browsers 1032 var _ie, _firefox, _opera, _webkit, _chrome; 1033 1034 // Actual IE browser for compatibility mode 1035 var _ie_real_version; 1036 1037 // Platforms 1038 var _osx, _windows, _linux, _android; 1039 1040 // Architectures 1041 var _win64; 1042 1043 // Devices 1044 var _iphone, _ipad, _native; 1045 1046 var _mobile; 1047 1048 function _populate() { 1049 if (_populated) { 1050 return; 1051 } 1052 1053 _populated = true; 1054 1055 // To work around buggy JS libraries that can't handle multi-digit 1056 // version numbers, Opera 10's user agent string claims it's Opera 1057 // 9, then later includes a Version/X.Y field: 1058 // 1059 // Opera/9.80 (foo) Presto/2.2.15 Version/10.10 1060 var uas = navigator.userAgent; 1061 var agent = /(?:MSIE.(\d+\.\d+))|(?:(?:Firefox|GranParadiso|Iceweasel).(\d+\.\d+))|(?:Opera(?:.+Version.|.)(\d+\.\d+))|(?:AppleWebKit.(\d+(?:\.\d+)?))|(?:Trident\/\d+\.\d+.*rv:(\d+\.\d+))/.exec(uas); 1062 var os = /(Mac OS X)|(Windows)|(Linux)/.exec(uas); 1063 1064 _iphone = /\b(iPhone|iP[ao]d)/.exec(uas); 1065 _ipad = /\b(iP[ao]d)/.exec(uas); 1066 _android = /Android/i.exec(uas); 1067 _native = /FBAN\/\w+;/i.exec(uas); 1068 _mobile = /Mobile/i.exec(uas); 1069 1070 // Note that the IE team blog would have you believe you should be checking 1071 // for 'Win64; x64'. But MSDN then reveals that you can actually be coming 1072 // from either x64 or ia64; so ultimately, you should just check for Win64 1073 // as in indicator of whether you're in 64-bit IE. 32-bit IE on 64-bit 1074 // Windows will send 'WOW64' instead. 1075 _win64 = !!(/Win64/.exec(uas)); 1076 1077 if (agent) { 1078 _ie = agent[1] ? parseFloat(agent[1]) : ( 1079 agent[5] ? parseFloat(agent[5]) : NaN); 1080 // IE compatibility mode 1081 if (_ie && document && document.documentMode) { 1082 _ie = document.documentMode; 1083 } 1084 // grab the "true" ie version from the trident token if available 1085 var trident = /(?:Trident\/(\d+.\d+))/.exec(uas); 1086 _ie_real_version = trident ? parseFloat(trident[1]) + 4 : _ie; 1087 1088 _firefox = agent[2] ? parseFloat(agent[2]) : NaN; 1089 _opera = agent[3] ? parseFloat(agent[3]) : NaN; 1090 _webkit = agent[4] ? parseFloat(agent[4]) : NaN; 1091 if (_webkit) { 1092 // We do not add the regexp to the above test, because it will always 1093 // match 'safari' only since 'AppleWebKit' appears before 'Chrome' in 1094 // the userAgent string. 1095 agent = /(?:Chrome\/(\d+\.\d+))/.exec(uas); 1096 _chrome = agent && agent[1] ? parseFloat(agent[1]) : NaN; 1097 } else { 1098 _chrome = NaN; 1099 } 1100 } else { 1101 _ie = _firefox = _opera = _chrome = _webkit = NaN; 1102 } 1103 1104 if (os) { 1105 if (os[1]) { 1106 // Detect OS X version. If no version number matches, set _osx to true. 1107 // Version examples: 10, 10_6_1, 10.7 1108 // Parses version number as a float, taking only first two sets of 1109 // digits. If only one set of digits is found, returns just the major 1110 // version number. 1111 var ver = /(?:Mac OS X (\d+(?:[._]\d+)?))/.exec(uas); 1112 1113 _osx = ver ? parseFloat(ver[1].replace('_', '.')) : true; 1114 } else { 1115 _osx = false; 1116 } 1117 _windows = !!os[2]; 1118 _linux = !!os[3]; 1119 } else { 1120 _osx = _windows = _linux = false; 1121 } 1122 } 1123 1124 var UserAgent_DEPRECATED = { 1125 1126 /** 1127 * Check if the UA is Internet Explorer. 1128 * 1129 * 1130 * @return float|NaN Version number (if match) or NaN. 1131 */ 1132 ie: function() { 1133 return _populate() || _ie; 1134 }, 1135 1136 /** 1137 * Check if we're in Internet Explorer compatibility mode. 1138 * 1139 * @return bool true if in compatibility mode, false if 1140 * not compatibility mode or not ie 1141 */ 1142 ieCompatibilityMode: function() { 1143 return _populate() || (_ie_real_version > _ie); 1144 }, 1145 1146 1147 /** 1148 * Whether the browser is 64-bit IE. Really, this is kind of weak sauce; we 1149 * only need this because Skype can't handle 64-bit IE yet. We need to remove 1150 * this when we don't need it -- tracked by #601957. 1151 */ 1152 ie64: function() { 1153 return UserAgent_DEPRECATED.ie() && _win64; 1154 }, 1155 1156 /** 1157 * Check if the UA is Firefox. 1158 * 1159 * 1160 * @return float|NaN Version number (if match) or NaN. 1161 */ 1162 firefox: function() { 1163 return _populate() || _firefox; 1164 }, 1165 1166 1167 /** 1168 * Check if the UA is Opera. 1169 * 1170 * 1171 * @return float|NaN Version number (if match) or NaN. 1172 */ 1173 opera: function() { 1174 return _populate() || _opera; 1175 }, 1176 1177 1178 /** 1179 * Check if the UA is WebKit. 1180 * 1181 * 1182 * @return float|NaN Version number (if match) or NaN. 1183 */ 1184 webkit: function() { 1185 return _populate() || _webkit; 1186 }, 1187 1188 /** 1189 * For Push 1190 * WILL BE REMOVED VERY SOON. Use UserAgent_DEPRECATED.webkit 1191 */ 1192 safari: function() { 1193 return UserAgent_DEPRECATED.webkit(); 1194 }, 1195 1196 /** 1197 * Check if the UA is a Chrome browser. 1198 * 1199 * 1200 * @return float|NaN Version number (if match) or NaN. 1201 */ 1202 chrome : function() { 1203 return _populate() || _chrome; 1204 }, 1205 1206 1207 /** 1208 * Check if the user is running Windows. 1209 * 1210 * @return bool `true' if the user's OS is Windows. 1211 */ 1212 windows: function() { 1213 return _populate() || _windows; 1214 }, 1215 1216 1217 /** 1218 * Check if the user is running Mac OS X. 1219 * 1220 * @return float|bool Returns a float if a version number is detected, 1221 * otherwise true/false. 1222 */ 1223 osx: function() { 1224 return _populate() || _osx; 1225 }, 1226 1227 /** 1228 * Check if the user is running Linux. 1229 * 1230 * @return bool `true' if the user's OS is some flavor of Linux. 1231 */ 1232 linux: function() { 1233 return _populate() || _linux; 1234 }, 1235 1236 /** 1237 * Check if the user is running on an iPhone or iPod platform. 1238 * 1239 * @return bool `true' if the user is running some flavor of the 1240 * iPhone OS. 1241 */ 1242 iphone: function() { 1243 return _populate() || _iphone; 1244 }, 1245 1246 mobile: function() { 1247 return _populate() || (_iphone || _ipad || _android || _mobile); 1248 }, 1249 1250 nativeApp: function() { 1251 // webviews inside of the native apps 1252 return _populate() || _native; 1253 }, 1254 1255 android: function() { 1256 return _populate() || _android; 1257 }, 1258 1259 ipad: function() { 1260 return _populate() || _ipad; 1261 } 1262 }; 1263 1264 module.exports = UserAgent_DEPRECATED; 1265 1266 1267 /***/ }), 1268 1269 /***/ 1087: 1270 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 1271 1272 "use strict"; 1273 /** 1274 * Copyright 2013-2015, Facebook, Inc. 1275 * All rights reserved. 1276 * 1277 * This source code is licensed under the BSD-style license found in the 1278 * LICENSE file in the root directory of this source tree. An additional grant 1279 * of patent rights can be found in the PATENTS file in the same directory. 1280 * 1281 * @providesModule isEventSupported 1282 */ 1283 1284 1285 1286 var ExecutionEnvironment = __webpack_require__(8202); 1287 1288 var useHasFeature; 1289 if (ExecutionEnvironment.canUseDOM) { 1290 useHasFeature = 1291 document.implementation && 1292 document.implementation.hasFeature && 1293 // always returns true in newer browsers as per the standard. 1294 // @see http://dom.spec.whatwg.org/#dom-domimplementation-hasfeature 1295 document.implementation.hasFeature('', '') !== true; 1296 } 1297 1298 /** 1299 * Checks if an event is supported in the current execution environment. 1300 * 1301 * NOTE: This will not work correctly for non-generic events such as `change`, 1302 * `reset`, `load`, `error`, and `select`. 1303 * 1304 * Borrows from Modernizr. 1305 * 1306 * @param {string} eventNameSuffix Event name, e.g. "click". 1307 * @param {?boolean} capture Check if the capture phase is supported. 1308 * @return {boolean} True if the event is supported. 1309 * @internal 1310 * @license Modernizr 3.0.0pre (Custom Build) | MIT 1311 */ 1312 function isEventSupported(eventNameSuffix, capture) { 1313 if (!ExecutionEnvironment.canUseDOM || 1314 capture && !('addEventListener' in document)) { 1315 return false; 1316 } 1317 1318 var eventName = 'on' + eventNameSuffix; 1319 var isSupported = eventName in document; 1320 1321 if (!isSupported) { 1322 var element = document.createElement('div'); 1323 element.setAttribute(eventName, 'return;'); 1324 isSupported = typeof element[eventName] === 'function'; 1325 } 1326 1327 if (!isSupported && useHasFeature && eventNameSuffix === 'wheel') { 1328 // This is the only way to test support for the `wheel` event in IE9+. 1329 isSupported = document.implementation.hasFeature('Events.wheel', '3.0'); 1330 } 1331 1332 return isSupported; 1333 } 1334 1335 module.exports = isEventSupported; 1336 1337 1338 /***/ }), 1339 1340 /***/ 7191: 1341 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 1342 1343 "use strict"; 1344 /** 1345 * Copyright (c) 2015, Facebook, Inc. 1346 * All rights reserved. 1347 * 1348 * This source code is licensed under the BSD-style license found in the 1349 * LICENSE file in the root directory of this source tree. An additional grant 1350 * of patent rights can be found in the PATENTS file in the same directory. 1351 * 1352 * @providesModule normalizeWheel 1353 * @typechecks 1354 */ 1355 1356 1357 1358 var UserAgent_DEPRECATED = __webpack_require__(2213); 1359 1360 var isEventSupported = __webpack_require__(1087); 1361 1362 1363 // Reasonable defaults 1364 var PIXEL_STEP = 10; 1365 var LINE_HEIGHT = 40; 1366 var PAGE_HEIGHT = 800; 1367 1368 /** 1369 * Mouse wheel (and 2-finger trackpad) support on the web sucks. It is 1370 * complicated, thus this doc is long and (hopefully) detailed enough to answer 1371 * your questions. 1372 * 1373 * If you need to react to the mouse wheel in a predictable way, this code is 1374 * like your bestest friend. * hugs * 1375 * 1376 * As of today, there are 4 DOM event types you can listen to: 1377 * 1378 * 'wheel' -- Chrome(31+), FF(17+), IE(9+) 1379 * 'mousewheel' -- Chrome, IE(6+), Opera, Safari 1380 * 'MozMousePixelScroll' -- FF(3.5 only!) (2010-2013) -- don't bother! 1381 * 'DOMMouseScroll' -- FF(0.9.7+) since 2003 1382 * 1383 * So what to do? The is the best: 1384 * 1385 * normalizeWheel.getEventType(); 1386 * 1387 * In your event callback, use this code to get sane interpretation of the 1388 * deltas. This code will return an object with properties: 1389 * 1390 * spinX -- normalized spin speed (use for zoom) - x plane 1391 * spinY -- " - y plane 1392 * pixelX -- normalized distance (to pixels) - x plane 1393 * pixelY -- " - y plane 1394 * 1395 * Wheel values are provided by the browser assuming you are using the wheel to 1396 * scroll a web page by a number of lines or pixels (or pages). Values can vary 1397 * significantly on different platforms and browsers, forgetting that you can 1398 * scroll at different speeds. Some devices (like trackpads) emit more events 1399 * at smaller increments with fine granularity, and some emit massive jumps with 1400 * linear speed or acceleration. 1401 * 1402 * This code does its best to normalize the deltas for you: 1403 * 1404 * - spin is trying to normalize how far the wheel was spun (or trackpad 1405 * dragged). This is super useful for zoom support where you want to 1406 * throw away the chunky scroll steps on the PC and make those equal to 1407 * the slow and smooth tiny steps on the Mac. Key data: This code tries to 1408 * resolve a single slow step on a wheel to 1. 1409 * 1410 * - pixel is normalizing the desired scroll delta in pixel units. You'll 1411 * get the crazy differences between browsers, but at least it'll be in 1412 * pixels! 1413 * 1414 * - positive value indicates scrolling DOWN/RIGHT, negative UP/LEFT. This 1415 * should translate to positive value zooming IN, negative zooming OUT. 1416 * This matches the newer 'wheel' event. 1417 * 1418 * Why are there spinX, spinY (or pixels)? 1419 * 1420 * - spinX is a 2-finger side drag on the trackpad, and a shift + wheel turn 1421 * with a mouse. It results in side-scrolling in the browser by default. 1422 * 1423 * - spinY is what you expect -- it's the classic axis of a mouse wheel. 1424 * 1425 * - I dropped spinZ/pixelZ. It is supported by the DOM 3 'wheel' event and 1426 * probably is by browsers in conjunction with fancy 3D controllers .. but 1427 * you know. 1428 * 1429 * Implementation info: 1430 * 1431 * Examples of 'wheel' event if you scroll slowly (down) by one step with an 1432 * average mouse: 1433 * 1434 * OS X + Chrome (mouse) - 4 pixel delta (wheelDelta -120) 1435 * OS X + Safari (mouse) - N/A pixel delta (wheelDelta -12) 1436 * OS X + Firefox (mouse) - 0.1 line delta (wheelDelta N/A) 1437 * Win8 + Chrome (mouse) - 100 pixel delta (wheelDelta -120) 1438 * Win8 + Firefox (mouse) - 3 line delta (wheelDelta -120) 1439 * 1440 * On the trackpad: 1441 * 1442 * OS X + Chrome (trackpad) - 2 pixel delta (wheelDelta -6) 1443 * OS X + Firefox (trackpad) - 1 pixel delta (wheelDelta N/A) 1444 * 1445 * On other/older browsers.. it's more complicated as there can be multiple and 1446 * also missing delta values. 1447 * 1448 * The 'wheel' event is more standard: 1449 * 1450 * http://www.w3.org/TR/DOM-Level-3-Events/#events-wheelevents 1451 * 1452 * The basics is that it includes a unit, deltaMode (pixels, lines, pages), and 1453 * deltaX, deltaY and deltaZ. Some browsers provide other values to maintain 1454 * backward compatibility with older events. Those other values help us 1455 * better normalize spin speed. Example of what the browsers provide: 1456 * 1457 * | event.wheelDelta | event.detail 1458 * ------------------+------------------+-------------- 1459 * Safari v5/OS X | -120 | 0 1460 * Safari v5/Win7 | -120 | 0 1461 * Chrome v17/OS X | -120 | 0 1462 * Chrome v17/Win7 | -120 | 0 1463 * IE9/Win7 | -120 | undefined 1464 * Firefox v4/OS X | undefined | 1 1465 * Firefox v4/Win7 | undefined | 3 1466 * 1467 */ 1468 function normalizeWheel(/*object*/ event) /*object*/ { 1469 var sX = 0, sY = 0, // spinX, spinY 1470 pX = 0, pY = 0; // pixelX, pixelY 1471 1472 // Legacy 1473 if ('detail' in event) { sY = event.detail; } 1474 if ('wheelDelta' in event) { sY = -event.wheelDelta / 120; } 1475 if ('wheelDeltaY' in event) { sY = -event.wheelDeltaY / 120; } 1476 if ('wheelDeltaX' in event) { sX = -event.wheelDeltaX / 120; } 1477 1478 // side scrolling on FF with DOMMouseScroll 1479 if ( 'axis' in event && event.axis === event.HORIZONTAL_AXIS ) { 1480 sX = sY; 1481 sY = 0; 1482 } 1483 1484 pX = sX * PIXEL_STEP; 1485 pY = sY * PIXEL_STEP; 1486 1487 if ('deltaY' in event) { pY = event.deltaY; } 1488 if ('deltaX' in event) { pX = event.deltaX; } 1489 1490 if ((pX || pY) && event.deltaMode) { 1491 if (event.deltaMode == 1) { // delta in LINE units 1492 pX *= LINE_HEIGHT; 1493 pY *= LINE_HEIGHT; 1494 } else { // delta in PAGE units 1495 pX *= PAGE_HEIGHT; 1496 pY *= PAGE_HEIGHT; 1497 } 1498 } 1499 1500 // Fall-back if spin cannot be determined 1501 if (pX && !sX) { sX = (pX < 1) ? -1 : 1; } 1502 if (pY && !sY) { sY = (pY < 1) ? -1 : 1; } 1503 1504 return { spinX : sX, 1505 spinY : sY, 1506 pixelX : pX, 1507 pixelY : pY }; 1508 } 1509 1510 1511 /** 1512 * The best combination if you prefer spinX + spinY normalization. It favors 1513 * the older DOMMouseScroll for Firefox, as FF does not include wheelDelta with 1514 * 'wheel' event, making spin speed determination impossible. 1515 */ 1516 normalizeWheel.getEventType = function() /*string*/ { 1517 return (UserAgent_DEPRECATED.firefox()) 1518 ? 'DOMMouseScroll' 1519 : (isEventSupported('wheel')) 1520 ? 'wheel' 1521 : 'mousewheel'; 1522 }; 1523 1524 module.exports = normalizeWheel; 1525 1526 1527 /***/ }), 1528 1529 /***/ 2775: 1530 /***/ ((module) => { 1531 1532 var x=String; 1533 var 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}}; 1534 module.exports=create(); 1535 module.exports.createColors = create; 1536 1537 1538 /***/ }), 1539 1540 /***/ 4465: 1541 /***/ ((__unused_webpack_module, exports) => { 1542 1543 "use strict"; 1544 1545 Object.defineProperty(exports, "__esModule", ({ value: true })); 1546 1547 1548 /***/ }), 1549 1550 /***/ 8036: 1551 /***/ (function(module, __unused_webpack_exports, __webpack_require__) { 1552 1553 "use strict"; 1554 1555 var __importDefault = (this && this.__importDefault) || function (mod) { 1556 return (mod && mod.__esModule) ? mod : { "default": mod }; 1557 }; 1558 __webpack_require__(4465); 1559 const postcss_1 = __importDefault(__webpack_require__(4529)); 1560 const PostCSSPlugin_1 = __importDefault(__webpack_require__(3576)); 1561 module.exports = (0, PostCSSPlugin_1.default)(postcss_1.default); 1562 1563 1564 /***/ }), 1565 1566 /***/ 5525: 1567 /***/ ((__unused_webpack_module, exports, __webpack_require__) => { 1568 1569 "use strict"; 1570 1571 Object.defineProperty(exports, "__esModule", ({ value: true })); 1572 exports.prefixWrapCSSSelector = exports.prefixWrapCSSRule = void 0; 1573 const CSSSelector_1 = __webpack_require__(3467); 1574 const prefixWrapCSSRule = (cssRule, nested, ignoredSelectors, prefixSelector, prefixRootTags) => { 1575 // Check each rule to see if it exactly matches our prefix selector, when 1576 // this happens, don't try to prefix that selector. 1577 const rules = cssRule.selectors.filter((selector) => !(0, CSSSelector_1.cssRuleMatchesPrefixSelector)({ selector: selector }, prefixSelector)); 1578 if (rules.length === 0) { 1579 return; 1580 } 1581 cssRule.selector = rules 1582 .map((cssSelector) => (0, exports.prefixWrapCSSSelector)(cssSelector, cssRule, nested, ignoredSelectors, prefixSelector, prefixRootTags)) 1583 .filter(CSSSelector_1.isValidCSSSelector) 1584 .join(", "); 1585 }; 1586 exports.prefixWrapCSSRule = prefixWrapCSSRule; 1587 const prefixWrapCSSSelector = (cssSelector, cssRule, nested, ignoredSelectors, prefixSelector, prefixRootTags) => { 1588 const cleanedSelector = (0, CSSSelector_1.cleanSelector)(cssSelector); 1589 if (cleanedSelector === "") { 1590 return null; 1591 } 1592 // Don't prefix nested selected. 1593 if (nested !== null && cleanedSelector.startsWith(nested, 0)) { 1594 return cleanedSelector; 1595 } 1596 // Do not prefix keyframes rules. 1597 if ((0, CSSSelector_1.isKeyframes)(cssRule)) { 1598 return cleanedSelector; 1599 } 1600 // Check for matching ignored selectors 1601 if (ignoredSelectors.some((currentValue) => cleanedSelector.match(currentValue))) { 1602 return cleanedSelector; 1603 } 1604 // Anything other than a root tag is always prefixed. 1605 if ((0, CSSSelector_1.isNotRootTag)(cleanedSelector)) { 1606 return prefixSelector + " " + cleanedSelector; 1607 } 1608 // Handle special case where root tags should be converted into classes 1609 // rather than being replaced. 1610 if (prefixRootTags) { 1611 return prefixSelector + " ." + cleanedSelector; 1612 } 1613 // HTML and Body elements cannot be contained within our container so lets 1614 // extract their styles. 1615 return cleanedSelector.replace(/^(body|html|:root)/, prefixSelector); 1616 }; 1617 exports.prefixWrapCSSSelector = prefixWrapCSSSelector; 1618 1619 1620 /***/ }), 1621 1622 /***/ 3467: 1623 /***/ ((__unused_webpack_module, exports) => { 1624 1625 "use strict"; 1626 1627 Object.defineProperty(exports, "__esModule", ({ value: true })); 1628 exports.cssRuleMatchesPrefixSelector = exports.isNotRootTag = exports.isKeyframes = exports.cleanSelector = exports.isValidCSSSelector = void 0; 1629 const ANY_WHITESPACE_AT_BEGINNING_OR_END = /(^\s*|\s*$)/g; 1630 const IS_ROOT_TAG = /^(body|html|:root).*$/; 1631 const isValidCSSSelector = (cssSelector) => { 1632 return cssSelector !== null; 1633 }; 1634 exports.isValidCSSSelector = isValidCSSSelector; 1635 const cleanSelector = (cssSelector) => { 1636 return cssSelector.replace(ANY_WHITESPACE_AT_BEGINNING_OR_END, ""); 1637 }; 1638 exports.cleanSelector = cleanSelector; 1639 const isKeyframes = (cssRule) => { 1640 const { parent } = cssRule; 1641 const parentReal = parent; 1642 // @see https://developer.mozilla.org/en-US/docs/Web/CSS/At-rule 1643 return (parent !== undefined && 1644 parentReal.type === "atrule" && 1645 parentReal.name !== undefined && 1646 parentReal.name.match(/keyframes$/) !== null); 1647 }; 1648 exports.isKeyframes = isKeyframes; 1649 const isNotRootTag = (cleanSelector) => { 1650 return !cleanSelector.match(IS_ROOT_TAG); 1651 }; 1652 exports.isNotRootTag = isNotRootTag; 1653 const cssRuleMatchesPrefixSelector = (cssRule, prefixSelector) => { 1654 const escapedPrefixSelector = prefixSelector.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); 1655 // eslint-disable-next-line security-node/non-literal-reg-expr 1656 const isPrefixSelector = new RegExp(`^$escapedPrefixSelector}$`); 1657 return isPrefixSelector.test(cssRule.selector); 1658 }; 1659 exports.cssRuleMatchesPrefixSelector = cssRuleMatchesPrefixSelector; 1660 1661 1662 /***/ }), 1663 1664 /***/ 9411: 1665 /***/ ((__unused_webpack_module, exports) => { 1666 1667 "use strict"; 1668 1669 Object.defineProperty(exports, "__esModule", ({ value: true })); 1670 exports.shouldIncludeFilePath = void 0; 1671 const shouldIncludeFilePath = (filePath, whitelist, blacklist) => { 1672 // If whitelist exists, check if rule is contained within it. 1673 if (whitelist.length > 0) { 1674 return (filePath != undefined && 1675 whitelist.some((currentValue) => filePath.match(currentValue))); 1676 } 1677 // If blacklist exists, check if rule is not contained within it. 1678 if (blacklist.length > 0) { 1679 return !(filePath != undefined && 1680 blacklist.some((currentValue) => filePath.match(currentValue))); 1681 } 1682 // In all other cases, presume rule should be prefixed. 1683 return true; 1684 }; 1685 exports.shouldIncludeFilePath = shouldIncludeFilePath; 1686 1687 1688 /***/ }), 1689 1690 /***/ 8061: 1691 /***/ (function(__unused_webpack_module, exports, __webpack_require__) { 1692 1693 "use strict"; 1694 1695 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { 1696 if (k2 === undefined) k2 = k; 1697 var desc = Object.getOwnPropertyDescriptor(m, k); 1698 if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { 1699 desc = { enumerable: true, get: function() { return m[k]; } }; 1700 } 1701 Object.defineProperty(o, k2, desc); 1702 }) : (function(o, m, k, k2) { 1703 if (k2 === undefined) k2 = k; 1704 o[k2] = m[k]; 1705 })); 1706 var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { 1707 Object.defineProperty(o, "default", { enumerable: true, value: v }); 1708 }) : function(o, v) { 1709 o["default"] = v; 1710 }); 1711 var __importStar = (this && this.__importStar) || function (mod) { 1712 if (mod && mod.__esModule) return mod; 1713 var result = {}; 1714 if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); 1715 __setModuleDefault(result, mod); 1716 return result; 1717 }; 1718 Object.defineProperty(exports, "__esModule", ({ value: true })); 1719 exports.asPostCSSv7PluginGenerator = void 0; 1720 const PostCSSPrefixWrap_1 = __importStar(__webpack_require__(1311)); 1721 const asPostCSSv7PluginGenerator = (postcss) => { 1722 return postcss.plugin(PostCSSPrefixWrap_1.PLUGIN_NAME, (prefixSelector, options) => { 1723 return new PostCSSPrefixWrap_1.default(prefixSelector, options).prefix(); 1724 }); 1725 }; 1726 exports.asPostCSSv7PluginGenerator = asPostCSSv7PluginGenerator; 1727 1728 1729 /***/ }), 1730 1731 /***/ 2888: 1732 /***/ (function(__unused_webpack_module, exports, __webpack_require__) { 1733 1734 "use strict"; 1735 1736 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { 1737 if (k2 === undefined) k2 = k; 1738 var desc = Object.getOwnPropertyDescriptor(m, k); 1739 if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { 1740 desc = { enumerable: true, get: function() { return m[k]; } }; 1741 } 1742 Object.defineProperty(o, k2, desc); 1743 }) : (function(o, m, k, k2) { 1744 if (k2 === undefined) k2 = k; 1745 o[k2] = m[k]; 1746 })); 1747 var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { 1748 Object.defineProperty(o, "default", { enumerable: true, value: v }); 1749 }) : function(o, v) { 1750 o["default"] = v; 1751 }); 1752 var __importStar = (this && this.__importStar) || function (mod) { 1753 if (mod && mod.__esModule) return mod; 1754 var result = {}; 1755 if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); 1756 __setModuleDefault(result, mod); 1757 return result; 1758 }; 1759 Object.defineProperty(exports, "__esModule", ({ value: true })); 1760 exports.asPostCSSv8PluginGenerator = exports.isPostCSSv8 = void 0; 1761 const PostCSSPrefixWrap_1 = __importStar(__webpack_require__(1311)); 1762 const isPostCSSv8 = (postcss) => postcss.Root !== undefined; 1763 exports.isPostCSSv8 = isPostCSSv8; 1764 const asPostCSSv8PluginGenerator = () => { 1765 return (prefixSelector, options) => { 1766 const plugin = new PostCSSPrefixWrap_1.default(prefixSelector, options); 1767 return { 1768 postcssPlugin: PostCSSPrefixWrap_1.PLUGIN_NAME, 1769 Once(root) { 1770 plugin.prefixRoot(root); 1771 }, 1772 }; 1773 }; 1774 }; 1775 exports.asPostCSSv8PluginGenerator = asPostCSSv8PluginGenerator; 1776 1777 1778 /***/ }), 1779 1780 /***/ 3576: 1781 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 1782 1783 "use strict"; 1784 1785 const PostCSS8Plugin_1 = __webpack_require__(2888); 1786 const PostCSS7Plugin_1 = __webpack_require__(8061); 1787 module.exports = (postcss) => { 1788 if ((0, PostCSS8Plugin_1.isPostCSSv8)(postcss)) { 1789 return (0, PostCSS8Plugin_1.asPostCSSv8PluginGenerator)(); 1790 } 1791 else { 1792 return (0, PostCSS7Plugin_1.asPostCSSv7PluginGenerator)(postcss); 1793 } 1794 }; 1795 1796 1797 /***/ }), 1798 1799 /***/ 1311: 1800 /***/ ((__unused_webpack_module, exports, __webpack_require__) => { 1801 1802 "use strict"; 1803 1804 Object.defineProperty(exports, "__esModule", ({ value: true })); 1805 exports.PLUGIN_NAME = void 0; 1806 const CSSRuleWrapper_1 = __webpack_require__(5525); 1807 const FileIncludeList_1 = __webpack_require__(9411); 1808 exports.PLUGIN_NAME = "postcss-prefixwrap"; 1809 class PostCSSPrefixWrap { 1810 blacklist; 1811 ignoredSelectors; 1812 isPrefixSelector; 1813 prefixRootTags; 1814 prefixSelector; 1815 whitelist; 1816 nested; 1817 constructor(prefixSelector, options = {}) { 1818 this.blacklist = options.blacklist ?? []; 1819 this.ignoredSelectors = options.ignoredSelectors ?? []; 1820 this.isPrefixSelector = new RegExp( 1821 // eslint-disable-next-line security-node/non-literal-reg-expr 1822 `^$prefixSelector.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`); 1823 this.prefixRootTags = options.prefixRootTags ?? false; 1824 this.prefixSelector = prefixSelector; 1825 this.whitelist = options.whitelist ?? []; 1826 this.nested = options.nested ?? null; 1827 } 1828 prefixRoot(css) { 1829 if ((0, FileIncludeList_1.shouldIncludeFilePath)(css.source?.input?.file, this.whitelist, this.blacklist)) { 1830 css.walkRules((cssRule) => { 1831 (0, CSSRuleWrapper_1.prefixWrapCSSRule)(cssRule, this.nested, this.ignoredSelectors, this.prefixSelector, this.prefixRootTags); 1832 }); 1833 } 1834 } 1835 prefix() { 1836 return (css) => { 1837 this.prefixRoot(css); 1838 }; 1839 } 1840 } 1841 exports["default"] = PostCSSPrefixWrap; 1842 1843 1844 /***/ }), 1845 1846 /***/ 5404: 1847 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 1848 1849 const CSSValueParser = __webpack_require__(1544) 1850 1851 /** 1852 * @type {import('postcss').PluginCreator} 1853 */ 1854 module.exports = (opts) => { 1855 1856 const DEFAULTS = { 1857 skipHostRelativeUrls: true, 1858 } 1859 const config = Object.assign(DEFAULTS, opts) 1860 1861 return { 1862 postcssPlugin: 'rebaseUrl', 1863 1864 Declaration(decl) { 1865 // The faster way to find Declaration node 1866 const parsedValue = CSSValueParser(decl.value) 1867 1868 let valueChanged = false 1869 parsedValue.walk(node => { 1870 if (node.type !== 'function' || node.value !== 'url') { 1871 return 1872 } 1873 1874 const urlVal = node.nodes[0].value 1875 1876 // bases relative URLs with rootUrl 1877 const basedUrl = new URL(urlVal, opts.rootUrl) 1878 1879 // skip host-relative, already normalized URLs (e.g. `/images/image.jpg`, without `..`s) 1880 if ((basedUrl.pathname === urlVal) && config.skipHostRelativeUrls) { 1881 return false // skip this value 1882 } 1883 1884 node.nodes[0].value = basedUrl.toString() 1885 valueChanged = true 1886 1887 return false // do not walk deeper 1888 }) 1889 1890 if (valueChanged) { 1891 decl.value = CSSValueParser.stringify(parsedValue) 1892 } 1893 1894 } 1895 } 1896 } 1897 1898 module.exports.postcss = true 1899 1900 1901 /***/ }), 1902 1903 /***/ 1544: 1904 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 1905 1906 var parse = __webpack_require__(8491); 1907 var walk = __webpack_require__(3815); 1908 var stringify = __webpack_require__(4725); 1909 1910 function ValueParser(value) { 1911 if (this instanceof ValueParser) { 1912 this.nodes = parse(value); 1913 return this; 1914 } 1915 return new ValueParser(value); 1916 } 1917 1918 ValueParser.prototype.toString = function() { 1919 return Array.isArray(this.nodes) ? stringify(this.nodes) : ""; 1920 }; 1921 1922 ValueParser.prototype.walk = function(cb, bubble) { 1923 walk(this.nodes, cb, bubble); 1924 return this; 1925 }; 1926 1927 ValueParser.unit = __webpack_require__(1524); 1928 1929 ValueParser.walk = walk; 1930 1931 ValueParser.stringify = stringify; 1932 1933 module.exports = ValueParser; 1934 1935 1936 /***/ }), 1937 1938 /***/ 8491: 1939 /***/ ((module) => { 1940 1941 var openParentheses = "(".charCodeAt(0); 1942 var closeParentheses = ")".charCodeAt(0); 1943 var singleQuote = "'".charCodeAt(0); 1944 var doubleQuote = '"'.charCodeAt(0); 1945 var backslash = "\\".charCodeAt(0); 1946 var slash = "/".charCodeAt(0); 1947 var comma = ",".charCodeAt(0); 1948 var colon = ":".charCodeAt(0); 1949 var star = "*".charCodeAt(0); 1950 var uLower = "u".charCodeAt(0); 1951 var uUpper = "U".charCodeAt(0); 1952 var plus = "+".charCodeAt(0); 1953 var isUnicodeRange = /^[a-f0-9?-]+$/i; 1954 1955 module.exports = function(input) { 1956 var tokens = []; 1957 var value = input; 1958 1959 var next, 1960 quote, 1961 prev, 1962 token, 1963 escape, 1964 escapePos, 1965 whitespacePos, 1966 parenthesesOpenPos; 1967 var pos = 0; 1968 var code = value.charCodeAt(pos); 1969 var max = value.length; 1970 var stack = [{ nodes: tokens }]; 1971 var balanced = 0; 1972 var parent; 1973 1974 var name = ""; 1975 var before = ""; 1976 var after = ""; 1977 1978 while (pos < max) { 1979 // Whitespaces 1980 if (code <= 32) { 1981 next = pos; 1982 do { 1983 next += 1; 1984 code = value.charCodeAt(next); 1985 } while (code <= 32); 1986 token = value.slice(pos, next); 1987 1988 prev = tokens[tokens.length - 1]; 1989 if (code === closeParentheses && balanced) { 1990 after = token; 1991 } else if (prev && prev.type === "div") { 1992 prev.after = token; 1993 prev.sourceEndIndex += token.length; 1994 } else if ( 1995 code === comma || 1996 code === colon || 1997 (code === slash && 1998 value.charCodeAt(next + 1) !== star && 1999 (!parent || 2000 (parent && parent.type === "function" && parent.value !== "calc"))) 2001 ) { 2002 before = token; 2003 } else { 2004 tokens.push({ 2005 type: "space", 2006 sourceIndex: pos, 2007 sourceEndIndex: next, 2008 value: token 2009 }); 2010 } 2011 2012 pos = next; 2013 2014 // Quotes 2015 } else if (code === singleQuote || code === doubleQuote) { 2016 next = pos; 2017 quote = code === singleQuote ? "'" : '"'; 2018 token = { 2019 type: "string", 2020 sourceIndex: pos, 2021 quote: quote 2022 }; 2023 do { 2024 escape = false; 2025 next = value.indexOf(quote, next + 1); 2026 if (~next) { 2027 escapePos = next; 2028 while (value.charCodeAt(escapePos - 1) === backslash) { 2029 escapePos -= 1; 2030 escape = !escape; 2031 } 2032 } else { 2033 value += quote; 2034 next = value.length - 1; 2035 token.unclosed = true; 2036 } 2037 } while (escape); 2038 token.value = value.slice(pos + 1, next); 2039 token.sourceEndIndex = token.unclosed ? next : next + 1; 2040 tokens.push(token); 2041 pos = next + 1; 2042 code = value.charCodeAt(pos); 2043 2044 // Comments 2045 } else if (code === slash && value.charCodeAt(pos + 1) === star) { 2046 next = value.indexOf("*/", pos); 2047 2048 token = { 2049 type: "comment", 2050 sourceIndex: pos, 2051 sourceEndIndex: next + 2 2052 }; 2053 2054 if (next === -1) { 2055 token.unclosed = true; 2056 next = value.length; 2057 token.sourceEndIndex = next; 2058 } 2059 2060 token.value = value.slice(pos + 2, next); 2061 tokens.push(token); 2062 2063 pos = next + 2; 2064 code = value.charCodeAt(pos); 2065 2066 // Operation within calc 2067 } else if ( 2068 (code === slash || code === star) && 2069 parent && 2070 parent.type === "function" && 2071 parent.value === "calc" 2072 ) { 2073 token = value[pos]; 2074 tokens.push({ 2075 type: "word", 2076 sourceIndex: pos - before.length, 2077 sourceEndIndex: pos + token.length, 2078 value: token 2079 }); 2080 pos += 1; 2081 code = value.charCodeAt(pos); 2082 2083 // Dividers 2084 } else if (code === slash || code === comma || code === colon) { 2085 token = value[pos]; 2086 2087 tokens.push({ 2088 type: "div", 2089 sourceIndex: pos - before.length, 2090 sourceEndIndex: pos + token.length, 2091 value: token, 2092 before: before, 2093 after: "" 2094 }); 2095 before = ""; 2096 2097 pos += 1; 2098 code = value.charCodeAt(pos); 2099 2100 // Open parentheses 2101 } else if (openParentheses === code) { 2102 // Whitespaces after open parentheses 2103 next = pos; 2104 do { 2105 next += 1; 2106 code = value.charCodeAt(next); 2107 } while (code <= 32); 2108 parenthesesOpenPos = pos; 2109 token = { 2110 type: "function", 2111 sourceIndex: pos - name.length, 2112 value: name, 2113 before: value.slice(parenthesesOpenPos + 1, next) 2114 }; 2115 pos = next; 2116 2117 if (name === "url" && code !== singleQuote && code !== doubleQuote) { 2118 next -= 1; 2119 do { 2120 escape = false; 2121 next = value.indexOf(")", next + 1); 2122 if (~next) { 2123 escapePos = next; 2124 while (value.charCodeAt(escapePos - 1) === backslash) { 2125 escapePos -= 1; 2126 escape = !escape; 2127 } 2128 } else { 2129 value += ")"; 2130 next = value.length - 1; 2131 token.unclosed = true; 2132 } 2133 } while (escape); 2134 // Whitespaces before closed 2135 whitespacePos = next; 2136 do { 2137 whitespacePos -= 1; 2138 code = value.charCodeAt(whitespacePos); 2139 } while (code <= 32); 2140 if (parenthesesOpenPos < whitespacePos) { 2141 if (pos !== whitespacePos + 1) { 2142 token.nodes = [ 2143 { 2144 type: "word", 2145 sourceIndex: pos, 2146 sourceEndIndex: whitespacePos + 1, 2147 value: value.slice(pos, whitespacePos + 1) 2148 } 2149 ]; 2150 } else { 2151 token.nodes = []; 2152 } 2153 if (token.unclosed && whitespacePos + 1 !== next) { 2154 token.after = ""; 2155 token.nodes.push({ 2156 type: "space", 2157 sourceIndex: whitespacePos + 1, 2158 sourceEndIndex: next, 2159 value: value.slice(whitespacePos + 1, next) 2160 }); 2161 } else { 2162 token.after = value.slice(whitespacePos + 1, next); 2163 token.sourceEndIndex = next; 2164 } 2165 } else { 2166 token.after = ""; 2167 token.nodes = []; 2168 } 2169 pos = next + 1; 2170 token.sourceEndIndex = token.unclosed ? next : pos; 2171 code = value.charCodeAt(pos); 2172 tokens.push(token); 2173 } else { 2174 balanced += 1; 2175 token.after = ""; 2176 token.sourceEndIndex = pos + 1; 2177 tokens.push(token); 2178 stack.push(token); 2179 tokens = token.nodes = []; 2180 parent = token; 2181 } 2182 name = ""; 2183 2184 // Close parentheses 2185 } else if (closeParentheses === code && balanced) { 2186 pos += 1; 2187 code = value.charCodeAt(pos); 2188 2189 parent.after = after; 2190 parent.sourceEndIndex += after.length; 2191 after = ""; 2192 balanced -= 1; 2193 stack[stack.length - 1].sourceEndIndex = pos; 2194 stack.pop(); 2195 parent = stack[balanced]; 2196 tokens = parent.nodes; 2197 2198 // Words 2199 } else { 2200 next = pos; 2201 do { 2202 if (code === backslash) { 2203 next += 1; 2204 } 2205 next += 1; 2206 code = value.charCodeAt(next); 2207 } while ( 2208 next < max && 2209 !( 2210 code <= 32 || 2211 code === singleQuote || 2212 code === doubleQuote || 2213 code === comma || 2214 code === colon || 2215 code === slash || 2216 code === openParentheses || 2217 (code === star && 2218 parent && 2219 parent.type === "function" && 2220 parent.value === "calc") || 2221 (code === slash && 2222 parent.type === "function" && 2223 parent.value === "calc") || 2224 (code === closeParentheses && balanced) 2225 ) 2226 ); 2227 token = value.slice(pos, next); 2228 2229 if (openParentheses === code) { 2230 name = token; 2231 } else if ( 2232 (uLower === token.charCodeAt(0) || uUpper === token.charCodeAt(0)) && 2233 plus === token.charCodeAt(1) && 2234 isUnicodeRange.test(token.slice(2)) 2235 ) { 2236 tokens.push({ 2237 type: "unicode-range", 2238 sourceIndex: pos, 2239 sourceEndIndex: next, 2240 value: token 2241 }); 2242 } else { 2243 tokens.push({ 2244 type: "word", 2245 sourceIndex: pos, 2246 sourceEndIndex: next, 2247 value: token 2248 }); 2249 } 2250 2251 pos = next; 2252 } 2253 } 2254 2255 for (pos = stack.length - 1; pos; pos -= 1) { 2256 stack[pos].unclosed = true; 2257 stack[pos].sourceEndIndex = value.length; 2258 } 2259 2260 return stack[0].nodes; 2261 }; 2262 2263 2264 /***/ }), 2265 2266 /***/ 4725: 2267 /***/ ((module) => { 2268 2269 function stringifyNode(node, custom) { 2270 var type = node.type; 2271 var value = node.value; 2272 var buf; 2273 var customResult; 2274 2275 if (custom && (customResult = custom(node)) !== undefined) { 2276 return customResult; 2277 } else if (type === "word" || type === "space") { 2278 return value; 2279 } else if (type === "string") { 2280 buf = node.quote || ""; 2281 return buf + value + (node.unclosed ? "" : buf); 2282 } else if (type === "comment") { 2283 return "/*" + value + (node.unclosed ? "" : "*/"); 2284 } else if (type === "div") { 2285 return (node.before || "") + value + (node.after || ""); 2286 } else if (Array.isArray(node.nodes)) { 2287 buf = stringify(node.nodes, custom); 2288 if (type !== "function") { 2289 return buf; 2290 } 2291 return ( 2292 value + 2293 "(" + 2294 (node.before || "") + 2295 buf + 2296 (node.after || "") + 2297 (node.unclosed ? "" : ")") 2298 ); 2299 } 2300 return value; 2301 } 2302 2303 function stringify(nodes, custom) { 2304 var result, i; 2305 2306 if (Array.isArray(nodes)) { 2307 result = ""; 2308 for (i = nodes.length - 1; ~i; i -= 1) { 2309 result = stringifyNode(nodes[i], custom) + result; 2310 } 2311 return result; 2312 } 2313 return stringifyNode(nodes, custom); 2314 } 2315 2316 module.exports = stringify; 2317 2318 2319 /***/ }), 2320 2321 /***/ 1524: 2322 /***/ ((module) => { 2323 2324 var minus = "-".charCodeAt(0); 2325 var plus = "+".charCodeAt(0); 2326 var dot = ".".charCodeAt(0); 2327 var exp = "e".charCodeAt(0); 2328 var EXP = "E".charCodeAt(0); 2329 2330 // Check if three code points would start a number 2331 // https://www.w3.org/TR/css-syntax-3/#starts-with-a-number 2332 function likeNumber(value) { 2333 var code = value.charCodeAt(0); 2334 var nextCode; 2335 2336 if (code === plus || code === minus) { 2337 nextCode = value.charCodeAt(1); 2338 2339 if (nextCode >= 48 && nextCode <= 57) { 2340 return true; 2341 } 2342 2343 var nextNextCode = value.charCodeAt(2); 2344 2345 if (nextCode === dot && nextNextCode >= 48 && nextNextCode <= 57) { 2346 return true; 2347 } 2348 2349 return false; 2350 } 2351 2352 if (code === dot) { 2353 nextCode = value.charCodeAt(1); 2354 2355 if (nextCode >= 48 && nextCode <= 57) { 2356 return true; 2357 } 2358 2359 return false; 2360 } 2361 2362 if (code >= 48 && code <= 57) { 2363 return true; 2364 } 2365 2366 return false; 2367 } 2368 2369 // Consume a number 2370 // https://www.w3.org/TR/css-syntax-3/#consume-number 2371 module.exports = function(value) { 2372 var pos = 0; 2373 var length = value.length; 2374 var code; 2375 var nextCode; 2376 var nextNextCode; 2377 2378 if (length === 0 || !likeNumber(value)) { 2379 return false; 2380 } 2381 2382 code = value.charCodeAt(pos); 2383 2384 if (code === plus || code === minus) { 2385 pos++; 2386 } 2387 2388 while (pos < length) { 2389 code = value.charCodeAt(pos); 2390 2391 if (code < 48 || code > 57) { 2392 break; 2393 } 2394 2395 pos += 1; 2396 } 2397 2398 code = value.charCodeAt(pos); 2399 nextCode = value.charCodeAt(pos + 1); 2400 2401 if (code === dot && nextCode >= 48 && nextCode <= 57) { 2402 pos += 2; 2403 2404 while (pos < length) { 2405 code = value.charCodeAt(pos); 2406 2407 if (code < 48 || code > 57) { 2408 break; 2409 } 2410 2411 pos += 1; 2412 } 2413 } 2414 2415 code = value.charCodeAt(pos); 2416 nextCode = value.charCodeAt(pos + 1); 2417 nextNextCode = value.charCodeAt(pos + 2); 2418 2419 if ( 2420 (code === exp || code === EXP) && 2421 ((nextCode >= 48 && nextCode <= 57) || 2422 ((nextCode === plus || nextCode === minus) && 2423 nextNextCode >= 48 && 2424 nextNextCode <= 57)) 2425 ) { 2426 pos += nextCode === plus || nextCode === minus ? 3 : 2; 2427 2428 while (pos < length) { 2429 code = value.charCodeAt(pos); 2430 2431 if (code < 48 || code > 57) { 2432 break; 2433 } 2434 2435 pos += 1; 2436 } 2437 } 2438 2439 return { 2440 number: value.slice(0, pos), 2441 unit: value.slice(pos) 2442 }; 2443 }; 2444 2445 2446 /***/ }), 2447 2448 /***/ 3815: 2449 /***/ ((module) => { 2450 2451 module.exports = function walk(nodes, cb, bubble) { 2452 var i, max, node, result; 2453 2454 for (i = 0, max = nodes.length; i < max; i += 1) { 2455 node = nodes[i]; 2456 if (!bubble) { 2457 result = cb(node, i, nodes); 2458 } 2459 2460 if ( 2461 result !== false && 2462 node.type === "function" && 2463 Array.isArray(node.nodes) 2464 ) { 2465 walk(node.nodes, cb, bubble); 2466 } 2467 2468 if (bubble) { 2469 cb(node, i, nodes); 2470 } 2471 } 2472 }; 2473 2474 2475 /***/ }), 2476 2477 /***/ 1326: 2478 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 2479 2480 "use strict"; 2481 2482 2483 let Container = __webpack_require__(683) 2484 2485 class AtRule extends Container { 2486 constructor(defaults) { 2487 super(defaults) 2488 this.type = 'atrule' 2489 } 2490 2491 append(...children) { 2492 if (!this.proxyOf.nodes) this.nodes = [] 2493 return super.append(...children) 2494 } 2495 2496 prepend(...children) { 2497 if (!this.proxyOf.nodes) this.nodes = [] 2498 return super.prepend(...children) 2499 } 2500 } 2501 2502 module.exports = AtRule 2503 AtRule.default = AtRule 2504 2505 Container.registerAtRule(AtRule) 2506 2507 2508 /***/ }), 2509 2510 /***/ 6589: 2511 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 2512 2513 "use strict"; 2514 2515 2516 let Node = __webpack_require__(7490) 2517 2518 class Comment extends Node { 2519 constructor(defaults) { 2520 super(defaults) 2521 this.type = 'comment' 2522 } 2523 } 2524 2525 module.exports = Comment 2526 Comment.default = Comment 2527 2528 2529 /***/ }), 2530 2531 /***/ 683: 2532 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 2533 2534 "use strict"; 2535 2536 2537 let { isClean, my } = __webpack_require__(1381) 2538 let Declaration = __webpack_require__(1516) 2539 let Comment = __webpack_require__(6589) 2540 let Node = __webpack_require__(7490) 2541 2542 let parse, Rule, AtRule, Root 2543 2544 function cleanSource(nodes) { 2545 return nodes.map(i => { 2546 if (i.nodes) i.nodes = cleanSource(i.nodes) 2547 delete i.source 2548 return i 2549 }) 2550 } 2551 2552 function markDirtyUp(node) { 2553 node[isClean] = false 2554 if (node.proxyOf.nodes) { 2555 for (let i of node.proxyOf.nodes) { 2556 markDirtyUp(i) 2557 } 2558 } 2559 } 2560 2561 class Container extends Node { 2562 append(...children) { 2563 for (let child of children) { 2564 let nodes = this.normalize(child, this.last) 2565 for (let node of nodes) this.proxyOf.nodes.push(node) 2566 } 2567 2568 this.markDirty() 2569 2570 return this 2571 } 2572 2573 cleanRaws(keepBetween) { 2574 super.cleanRaws(keepBetween) 2575 if (this.nodes) { 2576 for (let node of this.nodes) node.cleanRaws(keepBetween) 2577 } 2578 } 2579 2580 each(callback) { 2581 if (!this.proxyOf.nodes) return undefined 2582 let iterator = this.getIterator() 2583 2584 let index, result 2585 while (this.indexes[iterator] < this.proxyOf.nodes.length) { 2586 index = this.indexes[iterator] 2587 result = callback(this.proxyOf.nodes[index], index) 2588 if (result === false) break 2589 2590 this.indexes[iterator] += 1 2591 } 2592 2593 delete this.indexes[iterator] 2594 return result 2595 } 2596 2597 every(condition) { 2598 return this.nodes.every(condition) 2599 } 2600 2601 getIterator() { 2602 if (!this.lastEach) this.lastEach = 0 2603 if (!this.indexes) this.indexes = {} 2604 2605 this.lastEach += 1 2606 let iterator = this.lastEach 2607 this.indexes[iterator] = 0 2608 2609 return iterator 2610 } 2611 2612 getProxyProcessor() { 2613 return { 2614 get(node, prop) { 2615 if (prop === 'proxyOf') { 2616 return node 2617 } else if (!node[prop]) { 2618 return node[prop] 2619 } else if ( 2620 prop === 'each' || 2621 (typeof prop === 'string' && prop.startsWith('walk')) 2622 ) { 2623 return (...args) => { 2624 return node[prop]( 2625 ...args.map(i => { 2626 if (typeof i === 'function') { 2627 return (child, index) => i(child.toProxy(), index) 2628 } else { 2629 return i 2630 } 2631 }) 2632 ) 2633 } 2634 } else if (prop === 'every' || prop === 'some') { 2635 return cb => { 2636 return node[prop]((child, ...other) => 2637 cb(child.toProxy(), ...other) 2638 ) 2639 } 2640 } else if (prop === 'root') { 2641 return () => node.root().toProxy() 2642 } else if (prop === 'nodes') { 2643 return node.nodes.map(i => i.toProxy()) 2644 } else if (prop === 'first' || prop === 'last') { 2645 return node[prop].toProxy() 2646 } else { 2647 return node[prop] 2648 } 2649 }, 2650 2651 set(node, prop, value) { 2652 if (node[prop] === value) return true 2653 node[prop] = value 2654 if (prop === 'name' || prop === 'params' || prop === 'selector') { 2655 node.markDirty() 2656 } 2657 return true 2658 } 2659 } 2660 } 2661 2662 index(child) { 2663 if (typeof child === 'number') return child 2664 if (child.proxyOf) child = child.proxyOf 2665 return this.proxyOf.nodes.indexOf(child) 2666 } 2667 2668 insertAfter(exist, add) { 2669 let existIndex = this.index(exist) 2670 let nodes = this.normalize(add, this.proxyOf.nodes[existIndex]).reverse() 2671 existIndex = this.index(exist) 2672 for (let node of nodes) this.proxyOf.nodes.splice(existIndex + 1, 0, node) 2673 2674 let index 2675 for (let id in this.indexes) { 2676 index = this.indexes[id] 2677 if (existIndex < index) { 2678 this.indexes[id] = index + nodes.length 2679 } 2680 } 2681 2682 this.markDirty() 2683 2684 return this 2685 } 2686 2687 insertBefore(exist, add) { 2688 let existIndex = this.index(exist) 2689 let type = existIndex === 0 ? 'prepend' : false 2690 let nodes = this.normalize(add, this.proxyOf.nodes[existIndex], type).reverse() 2691 existIndex = this.index(exist) 2692 for (let node of nodes) this.proxyOf.nodes.splice(existIndex, 0, node) 2693 2694 let index 2695 for (let id in this.indexes) { 2696 index = this.indexes[id] 2697 if (existIndex <= index) { 2698 this.indexes[id] = index + nodes.length 2699 } 2700 } 2701 2702 this.markDirty() 2703 2704 return this 2705 } 2706 2707 normalize(nodes, sample) { 2708 if (typeof nodes === 'string') { 2709 nodes = cleanSource(parse(nodes).nodes) 2710 } else if (typeof nodes === 'undefined') { 2711 nodes = [] 2712 } else if (Array.isArray(nodes)) { 2713 nodes = nodes.slice(0) 2714 for (let i of nodes) { 2715 if (i.parent) i.parent.removeChild(i, 'ignore') 2716 } 2717 } else if (nodes.type === 'root' && this.type !== 'document') { 2718 nodes = nodes.nodes.slice(0) 2719 for (let i of nodes) { 2720 if (i.parent) i.parent.removeChild(i, 'ignore') 2721 } 2722 } else if (nodes.type) { 2723 nodes = [nodes] 2724 } else if (nodes.prop) { 2725 if (typeof nodes.value === 'undefined') { 2726 throw new Error('Value field is missed in node creation') 2727 } else if (typeof nodes.value !== 'string') { 2728 nodes.value = String(nodes.value) 2729 } 2730 nodes = [new Declaration(nodes)] 2731 } else if (nodes.selector) { 2732 nodes = [new Rule(nodes)] 2733 } else if (nodes.name) { 2734 nodes = [new AtRule(nodes)] 2735 } else if (nodes.text) { 2736 nodes = [new Comment(nodes)] 2737 } else { 2738 throw new Error('Unknown node type in node creation') 2739 } 2740 2741 let processed = nodes.map(i => { 2742 /* c8 ignore next */ 2743 if (!i[my]) Container.rebuild(i) 2744 i = i.proxyOf 2745 if (i.parent) i.parent.removeChild(i) 2746 if (i[isClean]) markDirtyUp(i) 2747 if (typeof i.raws.before === 'undefined') { 2748 if (sample && typeof sample.raws.before !== 'undefined') { 2749 i.raws.before = sample.raws.before.replace(/\S/g, '') 2750 } 2751 } 2752 i.parent = this.proxyOf 2753 return i 2754 }) 2755 2756 return processed 2757 } 2758 2759 prepend(...children) { 2760 children = children.reverse() 2761 for (let child of children) { 2762 let nodes = this.normalize(child, this.first, 'prepend').reverse() 2763 for (let node of nodes) this.proxyOf.nodes.unshift(node) 2764 for (let id in this.indexes) { 2765 this.indexes[id] = this.indexes[id] + nodes.length 2766 } 2767 } 2768 2769 this.markDirty() 2770 2771 return this 2772 } 2773 2774 push(child) { 2775 child.parent = this 2776 this.proxyOf.nodes.push(child) 2777 return this 2778 } 2779 2780 removeAll() { 2781 for (let node of this.proxyOf.nodes) node.parent = undefined 2782 this.proxyOf.nodes = [] 2783 2784 this.markDirty() 2785 2786 return this 2787 } 2788 2789 removeChild(child) { 2790 child = this.index(child) 2791 this.proxyOf.nodes[child].parent = undefined 2792 this.proxyOf.nodes.splice(child, 1) 2793 2794 let index 2795 for (let id in this.indexes) { 2796 index = this.indexes[id] 2797 if (index >= child) { 2798 this.indexes[id] = index - 1 2799 } 2800 } 2801 2802 this.markDirty() 2803 2804 return this 2805 } 2806 2807 replaceValues(pattern, opts, callback) { 2808 if (!callback) { 2809 callback = opts 2810 opts = {} 2811 } 2812 2813 this.walkDecls(decl => { 2814 if (opts.props && !opts.props.includes(decl.prop)) return 2815 if (opts.fast && !decl.value.includes(opts.fast)) return 2816 2817 decl.value = decl.value.replace(pattern, callback) 2818 }) 2819 2820 this.markDirty() 2821 2822 return this 2823 } 2824 2825 some(condition) { 2826 return this.nodes.some(condition) 2827 } 2828 2829 walk(callback) { 2830 return this.each((child, i) => { 2831 let result 2832 try { 2833 result = callback(child, i) 2834 } catch (e) { 2835 throw child.addToError(e) 2836 } 2837 if (result !== false && child.walk) { 2838 result = child.walk(callback) 2839 } 2840 2841 return result 2842 }) 2843 } 2844 2845 walkAtRules(name, callback) { 2846 if (!callback) { 2847 callback = name 2848 return this.walk((child, i) => { 2849 if (child.type === 'atrule') { 2850 return callback(child, i) 2851 } 2852 }) 2853 } 2854 if (name instanceof RegExp) { 2855 return this.walk((child, i) => { 2856 if (child.type === 'atrule' && name.test(child.name)) { 2857 return callback(child, i) 2858 } 2859 }) 2860 } 2861 return this.walk((child, i) => { 2862 if (child.type === 'atrule' && child.name === name) { 2863 return callback(child, i) 2864 } 2865 }) 2866 } 2867 2868 walkComments(callback) { 2869 return this.walk((child, i) => { 2870 if (child.type === 'comment') { 2871 return callback(child, i) 2872 } 2873 }) 2874 } 2875 2876 walkDecls(prop, callback) { 2877 if (!callback) { 2878 callback = prop 2879 return this.walk((child, i) => { 2880 if (child.type === 'decl') { 2881 return callback(child, i) 2882 } 2883 }) 2884 } 2885 if (prop instanceof RegExp) { 2886 return this.walk((child, i) => { 2887 if (child.type === 'decl' && prop.test(child.prop)) { 2888 return callback(child, i) 2889 } 2890 }) 2891 } 2892 return this.walk((child, i) => { 2893 if (child.type === 'decl' && child.prop === prop) { 2894 return callback(child, i) 2895 } 2896 }) 2897 } 2898 2899 walkRules(selector, callback) { 2900 if (!callback) { 2901 callback = selector 2902 2903 return this.walk((child, i) => { 2904 if (child.type === 'rule') { 2905 return callback(child, i) 2906 } 2907 }) 2908 } 2909 if (selector instanceof RegExp) { 2910 return this.walk((child, i) => { 2911 if (child.type === 'rule' && selector.test(child.selector)) { 2912 return callback(child, i) 2913 } 2914 }) 2915 } 2916 return this.walk((child, i) => { 2917 if (child.type === 'rule' && child.selector === selector) { 2918 return callback(child, i) 2919 } 2920 }) 2921 } 2922 2923 get first() { 2924 if (!this.proxyOf.nodes) return undefined 2925 return this.proxyOf.nodes[0] 2926 } 2927 2928 get last() { 2929 if (!this.proxyOf.nodes) return undefined 2930 return this.proxyOf.nodes[this.proxyOf.nodes.length - 1] 2931 } 2932 } 2933 2934 Container.registerParse = dependant => { 2935 parse = dependant 2936 } 2937 2938 Container.registerRule = dependant => { 2939 Rule = dependant 2940 } 2941 2942 Container.registerAtRule = dependant => { 2943 AtRule = dependant 2944 } 2945 2946 Container.registerRoot = dependant => { 2947 Root = dependant 2948 } 2949 2950 module.exports = Container 2951 Container.default = Container 2952 2953 /* c8 ignore start */ 2954 Container.rebuild = node => { 2955 if (node.type === 'atrule') { 2956 Object.setPrototypeOf(node, AtRule.prototype) 2957 } else if (node.type === 'rule') { 2958 Object.setPrototypeOf(node, Rule.prototype) 2959 } else if (node.type === 'decl') { 2960 Object.setPrototypeOf(node, Declaration.prototype) 2961 } else if (node.type === 'comment') { 2962 Object.setPrototypeOf(node, Comment.prototype) 2963 } else if (node.type === 'root') { 2964 Object.setPrototypeOf(node, Root.prototype) 2965 } 2966 2967 node[my] = true 2968 2969 if (node.nodes) { 2970 node.nodes.forEach(child => { 2971 Container.rebuild(child) 2972 }) 2973 } 2974 } 2975 /* c8 ignore stop */ 2976 2977 2978 /***/ }), 2979 2980 /***/ 356: 2981 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 2982 2983 "use strict"; 2984 2985 2986 let pico = __webpack_require__(2775) 2987 2988 let terminalHighlight = __webpack_require__(9746) 2989 2990 class CssSyntaxError extends Error { 2991 constructor(message, line, column, source, file, plugin) { 2992 super(message) 2993 this.name = 'CssSyntaxError' 2994 this.reason = message 2995 2996 if (file) { 2997 this.file = file 2998 } 2999 if (source) { 3000 this.source = source 3001 } 3002 if (plugin) { 3003 this.plugin = plugin 3004 } 3005 if (typeof line !== 'undefined' && typeof column !== 'undefined') { 3006 if (typeof line === 'number') { 3007 this.line = line 3008 this.column = column 3009 } else { 3010 this.line = line.line 3011 this.column = line.column 3012 this.endLine = column.line 3013 this.endColumn = column.column 3014 } 3015 } 3016 3017 this.setMessage() 3018 3019 if (Error.captureStackTrace) { 3020 Error.captureStackTrace(this, CssSyntaxError) 3021 } 3022 } 3023 3024 setMessage() { 3025 this.message = this.plugin ? this.plugin + ': ' : '' 3026 this.message += this.file ? this.file : '<css input>' 3027 if (typeof this.line !== 'undefined') { 3028 this.message += ':' + this.line + ':' + this.column 3029 } 3030 this.message += ': ' + this.reason 3031 } 3032 3033 showSourceCode(color) { 3034 if (!this.source) return '' 3035 3036 let css = this.source 3037 if (color == null) color = pico.isColorSupported 3038 if (terminalHighlight) { 3039 if (color) css = terminalHighlight(css) 3040 } 3041 3042 let lines = css.split(/\r?\n/) 3043 let start = Math.max(this.line - 3, 0) 3044 let end = Math.min(this.line + 2, lines.length) 3045 3046 let maxWidth = String(end).length 3047 3048 let mark, aside 3049 if (color) { 3050 let { bold, gray, red } = pico.createColors(true) 3051 mark = text => bold(red(text)) 3052 aside = text => gray(text) 3053 } else { 3054 mark = aside = str => str 3055 } 3056 3057 return lines 3058 .slice(start, end) 3059 .map((line, index) => { 3060 let number = start + 1 + index 3061 let gutter = ' ' + (' ' + number).slice(-maxWidth) + ' | ' 3062 if (number === this.line) { 3063 let spacing = 3064 aside(gutter.replace(/\d/g, ' ')) + 3065 line.slice(0, this.column - 1).replace(/[^\t]/g, ' ') 3066 return mark('>') + aside(gutter) + line + '\n ' + spacing + mark('^') 3067 } 3068 return ' ' + aside(gutter) + line 3069 }) 3070 .join('\n') 3071 } 3072 3073 toString() { 3074 let code = this.showSourceCode() 3075 if (code) { 3076 code = '\n\n' + code + '\n' 3077 } 3078 return this.name + ': ' + this.message + code 3079 } 3080 } 3081 3082 module.exports = CssSyntaxError 3083 CssSyntaxError.default = CssSyntaxError 3084 3085 3086 /***/ }), 3087 3088 /***/ 1516: 3089 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 3090 3091 "use strict"; 3092 3093 3094 let Node = __webpack_require__(7490) 3095 3096 class Declaration extends Node { 3097 constructor(defaults) { 3098 if ( 3099 defaults && 3100 typeof defaults.value !== 'undefined' && 3101 typeof defaults.value !== 'string' 3102 ) { 3103 defaults = { ...defaults, value: String(defaults.value) } 3104 } 3105 super(defaults) 3106 this.type = 'decl' 3107 } 3108 3109 get variable() { 3110 return this.prop.startsWith('--') || this.prop[0] === '$' 3111 } 3112 } 3113 3114 module.exports = Declaration 3115 Declaration.default = Declaration 3116 3117 3118 /***/ }), 3119 3120 /***/ 271: 3121 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 3122 3123 "use strict"; 3124 3125 3126 let Container = __webpack_require__(683) 3127 3128 let LazyResult, Processor 3129 3130 class Document extends Container { 3131 constructor(defaults) { 3132 // type needs to be passed to super, otherwise child roots won't be normalized correctly 3133 super({ type: 'document', ...defaults }) 3134 3135 if (!this.nodes) { 3136 this.nodes = [] 3137 } 3138 } 3139 3140 toResult(opts = {}) { 3141 let lazy = new LazyResult(new Processor(), this, opts) 3142 3143 return lazy.stringify() 3144 } 3145 } 3146 3147 Document.registerLazyResult = dependant => { 3148 LazyResult = dependant 3149 } 3150 3151 Document.registerProcessor = dependant => { 3152 Processor = dependant 3153 } 3154 3155 module.exports = Document 3156 Document.default = Document 3157 3158 3159 /***/ }), 3160 3161 /***/ 8940: 3162 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 3163 3164 "use strict"; 3165 3166 3167 let Declaration = __webpack_require__(1516) 3168 let PreviousMap = __webpack_require__(5696) 3169 let Comment = __webpack_require__(6589) 3170 let AtRule = __webpack_require__(1326) 3171 let Input = __webpack_require__(5380) 3172 let Root = __webpack_require__(9434) 3173 let Rule = __webpack_require__(4092) 3174 3175 function fromJSON(json, inputs) { 3176 if (Array.isArray(json)) return json.map(n => fromJSON(n)) 3177 3178 let { inputs: ownInputs, ...defaults } = json 3179 if (ownInputs) { 3180 inputs = [] 3181 for (let input of ownInputs) { 3182 let inputHydrated = { ...input, __proto__: Input.prototype } 3183 if (inputHydrated.map) { 3184 inputHydrated.map = { 3185 ...inputHydrated.map, 3186 __proto__: PreviousMap.prototype 3187 } 3188 } 3189 inputs.push(inputHydrated) 3190 } 3191 } 3192 if (defaults.nodes) { 3193 defaults.nodes = json.nodes.map(n => fromJSON(n, inputs)) 3194 } 3195 if (defaults.source) { 3196 let { inputId, ...source } = defaults.source 3197 defaults.source = source 3198 if (inputId != null) { 3199 defaults.source.input = inputs[inputId] 3200 } 3201 } 3202 if (defaults.type === 'root') { 3203 return new Root(defaults) 3204 } else if (defaults.type === 'decl') { 3205 return new Declaration(defaults) 3206 } else if (defaults.type === 'rule') { 3207 return new Rule(defaults) 3208 } else if (defaults.type === 'comment') { 3209 return new Comment(defaults) 3210 } else if (defaults.type === 'atrule') { 3211 return new AtRule(defaults) 3212 } else { 3213 throw new Error('Unknown node type: ' + json.type) 3214 } 3215 } 3216 3217 module.exports = fromJSON 3218 fromJSON.default = fromJSON 3219 3220 3221 /***/ }), 3222 3223 /***/ 5380: 3224 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 3225 3226 "use strict"; 3227 3228 3229 let { SourceMapConsumer, SourceMapGenerator } = __webpack_require__(1866) 3230 let { fileURLToPath, pathToFileURL } = __webpack_require__(2739) 3231 let { isAbsolute, resolve } = __webpack_require__(197) 3232 let { nanoid } = __webpack_require__(5042) 3233 3234 let terminalHighlight = __webpack_require__(9746) 3235 let CssSyntaxError = __webpack_require__(356) 3236 let PreviousMap = __webpack_require__(5696) 3237 3238 let fromOffsetCache = Symbol('fromOffsetCache') 3239 3240 let sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator) 3241 let pathAvailable = Boolean(resolve && isAbsolute) 3242 3243 class Input { 3244 constructor(css, opts = {}) { 3245 if ( 3246 css === null || 3247 typeof css === 'undefined' || 3248 (typeof css === 'object' && !css.toString) 3249 ) { 3250 throw new Error(`PostCSS received $css} instead of CSS string`) 3251 } 3252 3253 this.css = css.toString() 3254 3255 if (this.css[0] === '\uFEFF' || this.css[0] === '\uFFFE') { 3256 this.hasBOM = true 3257 this.css = this.css.slice(1) 3258 } else { 3259 this.hasBOM = false 3260 } 3261 3262 if (opts.from) { 3263 if ( 3264 !pathAvailable || 3265 /^\w+:\/\//.test(opts.from) || 3266 isAbsolute(opts.from) 3267 ) { 3268 this.file = opts.from 3269 } else { 3270 this.file = resolve(opts.from) 3271 } 3272 } 3273 3274 if (pathAvailable && sourceMapAvailable) { 3275 let map = new PreviousMap(this.css, opts) 3276 if (map.text) { 3277 this.map = map 3278 let file = map.consumer().file 3279 if (!this.file && file) this.file = this.mapResolve(file) 3280 } 3281 } 3282 3283 if (!this.file) { 3284 this.id = '<input css ' + nanoid(6) + '>' 3285 } 3286 if (this.map) this.map.file = this.from 3287 } 3288 3289 error(message, line, column, opts = {}) { 3290 let result, endLine, endColumn 3291 3292 if (line && typeof line === 'object') { 3293 let start = line 3294 let end = column 3295 if (typeof start.offset === 'number') { 3296 let pos = this.fromOffset(start.offset) 3297 line = pos.line 3298 column = pos.col 3299 } else { 3300 line = start.line 3301 column = start.column 3302 } 3303 if (typeof end.offset === 'number') { 3304 let pos = this.fromOffset(end.offset) 3305 endLine = pos.line 3306 endColumn = pos.col 3307 } else { 3308 endLine = end.line 3309 endColumn = end.column 3310 } 3311 } else if (!column) { 3312 let pos = this.fromOffset(line) 3313 line = pos.line 3314 column = pos.col 3315 } 3316 3317 let origin = this.origin(line, column, endLine, endColumn) 3318 if (origin) { 3319 result = new CssSyntaxError( 3320 message, 3321 origin.endLine === undefined 3322 ? origin.line 3323 : { column: origin.column, line: origin.line }, 3324 origin.endLine === undefined 3325 ? origin.column 3326 : { column: origin.endColumn, line: origin.endLine }, 3327 origin.source, 3328 origin.file, 3329 opts.plugin 3330 ) 3331 } else { 3332 result = new CssSyntaxError( 3333 message, 3334 endLine === undefined ? line : { column, line }, 3335 endLine === undefined ? column : { column: endColumn, line: endLine }, 3336 this.css, 3337 this.file, 3338 opts.plugin 3339 ) 3340 } 3341 3342 result.input = { column, endColumn, endLine, line, source: this.css } 3343 if (this.file) { 3344 if (pathToFileURL) { 3345 result.input.url = pathToFileURL(this.file).toString() 3346 } 3347 result.input.file = this.file 3348 } 3349 3350 return result 3351 } 3352 3353 fromOffset(offset) { 3354 let lastLine, lineToIndex 3355 if (!this[fromOffsetCache]) { 3356 let lines = this.css.split('\n') 3357 lineToIndex = new Array(lines.length) 3358 let prevIndex = 0 3359 3360 for (let i = 0, l = lines.length; i < l; i++) { 3361 lineToIndex[i] = prevIndex 3362 prevIndex += lines[i].length + 1 3363 } 3364 3365 this[fromOffsetCache] = lineToIndex 3366 } else { 3367 lineToIndex = this[fromOffsetCache] 3368 } 3369 lastLine = lineToIndex[lineToIndex.length - 1] 3370 3371 let min = 0 3372 if (offset >= lastLine) { 3373 min = lineToIndex.length - 1 3374 } else { 3375 let max = lineToIndex.length - 2 3376 let mid 3377 while (min < max) { 3378 mid = min + ((max - min) >> 1) 3379 if (offset < lineToIndex[mid]) { 3380 max = mid - 1 3381 } else if (offset >= lineToIndex[mid + 1]) { 3382 min = mid + 1 3383 } else { 3384 min = mid 3385 break 3386 } 3387 } 3388 } 3389 return { 3390 col: offset - lineToIndex[min] + 1, 3391 line: min + 1 3392 } 3393 } 3394 3395 mapResolve(file) { 3396 if (/^\w+:\/\//.test(file)) { 3397 return file 3398 } 3399 return resolve(this.map.consumer().sourceRoot || this.map.root || '.', file) 3400 } 3401 3402 origin(line, column, endLine, endColumn) { 3403 if (!this.map) return false 3404 let consumer = this.map.consumer() 3405 3406 let from = consumer.originalPositionFor({ column, line }) 3407 if (!from.source) return false 3408 3409 let to 3410 if (typeof endLine === 'number') { 3411 to = consumer.originalPositionFor({ column: endColumn, line: endLine }) 3412 } 3413 3414 let fromUrl 3415 3416 if (isAbsolute(from.source)) { 3417 fromUrl = pathToFileURL(from.source) 3418 } else { 3419 fromUrl = new URL( 3420 from.source, 3421 this.map.consumer().sourceRoot || pathToFileURL(this.map.mapFile) 3422 ) 3423 } 3424 3425 let result = { 3426 column: from.column, 3427 endColumn: to && to.column, 3428 endLine: to && to.line, 3429 line: from.line, 3430 url: fromUrl.toString() 3431 } 3432 3433 if (fromUrl.protocol === 'file:') { 3434 if (fileURLToPath) { 3435 result.file = fileURLToPath(fromUrl) 3436 } else { 3437 /* c8 ignore next 2 */ 3438 throw new Error(`file: protocol is not available in this PostCSS build`) 3439 } 3440 } 3441 3442 let source = consumer.sourceContentFor(from.source) 3443 if (source) result.source = source 3444 3445 return result 3446 } 3447 3448 toJSON() { 3449 let json = {} 3450 for (let name of ['hasBOM', 'css', 'file', 'id']) { 3451 if (this[name] != null) { 3452 json[name] = this[name] 3453 } 3454 } 3455 if (this.map) { 3456 json.map = { ...this.map } 3457 if (json.map.consumerCache) { 3458 json.map.consumerCache = undefined 3459 } 3460 } 3461 return json 3462 } 3463 3464 get from() { 3465 return this.file || this.id 3466 } 3467 } 3468 3469 module.exports = Input 3470 Input.default = Input 3471 3472 if (terminalHighlight && terminalHighlight.registerInput) { 3473 terminalHighlight.registerInput(Input) 3474 } 3475 3476 3477 /***/ }), 3478 3479 /***/ 448: 3480 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 3481 3482 "use strict"; 3483 3484 3485 let { isClean, my } = __webpack_require__(1381) 3486 let MapGenerator = __webpack_require__(1670) 3487 let stringify = __webpack_require__(633) 3488 let Container = __webpack_require__(683) 3489 let Document = __webpack_require__(271) 3490 let warnOnce = __webpack_require__(3122) 3491 let Result = __webpack_require__(9055) 3492 let parse = __webpack_require__(4295) 3493 let Root = __webpack_require__(9434) 3494 3495 const TYPE_TO_CLASS_NAME = { 3496 atrule: 'AtRule', 3497 comment: 'Comment', 3498 decl: 'Declaration', 3499 document: 'Document', 3500 root: 'Root', 3501 rule: 'Rule' 3502 } 3503 3504 const PLUGIN_PROPS = { 3505 AtRule: true, 3506 AtRuleExit: true, 3507 Comment: true, 3508 CommentExit: true, 3509 Declaration: true, 3510 DeclarationExit: true, 3511 Document: true, 3512 DocumentExit: true, 3513 Once: true, 3514 OnceExit: true, 3515 postcssPlugin: true, 3516 prepare: true, 3517 Root: true, 3518 RootExit: true, 3519 Rule: true, 3520 RuleExit: true 3521 } 3522 3523 const NOT_VISITORS = { 3524 Once: true, 3525 postcssPlugin: true, 3526 prepare: true 3527 } 3528 3529 const CHILDREN = 0 3530 3531 function isPromise(obj) { 3532 return typeof obj === 'object' && typeof obj.then === 'function' 3533 } 3534 3535 function getEvents(node) { 3536 let key = false 3537 let type = TYPE_TO_CLASS_NAME[node.type] 3538 if (node.type === 'decl') { 3539 key = node.prop.toLowerCase() 3540 } else if (node.type === 'atrule') { 3541 key = node.name.toLowerCase() 3542 } 3543 3544 if (key && node.append) { 3545 return [ 3546 type, 3547 type + '-' + key, 3548 CHILDREN, 3549 type + 'Exit', 3550 type + 'Exit-' + key 3551 ] 3552 } else if (key) { 3553 return [type, type + '-' + key, type + 'Exit', type + 'Exit-' + key] 3554 } else if (node.append) { 3555 return [type, CHILDREN, type + 'Exit'] 3556 } else { 3557 return [type, type + 'Exit'] 3558 } 3559 } 3560 3561 function toStack(node) { 3562 let events 3563 if (node.type === 'document') { 3564 events = ['Document', CHILDREN, 'DocumentExit'] 3565 } else if (node.type === 'root') { 3566 events = ['Root', CHILDREN, 'RootExit'] 3567 } else { 3568 events = getEvents(node) 3569 } 3570 3571 return { 3572 eventIndex: 0, 3573 events, 3574 iterator: 0, 3575 node, 3576 visitorIndex: 0, 3577 visitors: [] 3578 } 3579 } 3580 3581 function cleanMarks(node) { 3582 node[isClean] = false 3583 if (node.nodes) node.nodes.forEach(i => cleanMarks(i)) 3584 return node 3585 } 3586 3587 let postcss = {} 3588 3589 class LazyResult { 3590 constructor(processor, css, opts) { 3591 this.stringified = false 3592 this.processed = false 3593 3594 let root 3595 if ( 3596 typeof css === 'object' && 3597 css !== null && 3598 (css.type === 'root' || css.type === 'document') 3599 ) { 3600 root = cleanMarks(css) 3601 } else if (css instanceof LazyResult || css instanceof Result) { 3602 root = cleanMarks(css.root) 3603 if (css.map) { 3604 if (typeof opts.map === 'undefined') opts.map = {} 3605 if (!opts.map.inline) opts.map.inline = false 3606 opts.map.prev = css.map 3607 } 3608 } else { 3609 let parser = parse 3610 if (opts.syntax) parser = opts.syntax.parse 3611 if (opts.parser) parser = opts.parser 3612 if (parser.parse) parser = parser.parse 3613 3614 try { 3615 root = parser(css, opts) 3616 } catch (error) { 3617 this.processed = true 3618 this.error = error 3619 } 3620 3621 if (root && !root[my]) { 3622 /* c8 ignore next 2 */ 3623 Container.rebuild(root) 3624 } 3625 } 3626 3627 this.result = new Result(processor, root, opts) 3628 this.helpers = { ...postcss, postcss, result: this.result } 3629 this.plugins = this.processor.plugins.map(plugin => { 3630 if (typeof plugin === 'object' && plugin.prepare) { 3631 return { ...plugin, ...plugin.prepare(this.result) } 3632 } else { 3633 return plugin 3634 } 3635 }) 3636 } 3637 3638 async() { 3639 if (this.error) return Promise.reject(this.error) 3640 if (this.processed) return Promise.resolve(this.result) 3641 if (!this.processing) { 3642 this.processing = this.runAsync() 3643 } 3644 return this.processing 3645 } 3646 3647 catch(onRejected) { 3648 return this.async().catch(onRejected) 3649 } 3650 3651 finally(onFinally) { 3652 return this.async().then(onFinally, onFinally) 3653 } 3654 3655 getAsyncError() { 3656 throw new Error('Use process(css).then(cb) to work with async plugins') 3657 } 3658 3659 handleError(error, node) { 3660 let plugin = this.result.lastPlugin 3661 try { 3662 if (node) node.addToError(error) 3663 this.error = error 3664 if (error.name === 'CssSyntaxError' && !error.plugin) { 3665 error.plugin = plugin.postcssPlugin 3666 error.setMessage() 3667 } else if (plugin.postcssVersion) { 3668 if (false) {} 3669 } 3670 } catch (err) { 3671 /* c8 ignore next 3 */ 3672 // eslint-disable-next-line no-console 3673 if (console && console.error) console.error(err) 3674 } 3675 return error 3676 } 3677 3678 prepareVisitors() { 3679 this.listeners = {} 3680 let add = (plugin, type, cb) => { 3681 if (!this.listeners[type]) this.listeners[type] = [] 3682 this.listeners[type].push([plugin, cb]) 3683 } 3684 for (let plugin of this.plugins) { 3685 if (typeof plugin === 'object') { 3686 for (let event in plugin) { 3687 if (!PLUGIN_PROPS[event] && /^[A-Z]/.test(event)) { 3688 throw new Error( 3689 `Unknown event $event} in $plugin.postcssPlugin}. ` + 3690 `Try to update PostCSS ($this.processor.version} now).` 3691 ) 3692 } 3693 if (!NOT_VISITORS[event]) { 3694 if (typeof plugin[event] === 'object') { 3695 for (let filter in plugin[event]) { 3696 if (filter === '*') { 3697 add(plugin, event, plugin[event][filter]) 3698 } else { 3699 add( 3700 plugin, 3701 event + '-' + filter.toLowerCase(), 3702 plugin[event][filter] 3703 ) 3704 } 3705 } 3706 } else if (typeof plugin[event] === 'function') { 3707 add(plugin, event, plugin[event]) 3708 } 3709 } 3710 } 3711 } 3712 } 3713 this.hasListener = Object.keys(this.listeners).length > 0 3714 } 3715 3716 async runAsync() { 3717 this.plugin = 0 3718 for (let i = 0; i < this.plugins.length; i++) { 3719 let plugin = this.plugins[i] 3720 let promise = this.runOnRoot(plugin) 3721 if (isPromise(promise)) { 3722 try { 3723 await promise 3724 } catch (error) { 3725 throw this.handleError(error) 3726 } 3727 } 3728 } 3729 3730 this.prepareVisitors() 3731 if (this.hasListener) { 3732 let root = this.result.root 3733 while (!root[isClean]) { 3734 root[isClean] = true 3735 let stack = [toStack(root)] 3736 while (stack.length > 0) { 3737 let promise = this.visitTick(stack) 3738 if (isPromise(promise)) { 3739 try { 3740 await promise 3741 } catch (e) { 3742 let node = stack[stack.length - 1].node 3743 throw this.handleError(e, node) 3744 } 3745 } 3746 } 3747 } 3748 3749 if (this.listeners.OnceExit) { 3750 for (let [plugin, visitor] of this.listeners.OnceExit) { 3751 this.result.lastPlugin = plugin 3752 try { 3753 if (root.type === 'document') { 3754 let roots = root.nodes.map(subRoot => 3755 visitor(subRoot, this.helpers) 3756 ) 3757 3758 await Promise.all(roots) 3759 } else { 3760 await visitor(root, this.helpers) 3761 } 3762 } catch (e) { 3763 throw this.handleError(e) 3764 } 3765 } 3766 } 3767 } 3768 3769 this.processed = true 3770 return this.stringify() 3771 } 3772 3773 runOnRoot(plugin) { 3774 this.result.lastPlugin = plugin 3775 try { 3776 if (typeof plugin === 'object' && plugin.Once) { 3777 if (this.result.root.type === 'document') { 3778 let roots = this.result.root.nodes.map(root => 3779 plugin.Once(root, this.helpers) 3780 ) 3781 3782 if (isPromise(roots[0])) { 3783 return Promise.all(roots) 3784 } 3785 3786 return roots 3787 } 3788 3789 return plugin.Once(this.result.root, this.helpers) 3790 } else if (typeof plugin === 'function') { 3791 return plugin(this.result.root, this.result) 3792 } 3793 } catch (error) { 3794 throw this.handleError(error) 3795 } 3796 } 3797 3798 stringify() { 3799 if (this.error) throw this.error 3800 if (this.stringified) return this.result 3801 this.stringified = true 3802 3803 this.sync() 3804 3805 let opts = this.result.opts 3806 let str = stringify 3807 if (opts.syntax) str = opts.syntax.stringify 3808 if (opts.stringifier) str = opts.stringifier 3809 if (str.stringify) str = str.stringify 3810 3811 let map = new MapGenerator(str, this.result.root, this.result.opts) 3812 let data = map.generate() 3813 this.result.css = data[0] 3814 this.result.map = data[1] 3815 3816 return this.result 3817 } 3818 3819 sync() { 3820 if (this.error) throw this.error 3821 if (this.processed) return this.result 3822 this.processed = true 3823 3824 if (this.processing) { 3825 throw this.getAsyncError() 3826 } 3827 3828 for (let plugin of this.plugins) { 3829 let promise = this.runOnRoot(plugin) 3830 if (isPromise(promise)) { 3831 throw this.getAsyncError() 3832 } 3833 } 3834 3835 this.prepareVisitors() 3836 if (this.hasListener) { 3837 let root = this.result.root 3838 while (!root[isClean]) { 3839 root[isClean] = true 3840 this.walkSync(root) 3841 } 3842 if (this.listeners.OnceExit) { 3843 if (root.type === 'document') { 3844 for (let subRoot of root.nodes) { 3845 this.visitSync(this.listeners.OnceExit, subRoot) 3846 } 3847 } else { 3848 this.visitSync(this.listeners.OnceExit, root) 3849 } 3850 } 3851 } 3852 3853 return this.result 3854 } 3855 3856 then(onFulfilled, onRejected) { 3857 if (false) {} 3858 return this.async().then(onFulfilled, onRejected) 3859 } 3860 3861 toString() { 3862 return this.css 3863 } 3864 3865 visitSync(visitors, node) { 3866 for (let [plugin, visitor] of visitors) { 3867 this.result.lastPlugin = plugin 3868 let promise 3869 try { 3870 promise = visitor(node, this.helpers) 3871 } catch (e) { 3872 throw this.handleError(e, node.proxyOf) 3873 } 3874 if (node.type !== 'root' && node.type !== 'document' && !node.parent) { 3875 return true 3876 } 3877 if (isPromise(promise)) { 3878 throw this.getAsyncError() 3879 } 3880 } 3881 } 3882 3883 visitTick(stack) { 3884 let visit = stack[stack.length - 1] 3885 let { node, visitors } = visit 3886 3887 if (node.type !== 'root' && node.type !== 'document' && !node.parent) { 3888 stack.pop() 3889 return 3890 } 3891 3892 if (visitors.length > 0 && visit.visitorIndex < visitors.length) { 3893 let [plugin, visitor] = visitors[visit.visitorIndex] 3894 visit.visitorIndex += 1 3895 if (visit.visitorIndex === visitors.length) { 3896 visit.visitors = [] 3897 visit.visitorIndex = 0 3898 } 3899 this.result.lastPlugin = plugin 3900 try { 3901 return visitor(node.toProxy(), this.helpers) 3902 } catch (e) { 3903 throw this.handleError(e, node) 3904 } 3905 } 3906 3907 if (visit.iterator !== 0) { 3908 let iterator = visit.iterator 3909 let child 3910 while ((child = node.nodes[node.indexes[iterator]])) { 3911 node.indexes[iterator] += 1 3912 if (!child[isClean]) { 3913 child[isClean] = true 3914 stack.push(toStack(child)) 3915 return 3916 } 3917 } 3918 visit.iterator = 0 3919 delete node.indexes[iterator] 3920 } 3921 3922 let events = visit.events 3923 while (visit.eventIndex < events.length) { 3924 let event = events[visit.eventIndex] 3925 visit.eventIndex += 1 3926 if (event === CHILDREN) { 3927 if (node.nodes && node.nodes.length) { 3928 node[isClean] = true 3929 visit.iterator = node.getIterator() 3930 } 3931 return 3932 } else if (this.listeners[event]) { 3933 visit.visitors = this.listeners[event] 3934 return 3935 } 3936 } 3937 stack.pop() 3938 } 3939 3940 walkSync(node) { 3941 node[isClean] = true 3942 let events = getEvents(node) 3943 for (let event of events) { 3944 if (event === CHILDREN) { 3945 if (node.nodes) { 3946 node.each(child => { 3947 if (!child[isClean]) this.walkSync(child) 3948 }) 3949 } 3950 } else { 3951 let visitors = this.listeners[event] 3952 if (visitors) { 3953 if (this.visitSync(visitors, node.toProxy())) return 3954 } 3955 } 3956 } 3957 } 3958 3959 warnings() { 3960 return this.sync().warnings() 3961 } 3962 3963 get content() { 3964 return this.stringify().content 3965 } 3966 3967 get css() { 3968 return this.stringify().css 3969 } 3970 3971 get map() { 3972 return this.stringify().map 3973 } 3974 3975 get messages() { 3976 return this.sync().messages 3977 } 3978 3979 get opts() { 3980 return this.result.opts 3981 } 3982 3983 get processor() { 3984 return this.result.processor 3985 } 3986 3987 get root() { 3988 return this.sync().root 3989 } 3990 3991 get [Symbol.toStringTag]() { 3992 return 'LazyResult' 3993 } 3994 } 3995 3996 LazyResult.registerPostcss = dependant => { 3997 postcss = dependant 3998 } 3999 4000 module.exports = LazyResult 4001 LazyResult.default = LazyResult 4002 4003 Root.registerLazyResult(LazyResult) 4004 Document.registerLazyResult(LazyResult) 4005 4006 4007 /***/ }), 4008 4009 /***/ 7374: 4010 /***/ ((module) => { 4011 4012 "use strict"; 4013 4014 4015 let list = { 4016 comma(string) { 4017 return list.split(string, [','], true) 4018 }, 4019 4020 space(string) { 4021 let spaces = [' ', '\n', '\t'] 4022 return list.split(string, spaces) 4023 }, 4024 4025 split(string, separators, last) { 4026 let array = [] 4027 let current = '' 4028 let split = false 4029 4030 let func = 0 4031 let inQuote = false 4032 let prevQuote = '' 4033 let escape = false 4034 4035 for (let letter of string) { 4036 if (escape) { 4037 escape = false 4038 } else if (letter === '\\') { 4039 escape = true 4040 } else if (inQuote) { 4041 if (letter === prevQuote) { 4042 inQuote = false 4043 } 4044 } else if (letter === '"' || letter === "'") { 4045 inQuote = true 4046 prevQuote = letter 4047 } else if (letter === '(') { 4048 func += 1 4049 } else if (letter === ')') { 4050 if (func > 0) func -= 1 4051 } else if (func === 0) { 4052 if (separators.includes(letter)) split = true 4053 } 4054 4055 if (split) { 4056 if (current !== '') array.push(current.trim()) 4057 current = '' 4058 split = false 4059 } else { 4060 current += letter 4061 } 4062 } 4063 4064 if (last || current !== '') array.push(current.trim()) 4065 return array 4066 } 4067 } 4068 4069 module.exports = list 4070 list.default = list 4071 4072 4073 /***/ }), 4074 4075 /***/ 1670: 4076 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 4077 4078 "use strict"; 4079 4080 4081 let { SourceMapConsumer, SourceMapGenerator } = __webpack_require__(1866) 4082 let { dirname, relative, resolve, sep } = __webpack_require__(197) 4083 let { pathToFileURL } = __webpack_require__(2739) 4084 4085 let Input = __webpack_require__(5380) 4086 4087 let sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator) 4088 let pathAvailable = Boolean(dirname && resolve && relative && sep) 4089 4090 class MapGenerator { 4091 constructor(stringify, root, opts, cssString) { 4092 this.stringify = stringify 4093 this.mapOpts = opts.map || {} 4094 this.root = root 4095 this.opts = opts 4096 this.css = cssString 4097 this.originalCSS = cssString 4098 this.usesFileUrls = !this.mapOpts.from && this.mapOpts.absolute 4099 4100 this.memoizedFileURLs = new Map() 4101 this.memoizedPaths = new Map() 4102 this.memoizedURLs = new Map() 4103 } 4104 4105 addAnnotation() { 4106 let content 4107 4108 if (this.isInline()) { 4109 content = 4110 'data:application/json;base64,' + this.toBase64(this.map.toString()) 4111 } else if (typeof this.mapOpts.annotation === 'string') { 4112 content = this.mapOpts.annotation 4113 } else if (typeof this.mapOpts.annotation === 'function') { 4114 content = this.mapOpts.annotation(this.opts.to, this.root) 4115 } else { 4116 content = this.outputFile() + '.map' 4117 } 4118 let eol = '\n' 4119 if (this.css.includes('\r\n')) eol = '\r\n' 4120 4121 this.css += eol + '/*# sourceMappingURL=' + content + ' */' 4122 } 4123 4124 applyPrevMaps() { 4125 for (let prev of this.previous()) { 4126 let from = this.toUrl(this.path(prev.file)) 4127 let root = prev.root || dirname(prev.file) 4128 let map 4129 4130 if (this.mapOpts.sourcesContent === false) { 4131 map = new SourceMapConsumer(prev.text) 4132 if (map.sourcesContent) { 4133 map.sourcesContent = null 4134 } 4135 } else { 4136 map = prev.consumer() 4137 } 4138 4139 this.map.applySourceMap(map, from, this.toUrl(this.path(root))) 4140 } 4141 } 4142 4143 clearAnnotation() { 4144 if (this.mapOpts.annotation === false) return 4145 4146 if (this.root) { 4147 let node 4148 for (let i = this.root.nodes.length - 1; i >= 0; i--) { 4149 node = this.root.nodes[i] 4150 if (node.type !== 'comment') continue 4151 if (node.text.indexOf('# sourceMappingURL=') === 0) { 4152 this.root.removeChild(i) 4153 } 4154 } 4155 } else if (this.css) { 4156 this.css = this.css.replace(/\n*?\/\*#[\S\s]*?\*\/$/gm, '') 4157 } 4158 } 4159 4160 generate() { 4161 this.clearAnnotation() 4162 if (pathAvailable && sourceMapAvailable && this.isMap()) { 4163 return this.generateMap() 4164 } else { 4165 let result = '' 4166 this.stringify(this.root, i => { 4167 result += i 4168 }) 4169 return [result] 4170 } 4171 } 4172 4173 generateMap() { 4174 if (this.root) { 4175 this.generateString() 4176 } else if (this.previous().length === 1) { 4177 let prev = this.previous()[0].consumer() 4178 prev.file = this.outputFile() 4179 this.map = SourceMapGenerator.fromSourceMap(prev, { 4180 ignoreInvalidMapping: true 4181 }) 4182 } else { 4183 this.map = new SourceMapGenerator({ 4184 file: this.outputFile(), 4185 ignoreInvalidMapping: true 4186 }) 4187 this.map.addMapping({ 4188 generated: { column: 0, line: 1 }, 4189 original: { column: 0, line: 1 }, 4190 source: this.opts.from 4191 ? this.toUrl(this.path(this.opts.from)) 4192 : '<no source>' 4193 }) 4194 } 4195 4196 if (this.isSourcesContent()) this.setSourcesContent() 4197 if (this.root && this.previous().length > 0) this.applyPrevMaps() 4198 if (this.isAnnotation()) this.addAnnotation() 4199 4200 if (this.isInline()) { 4201 return [this.css] 4202 } else { 4203 return [this.css, this.map] 4204 } 4205 } 4206 4207 generateString() { 4208 this.css = '' 4209 this.map = new SourceMapGenerator({ 4210 file: this.outputFile(), 4211 ignoreInvalidMapping: true 4212 }) 4213 4214 let line = 1 4215 let column = 1 4216 4217 let noSource = '<no source>' 4218 let mapping = { 4219 generated: { column: 0, line: 0 }, 4220 original: { column: 0, line: 0 }, 4221 source: '' 4222 } 4223 4224 let lines, last 4225 this.stringify(this.root, (str, node, type) => { 4226 this.css += str 4227 4228 if (node && type !== 'end') { 4229 mapping.generated.line = line 4230 mapping.generated.column = column - 1 4231 if (node.source && node.source.start) { 4232 mapping.source = this.sourcePath(node) 4233 mapping.original.line = node.source.start.line 4234 mapping.original.column = node.source.start.column - 1 4235 this.map.addMapping(mapping) 4236 } else { 4237 mapping.source = noSource 4238 mapping.original.line = 1 4239 mapping.original.column = 0 4240 this.map.addMapping(mapping) 4241 } 4242 } 4243 4244 lines = str.match(/\n/g) 4245 if (lines) { 4246 line += lines.length 4247 last = str.lastIndexOf('\n') 4248 column = str.length - last 4249 } else { 4250 column += str.length 4251 } 4252 4253 if (node && type !== 'start') { 4254 let p = node.parent || { raws: {} } 4255 let childless = 4256 node.type === 'decl' || (node.type === 'atrule' && !node.nodes) 4257 if (!childless || node !== p.last || p.raws.semicolon) { 4258 if (node.source && node.source.end) { 4259 mapping.source = this.sourcePath(node) 4260 mapping.original.line = node.source.end.line 4261 mapping.original.column = node.source.end.column - 1 4262 mapping.generated.line = line 4263 mapping.generated.column = column - 2 4264 this.map.addMapping(mapping) 4265 } else { 4266 mapping.source = noSource 4267 mapping.original.line = 1 4268 mapping.original.column = 0 4269 mapping.generated.line = line 4270 mapping.generated.column = column - 1 4271 this.map.addMapping(mapping) 4272 } 4273 } 4274 } 4275 }) 4276 } 4277 4278 isAnnotation() { 4279 if (this.isInline()) { 4280 return true 4281 } 4282 if (typeof this.mapOpts.annotation !== 'undefined') { 4283 return this.mapOpts.annotation 4284 } 4285 if (this.previous().length) { 4286 return this.previous().some(i => i.annotation) 4287 } 4288 return true 4289 } 4290 4291 isInline() { 4292 if (typeof this.mapOpts.inline !== 'undefined') { 4293 return this.mapOpts.inline 4294 } 4295 4296 let annotation = this.mapOpts.annotation 4297 if (typeof annotation !== 'undefined' && annotation !== true) { 4298 return false 4299 } 4300 4301 if (this.previous().length) { 4302 return this.previous().some(i => i.inline) 4303 } 4304 return true 4305 } 4306 4307 isMap() { 4308 if (typeof this.opts.map !== 'undefined') { 4309 return !!this.opts.map 4310 } 4311 return this.previous().length > 0 4312 } 4313 4314 isSourcesContent() { 4315 if (typeof this.mapOpts.sourcesContent !== 'undefined') { 4316 return this.mapOpts.sourcesContent 4317 } 4318 if (this.previous().length) { 4319 return this.previous().some(i => i.withContent()) 4320 } 4321 return true 4322 } 4323 4324 outputFile() { 4325 if (this.opts.to) { 4326 return this.path(this.opts.to) 4327 } else if (this.opts.from) { 4328 return this.path(this.opts.from) 4329 } else { 4330 return 'to.css' 4331 } 4332 } 4333 4334 path(file) { 4335 if (this.mapOpts.absolute) return file 4336 if (file.charCodeAt(0) === 60 /* `<` */) return file 4337 if (/^\w+:\/\//.test(file)) return file 4338 let cached = this.memoizedPaths.get(file) 4339 if (cached) return cached 4340 4341 let from = this.opts.to ? dirname(this.opts.to) : '.' 4342 4343 if (typeof this.mapOpts.annotation === 'string') { 4344 from = dirname(resolve(from, this.mapOpts.annotation)) 4345 } 4346 4347 let path = relative(from, file) 4348 this.memoizedPaths.set(file, path) 4349 4350 return path 4351 } 4352 4353 previous() { 4354 if (!this.previousMaps) { 4355 this.previousMaps = [] 4356 if (this.root) { 4357 this.root.walk(node => { 4358 if (node.source && node.source.input.map) { 4359 let map = node.source.input.map 4360 if (!this.previousMaps.includes(map)) { 4361 this.previousMaps.push(map) 4362 } 4363 } 4364 }) 4365 } else { 4366 let input = new Input(this.originalCSS, this.opts) 4367 if (input.map) this.previousMaps.push(input.map) 4368 } 4369 } 4370 4371 return this.previousMaps 4372 } 4373 4374 setSourcesContent() { 4375 let already = {} 4376 if (this.root) { 4377 this.root.walk(node => { 4378 if (node.source) { 4379 let from = node.source.input.from 4380 if (from && !already[from]) { 4381 already[from] = true 4382 let fromUrl = this.usesFileUrls 4383 ? this.toFileUrl(from) 4384 : this.toUrl(this.path(from)) 4385 this.map.setSourceContent(fromUrl, node.source.input.css) 4386 } 4387 } 4388 }) 4389 } else if (this.css) { 4390 let from = this.opts.from 4391 ? this.toUrl(this.path(this.opts.from)) 4392 : '<no source>' 4393 this.map.setSourceContent(from, this.css) 4394 } 4395 } 4396 4397 sourcePath(node) { 4398 if (this.mapOpts.from) { 4399 return this.toUrl(this.mapOpts.from) 4400 } else if (this.usesFileUrls) { 4401 return this.toFileUrl(node.source.input.from) 4402 } else { 4403 return this.toUrl(this.path(node.source.input.from)) 4404 } 4405 } 4406 4407 toBase64(str) { 4408 if (Buffer) { 4409 return Buffer.from(str).toString('base64') 4410 } else { 4411 return window.btoa(unescape(encodeURIComponent(str))) 4412 } 4413 } 4414 4415 toFileUrl(path) { 4416 let cached = this.memoizedFileURLs.get(path) 4417 if (cached) return cached 4418 4419 if (pathToFileURL) { 4420 let fileURL = pathToFileURL(path).toString() 4421 this.memoizedFileURLs.set(path, fileURL) 4422 4423 return fileURL 4424 } else { 4425 throw new Error( 4426 '`map.absolute` option is not available in this PostCSS build' 4427 ) 4428 } 4429 } 4430 4431 toUrl(path) { 4432 let cached = this.memoizedURLs.get(path) 4433 if (cached) return cached 4434 4435 if (sep === '\\') { 4436 path = path.replace(/\\/g, '/') 4437 } 4438 4439 let url = encodeURI(path).replace(/[#?]/g, encodeURIComponent) 4440 this.memoizedURLs.set(path, url) 4441 4442 return url 4443 } 4444 } 4445 4446 module.exports = MapGenerator 4447 4448 4449 /***/ }), 4450 4451 /***/ 7661: 4452 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 4453 4454 "use strict"; 4455 4456 4457 let MapGenerator = __webpack_require__(1670) 4458 let stringify = __webpack_require__(633) 4459 let warnOnce = __webpack_require__(3122) 4460 let parse = __webpack_require__(4295) 4461 const Result = __webpack_require__(9055) 4462 4463 class NoWorkResult { 4464 constructor(processor, css, opts) { 4465 css = css.toString() 4466 this.stringified = false 4467 4468 this._processor = processor 4469 this._css = css 4470 this._opts = opts 4471 this._map = undefined 4472 let root 4473 4474 let str = stringify 4475 this.result = new Result(this._processor, root, this._opts) 4476 this.result.css = css 4477 4478 let self = this 4479 Object.defineProperty(this.result, 'root', { 4480 get() { 4481 return self.root 4482 } 4483 }) 4484 4485 let map = new MapGenerator(str, root, this._opts, css) 4486 if (map.isMap()) { 4487 let [generatedCSS, generatedMap] = map.generate() 4488 if (generatedCSS) { 4489 this.result.css = generatedCSS 4490 } 4491 if (generatedMap) { 4492 this.result.map = generatedMap 4493 } 4494 } else { 4495 map.clearAnnotation() 4496 this.result.css = map.css 4497 } 4498 } 4499 4500 async() { 4501 if (this.error) return Promise.reject(this.error) 4502 return Promise.resolve(this.result) 4503 } 4504 4505 catch(onRejected) { 4506 return this.async().catch(onRejected) 4507 } 4508 4509 finally(onFinally) { 4510 return this.async().then(onFinally, onFinally) 4511 } 4512 4513 sync() { 4514 if (this.error) throw this.error 4515 return this.result 4516 } 4517 4518 then(onFulfilled, onRejected) { 4519 if (false) {} 4520 4521 return this.async().then(onFulfilled, onRejected) 4522 } 4523 4524 toString() { 4525 return this._css 4526 } 4527 4528 warnings() { 4529 return [] 4530 } 4531 4532 get content() { 4533 return this.result.css 4534 } 4535 4536 get css() { 4537 return this.result.css 4538 } 4539 4540 get map() { 4541 return this.result.map 4542 } 4543 4544 get messages() { 4545 return [] 4546 } 4547 4548 get opts() { 4549 return this.result.opts 4550 } 4551 4552 get processor() { 4553 return this.result.processor 4554 } 4555 4556 get root() { 4557 if (this._root) { 4558 return this._root 4559 } 4560 4561 let root 4562 let parser = parse 4563 4564 try { 4565 root = parser(this._css, this._opts) 4566 } catch (error) { 4567 this.error = error 4568 } 4569 4570 if (this.error) { 4571 throw this.error 4572 } else { 4573 this._root = root 4574 return root 4575 } 4576 } 4577 4578 get [Symbol.toStringTag]() { 4579 return 'NoWorkResult' 4580 } 4581 } 4582 4583 module.exports = NoWorkResult 4584 NoWorkResult.default = NoWorkResult 4585 4586 4587 /***/ }), 4588 4589 /***/ 7490: 4590 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 4591 4592 "use strict"; 4593 4594 4595 let { isClean, my } = __webpack_require__(1381) 4596 let CssSyntaxError = __webpack_require__(356) 4597 let Stringifier = __webpack_require__(346) 4598 let stringify = __webpack_require__(633) 4599 4600 function cloneNode(obj, parent) { 4601 let cloned = new obj.constructor() 4602 4603 for (let i in obj) { 4604 if (!Object.prototype.hasOwnProperty.call(obj, i)) { 4605 /* c8 ignore next 2 */ 4606 continue 4607 } 4608 if (i === 'proxyCache') continue 4609 let value = obj[i] 4610 let type = typeof value 4611 4612 if (i === 'parent' && type === 'object') { 4613 if (parent) cloned[i] = parent 4614 } else if (i === 'source') { 4615 cloned[i] = value 4616 } else if (Array.isArray(value)) { 4617 cloned[i] = value.map(j => cloneNode(j, cloned)) 4618 } else { 4619 if (type === 'object' && value !== null) value = cloneNode(value) 4620 cloned[i] = value 4621 } 4622 } 4623 4624 return cloned 4625 } 4626 4627 class Node { 4628 constructor(defaults = {}) { 4629 this.raws = {} 4630 this[isClean] = false 4631 this[my] = true 4632 4633 for (let name in defaults) { 4634 if (name === 'nodes') { 4635 this.nodes = [] 4636 for (let node of defaults[name]) { 4637 if (typeof node.clone === 'function') { 4638 this.append(node.clone()) 4639 } else { 4640 this.append(node) 4641 } 4642 } 4643 } else { 4644 this[name] = defaults[name] 4645 } 4646 } 4647 } 4648 4649 addToError(error) { 4650 error.postcssNode = this 4651 if (error.stack && this.source && /\n\s{4}at /.test(error.stack)) { 4652 let s = this.source 4653 error.stack = error.stack.replace( 4654 /\n\s{4}at /, 4655 `$&$s.input.from}:$s.start.line}:$s.start.column}$&` 4656 ) 4657 } 4658 return error 4659 } 4660 4661 after(add) { 4662 this.parent.insertAfter(this, add) 4663 return this 4664 } 4665 4666 assign(overrides = {}) { 4667 for (let name in overrides) { 4668 this[name] = overrides[name] 4669 } 4670 return this 4671 } 4672 4673 before(add) { 4674 this.parent.insertBefore(this, add) 4675 return this 4676 } 4677 4678 cleanRaws(keepBetween) { 4679 delete this.raws.before 4680 delete this.raws.after 4681 if (!keepBetween) delete this.raws.between 4682 } 4683 4684 clone(overrides = {}) { 4685 let cloned = cloneNode(this) 4686 for (let name in overrides) { 4687 cloned[name] = overrides[name] 4688 } 4689 return cloned 4690 } 4691 4692 cloneAfter(overrides = {}) { 4693 let cloned = this.clone(overrides) 4694 this.parent.insertAfter(this, cloned) 4695 return cloned 4696 } 4697 4698 cloneBefore(overrides = {}) { 4699 let cloned = this.clone(overrides) 4700 this.parent.insertBefore(this, cloned) 4701 return cloned 4702 } 4703 4704 error(message, opts = {}) { 4705 if (this.source) { 4706 let { end, start } = this.rangeBy(opts) 4707 return this.source.input.error( 4708 message, 4709 { column: start.column, line: start.line }, 4710 { column: end.column, line: end.line }, 4711 opts 4712 ) 4713 } 4714 return new CssSyntaxError(message) 4715 } 4716 4717 getProxyProcessor() { 4718 return { 4719 get(node, prop) { 4720 if (prop === 'proxyOf') { 4721 return node 4722 } else if (prop === 'root') { 4723 return () => node.root().toProxy() 4724 } else { 4725 return node[prop] 4726 } 4727 }, 4728 4729 set(node, prop, value) { 4730 if (node[prop] === value) return true 4731 node[prop] = value 4732 if ( 4733 prop === 'prop' || 4734 prop === 'value' || 4735 prop === 'name' || 4736 prop === 'params' || 4737 prop === 'important' || 4738 /* c8 ignore next */ 4739 prop === 'text' 4740 ) { 4741 node.markDirty() 4742 } 4743 return true 4744 } 4745 } 4746 } 4747 4748 markDirty() { 4749 if (this[isClean]) { 4750 this[isClean] = false 4751 let next = this 4752 while ((next = next.parent)) { 4753 next[isClean] = false 4754 } 4755 } 4756 } 4757 4758 next() { 4759 if (!this.parent) return undefined 4760 let index = this.parent.index(this) 4761 return this.parent.nodes[index + 1] 4762 } 4763 4764 positionBy(opts, stringRepresentation) { 4765 let pos = this.source.start 4766 if (opts.index) { 4767 pos = this.positionInside(opts.index, stringRepresentation) 4768 } else if (opts.word) { 4769 stringRepresentation = this.toString() 4770 let index = stringRepresentation.indexOf(opts.word) 4771 if (index !== -1) pos = this.positionInside(index, stringRepresentation) 4772 } 4773 return pos 4774 } 4775 4776 positionInside(index, stringRepresentation) { 4777 let string = stringRepresentation || this.toString() 4778 let column = this.source.start.column 4779 let line = this.source.start.line 4780 4781 for (let i = 0; i < index; i++) { 4782 if (string[i] === '\n') { 4783 column = 1 4784 line += 1 4785 } else { 4786 column += 1 4787 } 4788 } 4789 4790 return { column, line } 4791 } 4792 4793 prev() { 4794 if (!this.parent) return undefined 4795 let index = this.parent.index(this) 4796 return this.parent.nodes[index - 1] 4797 } 4798 4799 rangeBy(opts) { 4800 let start = { 4801 column: this.source.start.column, 4802 line: this.source.start.line 4803 } 4804 let end = this.source.end 4805 ? { 4806 column: this.source.end.column + 1, 4807 line: this.source.end.line 4808 } 4809 : { 4810 column: start.column + 1, 4811 line: start.line 4812 } 4813 4814 if (opts.word) { 4815 let stringRepresentation = this.toString() 4816 let index = stringRepresentation.indexOf(opts.word) 4817 if (index !== -1) { 4818 start = this.positionInside(index, stringRepresentation) 4819 end = this.positionInside(index + opts.word.length, stringRepresentation) 4820 } 4821 } else { 4822 if (opts.start) { 4823 start = { 4824 column: opts.start.column, 4825 line: opts.start.line 4826 } 4827 } else if (opts.index) { 4828 start = this.positionInside(opts.index) 4829 } 4830 4831 if (opts.end) { 4832 end = { 4833 column: opts.end.column, 4834 line: opts.end.line 4835 } 4836 } else if (typeof opts.endIndex === 'number') { 4837 end = this.positionInside(opts.endIndex) 4838 } else if (opts.index) { 4839 end = this.positionInside(opts.index + 1) 4840 } 4841 } 4842 4843 if ( 4844 end.line < start.line || 4845 (end.line === start.line && end.column <= start.column) 4846 ) { 4847 end = { column: start.column + 1, line: start.line } 4848 } 4849 4850 return { end, start } 4851 } 4852 4853 raw(prop, defaultType) { 4854 let str = new Stringifier() 4855 return str.raw(this, prop, defaultType) 4856 } 4857 4858 remove() { 4859 if (this.parent) { 4860 this.parent.removeChild(this) 4861 } 4862 this.parent = undefined 4863 return this 4864 } 4865 4866 replaceWith(...nodes) { 4867 if (this.parent) { 4868 let bookmark = this 4869 let foundSelf = false 4870 for (let node of nodes) { 4871 if (node === this) { 4872 foundSelf = true 4873 } else if (foundSelf) { 4874 this.parent.insertAfter(bookmark, node) 4875 bookmark = node 4876 } else { 4877 this.parent.insertBefore(bookmark, node) 4878 } 4879 } 4880 4881 if (!foundSelf) { 4882 this.remove() 4883 } 4884 } 4885 4886 return this 4887 } 4888 4889 root() { 4890 let result = this 4891 while (result.parent && result.parent.type !== 'document') { 4892 result = result.parent 4893 } 4894 return result 4895 } 4896 4897 toJSON(_, inputs) { 4898 let fixed = {} 4899 let emitInputs = inputs == null 4900 inputs = inputs || new Map() 4901 let inputsNextIndex = 0 4902 4903 for (let name in this) { 4904 if (!Object.prototype.hasOwnProperty.call(this, name)) { 4905 /* c8 ignore next 2 */ 4906 continue 4907 } 4908 if (name === 'parent' || name === 'proxyCache') continue 4909 let value = this[name] 4910 4911 if (Array.isArray(value)) { 4912 fixed[name] = value.map(i => { 4913 if (typeof i === 'object' && i.toJSON) { 4914 return i.toJSON(null, inputs) 4915 } else { 4916 return i 4917 } 4918 }) 4919 } else if (typeof value === 'object' && value.toJSON) { 4920 fixed[name] = value.toJSON(null, inputs) 4921 } else if (name === 'source') { 4922 let inputId = inputs.get(value.input) 4923 if (inputId == null) { 4924 inputId = inputsNextIndex 4925 inputs.set(value.input, inputsNextIndex) 4926 inputsNextIndex++ 4927 } 4928 fixed[name] = { 4929 end: value.end, 4930 inputId, 4931 start: value.start 4932 } 4933 } else { 4934 fixed[name] = value 4935 } 4936 } 4937 4938 if (emitInputs) { 4939 fixed.inputs = [...inputs.keys()].map(input => input.toJSON()) 4940 } 4941 4942 return fixed 4943 } 4944 4945 toProxy() { 4946 if (!this.proxyCache) { 4947 this.proxyCache = new Proxy(this, this.getProxyProcessor()) 4948 } 4949 return this.proxyCache 4950 } 4951 4952 toString(stringifier = stringify) { 4953 if (stringifier.stringify) stringifier = stringifier.stringify 4954 let result = '' 4955 stringifier(this, i => { 4956 result += i 4957 }) 4958 return result 4959 } 4960 4961 warn(result, text, opts) { 4962 let data = { node: this } 4963 for (let i in opts) data[i] = opts[i] 4964 return result.warn(text, data) 4965 } 4966 4967 get proxyOf() { 4968 return this 4969 } 4970 } 4971 4972 module.exports = Node 4973 Node.default = Node 4974 4975 4976 /***/ }), 4977 4978 /***/ 4295: 4979 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 4980 4981 "use strict"; 4982 4983 4984 let Container = __webpack_require__(683) 4985 let Parser = __webpack_require__(3937) 4986 let Input = __webpack_require__(5380) 4987 4988 function parse(css, opts) { 4989 let input = new Input(css, opts) 4990 let parser = new Parser(input) 4991 try { 4992 parser.parse() 4993 } catch (e) { 4994 if (false) {} 4995 throw e 4996 } 4997 4998 return parser.root 4999 } 5000 5001 module.exports = parse 5002 parse.default = parse 5003 5004 Container.registerParse(parse) 5005 5006 5007 /***/ }), 5008 5009 /***/ 3937: 5010 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 5011 5012 "use strict"; 5013 5014 5015 let Declaration = __webpack_require__(1516) 5016 let tokenizer = __webpack_require__(2327) 5017 let Comment = __webpack_require__(6589) 5018 let AtRule = __webpack_require__(1326) 5019 let Root = __webpack_require__(9434) 5020 let Rule = __webpack_require__(4092) 5021 5022 const SAFE_COMMENT_NEIGHBOR = { 5023 empty: true, 5024 space: true 5025 } 5026 5027 function findLastWithPosition(tokens) { 5028 for (let i = tokens.length - 1; i >= 0; i--) { 5029 let token = tokens[i] 5030 let pos = token[3] || token[2] 5031 if (pos) return pos 5032 } 5033 } 5034 5035 class Parser { 5036 constructor(input) { 5037 this.input = input 5038 5039 this.root = new Root() 5040 this.current = this.root 5041 this.spaces = '' 5042 this.semicolon = false 5043 5044 this.createTokenizer() 5045 this.root.source = { input, start: { column: 1, line: 1, offset: 0 } } 5046 } 5047 5048 atrule(token) { 5049 let node = new AtRule() 5050 node.name = token[1].slice(1) 5051 if (node.name === '') { 5052 this.unnamedAtrule(node, token) 5053 } 5054 this.init(node, token[2]) 5055 5056 let type 5057 let prev 5058 let shift 5059 let last = false 5060 let open = false 5061 let params = [] 5062 let brackets = [] 5063 5064 while (!this.tokenizer.endOfFile()) { 5065 token = this.tokenizer.nextToken() 5066 type = token[0] 5067 5068 if (type === '(' || type === '[') { 5069 brackets.push(type === '(' ? ')' : ']') 5070 } else if (type === '{' && brackets.length > 0) { 5071 brackets.push('}') 5072 } else if (type === brackets[brackets.length - 1]) { 5073 brackets.pop() 5074 } 5075 5076 if (brackets.length === 0) { 5077 if (type === ';') { 5078 node.source.end = this.getPosition(token[2]) 5079 node.source.end.offset++ 5080 this.semicolon = true 5081 break 5082 } else if (type === '{') { 5083 open = true 5084 break 5085 } else if (type === '}') { 5086 if (params.length > 0) { 5087 shift = params.length - 1 5088 prev = params[shift] 5089 while (prev && prev[0] === 'space') { 5090 prev = params[--shift] 5091 } 5092 if (prev) { 5093 node.source.end = this.getPosition(prev[3] || prev[2]) 5094 node.source.end.offset++ 5095 } 5096 } 5097 this.end(token) 5098 break 5099 } else { 5100 params.push(token) 5101 } 5102 } else { 5103 params.push(token) 5104 } 5105 5106 if (this.tokenizer.endOfFile()) { 5107 last = true 5108 break 5109 } 5110 } 5111 5112 node.raws.between = this.spacesAndCommentsFromEnd(params) 5113 if (params.length) { 5114 node.raws.afterName = this.spacesAndCommentsFromStart(params) 5115 this.raw(node, 'params', params) 5116 if (last) { 5117 token = params[params.length - 1] 5118 node.source.end = this.getPosition(token[3] || token[2]) 5119 node.source.end.offset++ 5120 this.spaces = node.raws.between 5121 node.raws.between = '' 5122 } 5123 } else { 5124 node.raws.afterName = '' 5125 node.params = '' 5126 } 5127 5128 if (open) { 5129 node.nodes = [] 5130 this.current = node 5131 } 5132 } 5133 5134 checkMissedSemicolon(tokens) { 5135 let colon = this.colon(tokens) 5136 if (colon === false) return 5137 5138 let founded = 0 5139 let token 5140 for (let j = colon - 1; j >= 0; j--) { 5141 token = tokens[j] 5142 if (token[0] !== 'space') { 5143 founded += 1 5144 if (founded === 2) break 5145 } 5146 } 5147 // If the token is a word, e.g. `!important`, `red` or any other valid property's value. 5148 // Then we need to return the colon after that word token. [3] is the "end" colon of that word. 5149 // And because we need it after that one we do +1 to get the next one. 5150 throw this.input.error( 5151 'Missed semicolon', 5152 token[0] === 'word' ? token[3] + 1 : token[2] 5153 ) 5154 } 5155 5156 colon(tokens) { 5157 let brackets = 0 5158 let token, type, prev 5159 for (let [i, element] of tokens.entries()) { 5160 token = element 5161 type = token[0] 5162 5163 if (type === '(') { 5164 brackets += 1 5165 } 5166 if (type === ')') { 5167 brackets -= 1 5168 } 5169 if (brackets === 0 && type === ':') { 5170 if (!prev) { 5171 this.doubleColon(token) 5172 } else if (prev[0] === 'word' && prev[1] === 'progid') { 5173 continue 5174 } else { 5175 return i 5176 } 5177 } 5178 5179 prev = token 5180 } 5181 return false 5182 } 5183 5184 comment(token) { 5185 let node = new Comment() 5186 this.init(node, token[2]) 5187 node.source.end = this.getPosition(token[3] || token[2]) 5188 node.source.end.offset++ 5189 5190 let text = token[1].slice(2, -2) 5191 if (/^\s*$/.test(text)) { 5192 node.text = '' 5193 node.raws.left = text 5194 node.raws.right = '' 5195 } else { 5196 let match = text.match(/^(\s*)([^]*\S)(\s*)$/) 5197 node.text = match[2] 5198 node.raws.left = match[1] 5199 node.raws.right = match[3] 5200 } 5201 } 5202 5203 createTokenizer() { 5204 this.tokenizer = tokenizer(this.input) 5205 } 5206 5207 decl(tokens, customProperty) { 5208 let node = new Declaration() 5209 this.init(node, tokens[0][2]) 5210 5211 let last = tokens[tokens.length - 1] 5212 if (last[0] === ';') { 5213 this.semicolon = true 5214 tokens.pop() 5215 } 5216 5217 node.source.end = this.getPosition( 5218 last[3] || last[2] || findLastWithPosition(tokens) 5219 ) 5220 node.source.end.offset++ 5221 5222 while (tokens[0][0] !== 'word') { 5223 if (tokens.length === 1) this.unknownWord(tokens) 5224 node.raws.before += tokens.shift()[1] 5225 } 5226 node.source.start = this.getPosition(tokens[0][2]) 5227 5228 node.prop = '' 5229 while (tokens.length) { 5230 let type = tokens[0][0] 5231 if (type === ':' || type === 'space' || type === 'comment') { 5232 break 5233 } 5234 node.prop += tokens.shift()[1] 5235 } 5236 5237 node.raws.between = '' 5238 5239 let token 5240 while (tokens.length) { 5241 token = tokens.shift() 5242 5243 if (token[0] === ':') { 5244 node.raws.between += token[1] 5245 break 5246 } else { 5247 if (token[0] === 'word' && /\w/.test(token[1])) { 5248 this.unknownWord([token]) 5249 } 5250 node.raws.between += token[1] 5251 } 5252 } 5253 5254 if (node.prop[0] === '_' || node.prop[0] === '*') { 5255 node.raws.before += node.prop[0] 5256 node.prop = node.prop.slice(1) 5257 } 5258 5259 let firstSpaces = [] 5260 let next 5261 while (tokens.length) { 5262 next = tokens[0][0] 5263 if (next !== 'space' && next !== 'comment') break 5264 firstSpaces.push(tokens.shift()) 5265 } 5266 5267 this.precheckMissedSemicolon(tokens) 5268 5269 for (let i = tokens.length - 1; i >= 0; i--) { 5270 token = tokens[i] 5271 if (token[1].toLowerCase() === '!important') { 5272 node.important = true 5273 let string = this.stringFrom(tokens, i) 5274 string = this.spacesFromEnd(tokens) + string 5275 if (string !== ' !important') node.raws.important = string 5276 break 5277 } else if (token[1].toLowerCase() === 'important') { 5278 let cache = tokens.slice(0) 5279 let str = '' 5280 for (let j = i; j > 0; j--) { 5281 let type = cache[j][0] 5282 if (str.trim().indexOf('!') === 0 && type !== 'space') { 5283 break 5284 } 5285 str = cache.pop()[1] + str 5286 } 5287 if (str.trim().indexOf('!') === 0) { 5288 node.important = true 5289 node.raws.important = str 5290 tokens = cache 5291 } 5292 } 5293 5294 if (token[0] !== 'space' && token[0] !== 'comment') { 5295 break 5296 } 5297 } 5298 5299 let hasWord = tokens.some(i => i[0] !== 'space' && i[0] !== 'comment') 5300 5301 if (hasWord) { 5302 node.raws.between += firstSpaces.map(i => i[1]).join('') 5303 firstSpaces = [] 5304 } 5305 this.raw(node, 'value', firstSpaces.concat(tokens), customProperty) 5306 5307 if (node.value.includes(':') && !customProperty) { 5308 this.checkMissedSemicolon(tokens) 5309 } 5310 } 5311 5312 doubleColon(token) { 5313 throw this.input.error( 5314 'Double colon', 5315 { offset: token[2] }, 5316 { offset: token[2] + token[1].length } 5317 ) 5318 } 5319 5320 emptyRule(token) { 5321 let node = new Rule() 5322 this.init(node, token[2]) 5323 node.selector = '' 5324 node.raws.between = '' 5325 this.current = node 5326 } 5327 5328 end(token) { 5329 if (this.current.nodes && this.current.nodes.length) { 5330 this.current.raws.semicolon = this.semicolon 5331 } 5332 this.semicolon = false 5333 5334 this.current.raws.after = (this.current.raws.after || '') + this.spaces 5335 this.spaces = '' 5336 5337 if (this.current.parent) { 5338 this.current.source.end = this.getPosition(token[2]) 5339 this.current.source.end.offset++ 5340 this.current = this.current.parent 5341 } else { 5342 this.unexpectedClose(token) 5343 } 5344 } 5345 5346 endFile() { 5347 if (this.current.parent) this.unclosedBlock() 5348 if (this.current.nodes && this.current.nodes.length) { 5349 this.current.raws.semicolon = this.semicolon 5350 } 5351 this.current.raws.after = (this.current.raws.after || '') + this.spaces 5352 this.root.source.end = this.getPosition(this.tokenizer.position()) 5353 } 5354 5355 freeSemicolon(token) { 5356 this.spaces += token[1] 5357 if (this.current.nodes) { 5358 let prev = this.current.nodes[this.current.nodes.length - 1] 5359 if (prev && prev.type === 'rule' && !prev.raws.ownSemicolon) { 5360 prev.raws.ownSemicolon = this.spaces 5361 this.spaces = '' 5362 } 5363 } 5364 } 5365 5366 // Helpers 5367 5368 getPosition(offset) { 5369 let pos = this.input.fromOffset(offset) 5370 return { 5371 column: pos.col, 5372 line: pos.line, 5373 offset 5374 } 5375 } 5376 5377 init(node, offset) { 5378 this.current.push(node) 5379 node.source = { 5380 input: this.input, 5381 start: this.getPosition(offset) 5382 } 5383 node.raws.before = this.spaces 5384 this.spaces = '' 5385 if (node.type !== 'comment') this.semicolon = false 5386 } 5387 5388 other(start) { 5389 let end = false 5390 let type = null 5391 let colon = false 5392 let bracket = null 5393 let brackets = [] 5394 let customProperty = start[1].startsWith('--') 5395 5396 let tokens = [] 5397 let token = start 5398 while (token) { 5399 type = token[0] 5400 tokens.push(token) 5401 5402 if (type === '(' || type === '[') { 5403 if (!bracket) bracket = token 5404 brackets.push(type === '(' ? ')' : ']') 5405 } else if (customProperty && colon && type === '{') { 5406 if (!bracket) bracket = token 5407 brackets.push('}') 5408 } else if (brackets.length === 0) { 5409 if (type === ';') { 5410 if (colon) { 5411 this.decl(tokens, customProperty) 5412 return 5413 } else { 5414 break 5415 } 5416 } else if (type === '{') { 5417 this.rule(tokens) 5418 return 5419 } else if (type === '}') { 5420 this.tokenizer.back(tokens.pop()) 5421 end = true 5422 break 5423 } else if (type === ':') { 5424 colon = true 5425 } 5426 } else if (type === brackets[brackets.length - 1]) { 5427 brackets.pop() 5428 if (brackets.length === 0) bracket = null 5429 } 5430 5431 token = this.tokenizer.nextToken() 5432 } 5433 5434 if (this.tokenizer.endOfFile()) end = true 5435 if (brackets.length > 0) this.unclosedBracket(bracket) 5436 5437 if (end && colon) { 5438 if (!customProperty) { 5439 while (tokens.length) { 5440 token = tokens[tokens.length - 1][0] 5441 if (token !== 'space' && token !== 'comment') break 5442 this.tokenizer.back(tokens.pop()) 5443 } 5444 } 5445 this.decl(tokens, customProperty) 5446 } else { 5447 this.unknownWord(tokens) 5448 } 5449 } 5450 5451 parse() { 5452 let token 5453 while (!this.tokenizer.endOfFile()) { 5454 token = this.tokenizer.nextToken() 5455 5456 switch (token[0]) { 5457 case 'space': 5458 this.spaces += token[1] 5459 break 5460 5461 case ';': 5462 this.freeSemicolon(token) 5463 break 5464 5465 case '}': 5466 this.end(token) 5467 break 5468 5469 case 'comment': 5470 this.comment(token) 5471 break 5472 5473 case 'at-word': 5474 this.atrule(token) 5475 break 5476 5477 case '{': 5478 this.emptyRule(token) 5479 break 5480 5481 default: 5482 this.other(token) 5483 break 5484 } 5485 } 5486 this.endFile() 5487 } 5488 5489 precheckMissedSemicolon(/* tokens */) { 5490 // Hook for Safe Parser 5491 } 5492 5493 raw(node, prop, tokens, customProperty) { 5494 let token, type 5495 let length = tokens.length 5496 let value = '' 5497 let clean = true 5498 let next, prev 5499 5500 for (let i = 0; i < length; i += 1) { 5501 token = tokens[i] 5502 type = token[0] 5503 if (type === 'space' && i === length - 1 && !customProperty) { 5504 clean = false 5505 } else if (type === 'comment') { 5506 prev = tokens[i - 1] ? tokens[i - 1][0] : 'empty' 5507 next = tokens[i + 1] ? tokens[i + 1][0] : 'empty' 5508 if (!SAFE_COMMENT_NEIGHBOR[prev] && !SAFE_COMMENT_NEIGHBOR[next]) { 5509 if (value.slice(-1) === ',') { 5510 clean = false 5511 } else { 5512 value += token[1] 5513 } 5514 } else { 5515 clean = false 5516 } 5517 } else { 5518 value += token[1] 5519 } 5520 } 5521 if (!clean) { 5522 let raw = tokens.reduce((all, i) => all + i[1], '') 5523 node.raws[prop] = { raw, value } 5524 } 5525 node[prop] = value 5526 } 5527 5528 rule(tokens) { 5529 tokens.pop() 5530 5531 let node = new Rule() 5532 this.init(node, tokens[0][2]) 5533 5534 node.raws.between = this.spacesAndCommentsFromEnd(tokens) 5535 this.raw(node, 'selector', tokens) 5536 this.current = node 5537 } 5538 5539 spacesAndCommentsFromEnd(tokens) { 5540 let lastTokenType 5541 let spaces = '' 5542 while (tokens.length) { 5543 lastTokenType = tokens[tokens.length - 1][0] 5544 if (lastTokenType !== 'space' && lastTokenType !== 'comment') break 5545 spaces = tokens.pop()[1] + spaces 5546 } 5547 return spaces 5548 } 5549 5550 // Errors 5551 5552 spacesAndCommentsFromStart(tokens) { 5553 let next 5554 let spaces = '' 5555 while (tokens.length) { 5556 next = tokens[0][0] 5557 if (next !== 'space' && next !== 'comment') break 5558 spaces += tokens.shift()[1] 5559 } 5560 return spaces 5561 } 5562 5563 spacesFromEnd(tokens) { 5564 let lastTokenType 5565 let spaces = '' 5566 while (tokens.length) { 5567 lastTokenType = tokens[tokens.length - 1][0] 5568 if (lastTokenType !== 'space') break 5569 spaces = tokens.pop()[1] + spaces 5570 } 5571 return spaces 5572 } 5573 5574 stringFrom(tokens, from) { 5575 let result = '' 5576 for (let i = from; i < tokens.length; i++) { 5577 result += tokens[i][1] 5578 } 5579 tokens.splice(from, tokens.length - from) 5580 return result 5581 } 5582 5583 unclosedBlock() { 5584 let pos = this.current.source.start 5585 throw this.input.error('Unclosed block', pos.line, pos.column) 5586 } 5587 5588 unclosedBracket(bracket) { 5589 throw this.input.error( 5590 'Unclosed bracket', 5591 { offset: bracket[2] }, 5592 { offset: bracket[2] + 1 } 5593 ) 5594 } 5595 5596 unexpectedClose(token) { 5597 throw this.input.error( 5598 'Unexpected }', 5599 { offset: token[2] }, 5600 { offset: token[2] + 1 } 5601 ) 5602 } 5603 5604 unknownWord(tokens) { 5605 throw this.input.error( 5606 'Unknown word', 5607 { offset: tokens[0][2] }, 5608 { offset: tokens[0][2] + tokens[0][1].length } 5609 ) 5610 } 5611 5612 unnamedAtrule(node, token) { 5613 throw this.input.error( 5614 'At-rule without name', 5615 { offset: token[2] }, 5616 { offset: token[2] + token[1].length } 5617 ) 5618 } 5619 } 5620 5621 module.exports = Parser 5622 5623 5624 /***/ }), 5625 5626 /***/ 4529: 5627 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 5628 5629 "use strict"; 5630 5631 5632 let CssSyntaxError = __webpack_require__(356) 5633 let Declaration = __webpack_require__(1516) 5634 let LazyResult = __webpack_require__(448) 5635 let Container = __webpack_require__(683) 5636 let Processor = __webpack_require__(9656) 5637 let stringify = __webpack_require__(633) 5638 let fromJSON = __webpack_require__(8940) 5639 let Document = __webpack_require__(271) 5640 let Warning = __webpack_require__(5776) 5641 let Comment = __webpack_require__(6589) 5642 let AtRule = __webpack_require__(1326) 5643 let Result = __webpack_require__(9055) 5644 let Input = __webpack_require__(5380) 5645 let parse = __webpack_require__(4295) 5646 let list = __webpack_require__(7374) 5647 let Rule = __webpack_require__(4092) 5648 let Root = __webpack_require__(9434) 5649 let Node = __webpack_require__(7490) 5650 5651 function postcss(...plugins) { 5652 if (plugins.length === 1 && Array.isArray(plugins[0])) { 5653 plugins = plugins[0] 5654 } 5655 return new Processor(plugins) 5656 } 5657 5658 postcss.plugin = function plugin(name, initializer) { 5659 let warningPrinted = false 5660 function creator(...args) { 5661 // eslint-disable-next-line no-console 5662 if (console && console.warn && !warningPrinted) { 5663 warningPrinted = true 5664 // eslint-disable-next-line no-console 5665 console.warn( 5666 name + 5667 ': postcss.plugin was deprecated. Migration guide:\n' + 5668 'https://evilmartians.com/chronicles/postcss-8-plugin-migration' 5669 ) 5670 if (process.env.LANG && process.env.LANG.startsWith('cn')) { 5671 /* c8 ignore next 7 */ 5672 // eslint-disable-next-line no-console 5673 console.warn( 5674 name + 5675 ': 里面 postcss.plugin 被弃用. 迁移指南:\n' + 5676 'https://www.w3ctech.com/topic/2226' 5677 ) 5678 } 5679 } 5680 let transformer = initializer(...args) 5681 transformer.postcssPlugin = name 5682 transformer.postcssVersion = new Processor().version 5683 return transformer 5684 } 5685 5686 let cache 5687 Object.defineProperty(creator, 'postcss', { 5688 get() { 5689 if (!cache) cache = creator() 5690 return cache 5691 } 5692 }) 5693 5694 creator.process = function (css, processOpts, pluginOpts) { 5695 return postcss([creator(pluginOpts)]).process(css, processOpts) 5696 } 5697 5698 return creator 5699 } 5700 5701 postcss.stringify = stringify 5702 postcss.parse = parse 5703 postcss.fromJSON = fromJSON 5704 postcss.list = list 5705 5706 postcss.comment = defaults => new Comment(defaults) 5707 postcss.atRule = defaults => new AtRule(defaults) 5708 postcss.decl = defaults => new Declaration(defaults) 5709 postcss.rule = defaults => new Rule(defaults) 5710 postcss.root = defaults => new Root(defaults) 5711 postcss.document = defaults => new Document(defaults) 5712 5713 postcss.CssSyntaxError = CssSyntaxError 5714 postcss.Declaration = Declaration 5715 postcss.Container = Container 5716 postcss.Processor = Processor 5717 postcss.Document = Document 5718 postcss.Comment = Comment 5719 postcss.Warning = Warning 5720 postcss.AtRule = AtRule 5721 postcss.Result = Result 5722 postcss.Input = Input 5723 postcss.Rule = Rule 5724 postcss.Root = Root 5725 postcss.Node = Node 5726 5727 LazyResult.registerPostcss(postcss) 5728 5729 module.exports = postcss 5730 postcss.default = postcss 5731 5732 5733 /***/ }), 5734 5735 /***/ 5696: 5736 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 5737 5738 "use strict"; 5739 5740 5741 let { SourceMapConsumer, SourceMapGenerator } = __webpack_require__(1866) 5742 let { existsSync, readFileSync } = __webpack_require__(9977) 5743 let { dirname, join } = __webpack_require__(197) 5744 5745 function fromBase64(str) { 5746 if (Buffer) { 5747 return Buffer.from(str, 'base64').toString() 5748 } else { 5749 /* c8 ignore next 2 */ 5750 return window.atob(str) 5751 } 5752 } 5753 5754 class PreviousMap { 5755 constructor(css, opts) { 5756 if (opts.map === false) return 5757 this.loadAnnotation(css) 5758 this.inline = this.startWith(this.annotation, 'data:') 5759 5760 let prev = opts.map ? opts.map.prev : undefined 5761 let text = this.loadMap(opts.from, prev) 5762 if (!this.mapFile && opts.from) { 5763 this.mapFile = opts.from 5764 } 5765 if (this.mapFile) this.root = dirname(this.mapFile) 5766 if (text) this.text = text 5767 } 5768 5769 consumer() { 5770 if (!this.consumerCache) { 5771 this.consumerCache = new SourceMapConsumer(this.text) 5772 } 5773 return this.consumerCache 5774 } 5775 5776 decodeInline(text) { 5777 let baseCharsetUri = /^data:application\/json;charset=utf-?8;base64,/ 5778 let baseUri = /^data:application\/json;base64,/ 5779 let charsetUri = /^data:application\/json;charset=utf-?8,/ 5780 let uri = /^data:application\/json,/ 5781 5782 if (charsetUri.test(text) || uri.test(text)) { 5783 return decodeURIComponent(text.substr(RegExp.lastMatch.length)) 5784 } 5785 5786 if (baseCharsetUri.test(text) || baseUri.test(text)) { 5787 return fromBase64(text.substr(RegExp.lastMatch.length)) 5788 } 5789 5790 let encoding = text.match(/data:application\/json;([^,]+),/)[1] 5791 throw new Error('Unsupported source map encoding ' + encoding) 5792 } 5793 5794 getAnnotationURL(sourceMapString) { 5795 return sourceMapString.replace(/^\/\*\s*# sourceMappingURL=/, '').trim() 5796 } 5797 5798 isMap(map) { 5799 if (typeof map !== 'object') return false 5800 return ( 5801 typeof map.mappings === 'string' || 5802 typeof map._mappings === 'string' || 5803 Array.isArray(map.sections) 5804 ) 5805 } 5806 5807 loadAnnotation(css) { 5808 let comments = css.match(/\/\*\s*# sourceMappingURL=/gm) 5809 if (!comments) return 5810 5811 // sourceMappingURLs from comments, strings, etc. 5812 let start = css.lastIndexOf(comments.pop()) 5813 let end = css.indexOf('*/', start) 5814 5815 if (start > -1 && end > -1) { 5816 // Locate the last sourceMappingURL to avoid pickin 5817 this.annotation = this.getAnnotationURL(css.substring(start, end)) 5818 } 5819 } 5820 5821 loadFile(path) { 5822 this.root = dirname(path) 5823 if (existsSync(path)) { 5824 this.mapFile = path 5825 return readFileSync(path, 'utf-8').toString().trim() 5826 } 5827 } 5828 5829 loadMap(file, prev) { 5830 if (prev === false) return false 5831 5832 if (prev) { 5833 if (typeof prev === 'string') { 5834 return prev 5835 } else if (typeof prev === 'function') { 5836 let prevPath = prev(file) 5837 if (prevPath) { 5838 let map = this.loadFile(prevPath) 5839 if (!map) { 5840 throw new Error( 5841 'Unable to load previous source map: ' + prevPath.toString() 5842 ) 5843 } 5844 return map 5845 } 5846 } else if (prev instanceof SourceMapConsumer) { 5847 return SourceMapGenerator.fromSourceMap(prev).toString() 5848 } else if (prev instanceof SourceMapGenerator) { 5849 return prev.toString() 5850 } else if (this.isMap(prev)) { 5851 return JSON.stringify(prev) 5852 } else { 5853 throw new Error( 5854 'Unsupported previous source map format: ' + prev.toString() 5855 ) 5856 } 5857 } else if (this.inline) { 5858 return this.decodeInline(this.annotation) 5859 } else if (this.annotation) { 5860 let map = this.annotation 5861 if (file) map = join(dirname(file), map) 5862 return this.loadFile(map) 5863 } 5864 } 5865 5866 startWith(string, start) { 5867 if (!string) return false 5868 return string.substr(0, start.length) === start 5869 } 5870 5871 withContent() { 5872 return !!( 5873 this.consumer().sourcesContent && 5874 this.consumer().sourcesContent.length > 0 5875 ) 5876 } 5877 } 5878 5879 module.exports = PreviousMap 5880 PreviousMap.default = PreviousMap 5881 5882 5883 /***/ }), 5884 5885 /***/ 9656: 5886 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 5887 5888 "use strict"; 5889 5890 5891 let NoWorkResult = __webpack_require__(7661) 5892 let LazyResult = __webpack_require__(448) 5893 let Document = __webpack_require__(271) 5894 let Root = __webpack_require__(9434) 5895 5896 class Processor { 5897 constructor(plugins = []) { 5898 this.version = '8.4.38' 5899 this.plugins = this.normalize(plugins) 5900 } 5901 5902 normalize(plugins) { 5903 let normalized = [] 5904 for (let i of plugins) { 5905 if (i.postcss === true) { 5906 i = i() 5907 } else if (i.postcss) { 5908 i = i.postcss 5909 } 5910 5911 if (typeof i === 'object' && Array.isArray(i.plugins)) { 5912 normalized = normalized.concat(i.plugins) 5913 } else if (typeof i === 'object' && i.postcssPlugin) { 5914 normalized.push(i) 5915 } else if (typeof i === 'function') { 5916 normalized.push(i) 5917 } else if (typeof i === 'object' && (i.parse || i.stringify)) { 5918 if (false) {} 5919 } else { 5920 throw new Error(i + ' is not a PostCSS plugin') 5921 } 5922 } 5923 return normalized 5924 } 5925 5926 process(css, opts = {}) { 5927 if ( 5928 !this.plugins.length && 5929 !opts.parser && 5930 !opts.stringifier && 5931 !opts.syntax 5932 ) { 5933 return new NoWorkResult(this, css, opts) 5934 } else { 5935 return new LazyResult(this, css, opts) 5936 } 5937 } 5938 5939 use(plugin) { 5940 this.plugins = this.plugins.concat(this.normalize([plugin])) 5941 return this 5942 } 5943 } 5944 5945 module.exports = Processor 5946 Processor.default = Processor 5947 5948 Root.registerProcessor(Processor) 5949 Document.registerProcessor(Processor) 5950 5951 5952 /***/ }), 5953 5954 /***/ 9055: 5955 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 5956 5957 "use strict"; 5958 5959 5960 let Warning = __webpack_require__(5776) 5961 5962 class Result { 5963 constructor(processor, root, opts) { 5964 this.processor = processor 5965 this.messages = [] 5966 this.root = root 5967 this.opts = opts 5968 this.css = undefined 5969 this.map = undefined 5970 } 5971 5972 toString() { 5973 return this.css 5974 } 5975 5976 warn(text, opts = {}) { 5977 if (!opts.plugin) { 5978 if (this.lastPlugin && this.lastPlugin.postcssPlugin) { 5979 opts.plugin = this.lastPlugin.postcssPlugin 5980 } 5981 } 5982 5983 let warning = new Warning(text, opts) 5984 this.messages.push(warning) 5985 5986 return warning 5987 } 5988 5989 warnings() { 5990 return this.messages.filter(i => i.type === 'warning') 5991 } 5992 5993 get content() { 5994 return this.css 5995 } 5996 } 5997 5998 module.exports = Result 5999 Result.default = Result 6000 6001 6002 /***/ }), 6003 6004 /***/ 9434: 6005 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 6006 6007 "use strict"; 6008 6009 6010 let Container = __webpack_require__(683) 6011 6012 let LazyResult, Processor 6013 6014 class Root extends Container { 6015 constructor(defaults) { 6016 super(defaults) 6017 this.type = 'root' 6018 if (!this.nodes) this.nodes = [] 6019 } 6020 6021 normalize(child, sample, type) { 6022 let nodes = super.normalize(child) 6023 6024 if (sample) { 6025 if (type === 'prepend') { 6026 if (this.nodes.length > 1) { 6027 sample.raws.before = this.nodes[1].raws.before 6028 } else { 6029 delete sample.raws.before 6030 } 6031 } else if (this.first !== sample) { 6032 for (let node of nodes) { 6033 node.raws.before = sample.raws.before 6034 } 6035 } 6036 } 6037 6038 return nodes 6039 } 6040 6041 removeChild(child, ignore) { 6042 let index = this.index(child) 6043 6044 if (!ignore && index === 0 && this.nodes.length > 1) { 6045 this.nodes[1].raws.before = this.nodes[index].raws.before 6046 } 6047 6048 return super.removeChild(child) 6049 } 6050 6051 toResult(opts = {}) { 6052 let lazy = new LazyResult(new Processor(), this, opts) 6053 return lazy.stringify() 6054 } 6055 } 6056 6057 Root.registerLazyResult = dependant => { 6058 LazyResult = dependant 6059 } 6060 6061 Root.registerProcessor = dependant => { 6062 Processor = dependant 6063 } 6064 6065 module.exports = Root 6066 Root.default = Root 6067 6068 Container.registerRoot(Root) 6069 6070 6071 /***/ }), 6072 6073 /***/ 4092: 6074 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 6075 6076 "use strict"; 6077 6078 6079 let Container = __webpack_require__(683) 6080 let list = __webpack_require__(7374) 6081 6082 class Rule extends Container { 6083 constructor(defaults) { 6084 super(defaults) 6085 this.type = 'rule' 6086 if (!this.nodes) this.nodes = [] 6087 } 6088 6089 get selectors() { 6090 return list.comma(this.selector) 6091 } 6092 6093 set selectors(values) { 6094 let match = this.selector ? this.selector.match(/,\s*/) : null 6095 let sep = match ? match[0] : ',' + this.raw('between', 'beforeOpen') 6096 this.selector = values.join(sep) 6097 } 6098 } 6099 6100 module.exports = Rule 6101 Rule.default = Rule 6102 6103 Container.registerRule(Rule) 6104 6105 6106 /***/ }), 6107 6108 /***/ 346: 6109 /***/ ((module) => { 6110 6111 "use strict"; 6112 6113 6114 const DEFAULT_RAW = { 6115 after: '\n', 6116 beforeClose: '\n', 6117 beforeComment: '\n', 6118 beforeDecl: '\n', 6119 beforeOpen: ' ', 6120 beforeRule: '\n', 6121 colon: ': ', 6122 commentLeft: ' ', 6123 commentRight: ' ', 6124 emptyBody: '', 6125 indent: ' ', 6126 semicolon: false 6127 } 6128 6129 function capitalize(str) { 6130 return str[0].toUpperCase() + str.slice(1) 6131 } 6132 6133 class Stringifier { 6134 constructor(builder) { 6135 this.builder = builder 6136 } 6137 6138 atrule(node, semicolon) { 6139 let name = '@' + node.name 6140 let params = node.params ? this.rawValue(node, 'params') : '' 6141 6142 if (typeof node.raws.afterName !== 'undefined') { 6143 name += node.raws.afterName 6144 } else if (params) { 6145 name += ' ' 6146 } 6147 6148 if (node.nodes) { 6149 this.block(node, name + params) 6150 } else { 6151 let end = (node.raws.between || '') + (semicolon ? ';' : '') 6152 this.builder(name + params + end, node) 6153 } 6154 } 6155 6156 beforeAfter(node, detect) { 6157 let value 6158 if (node.type === 'decl') { 6159 value = this.raw(node, null, 'beforeDecl') 6160 } else if (node.type === 'comment') { 6161 value = this.raw(node, null, 'beforeComment') 6162 } else if (detect === 'before') { 6163 value = this.raw(node, null, 'beforeRule') 6164 } else { 6165 value = this.raw(node, null, 'beforeClose') 6166 } 6167 6168 let buf = node.parent 6169 let depth = 0 6170 while (buf && buf.type !== 'root') { 6171 depth += 1 6172 buf = buf.parent 6173 } 6174 6175 if (value.includes('\n')) { 6176 let indent = this.raw(node, null, 'indent') 6177 if (indent.length) { 6178 for (let step = 0; step < depth; step++) value += indent 6179 } 6180 } 6181 6182 return value 6183 } 6184 6185 block(node, start) { 6186 let between = this.raw(node, 'between', 'beforeOpen') 6187 this.builder(start + between + '{', node, 'start') 6188 6189 let after 6190 if (node.nodes && node.nodes.length) { 6191 this.body(node) 6192 after = this.raw(node, 'after') 6193 } else { 6194 after = this.raw(node, 'after', 'emptyBody') 6195 } 6196 6197 if (after) this.builder(after) 6198 this.builder('}', node, 'end') 6199 } 6200 6201 body(node) { 6202 let last = node.nodes.length - 1 6203 while (last > 0) { 6204 if (node.nodes[last].type !== 'comment') break 6205 last -= 1 6206 } 6207 6208 let semicolon = this.raw(node, 'semicolon') 6209 for (let i = 0; i < node.nodes.length; i++) { 6210 let child = node.nodes[i] 6211 let before = this.raw(child, 'before') 6212 if (before) this.builder(before) 6213 this.stringify(child, last !== i || semicolon) 6214 } 6215 } 6216 6217 comment(node) { 6218 let left = this.raw(node, 'left', 'commentLeft') 6219 let right = this.raw(node, 'right', 'commentRight') 6220 this.builder('/*' + left + node.text + right + '*/', node) 6221 } 6222 6223 decl(node, semicolon) { 6224 let between = this.raw(node, 'between', 'colon') 6225 let string = node.prop + between + this.rawValue(node, 'value') 6226 6227 if (node.important) { 6228 string += node.raws.important || ' !important' 6229 } 6230 6231 if (semicolon) string += ';' 6232 this.builder(string, node) 6233 } 6234 6235 document(node) { 6236 this.body(node) 6237 } 6238 6239 raw(node, own, detect) { 6240 let value 6241 if (!detect) detect = own 6242 6243 // Already had 6244 if (own) { 6245 value = node.raws[own] 6246 if (typeof value !== 'undefined') return value 6247 } 6248 6249 let parent = node.parent 6250 6251 if (detect === 'before') { 6252 // Hack for first rule in CSS 6253 if (!parent || (parent.type === 'root' && parent.first === node)) { 6254 return '' 6255 } 6256 6257 // `root` nodes in `document` should use only their own raws 6258 if (parent && parent.type === 'document') { 6259 return '' 6260 } 6261 } 6262 6263 // Floating child without parent 6264 if (!parent) return DEFAULT_RAW[detect] 6265 6266 // Detect style by other nodes 6267 let root = node.root() 6268 if (!root.rawCache) root.rawCache = {} 6269 if (typeof root.rawCache[detect] !== 'undefined') { 6270 return root.rawCache[detect] 6271 } 6272 6273 if (detect === 'before' || detect === 'after') { 6274 return this.beforeAfter(node, detect) 6275 } else { 6276 let method = 'raw' + capitalize(detect) 6277 if (this[method]) { 6278 value = this[method](root, node) 6279 } else { 6280 root.walk(i => { 6281 value = i.raws[own] 6282 if (typeof value !== 'undefined') return false 6283 }) 6284 } 6285 } 6286 6287 if (typeof value === 'undefined') value = DEFAULT_RAW[detect] 6288 6289 root.rawCache[detect] = value 6290 return value 6291 } 6292 6293 rawBeforeClose(root) { 6294 let value 6295 root.walk(i => { 6296 if (i.nodes && i.nodes.length > 0) { 6297 if (typeof i.raws.after !== 'undefined') { 6298 value = i.raws.after 6299 if (value.includes('\n')) { 6300 value = value.replace(/[^\n]+$/, '') 6301 } 6302 return false 6303 } 6304 } 6305 }) 6306 if (value) value = value.replace(/\S/g, '') 6307 return value 6308 } 6309 6310 rawBeforeComment(root, node) { 6311 let value 6312 root.walkComments(i => { 6313 if (typeof i.raws.before !== 'undefined') { 6314 value = i.raws.before 6315 if (value.includes('\n')) { 6316 value = value.replace(/[^\n]+$/, '') 6317 } 6318 return false 6319 } 6320 }) 6321 if (typeof value === 'undefined') { 6322 value = this.raw(node, null, 'beforeDecl') 6323 } else if (value) { 6324 value = value.replace(/\S/g, '') 6325 } 6326 return value 6327 } 6328 6329 rawBeforeDecl(root, node) { 6330 let value 6331 root.walkDecls(i => { 6332 if (typeof i.raws.before !== 'undefined') { 6333 value = i.raws.before 6334 if (value.includes('\n')) { 6335 value = value.replace(/[^\n]+$/, '') 6336 } 6337 return false 6338 } 6339 }) 6340 if (typeof value === 'undefined') { 6341 value = this.raw(node, null, 'beforeRule') 6342 } else if (value) { 6343 value = value.replace(/\S/g, '') 6344 } 6345 return value 6346 } 6347 6348 rawBeforeOpen(root) { 6349 let value 6350 root.walk(i => { 6351 if (i.type !== 'decl') { 6352 value = i.raws.between 6353 if (typeof value !== 'undefined') return false 6354 } 6355 }) 6356 return value 6357 } 6358 6359 rawBeforeRule(root) { 6360 let value 6361 root.walk(i => { 6362 if (i.nodes && (i.parent !== root || root.first !== i)) { 6363 if (typeof i.raws.before !== 'undefined') { 6364 value = i.raws.before 6365 if (value.includes('\n')) { 6366 value = value.replace(/[^\n]+$/, '') 6367 } 6368 return false 6369 } 6370 } 6371 }) 6372 if (value) value = value.replace(/\S/g, '') 6373 return value 6374 } 6375 6376 rawColon(root) { 6377 let value 6378 root.walkDecls(i => { 6379 if (typeof i.raws.between !== 'undefined') { 6380 value = i.raws.between.replace(/[^\s:]/g, '') 6381 return false 6382 } 6383 }) 6384 return value 6385 } 6386 6387 rawEmptyBody(root) { 6388 let value 6389 root.walk(i => { 6390 if (i.nodes && i.nodes.length === 0) { 6391 value = i.raws.after 6392 if (typeof value !== 'undefined') return false 6393 } 6394 }) 6395 return value 6396 } 6397 6398 rawIndent(root) { 6399 if (root.raws.indent) return root.raws.indent 6400 let value 6401 root.walk(i => { 6402 let p = i.parent 6403 if (p && p !== root && p.parent && p.parent === root) { 6404 if (typeof i.raws.before !== 'undefined') { 6405 let parts = i.raws.before.split('\n') 6406 value = parts[parts.length - 1] 6407 value = value.replace(/\S/g, '') 6408 return false 6409 } 6410 } 6411 }) 6412 return value 6413 } 6414 6415 rawSemicolon(root) { 6416 let value 6417 root.walk(i => { 6418 if (i.nodes && i.nodes.length && i.last.type === 'decl') { 6419 value = i.raws.semicolon 6420 if (typeof value !== 'undefined') return false 6421 } 6422 }) 6423 return value 6424 } 6425 6426 rawValue(node, prop) { 6427 let value = node[prop] 6428 let raw = node.raws[prop] 6429 if (raw && raw.value === value) { 6430 return raw.raw 6431 } 6432 6433 return value 6434 } 6435 6436 root(node) { 6437 this.body(node) 6438 if (node.raws.after) this.builder(node.raws.after) 6439 } 6440 6441 rule(node) { 6442 this.block(node, this.rawValue(node, 'selector')) 6443 if (node.raws.ownSemicolon) { 6444 this.builder(node.raws.ownSemicolon, node, 'end') 6445 } 6446 } 6447 6448 stringify(node, semicolon) { 6449 /* c8 ignore start */ 6450 if (!this[node.type]) { 6451 throw new Error( 6452 'Unknown AST node type ' + 6453 node.type + 6454 '. ' + 6455 'Maybe you need to change PostCSS stringifier.' 6456 ) 6457 } 6458 /* c8 ignore stop */ 6459 this[node.type](node, semicolon) 6460 } 6461 } 6462 6463 module.exports = Stringifier 6464 Stringifier.default = Stringifier 6465 6466 6467 /***/ }), 6468 6469 /***/ 633: 6470 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 6471 6472 "use strict"; 6473 6474 6475 let Stringifier = __webpack_require__(346) 6476 6477 function stringify(node, builder) { 6478 let str = new Stringifier(builder) 6479 str.stringify(node) 6480 } 6481 6482 module.exports = stringify 6483 stringify.default = stringify 6484 6485 6486 /***/ }), 6487 6488 /***/ 1381: 6489 /***/ ((module) => { 6490 6491 "use strict"; 6492 6493 6494 module.exports.isClean = Symbol('isClean') 6495 6496 module.exports.my = Symbol('my') 6497 6498 6499 /***/ }), 6500 6501 /***/ 2327: 6502 /***/ ((module) => { 6503 6504 "use strict"; 6505 6506 6507 const SINGLE_QUOTE = "'".charCodeAt(0) 6508 const DOUBLE_QUOTE = '"'.charCodeAt(0) 6509 const BACKSLASH = '\\'.charCodeAt(0) 6510 const SLASH = '/'.charCodeAt(0) 6511 const NEWLINE = '\n'.charCodeAt(0) 6512 const SPACE = ' '.charCodeAt(0) 6513 const FEED = '\f'.charCodeAt(0) 6514 const TAB = '\t'.charCodeAt(0) 6515 const CR = '\r'.charCodeAt(0) 6516 const OPEN_SQUARE = '['.charCodeAt(0) 6517 const CLOSE_SQUARE = ']'.charCodeAt(0) 6518 const OPEN_PARENTHESES = '('.charCodeAt(0) 6519 const CLOSE_PARENTHESES = ')'.charCodeAt(0) 6520 const OPEN_CURLY = '{'.charCodeAt(0) 6521 const CLOSE_CURLY = '}'.charCodeAt(0) 6522 const SEMICOLON = ';'.charCodeAt(0) 6523 const ASTERISK = '*'.charCodeAt(0) 6524 const COLON = ':'.charCodeAt(0) 6525 const AT = '@'.charCodeAt(0) 6526 6527 const RE_AT_END = /[\t\n\f\r "#'()/;[\\\]{}]/g 6528 const RE_WORD_END = /[\t\n\f\r !"#'():;@[\\\]{}]|\/(?=\*)/g 6529 const RE_BAD_BRACKET = /.[\r\n"'(/\\]/ 6530 const RE_HEX_ESCAPE = /[\da-f]/i 6531 6532 module.exports = function tokenizer(input, options = {}) { 6533 let css = input.css.valueOf() 6534 let ignore = options.ignoreErrors 6535 6536 let code, next, quote, content, escape 6537 let escaped, escapePos, prev, n, currentToken 6538 6539 let length = css.length 6540 let pos = 0 6541 let buffer = [] 6542 let returned = [] 6543 6544 function position() { 6545 return pos 6546 } 6547 6548 function unclosed(what) { 6549 throw input.error('Unclosed ' + what, pos) 6550 } 6551 6552 function endOfFile() { 6553 return returned.length === 0 && pos >= length 6554 } 6555 6556 function nextToken(opts) { 6557 if (returned.length) return returned.pop() 6558 if (pos >= length) return 6559 6560 let ignoreUnclosed = opts ? opts.ignoreUnclosed : false 6561 6562 code = css.charCodeAt(pos) 6563 6564 switch (code) { 6565 case NEWLINE: 6566 case SPACE: 6567 case TAB: 6568 case CR: 6569 case FEED: { 6570 next = pos 6571 do { 6572 next += 1 6573 code = css.charCodeAt(next) 6574 } while ( 6575 code === SPACE || 6576 code === NEWLINE || 6577 code === TAB || 6578 code === CR || 6579 code === FEED 6580 ) 6581 6582 currentToken = ['space', css.slice(pos, next)] 6583 pos = next - 1 6584 break 6585 } 6586 6587 case OPEN_SQUARE: 6588 case CLOSE_SQUARE: 6589 case OPEN_CURLY: 6590 case CLOSE_CURLY: 6591 case COLON: 6592 case SEMICOLON: 6593 case CLOSE_PARENTHESES: { 6594 let controlChar = String.fromCharCode(code) 6595 currentToken = [controlChar, controlChar, pos] 6596 break 6597 } 6598 6599 case OPEN_PARENTHESES: { 6600 prev = buffer.length ? buffer.pop()[1] : '' 6601 n = css.charCodeAt(pos + 1) 6602 if ( 6603 prev === 'url' && 6604 n !== SINGLE_QUOTE && 6605 n !== DOUBLE_QUOTE && 6606 n !== SPACE && 6607 n !== NEWLINE && 6608 n !== TAB && 6609 n !== FEED && 6610 n !== CR 6611 ) { 6612 next = pos 6613 do { 6614 escaped = false 6615 next = css.indexOf(')', next + 1) 6616 if (next === -1) { 6617 if (ignore || ignoreUnclosed) { 6618 next = pos 6619 break 6620 } else { 6621 unclosed('bracket') 6622 } 6623 } 6624 escapePos = next 6625 while (css.charCodeAt(escapePos - 1) === BACKSLASH) { 6626 escapePos -= 1 6627 escaped = !escaped 6628 } 6629 } while (escaped) 6630 6631 currentToken = ['brackets', css.slice(pos, next + 1), pos, next] 6632 6633 pos = next 6634 } else { 6635 next = css.indexOf(')', pos + 1) 6636 content = css.slice(pos, next + 1) 6637 6638 if (next === -1 || RE_BAD_BRACKET.test(content)) { 6639 currentToken = ['(', '(', pos] 6640 } else { 6641 currentToken = ['brackets', content, pos, next] 6642 pos = next 6643 } 6644 } 6645 6646 break 6647 } 6648 6649 case SINGLE_QUOTE: 6650 case DOUBLE_QUOTE: { 6651 quote = code === SINGLE_QUOTE ? "'" : '"' 6652 next = pos 6653 do { 6654 escaped = false 6655 next = css.indexOf(quote, next + 1) 6656 if (next === -1) { 6657 if (ignore || ignoreUnclosed) { 6658 next = pos + 1 6659 break 6660 } else { 6661 unclosed('string') 6662 } 6663 } 6664 escapePos = next 6665 while (css.charCodeAt(escapePos - 1) === BACKSLASH) { 6666 escapePos -= 1 6667 escaped = !escaped 6668 } 6669 } while (escaped) 6670 6671 currentToken = ['string', css.slice(pos, next + 1), pos, next] 6672 pos = next 6673 break 6674 } 6675 6676 case AT: { 6677 RE_AT_END.lastIndex = pos + 1 6678 RE_AT_END.test(css) 6679 if (RE_AT_END.lastIndex === 0) { 6680 next = css.length - 1 6681 } else { 6682 next = RE_AT_END.lastIndex - 2 6683 } 6684 6685 currentToken = ['at-word', css.slice(pos, next + 1), pos, next] 6686 6687 pos = next 6688 break 6689 } 6690 6691 case BACKSLASH: { 6692 next = pos 6693 escape = true 6694 while (css.charCodeAt(next + 1) === BACKSLASH) { 6695 next += 1 6696 escape = !escape 6697 } 6698 code = css.charCodeAt(next + 1) 6699 if ( 6700 escape && 6701 code !== SLASH && 6702 code !== SPACE && 6703 code !== NEWLINE && 6704 code !== TAB && 6705 code !== CR && 6706 code !== FEED 6707 ) { 6708 next += 1 6709 if (RE_HEX_ESCAPE.test(css.charAt(next))) { 6710 while (RE_HEX_ESCAPE.test(css.charAt(next + 1))) { 6711 next += 1 6712 } 6713 if (css.charCodeAt(next + 1) === SPACE) { 6714 next += 1 6715 } 6716 } 6717 } 6718 6719 currentToken = ['word', css.slice(pos, next + 1), pos, next] 6720 6721 pos = next 6722 break 6723 } 6724 6725 default: { 6726 if (code === SLASH && css.charCodeAt(pos + 1) === ASTERISK) { 6727 next = css.indexOf('*/', pos + 2) + 1 6728 if (next === 0) { 6729 if (ignore || ignoreUnclosed) { 6730 next = css.length 6731 } else { 6732 unclosed('comment') 6733 } 6734 } 6735 6736 currentToken = ['comment', css.slice(pos, next + 1), pos, next] 6737 pos = next 6738 } else { 6739 RE_WORD_END.lastIndex = pos + 1 6740 RE_WORD_END.test(css) 6741 if (RE_WORD_END.lastIndex === 0) { 6742 next = css.length - 1 6743 } else { 6744 next = RE_WORD_END.lastIndex - 2 6745 } 6746 6747 currentToken = ['word', css.slice(pos, next + 1), pos, next] 6748 buffer.push(currentToken) 6749 pos = next 6750 } 6751 6752 break 6753 } 6754 } 6755 6756 pos++ 6757 return currentToken 6758 } 6759 6760 function back(token) { 6761 returned.push(token) 6762 } 6763 6764 return { 6765 back, 6766 endOfFile, 6767 nextToken, 6768 position 6769 } 6770 } 6771 6772 6773 /***/ }), 6774 6775 /***/ 3122: 6776 /***/ ((module) => { 6777 6778 "use strict"; 6779 /* eslint-disable no-console */ 6780 6781 6782 let printed = {} 6783 6784 module.exports = function warnOnce(message) { 6785 if (printed[message]) return 6786 printed[message] = true 6787 6788 if (typeof console !== 'undefined' && console.warn) { 6789 console.warn(message) 6790 } 6791 } 6792 6793 6794 /***/ }), 6795 6796 /***/ 5776: 6797 /***/ ((module) => { 6798 6799 "use strict"; 6800 6801 6802 class Warning { 6803 constructor(text, opts = {}) { 6804 this.type = 'warning' 6805 this.text = text 6806 6807 if (opts.node && opts.node.source) { 6808 let range = opts.node.rangeBy(opts) 6809 this.line = range.start.line 6810 this.column = range.start.column 6811 this.endLine = range.end.line 6812 this.endColumn = range.end.column 6813 } 6814 6815 for (let opt in opts) this[opt] = opts[opt] 6816 } 6817 6818 toString() { 6819 if (this.node) { 6820 return this.node.error(this.text, { 6821 index: this.index, 6822 plugin: this.plugin, 6823 word: this.word 6824 }).message 6825 } 6826 6827 if (this.plugin) { 6828 return this.plugin + ': ' + this.text 6829 } 6830 6831 return this.text 6832 } 6833 } 6834 6835 module.exports = Warning 6836 Warning.default = Warning 6837 6838 6839 /***/ }), 6840 6841 /***/ 628: 6842 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 6843 6844 "use strict"; 6845 /** 6846 * Copyright (c) 2013-present, Facebook, Inc. 6847 * 6848 * This source code is licensed under the MIT license found in the 6849 * LICENSE file in the root directory of this source tree. 6850 */ 6851 6852 6853 6854 var ReactPropTypesSecret = __webpack_require__(4067); 6855 6856 function emptyFunction() {} 6857 function emptyFunctionWithReset() {} 6858 emptyFunctionWithReset.resetWarningCache = emptyFunction; 6859 6860 module.exports = function() { 6861 function shim(props, propName, componentName, location, propFullName, secret) { 6862 if (secret === ReactPropTypesSecret) { 6863 // It is still safe when called from React. 6864 return; 6865 } 6866 var err = new Error( 6867 'Calling PropTypes validators directly is not supported by the `prop-types` package. ' + 6868 'Use PropTypes.checkPropTypes() to call them. ' + 6869 'Read more at http://fb.me/use-check-prop-types' 6870 ); 6871 err.name = 'Invariant Violation'; 6872 throw err; 6873 }; 6874 shim.isRequired = shim; 6875 function getShim() { 6876 return shim; 6877 }; 6878 // Important! 6879 // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`. 6880 var ReactPropTypes = { 6881 array: shim, 6882 bigint: shim, 6883 bool: shim, 6884 func: shim, 6885 number: shim, 6886 object: shim, 6887 string: shim, 6888 symbol: shim, 6889 6890 any: shim, 6891 arrayOf: getShim, 6892 element: shim, 6893 elementType: shim, 6894 instanceOf: getShim, 6895 node: shim, 6896 objectOf: getShim, 6897 oneOf: getShim, 6898 oneOfType: getShim, 6899 shape: getShim, 6900 exact: getShim, 6901 6902 checkPropTypes: emptyFunctionWithReset, 6903 resetWarningCache: emptyFunction 6904 }; 6905 6906 ReactPropTypes.PropTypes = ReactPropTypes; 6907 6908 return ReactPropTypes; 6909 }; 6910 6911 6912 /***/ }), 6913 6914 /***/ 5826: 6915 /***/ ((module, __unused_webpack_exports, __webpack_require__) => { 6916 6917 /** 6918 * Copyright (c) 2013-present, Facebook, Inc. 6919 * 6920 * This source code is licensed under the MIT license found in the 6921 * LICENSE file in the root directory of this source tree. 6922 */ 6923 6924 if (false) { var throwOnDirectAccess, ReactIs; } else { 6925 // By explicitly using `prop-types` you are opting into new production behavior. 6926 // http://fb.me/prop-types-in-prod 6927 module.exports = __webpack_require__(628)(); 6928 } 6929 6930 6931 /***/ }), 6932 6933 /***/ 4067: 6934 /***/ ((module) => { 6935 6936 "use strict"; 6937 /** 6938 * Copyright (c) 2013-present, Facebook, Inc. 6939 * 6940 * This source code is licensed under the MIT license found in the 6941 * LICENSE file in the root directory of this source tree. 6942 */ 6943 6944 6945 6946 var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED'; 6947 6948 module.exports = ReactPropTypesSecret; 6949 6950 6951 /***/ }), 6952 6953 /***/ 4462: 6954 /***/ (function(__unused_webpack_module, exports, __webpack_require__) { 6955 6956 "use strict"; 6957 6958 var __extends = (this && this.__extends) || (function () { 6959 var extendStatics = Object.setPrototypeOf || 6960 ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || 6961 function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; 6962 return function (d, b) { 6963 extendStatics(d, b); 6964 function __() { this.constructor = d; } 6965 d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); 6966 }; 6967 })(); 6968 var __assign = (this && this.__assign) || Object.assign || function(t) { 6969 for (var s, i = 1, n = arguments.length; i < n; i++) { 6970 s = arguments[i]; 6971 for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) 6972 t[p] = s[p]; 6973 } 6974 return t; 6975 }; 6976 var __rest = (this && this.__rest) || function (s, e) { 6977 var t = {}; 6978 for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) 6979 t[p] = s[p]; 6980 if (s != null && typeof Object.getOwnPropertySymbols === "function") 6981 for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0) 6982 t[p[i]] = s[p[i]]; 6983 return t; 6984 }; 6985 exports.__esModule = true; 6986 var React = __webpack_require__(1609); 6987 var PropTypes = __webpack_require__(5826); 6988 var autosize = __webpack_require__(4306); 6989 var _getLineHeight = __webpack_require__(461); 6990 var getLineHeight = _getLineHeight; 6991 var RESIZED = "autosize:resized"; 6992 /** 6993 * A light replacement for built-in textarea component 6994 * which automaticaly adjusts its height to match the content 6995 */ 6996 var TextareaAutosizeClass = /** @class */ (function (_super) { 6997 __extends(TextareaAutosizeClass, _super); 6998 function TextareaAutosizeClass() { 6999 var _this = _super !== null && _super.apply(this, arguments) || this; 7000 _this.state = { 7001 lineHeight: null 7002 }; 7003 _this.textarea = null; 7004 _this.onResize = function (e) { 7005 if (_this.props.onResize) { 7006 _this.props.onResize(e); 7007 } 7008 }; 7009 _this.updateLineHeight = function () { 7010 if (_this.textarea) { 7011 _this.setState({ 7012 lineHeight: getLineHeight(_this.textarea) 7013 }); 7014 } 7015 }; 7016 _this.onChange = function (e) { 7017 var onChange = _this.props.onChange; 7018 _this.currentValue = e.currentTarget.value; 7019 onChange && onChange(e); 7020 }; 7021 return _this; 7022 } 7023 TextareaAutosizeClass.prototype.componentDidMount = function () { 7024 var _this = this; 7025 var _a = this.props, maxRows = _a.maxRows, async = _a.async; 7026 if (typeof maxRows === "number") { 7027 this.updateLineHeight(); 7028 } 7029 if (typeof maxRows === "number" || async) { 7030 /* 7031 the defer is needed to: 7032 - force "autosize" to activate the scrollbar when this.props.maxRows is passed 7033 - support StyledComponents (see #71) 7034 */ 7035 setTimeout(function () { return _this.textarea && autosize(_this.textarea); }); 7036 } 7037 else { 7038 this.textarea && autosize(this.textarea); 7039 } 7040 if (this.textarea) { 7041 this.textarea.addEventListener(RESIZED, this.onResize); 7042 } 7043 }; 7044 TextareaAutosizeClass.prototype.componentWillUnmount = function () { 7045 if (this.textarea) { 7046 this.textarea.removeEventListener(RESIZED, this.onResize); 7047 autosize.destroy(this.textarea); 7048 } 7049 }; 7050 TextareaAutosizeClass.prototype.render = function () { 7051 var _this = this; 7052 var _a = this, _b = _a.props, onResize = _b.onResize, maxRows = _b.maxRows, onChange = _b.onChange, style = _b.style, innerRef = _b.innerRef, children = _b.children, props = __rest(_b, ["onResize", "maxRows", "onChange", "style", "innerRef", "children"]), lineHeight = _a.state.lineHeight; 7053 var maxHeight = maxRows && lineHeight ? lineHeight * maxRows : null; 7054 return (React.createElement("textarea", __assign({}, props, { onChange: this.onChange, style: maxHeight ? __assign({}, style, { maxHeight: maxHeight }) : style, ref: function (element) { 7055 _this.textarea = element; 7056 if (typeof _this.props.innerRef === 'function') { 7057 _this.props.innerRef(element); 7058 } 7059 else if (_this.props.innerRef) { 7060 _this.props.innerRef.current = element; 7061 } 7062 } }), children)); 7063 }; 7064 TextareaAutosizeClass.prototype.componentDidUpdate = function () { 7065 this.textarea && autosize.update(this.textarea); 7066 }; 7067 TextareaAutosizeClass.defaultProps = { 7068 rows: 1, 7069 async: false 7070 }; 7071 TextareaAutosizeClass.propTypes = { 7072 rows: PropTypes.number, 7073 maxRows: PropTypes.number, 7074 onResize: PropTypes.func, 7075 innerRef: PropTypes.any, 7076 async: PropTypes.bool 7077 }; 7078 return TextareaAutosizeClass; 7079 }(React.Component)); 7080 exports.TextareaAutosize = React.forwardRef(function (props, ref) { 7081 return React.createElement(TextareaAutosizeClass, __assign({}, props, { innerRef: ref })); 7082 }); 7083 7084 7085 /***/ }), 7086 7087 /***/ 4132: 7088 /***/ ((__unused_webpack_module, exports, __webpack_require__) => { 7089 7090 "use strict"; 7091 var __webpack_unused_export__; 7092 7093 __webpack_unused_export__ = true; 7094 var TextareaAutosize_1 = __webpack_require__(4462); 7095 exports.A = TextareaAutosize_1.TextareaAutosize; 7096 7097 7098 /***/ }), 7099 7100 /***/ 9681: 7101 /***/ ((module) => { 7102 7103 var characterMap = { 7104 "À": "A", 7105 "Á": "A", 7106 "Â": "A", 7107 "Ã": "A", 7108 "Ä": "A", 7109 "Å": "A", 7110 "Ấ": "A", 7111 "Ắ": "A", 7112 "Ẳ": "A", 7113 "Ẵ": "A", 7114 "Ặ": "A", 7115 "Æ": "AE", 7116 "Ầ": "A", 7117 "Ằ": "A", 7118 "Ȃ": "A", 7119 "Ả": "A", 7120 "Ạ": "A", 7121 "Ẩ": "A", 7122 "Ẫ": "A", 7123 "Ậ": "A", 7124 "Ç": "C", 7125 "Ḉ": "C", 7126 "È": "E", 7127 "É": "E", 7128 "Ê": "E", 7129 "Ë": "E", 7130 "Ế": "E", 7131 "Ḗ": "E", 7132 "Ề": "E", 7133 "Ḕ": "E", 7134 "Ḝ": "E", 7135 "Ȇ": "E", 7136 "Ẻ": "E", 7137 "Ẽ": "E", 7138 "Ẹ": "E", 7139 "Ể": "E", 7140 "Ễ": "E", 7141 "Ệ": "E", 7142 "Ì": "I", 7143 "Í": "I", 7144 "Î": "I", 7145 "Ï": "I", 7146 "Ḯ": "I", 7147 "Ȋ": "I", 7148 "Ỉ": "I", 7149 "Ị": "I", 7150 "Ð": "D", 7151 "Ñ": "N", 7152 "Ò": "O", 7153 "Ó": "O", 7154 "Ô": "O", 7155 "Õ": "O", 7156 "Ö": "O", 7157 "Ø": "O", 7158 "Ố": "O", 7159 "Ṍ": "O", 7160 "Ṓ": "O", 7161 "Ȏ": "O", 7162 "Ỏ": "O", 7163 "Ọ": "O", 7164 "Ổ": "O", 7165 "Ỗ": "O", 7166 "Ộ": "O", 7167 "Ờ": "O", 7168 "Ở": "O", 7169 "Ỡ": "O", 7170 "Ớ": "O", 7171 "Ợ": "O", 7172 "Ù": "U", 7173 "Ú": "U", 7174 "Û": "U", 7175 "Ü": "U", 7176 "Ủ": "U", 7177 "Ụ": "U", 7178 "Ử": "U", 7179 "Ữ": "U", 7180 "Ự": "U", 7181 "Ý": "Y", 7182 "à": "a", 7183 "á": "a", 7184 "â": "a", 7185 "ã": "a", 7186 "ä": "a", 7187 "å": "a", 7188 "ấ": "a", 7189 "ắ": "a", 7190 "ẳ": "a", 7191 "ẵ": "a", 7192 "ặ": "a", 7193 "æ": "ae", 7194 "ầ": "a", 7195 "ằ": "a", 7196 "ȃ": "a", 7197 "ả": "a", 7198 "ạ": "a", 7199 "ẩ": "a", 7200 "ẫ": "a", 7201 "ậ": "a", 7202 "ç": "c", 7203 "ḉ": "c", 7204 "è": "e", 7205 "é": "e", 7206 "ê": "e", 7207 "ë": "e", 7208 "ế": "e", 7209 "ḗ": "e", 7210 "ề": "e", 7211 "ḕ": "e", 7212 "ḝ": "e", 7213 "ȇ": "e", 7214 "ẻ": "e", 7215 "ẽ": "e", 7216 "ẹ": "e", 7217 "ể": "e", 7218 "ễ": "e", 7219 "ệ": "e", 7220 "ì": "i", 7221 "í": "i", 7222 "î": "i", 7223 "ï": "i", 7224 "ḯ": "i", 7225 "ȋ": "i", 7226 "ỉ": "i", 7227 "ị": "i", 7228 "ð": "d", 7229 "ñ": "n", 7230 "ò": "o", 7231 "ó": "o", 7232 "ô": "o", 7233 "õ": "o", 7234 "ö": "o", 7235 "ø": "o", 7236 "ố": "o", 7237 "ṍ": "o", 7238 "ṓ": "o", 7239 "ȏ": "o", 7240 "ỏ": "o", 7241 "ọ": "o", 7242 "ổ": "o", 7243 "ỗ": "o", 7244 "ộ": "o", 7245 "ờ": "o", 7246 "ở": "o", 7247 "ỡ": "o", 7248 "ớ": "o", 7249 "ợ": "o", 7250 "ù": "u", 7251 "ú": "u", 7252 "û": "u", 7253 "ü": "u", 7254 "ủ": "u", 7255 "ụ": "u", 7256 "ử": "u", 7257 "ữ": "u", 7258 "ự": "u", 7259 "ý": "y", 7260 "ÿ": "y", 7261 "Ā": "A", 7262 "ā": "a", 7263 "Ă": "A", 7264 "ă": "a", 7265 "Ą": "A", 7266 "ą": "a", 7267 "Ć": "C", 7268 "ć": "c", 7269 "Ĉ": "C", 7270 "ĉ": "c", 7271 "Ċ": "C", 7272 "ċ": "c", 7273 "Č": "C", 7274 "č": "c", 7275 "C̆": "C", 7276 "c̆": "c", 7277 "Ď": "D", 7278 "ď": "d", 7279 "Đ": "D", 7280 "đ": "d", 7281 "Ē": "E", 7282 "ē": "e", 7283 "Ĕ": "E", 7284 "ĕ": "e", 7285 "Ė": "E", 7286 "ė": "e", 7287 "Ę": "E", 7288 "ę": "e", 7289 "Ě": "E", 7290 "ě": "e", 7291 "Ĝ": "G", 7292 "Ǵ": "G", 7293 "ĝ": "g", 7294 "ǵ": "g", 7295 "Ğ": "G", 7296 "ğ": "g", 7297 "Ġ": "G", 7298 "ġ": "g", 7299 "Ģ": "G", 7300 "ģ": "g", 7301 "Ĥ": "H", 7302 "ĥ": "h", 7303 "Ħ": "H", 7304 "ħ": "h", 7305 "Ḫ": "H", 7306 "ḫ": "h", 7307 "Ĩ": "I", 7308 "ĩ": "i", 7309 "Ī": "I", 7310 "ī": "i", 7311 "Ĭ": "I", 7312 "ĭ": "i", 7313 "Į": "I", 7314 "į": "i", 7315 "İ": "I", 7316 "ı": "i", 7317 "IJ": "IJ", 7318 "ij": "ij", 7319 "Ĵ": "J", 7320 "ĵ": "j", 7321 "Ķ": "K", 7322 "ķ": "k", 7323 "Ḱ": "K", 7324 "ḱ": "k", 7325 "K̆": "K", 7326 "k̆": "k", 7327 "Ĺ": "L", 7328 "ĺ": "l", 7329 "Ļ": "L", 7330 "ļ": "l", 7331 "Ľ": "L", 7332 "ľ": "l", 7333 "Ŀ": "L", 7334 "ŀ": "l", 7335 "Ł": "l", 7336 "ł": "l", 7337 "Ḿ": "M", 7338 "ḿ": "m", 7339 "M̆": "M", 7340 "m̆": "m", 7341 "Ń": "N", 7342 "ń": "n", 7343 "Ņ": "N", 7344 "ņ": "n", 7345 "Ň": "N", 7346 "ň": "n", 7347 "ʼn": "n", 7348 "N̆": "N", 7349 "n̆": "n", 7350 "Ō": "O", 7351 "ō": "o", 7352 "Ŏ": "O", 7353 "ŏ": "o", 7354 "Ő": "O", 7355 "ő": "o", 7356 "Œ": "OE", 7357 "œ": "oe", 7358 "P̆": "P", 7359 "p̆": "p", 7360 "Ŕ": "R", 7361 "ŕ": "r", 7362 "Ŗ": "R", 7363 "ŗ": "r", 7364 "Ř": "R", 7365 "ř": "r", 7366 "R̆": "R", 7367 "r̆": "r", 7368 "Ȓ": "R", 7369 "ȓ": "r", 7370 "Ś": "S", 7371 "ś": "s", 7372 "Ŝ": "S", 7373 "ŝ": "s", 7374 "Ş": "S", 7375 "Ș": "S", 7376 "ș": "s", 7377 "ş": "s", 7378 "Š": "S", 7379 "š": "s", 7380 "Ţ": "T", 7381 "ţ": "t", 7382 "ț": "t", 7383 "Ț": "T", 7384 "Ť": "T", 7385 "ť": "t", 7386 "Ŧ": "T", 7387 "ŧ": "t", 7388 "T̆": "T", 7389 "t̆": "t", 7390 "Ũ": "U", 7391 "ũ": "u", 7392 "Ū": "U", 7393 "ū": "u", 7394 "Ŭ": "U", 7395 "ŭ": "u", 7396 "Ů": "U", 7397 "ů": "u", 7398 "Ű": "U", 7399 "ű": "u", 7400 "Ų": "U", 7401 "ų": "u", 7402 "Ȗ": "U", 7403 "ȗ": "u", 7404 "V̆": "V", 7405 "v̆": "v", 7406 "Ŵ": "W", 7407 "ŵ": "w", 7408 "Ẃ": "W", 7409 "ẃ": "w", 7410 "X̆": "X", 7411 "x̆": "x", 7412 "Ŷ": "Y", 7413 "ŷ": "y", 7414 "Ÿ": "Y", 7415 "Y̆": "Y", 7416 "y̆": "y", 7417 "Ź": "Z", 7418 "ź": "z", 7419 "Ż": "Z", 7420 "ż": "z", 7421 "Ž": "Z", 7422 "ž": "z", 7423 "ſ": "s", 7424 "ƒ": "f", 7425 "Ơ": "O", 7426 "ơ": "o", 7427 "Ư": "U", 7428 "ư": "u", 7429 "Ǎ": "A", 7430 "ǎ": "a", 7431 "Ǐ": "I", 7432 "ǐ": "i", 7433 "Ǒ": "O", 7434 "ǒ": "o", 7435 "Ǔ": "U", 7436 "ǔ": "u", 7437 "Ǖ": "U", 7438 "ǖ": "u", 7439 "Ǘ": "U", 7440 "ǘ": "u", 7441 "Ǚ": "U", 7442 "ǚ": "u", 7443 "Ǜ": "U", 7444 "ǜ": "u", 7445 "Ứ": "U", 7446 "ứ": "u", 7447 "Ṹ": "U", 7448 "ṹ": "u", 7449 "Ǻ": "A", 7450 "ǻ": "a", 7451 "Ǽ": "AE", 7452 "ǽ": "ae", 7453 "Ǿ": "O", 7454 "ǿ": "o", 7455 "Þ": "TH", 7456 "þ": "th", 7457 "Ṕ": "P", 7458 "ṕ": "p", 7459 "Ṥ": "S", 7460 "ṥ": "s", 7461 "X́": "X", 7462 "x́": "x", 7463 "Ѓ": "Г", 7464 "ѓ": "г", 7465 "Ќ": "К", 7466 "ќ": "к", 7467 "A̋": "A", 7468 "a̋": "a", 7469 "E̋": "E", 7470 "e̋": "e", 7471 "I̋": "I", 7472 "i̋": "i", 7473 "Ǹ": "N", 7474 "ǹ": "n", 7475 "Ồ": "O", 7476 "ồ": "o", 7477 "Ṑ": "O", 7478 "ṑ": "o", 7479 "Ừ": "U", 7480 "ừ": "u", 7481 "Ẁ": "W", 7482 "ẁ": "w", 7483 "Ỳ": "Y", 7484 "ỳ": "y", 7485 "Ȁ": "A", 7486 "ȁ": "a", 7487 "Ȅ": "E", 7488 "ȅ": "e", 7489 "Ȉ": "I", 7490 "ȉ": "i", 7491 "Ȍ": "O", 7492 "ȍ": "o", 7493 "Ȑ": "R", 7494 "ȑ": "r", 7495 "Ȕ": "U", 7496 "ȕ": "u", 7497 "B̌": "B", 7498 "b̌": "b", 7499 "Č̣": "C", 7500 "č̣": "c", 7501 "Ê̌": "E", 7502 "ê̌": "e", 7503 "F̌": "F", 7504 "f̌": "f", 7505 "Ǧ": "G", 7506 "ǧ": "g", 7507 "Ȟ": "H", 7508 "ȟ": "h", 7509 "J̌": "J", 7510 "ǰ": "j", 7511 "Ǩ": "K", 7512 "ǩ": "k", 7513 "M̌": "M", 7514 "m̌": "m", 7515 "P̌": "P", 7516 "p̌": "p", 7517 "Q̌": "Q", 7518 "q̌": "q", 7519 "Ř̩": "R", 7520 "ř̩": "r", 7521 "Ṧ": "S", 7522 "ṧ": "s", 7523 "V̌": "V", 7524 "v̌": "v", 7525 "W̌": "W", 7526 "w̌": "w", 7527 "X̌": "X", 7528 "x̌": "x", 7529 "Y̌": "Y", 7530 "y̌": "y", 7531 "A̧": "A", 7532 "a̧": "a", 7533 "B̧": "B", 7534 "b̧": "b", 7535 "Ḑ": "D", 7536 "ḑ": "d", 7537 "Ȩ": "E", 7538 "ȩ": "e", 7539 "Ɛ̧": "E", 7540 "ɛ̧": "e", 7541 "Ḩ": "H", 7542 "ḩ": "h", 7543 "I̧": "I", 7544 "i̧": "i", 7545 "Ɨ̧": "I", 7546 "ɨ̧": "i", 7547 "M̧": "M", 7548 "m̧": "m", 7549 "O̧": "O", 7550 "o̧": "o", 7551 "Q̧": "Q", 7552 "q̧": "q", 7553 "U̧": "U", 7554 "u̧": "u", 7555 "X̧": "X", 7556 "x̧": "x", 7557 "Z̧": "Z", 7558 "z̧": "z", 7559 "й":"и", 7560 "Й":"И", 7561 "ё":"е", 7562 "Ё":"Е", 7563 }; 7564 7565 var chars = Object.keys(characterMap).join('|'); 7566 var allAccents = new RegExp(chars, 'g'); 7567 var firstAccent = new RegExp(chars, ''); 7568 7569 function matcher(match) { 7570 return characterMap[match]; 7571 } 7572 7573 var removeAccents = function(string) { 7574 return string.replace(allAccents, matcher); 7575 }; 7576 7577 var hasAccents = function(string) { 7578 return !!string.match(firstAccent); 7579 }; 7580 7581 module.exports = removeAccents; 7582 module.exports.has = hasAccents; 7583 module.exports.remove = removeAccents; 7584 7585 7586 /***/ }), 7587 7588 /***/ 1609: 7589 /***/ ((module) => { 7590 7591 "use strict"; 7592 module.exports = window["React"]; 7593 7594 /***/ }), 7595 7596 /***/ 9746: 7597 /***/ (() => { 7598 7599 /* (ignored) */ 7600 7601 /***/ }), 7602 7603 /***/ 9977: 7604 /***/ (() => { 7605 7606 /* (ignored) */ 7607 7608 /***/ }), 7609 7610 /***/ 197: 7611 /***/ (() => { 7612 7613 /* (ignored) */ 7614 7615 /***/ }), 7616 7617 /***/ 1866: 7618 /***/ (() => { 7619 7620 /* (ignored) */ 7621 7622 /***/ }), 7623 7624 /***/ 2739: 7625 /***/ (() => { 7626 7627 /* (ignored) */ 7628 7629 /***/ }), 7630 7631 /***/ 5042: 7632 /***/ ((module) => { 7633 7634 let urlAlphabet = 7635 'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict' 7636 let customAlphabet = (alphabet, defaultSize = 21) => { 7637 return (size = defaultSize) => { 7638 let id = '' 7639 let i = size 7640 while (i--) { 7641 id += alphabet[(Math.random() * alphabet.length) | 0] 7642 } 7643 return id 7644 } 7645 } 7646 let nanoid = (size = 21) => { 7647 let id = '' 7648 let i = size 7649 while (i--) { 7650 id += urlAlphabet[(Math.random() * 64) | 0] 7651 } 7652 return id 7653 } 7654 module.exports = { nanoid, customAlphabet } 7655 7656 7657 /***/ }) 7658 7659 /******/ }); 7660 /************************************************************************/ 7661 /******/ // The module cache 7662 /******/ var __webpack_module_cache__ = {}; 7663 /******/ 7664 /******/ // The require function 7665 /******/ function __webpack_require__(moduleId) { 7666 /******/ // Check if module is in cache 7667 /******/ var cachedModule = __webpack_module_cache__[moduleId]; 7668 /******/ if (cachedModule !== undefined) { 7669 /******/ return cachedModule.exports; 7670 /******/ } 7671 /******/ // Create a new module (and put it into the cache) 7672 /******/ var module = __webpack_module_cache__[moduleId] = { 7673 /******/ // no module.id needed 7674 /******/ // no module.loaded needed 7675 /******/ exports: {} 7676 /******/ }; 7677 /******/ 7678 /******/ // Execute the module function 7679 /******/ __webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__); 7680 /******/ 7681 /******/ // Return the exports of the module 7682 /******/ return module.exports; 7683 /******/ } 7684 /******/ 7685 /************************************************************************/ 7686 /******/ /* webpack/runtime/compat get default export */ 7687 /******/ (() => { 7688 /******/ // getDefaultExport function for compatibility with non-harmony modules 7689 /******/ __webpack_require__.n = (module) => { 7690 /******/ var getter = module && module.__esModule ? 7691 /******/ () => (module['default']) : 7692 /******/ () => (module); 7693 /******/ __webpack_require__.d(getter, { a: getter }); 7694 /******/ return getter; 7695 /******/ }; 7696 /******/ })(); 7697 /******/ 7698 /******/ /* webpack/runtime/define property getters */ 7699 /******/ (() => { 7700 /******/ // define getter functions for harmony exports 7701 /******/ __webpack_require__.d = (exports, definition) => { 7702 /******/ for(var key in definition) { 7703 /******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) { 7704 /******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] }); 7705 /******/ } 7706 /******/ } 7707 /******/ }; 7708 /******/ })(); 7709 /******/ 7710 /******/ /* webpack/runtime/hasOwnProperty shorthand */ 7711 /******/ (() => { 7712 /******/ __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop)) 7713 /******/ })(); 7714 /******/ 7715 /******/ /* webpack/runtime/make namespace object */ 7716 /******/ (() => { 7717 /******/ // define __esModule on exports 7718 /******/ __webpack_require__.r = (exports) => { 7719 /******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { 7720 /******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); 7721 /******/ } 7722 /******/ Object.defineProperty(exports, '__esModule', { value: true }); 7723 /******/ }; 7724 /******/ })(); 7725 /******/ 7726 /************************************************************************/ 7727 var __webpack_exports__ = {}; 7728 // This entry need to be wrapped in an IIFE because it need to be in strict mode. 7729 (() => { 7730 "use strict"; 7731 // ESM COMPAT FLAG 7732 __webpack_require__.r(__webpack_exports__); 7733 7734 // EXPORTS 7735 __webpack_require__.d(__webpack_exports__, { 7736 AlignmentControl: () => (/* reexport */ AlignmentControl), 7737 AlignmentToolbar: () => (/* reexport */ AlignmentToolbar), 7738 Autocomplete: () => (/* reexport */ autocomplete), 7739 BlockAlignmentControl: () => (/* reexport */ BlockAlignmentControl), 7740 BlockAlignmentToolbar: () => (/* reexport */ BlockAlignmentToolbar), 7741 BlockBreadcrumb: () => (/* reexport */ block_breadcrumb), 7742 BlockCanvas: () => (/* reexport */ block_canvas), 7743 BlockColorsStyleSelector: () => (/* reexport */ color_style_selector), 7744 BlockContextProvider: () => (/* reexport */ BlockContextProvider), 7745 BlockControls: () => (/* reexport */ block_controls), 7746 BlockEdit: () => (/* reexport */ BlockEdit), 7747 BlockEditorKeyboardShortcuts: () => (/* reexport */ keyboard_shortcuts), 7748 BlockEditorProvider: () => (/* reexport */ provider), 7749 BlockFormatControls: () => (/* reexport */ BlockFormatControls), 7750 BlockIcon: () => (/* reexport */ block_icon), 7751 BlockInspector: () => (/* reexport */ block_inspector), 7752 BlockList: () => (/* reexport */ BlockList), 7753 BlockMover: () => (/* reexport */ block_mover), 7754 BlockNavigationDropdown: () => (/* reexport */ dropdown), 7755 BlockPopover: () => (/* reexport */ block_popover), 7756 BlockPreview: () => (/* reexport */ block_preview), 7757 BlockSelectionClearer: () => (/* reexport */ BlockSelectionClearer), 7758 BlockSettingsMenu: () => (/* reexport */ block_settings_menu), 7759 BlockSettingsMenuControls: () => (/* reexport */ block_settings_menu_controls), 7760 BlockStyles: () => (/* reexport */ block_styles), 7761 BlockTitle: () => (/* reexport */ BlockTitle), 7762 BlockToolbar: () => (/* reexport */ BlockToolbar), 7763 BlockTools: () => (/* reexport */ BlockTools), 7764 BlockVerticalAlignmentControl: () => (/* reexport */ BlockVerticalAlignmentControl), 7765 BlockVerticalAlignmentToolbar: () => (/* reexport */ BlockVerticalAlignmentToolbar), 7766 ButtonBlockAppender: () => (/* reexport */ button_block_appender), 7767 ButtonBlockerAppender: () => (/* reexport */ ButtonBlockerAppender), 7768 ColorPalette: () => (/* reexport */ color_palette), 7769 ColorPaletteControl: () => (/* reexport */ ColorPaletteControl), 7770 ContrastChecker: () => (/* reexport */ contrast_checker), 7771 CopyHandler: () => (/* reexport */ CopyHandler), 7772 DefaultBlockAppender: () => (/* reexport */ DefaultBlockAppender), 7773 FontSizePicker: () => (/* reexport */ font_size_picker), 7774 HeadingLevelDropdown: () => (/* reexport */ HeadingLevelDropdown), 7775 HeightControl: () => (/* reexport */ HeightControl), 7776 InnerBlocks: () => (/* reexport */ inner_blocks), 7777 Inserter: () => (/* reexport */ inserter), 7778 InspectorAdvancedControls: () => (/* reexport */ InspectorAdvancedControls), 7779 InspectorControls: () => (/* reexport */ inspector_controls), 7780 JustifyContentControl: () => (/* reexport */ JustifyContentControl), 7781 JustifyToolbar: () => (/* reexport */ JustifyToolbar), 7782 LineHeightControl: () => (/* reexport */ line_height_control), 7783 MediaPlaceholder: () => (/* reexport */ media_placeholder), 7784 MediaReplaceFlow: () => (/* reexport */ media_replace_flow), 7785 MediaUpload: () => (/* reexport */ media_upload), 7786 MediaUploadCheck: () => (/* reexport */ check), 7787 MultiSelectScrollIntoView: () => (/* reexport */ MultiSelectScrollIntoView), 7788 NavigableToolbar: () => (/* reexport */ NavigableToolbar), 7789 ObserveTyping: () => (/* reexport */ observe_typing), 7790 PanelColorSettings: () => (/* reexport */ panel_color_settings), 7791 PlainText: () => (/* reexport */ plain_text), 7792 RecursionProvider: () => (/* reexport */ RecursionProvider), 7793 ReusableBlocksRenameHint: () => (/* reexport */ ReusableBlocksRenameHint), 7794 RichText: () => (/* reexport */ rich_text), 7795 RichTextShortcut: () => (/* reexport */ RichTextShortcut), 7796 RichTextToolbarButton: () => (/* reexport */ RichTextToolbarButton), 7797 SETTINGS_DEFAULTS: () => (/* reexport */ SETTINGS_DEFAULTS), 7798 SkipToSelectedBlock: () => (/* reexport */ SkipToSelectedBlock), 7799 ToolSelector: () => (/* reexport */ tool_selector), 7800 Typewriter: () => (/* reexport */ typewriter), 7801 URLInput: () => (/* reexport */ url_input), 7802 URLInputButton: () => (/* reexport */ url_input_button), 7803 URLPopover: () => (/* reexport */ url_popover), 7804 Warning: () => (/* reexport */ warning), 7805 WritingFlow: () => (/* reexport */ writing_flow), 7806 __experimentalBlockAlignmentMatrixControl: () => (/* reexport */ block_alignment_matrix_control), 7807 __experimentalBlockFullHeightAligmentControl: () => (/* reexport */ block_full_height_alignment_control), 7808 __experimentalBlockPatternSetup: () => (/* reexport */ block_pattern_setup), 7809 __experimentalBlockPatternsList: () => (/* reexport */ block_patterns_list), 7810 __experimentalBlockVariationPicker: () => (/* reexport */ block_variation_picker), 7811 __experimentalBlockVariationTransforms: () => (/* reexport */ block_variation_transforms), 7812 __experimentalBorderRadiusControl: () => (/* reexport */ BorderRadiusControl), 7813 __experimentalColorGradientControl: () => (/* reexport */ control), 7814 __experimentalColorGradientSettingsDropdown: () => (/* reexport */ ColorGradientSettingsDropdown), 7815 __experimentalDateFormatPicker: () => (/* reexport */ DateFormatPicker), 7816 __experimentalDuotoneControl: () => (/* reexport */ duotone_control), 7817 __experimentalFontAppearanceControl: () => (/* reexport */ FontAppearanceControl), 7818 __experimentalFontFamilyControl: () => (/* reexport */ FontFamilyControl), 7819 __experimentalGetBorderClassesAndStyles: () => (/* reexport */ getBorderClassesAndStyles), 7820 __experimentalGetColorClassesAndStyles: () => (/* reexport */ getColorClassesAndStyles), 7821 __experimentalGetElementClassName: () => (/* reexport */ __experimentalGetElementClassName), 7822 __experimentalGetGapCSSValue: () => (/* reexport */ getGapCSSValue), 7823 __experimentalGetGradientClass: () => (/* reexport */ __experimentalGetGradientClass), 7824 __experimentalGetGradientObjectByGradientValue: () => (/* reexport */ __experimentalGetGradientObjectByGradientValue), 7825 __experimentalGetShadowClassesAndStyles: () => (/* reexport */ getShadowClassesAndStyles), 7826 __experimentalGetSpacingClassesAndStyles: () => (/* reexport */ getSpacingClassesAndStyles), 7827 __experimentalImageEditor: () => (/* reexport */ ImageEditor), 7828 __experimentalImageSizeControl: () => (/* reexport */ ImageSizeControl), 7829 __experimentalImageURLInputUI: () => (/* reexport */ ImageURLInputUI), 7830 __experimentalInspectorPopoverHeader: () => (/* reexport */ InspectorPopoverHeader), 7831 __experimentalLetterSpacingControl: () => (/* reexport */ LetterSpacingControl), 7832 __experimentalLibrary: () => (/* reexport */ library), 7833 __experimentalLinkControl: () => (/* reexport */ link_control), 7834 __experimentalLinkControlSearchInput: () => (/* reexport */ search_input), 7835 __experimentalLinkControlSearchItem: () => (/* reexport */ search_item), 7836 __experimentalLinkControlSearchResults: () => (/* reexport */ LinkControlSearchResults), 7837 __experimentalListView: () => (/* reexport */ components_list_view), 7838 __experimentalPanelColorGradientSettings: () => (/* reexport */ panel_color_gradient_settings), 7839 __experimentalPreviewOptions: () => (/* reexport */ PreviewOptions), 7840 __experimentalPublishDateTimePicker: () => (/* reexport */ publish_date_time_picker), 7841 __experimentalRecursionProvider: () => (/* reexport */ DeprecatedExperimentalRecursionProvider), 7842 __experimentalResponsiveBlockControl: () => (/* reexport */ responsive_block_control), 7843 __experimentalSpacingSizesControl: () => (/* reexport */ SpacingSizesControl), 7844 __experimentalTextDecorationControl: () => (/* reexport */ TextDecorationControl), 7845 __experimentalTextTransformControl: () => (/* reexport */ TextTransformControl), 7846 __experimentalUnitControl: () => (/* reexport */ UnitControl), 7847 __experimentalUseBlockOverlayActive: () => (/* reexport */ useBlockOverlayActive), 7848 __experimentalUseBlockPreview: () => (/* reexport */ useBlockPreview), 7849 __experimentalUseBorderProps: () => (/* reexport */ useBorderProps), 7850 __experimentalUseColorProps: () => (/* reexport */ useColorProps), 7851 __experimentalUseCustomSides: () => (/* reexport */ useCustomSides), 7852 __experimentalUseGradient: () => (/* reexport */ __experimentalUseGradient), 7853 __experimentalUseHasRecursion: () => (/* reexport */ DeprecatedExperimentalUseHasRecursion), 7854 __experimentalUseMultipleOriginColorsAndGradients: () => (/* reexport */ useMultipleOriginColorsAndGradients), 7855 __experimentalUseResizeCanvas: () => (/* reexport */ useResizeCanvas), 7856 __experimentalWritingModeControl: () => (/* reexport */ WritingModeControl), 7857 __unstableBlockNameContext: () => (/* reexport */ block_name_context), 7858 __unstableBlockSettingsMenuFirstItem: () => (/* reexport */ block_settings_menu_first_item), 7859 __unstableBlockToolbarLastItem: () => (/* reexport */ block_toolbar_last_item), 7860 __unstableEditorStyles: () => (/* reexport */ editor_styles), 7861 __unstableIframe: () => (/* reexport */ iframe), 7862 __unstableInserterMenuExtension: () => (/* reexport */ inserter_menu_extension), 7863 __unstableRichTextInputEvent: () => (/* reexport */ __unstableRichTextInputEvent), 7864 __unstableUseBlockSelectionClearer: () => (/* reexport */ useBlockSelectionClearer), 7865 __unstableUseClipboardHandler: () => (/* reexport */ __unstableUseClipboardHandler), 7866 __unstableUseMouseMoveTypingReset: () => (/* reexport */ useMouseMoveTypingReset), 7867 __unstableUseTypewriter: () => (/* reexport */ useTypewriter), 7868 __unstableUseTypingObserver: () => (/* reexport */ useTypingObserver), 7869 createCustomColorsHOC: () => (/* reexport */ createCustomColorsHOC), 7870 getColorClassName: () => (/* reexport */ getColorClassName), 7871 getColorObjectByAttributeValues: () => (/* reexport */ getColorObjectByAttributeValues), 7872 getColorObjectByColorValue: () => (/* reexport */ getColorObjectByColorValue), 7873 getComputedFluidTypographyValue: () => (/* reexport */ getComputedFluidTypographyValue), 7874 getCustomValueFromPreset: () => (/* reexport */ getCustomValueFromPreset), 7875 getFontSize: () => (/* reexport */ utils_getFontSize), 7876 getFontSizeClass: () => (/* reexport */ getFontSizeClass), 7877 getFontSizeObjectByValue: () => (/* reexport */ utils_getFontSizeObjectByValue), 7878 getGradientSlugByValue: () => (/* reexport */ getGradientSlugByValue), 7879 getGradientValueBySlug: () => (/* reexport */ getGradientValueBySlug), 7880 getPxFromCssUnit: () => (/* reexport */ get_px_from_css_unit), 7881 getSpacingPresetCssVar: () => (/* reexport */ getSpacingPresetCssVar), 7882 getTypographyClassesAndStyles: () => (/* reexport */ getTypographyClassesAndStyles), 7883 isValueSpacingPreset: () => (/* reexport */ isValueSpacingPreset), 7884 privateApis: () => (/* reexport */ privateApis), 7885 store: () => (/* reexport */ store), 7886 storeConfig: () => (/* reexport */ storeConfig), 7887 transformStyles: () => (/* reexport */ transform_styles), 7888 useBlockCommands: () => (/* reexport */ useBlockCommands), 7889 useBlockDisplayInformation: () => (/* reexport */ useBlockDisplayInformation), 7890 useBlockEditContext: () => (/* reexport */ useBlockEditContext), 7891 useBlockEditingMode: () => (/* reexport */ useBlockEditingMode), 7892 useBlockProps: () => (/* reexport */ use_block_props_useBlockProps), 7893 useCachedTruthy: () => (/* reexport */ useCachedTruthy), 7894 useHasRecursion: () => (/* reexport */ useHasRecursion), 7895 useInnerBlocksProps: () => (/* reexport */ useInnerBlocksProps), 7896 useSetting: () => (/* reexport */ useSetting), 7897 useSettings: () => (/* reexport */ use_settings_useSettings), 7898 useZoomOut: () => (/* reexport */ useZoomOut), 7899 withColorContext: () => (/* reexport */ with_color_context), 7900 withColors: () => (/* reexport */ withColors), 7901 withFontSizes: () => (/* reexport */ with_font_sizes) 7902 }); 7903 7904 // NAMESPACE OBJECT: ./node_modules/@wordpress/block-editor/build-module/store/private-selectors.js 7905 var private_selectors_namespaceObject = {}; 7906 __webpack_require__.r(private_selectors_namespaceObject); 7907 __webpack_require__.d(private_selectors_namespaceObject, { 7908 getAllPatterns: () => (getAllPatterns), 7909 getBlockRemovalRules: () => (getBlockRemovalRules), 7910 getBlockSettings: () => (getBlockSettings), 7911 getBlockWithoutAttributes: () => (getBlockWithoutAttributes), 7912 getContentLockingParent: () => (getContentLockingParent), 7913 getEnabledBlockParents: () => (getEnabledBlockParents), 7914 getEnabledClientIdsTree: () => (getEnabledClientIdsTree), 7915 getExpandedBlock: () => (getExpandedBlock), 7916 getInserterMediaCategories: () => (getInserterMediaCategories), 7917 getLastFocus: () => (getLastFocus), 7918 getLastInsertedBlocksClientIds: () => (getLastInsertedBlocksClientIds), 7919 getOpenedBlockSettingsMenu: () => (getOpenedBlockSettingsMenu), 7920 getPatternBySlug: () => (getPatternBySlug), 7921 getRegisteredInserterMediaCategories: () => (getRegisteredInserterMediaCategories), 7922 getRemovalPromptData: () => (getRemovalPromptData), 7923 getReusableBlocks: () => (getReusableBlocks), 7924 getStyleOverrides: () => (getStyleOverrides), 7925 getTemporarilyEditingAsBlocks: () => (getTemporarilyEditingAsBlocks), 7926 getTemporarilyEditingFocusModeToRevert: () => (getTemporarilyEditingFocusModeToRevert), 7927 hasAllowedPatterns: () => (hasAllowedPatterns), 7928 isBlockInterfaceHidden: () => (private_selectors_isBlockInterfaceHidden), 7929 isBlockSubtreeDisabled: () => (isBlockSubtreeDisabled), 7930 isDragging: () => (private_selectors_isDragging), 7931 isResolvingPatterns: () => (isResolvingPatterns) 7932 }); 7933 7934 // NAMESPACE OBJECT: ./node_modules/@wordpress/block-editor/build-module/store/selectors.js 7935 var selectors_namespaceObject = {}; 7936 __webpack_require__.r(selectors_namespaceObject); 7937 __webpack_require__.d(selectors_namespaceObject, { 7938 __experimentalGetActiveBlockIdByBlockNames: () => (__experimentalGetActiveBlockIdByBlockNames), 7939 __experimentalGetAllowedBlocks: () => (__experimentalGetAllowedBlocks), 7940 __experimentalGetAllowedPatterns: () => (__experimentalGetAllowedPatterns), 7941 __experimentalGetBlockListSettingsForBlocks: () => (__experimentalGetBlockListSettingsForBlocks), 7942 __experimentalGetDirectInsertBlock: () => (__experimentalGetDirectInsertBlock), 7943 __experimentalGetGlobalBlocksByName: () => (__experimentalGetGlobalBlocksByName), 7944 __experimentalGetLastBlockAttributeChanges: () => (__experimentalGetLastBlockAttributeChanges), 7945 __experimentalGetParsedPattern: () => (__experimentalGetParsedPattern), 7946 __experimentalGetPatternTransformItems: () => (__experimentalGetPatternTransformItems), 7947 __experimentalGetPatternsByBlockTypes: () => (__experimentalGetPatternsByBlockTypes), 7948 __experimentalGetReusableBlockTitle: () => (__experimentalGetReusableBlockTitle), 7949 __unstableGetBlockWithoutInnerBlocks: () => (__unstableGetBlockWithoutInnerBlocks), 7950 __unstableGetClientIdWithClientIdsTree: () => (__unstableGetClientIdWithClientIdsTree), 7951 __unstableGetClientIdsTree: () => (__unstableGetClientIdsTree), 7952 __unstableGetContentLockingParent: () => (__unstableGetContentLockingParent), 7953 __unstableGetEditorMode: () => (__unstableGetEditorMode), 7954 __unstableGetSelectedBlocksWithPartialSelection: () => (__unstableGetSelectedBlocksWithPartialSelection), 7955 __unstableGetTemporarilyEditingAsBlocks: () => (__unstableGetTemporarilyEditingAsBlocks), 7956 __unstableGetTemporarilyEditingFocusModeToRevert: () => (__unstableGetTemporarilyEditingFocusModeToRevert), 7957 __unstableGetVisibleBlocks: () => (__unstableGetVisibleBlocks), 7958 __unstableHasActiveBlockOverlayActive: () => (__unstableHasActiveBlockOverlayActive), 7959 __unstableIsFullySelected: () => (__unstableIsFullySelected), 7960 __unstableIsLastBlockChangeIgnored: () => (__unstableIsLastBlockChangeIgnored), 7961 __unstableIsSelectionCollapsed: () => (__unstableIsSelectionCollapsed), 7962 __unstableIsSelectionMergeable: () => (__unstableIsSelectionMergeable), 7963 __unstableIsWithinBlockOverlay: () => (__unstableIsWithinBlockOverlay), 7964 __unstableSelectionHasUnmergeableBlock: () => (__unstableSelectionHasUnmergeableBlock), 7965 areInnerBlocksControlled: () => (areInnerBlocksControlled), 7966 canEditBlock: () => (canEditBlock), 7967 canInsertBlockType: () => (canInsertBlockType), 7968 canInsertBlocks: () => (canInsertBlocks), 7969 canLockBlockType: () => (canLockBlockType), 7970 canMoveBlock: () => (canMoveBlock), 7971 canMoveBlocks: () => (canMoveBlocks), 7972 canRemoveBlock: () => (canRemoveBlock), 7973 canRemoveBlocks: () => (canRemoveBlocks), 7974 didAutomaticChange: () => (didAutomaticChange), 7975 getAdjacentBlockClientId: () => (getAdjacentBlockClientId), 7976 getAllowedBlocks: () => (getAllowedBlocks), 7977 getBlock: () => (getBlock), 7978 getBlockAttributes: () => (getBlockAttributes), 7979 getBlockCount: () => (getBlockCount), 7980 getBlockEditingMode: () => (getBlockEditingMode), 7981 getBlockHierarchyRootClientId: () => (getBlockHierarchyRootClientId), 7982 getBlockIndex: () => (getBlockIndex), 7983 getBlockInsertionPoint: () => (getBlockInsertionPoint), 7984 getBlockListSettings: () => (getBlockListSettings), 7985 getBlockMode: () => (getBlockMode), 7986 getBlockName: () => (getBlockName), 7987 getBlockNamesByClientId: () => (getBlockNamesByClientId), 7988 getBlockOrder: () => (getBlockOrder), 7989 getBlockParents: () => (getBlockParents), 7990 getBlockParentsByBlockName: () => (getBlockParentsByBlockName), 7991 getBlockRootClientId: () => (getBlockRootClientId), 7992 getBlockSelectionEnd: () => (getBlockSelectionEnd), 7993 getBlockSelectionStart: () => (getBlockSelectionStart), 7994 getBlockTransformItems: () => (getBlockTransformItems), 7995 getBlocks: () => (getBlocks), 7996 getBlocksByClientId: () => (getBlocksByClientId), 7997 getBlocksByName: () => (getBlocksByName), 7998 getClientIdsOfDescendants: () => (getClientIdsOfDescendants), 7999 getClientIdsWithDescendants: () => (getClientIdsWithDescendants), 8000 getDirectInsertBlock: () => (getDirectInsertBlock), 8001 getDraggedBlockClientIds: () => (getDraggedBlockClientIds), 8002 getFirstMultiSelectedBlockClientId: () => (getFirstMultiSelectedBlockClientId), 8003 getGlobalBlockCount: () => (getGlobalBlockCount), 8004 getInserterItems: () => (getInserterItems), 8005 getLastMultiSelectedBlockClientId: () => (getLastMultiSelectedBlockClientId), 8006 getLowestCommonAncestorWithSelectedBlock: () => (getLowestCommonAncestorWithSelectedBlock), 8007 getMultiSelectedBlockClientIds: () => (getMultiSelectedBlockClientIds), 8008 getMultiSelectedBlocks: () => (getMultiSelectedBlocks), 8009 getMultiSelectedBlocksEndClientId: () => (getMultiSelectedBlocksEndClientId), 8010 getMultiSelectedBlocksStartClientId: () => (getMultiSelectedBlocksStartClientId), 8011 getNextBlockClientId: () => (getNextBlockClientId), 8012 getPatternsByBlockTypes: () => (getPatternsByBlockTypes), 8013 getPreviousBlockClientId: () => (getPreviousBlockClientId), 8014 getSelectedBlock: () => (getSelectedBlock), 8015 getSelectedBlockClientId: () => (getSelectedBlockClientId), 8016 getSelectedBlockClientIds: () => (getSelectedBlockClientIds), 8017 getSelectedBlockCount: () => (getSelectedBlockCount), 8018 getSelectedBlocksInitialCaretPosition: () => (getSelectedBlocksInitialCaretPosition), 8019 getSelectionEnd: () => (getSelectionEnd), 8020 getSelectionStart: () => (getSelectionStart), 8021 getSettings: () => (getSettings), 8022 getTemplate: () => (getTemplate), 8023 getTemplateLock: () => (getTemplateLock), 8024 hasBlockMovingClientId: () => (selectors_hasBlockMovingClientId), 8025 hasDraggedInnerBlock: () => (hasDraggedInnerBlock), 8026 hasInserterItems: () => (hasInserterItems), 8027 hasMultiSelection: () => (hasMultiSelection), 8028 hasSelectedBlock: () => (hasSelectedBlock), 8029 hasSelectedInnerBlock: () => (hasSelectedInnerBlock), 8030 isAncestorBeingDragged: () => (isAncestorBeingDragged), 8031 isAncestorMultiSelected: () => (isAncestorMultiSelected), 8032 isBlockBeingDragged: () => (isBlockBeingDragged), 8033 isBlockHighlighted: () => (isBlockHighlighted), 8034 isBlockInsertionPointVisible: () => (isBlockInsertionPointVisible), 8035 isBlockMultiSelected: () => (isBlockMultiSelected), 8036 isBlockSelected: () => (isBlockSelected), 8037 isBlockValid: () => (isBlockValid), 8038 isBlockVisible: () => (isBlockVisible), 8039 isBlockWithinSelection: () => (isBlockWithinSelection), 8040 isCaretWithinFormattedText: () => (isCaretWithinFormattedText), 8041 isDraggingBlocks: () => (isDraggingBlocks), 8042 isFirstMultiSelectedBlock: () => (isFirstMultiSelectedBlock), 8043 isGroupable: () => (isGroupable), 8044 isLastBlockChangePersistent: () => (isLastBlockChangePersistent), 8045 isMultiSelecting: () => (selectors_isMultiSelecting), 8046 isNavigationMode: () => (isNavigationMode), 8047 isSelectionEnabled: () => (selectors_isSelectionEnabled), 8048 isTyping: () => (selectors_isTyping), 8049 isUngroupable: () => (isUngroupable), 8050 isValidTemplate: () => (isValidTemplate), 8051 wasBlockJustInserted: () => (wasBlockJustInserted) 8052 }); 8053 8054 // NAMESPACE OBJECT: ./node_modules/@wordpress/block-editor/build-module/store/private-actions.js 8055 var private_actions_namespaceObject = {}; 8056 __webpack_require__.r(private_actions_namespaceObject); 8057 __webpack_require__.d(private_actions_namespaceObject, { 8058 __experimentalUpdateSettings: () => (__experimentalUpdateSettings), 8059 clearBlockRemovalPrompt: () => (clearBlockRemovalPrompt), 8060 deleteStyleOverride: () => (deleteStyleOverride), 8061 ensureDefaultBlock: () => (ensureDefaultBlock), 8062 expandBlock: () => (expandBlock), 8063 hideBlockInterface: () => (hideBlockInterface), 8064 modifyContentLockBlock: () => (modifyContentLockBlock), 8065 privateRemoveBlocks: () => (privateRemoveBlocks), 8066 setBlockRemovalRules: () => (setBlockRemovalRules), 8067 setLastFocus: () => (setLastFocus), 8068 setOpenedBlockSettingsMenu: () => (setOpenedBlockSettingsMenu), 8069 setStyleOverride: () => (setStyleOverride), 8070 showBlockInterface: () => (showBlockInterface), 8071 startDragging: () => (startDragging), 8072 stopDragging: () => (stopDragging), 8073 stopEditingAsBlocks: () => (stopEditingAsBlocks), 8074 syncDerivedUpdates: () => (syncDerivedUpdates) 8075 }); 8076 8077 // NAMESPACE OBJECT: ./node_modules/@wordpress/block-editor/build-module/store/actions.js 8078 var actions_namespaceObject = {}; 8079 __webpack_require__.r(actions_namespaceObject); 8080 __webpack_require__.d(actions_namespaceObject, { 8081 __unstableDeleteSelection: () => (__unstableDeleteSelection), 8082 __unstableExpandSelection: () => (__unstableExpandSelection), 8083 __unstableMarkAutomaticChange: () => (__unstableMarkAutomaticChange), 8084 __unstableMarkLastChangeAsPersistent: () => (__unstableMarkLastChangeAsPersistent), 8085 __unstableMarkNextChangeAsNotPersistent: () => (__unstableMarkNextChangeAsNotPersistent), 8086 __unstableSaveReusableBlock: () => (__unstableSaveReusableBlock), 8087 __unstableSetEditorMode: () => (__unstableSetEditorMode), 8088 __unstableSetTemporarilyEditingAsBlocks: () => (__unstableSetTemporarilyEditingAsBlocks), 8089 __unstableSplitSelection: () => (__unstableSplitSelection), 8090 clearSelectedBlock: () => (clearSelectedBlock), 8091 duplicateBlocks: () => (duplicateBlocks), 8092 enterFormattedText: () => (enterFormattedText), 8093 exitFormattedText: () => (exitFormattedText), 8094 flashBlock: () => (flashBlock), 8095 hideInsertionPoint: () => (hideInsertionPoint), 8096 insertAfterBlock: () => (insertAfterBlock), 8097 insertBeforeBlock: () => (insertBeforeBlock), 8098 insertBlock: () => (insertBlock), 8099 insertBlocks: () => (insertBlocks), 8100 insertDefaultBlock: () => (insertDefaultBlock), 8101 mergeBlocks: () => (mergeBlocks), 8102 moveBlockToPosition: () => (moveBlockToPosition), 8103 moveBlocksDown: () => (moveBlocksDown), 8104 moveBlocksToPosition: () => (moveBlocksToPosition), 8105 moveBlocksUp: () => (moveBlocksUp), 8106 multiSelect: () => (multiSelect), 8107 receiveBlocks: () => (receiveBlocks), 8108 registerInserterMediaCategory: () => (registerInserterMediaCategory), 8109 removeBlock: () => (removeBlock), 8110 removeBlocks: () => (removeBlocks), 8111 replaceBlock: () => (replaceBlock), 8112 replaceBlocks: () => (replaceBlocks), 8113 replaceInnerBlocks: () => (replaceInnerBlocks), 8114 resetBlocks: () => (resetBlocks), 8115 resetSelection: () => (resetSelection), 8116 selectBlock: () => (selectBlock), 8117 selectNextBlock: () => (selectNextBlock), 8118 selectPreviousBlock: () => (selectPreviousBlock), 8119 selectionChange: () => (selectionChange), 8120 setBlockEditingMode: () => (setBlockEditingMode), 8121 setBlockMovingClientId: () => (setBlockMovingClientId), 8122 setBlockVisibility: () => (setBlockVisibility), 8123 setHasControlledInnerBlocks: () => (setHasControlledInnerBlocks), 8124 setNavigationMode: () => (setNavigationMode), 8125 setTemplateValidity: () => (setTemplateValidity), 8126 showInsertionPoint: () => (showInsertionPoint), 8127 startDraggingBlocks: () => (startDraggingBlocks), 8128 startMultiSelect: () => (startMultiSelect), 8129 startTyping: () => (startTyping), 8130 stopDraggingBlocks: () => (stopDraggingBlocks), 8131 stopMultiSelect: () => (stopMultiSelect), 8132 stopTyping: () => (stopTyping), 8133 synchronizeTemplate: () => (synchronizeTemplate), 8134 toggleBlockHighlight: () => (toggleBlockHighlight), 8135 toggleBlockMode: () => (toggleBlockMode), 8136 toggleSelection: () => (toggleSelection), 8137 unsetBlockEditingMode: () => (unsetBlockEditingMode), 8138 updateBlock: () => (updateBlock), 8139 updateBlockAttributes: () => (updateBlockAttributes), 8140 updateBlockListSettings: () => (updateBlockListSettings), 8141 updateSettings: () => (updateSettings), 8142 validateBlocksToTemplate: () => (validateBlocksToTemplate) 8143 }); 8144 8145 // NAMESPACE OBJECT: ./node_modules/@wordpress/block-editor/build-module/components/global-styles/index.js 8146 var global_styles_namespaceObject = {}; 8147 __webpack_require__.r(global_styles_namespaceObject); 8148 __webpack_require__.d(global_styles_namespaceObject, { 8149 AdvancedPanel: () => (AdvancedPanel), 8150 BackgroundPanel: () => (BackgroundPanel), 8151 BorderPanel: () => (BorderPanel), 8152 ColorPanel: () => (ColorPanel), 8153 DimensionsPanel: () => (DimensionsPanel), 8154 FiltersPanel: () => (FiltersPanel), 8155 GlobalStylesContext: () => (GlobalStylesContext), 8156 ImageSettingsPanel: () => (ImageSettingsPanel), 8157 TypographyPanel: () => (TypographyPanel), 8158 areGlobalStyleConfigsEqual: () => (areGlobalStyleConfigsEqual), 8159 getBlockCSSSelector: () => (getBlockCSSSelector), 8160 getBlockSelectors: () => (getBlockSelectors), 8161 getGlobalStylesChanges: () => (getGlobalStylesChanges), 8162 getLayoutStyles: () => (getLayoutStyles), 8163 toStyles: () => (toStyles), 8164 useGlobalSetting: () => (useGlobalSetting), 8165 useGlobalStyle: () => (useGlobalStyle), 8166 useGlobalStyleLinks: () => (useGlobalStyleLinks), 8167 useGlobalStylesOutput: () => (useGlobalStylesOutput), 8168 useGlobalStylesOutputWithConfig: () => (useGlobalStylesOutputWithConfig), 8169 useGlobalStylesReset: () => (useGlobalStylesReset), 8170 useHasBackgroundPanel: () => (useHasBackgroundPanel), 8171 useHasBorderPanel: () => (useHasBorderPanel), 8172 useHasBorderPanelControls: () => (useHasBorderPanelControls), 8173 useHasColorPanel: () => (useHasColorPanel), 8174 useHasDimensionsPanel: () => (useHasDimensionsPanel), 8175 useHasFiltersPanel: () => (useHasFiltersPanel), 8176 useHasImageSettingsPanel: () => (useHasImageSettingsPanel), 8177 useHasTypographyPanel: () => (useHasTypographyPanel), 8178 useSettingsForBlockElement: () => (useSettingsForBlockElement) 8179 }); 8180 8181 ;// CONCATENATED MODULE: external ["wp","blocks"] 8182 const external_wp_blocks_namespaceObject = window["wp"]["blocks"]; 8183 ;// CONCATENATED MODULE: external ["wp","element"] 8184 const external_wp_element_namespaceObject = window["wp"]["element"]; 8185 ;// CONCATENATED MODULE: external ["wp","data"] 8186 const external_wp_data_namespaceObject = window["wp"]["data"]; 8187 ;// CONCATENATED MODULE: external ["wp","compose"] 8188 const external_wp_compose_namespaceObject = window["wp"]["compose"]; 8189 ;// CONCATENATED MODULE: external ["wp","hooks"] 8190 const external_wp_hooks_namespaceObject = window["wp"]["hooks"]; 8191 ;// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-edit/context.js 8192 /** 8193 * WordPress dependencies 8194 */ 8195 8196 const mayDisplayControlsKey = Symbol('mayDisplayControls'); 8197 const mayDisplayParentControlsKey = Symbol('mayDisplayParentControls'); 8198 const blockEditingModeKey = Symbol('blockEditingMode'); 8199 const blockBindingsKey = Symbol('blockBindings'); 8200 const isPreviewModeKey = Symbol('isPreviewMode'); 8201 const DEFAULT_BLOCK_EDIT_CONTEXT = { 8202 name: '', 8203 isSelected: false 8204 }; 8205 const Context = (0,external_wp_element_namespaceObject.createContext)(DEFAULT_BLOCK_EDIT_CONTEXT); 8206 const { 8207 Provider 8208 } = Context; 8209 8210 8211 /** 8212 * A hook that returns the block edit context. 8213 * 8214 * @return {Object} Block edit context 8215 */ 8216 function useBlockEditContext() { 8217 return (0,external_wp_element_namespaceObject.useContext)(Context); 8218 } 8219 8220 ;// CONCATENATED MODULE: external ["wp","deprecated"] 8221 const external_wp_deprecated_namespaceObject = window["wp"]["deprecated"]; 8222 var external_wp_deprecated_default = /*#__PURE__*/__webpack_require__.n(external_wp_deprecated_namespaceObject); 8223 // EXTERNAL MODULE: ./node_modules/fast-deep-equal/es6/index.js 8224 var es6 = __webpack_require__(7734); 8225 var es6_default = /*#__PURE__*/__webpack_require__.n(es6); 8226 ;// CONCATENATED MODULE: external ["wp","i18n"] 8227 const external_wp_i18n_namespaceObject = window["wp"]["i18n"]; 8228 ;// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/store/defaults.js 8229 /** 8230 * WordPress dependencies 8231 */ 8232 8233 const PREFERENCES_DEFAULTS = { 8234 insertUsage: {} 8235 }; 8236 8237 /** 8238 * The default editor settings 8239 * 8240 * @typedef {Object} SETTINGS_DEFAULT 8241 * @property {boolean} alignWide Enable/Disable Wide/Full Alignments 8242 * @property {boolean} supportsLayout Enable/disable layouts support in container blocks. 8243 * @property {boolean} imageEditing Image Editing settings set to false to disable. 8244 * @property {Array} imageSizes Available image sizes 8245 * @property {number} maxWidth Max width to constraint resizing 8246 * @property {boolean|Array} allowedBlockTypes Allowed block types 8247 * @property {boolean} hasFixedToolbar Whether or not the editor toolbar is fixed 8248 * @property {boolean} distractionFree Whether or not the editor UI is distraction free 8249 * @property {boolean} focusMode Whether the focus mode is enabled or not 8250 * @property {Array} styles Editor Styles 8251 * @property {boolean} keepCaretInsideBlock Whether caret should move between blocks in edit mode 8252 * @property {string} bodyPlaceholder Empty post placeholder 8253 * @property {string} titlePlaceholder Empty title placeholder 8254 * @property {boolean} canLockBlocks Whether the user can manage Block Lock state 8255 * @property {boolean} codeEditingEnabled Whether or not the user can switch to the code editor 8256 * @property {boolean} generateAnchors Enable/Disable auto anchor generation for Heading blocks 8257 * @property {boolean} enableOpenverseMediaCategory Enable/Disable the Openverse media category in the inserter. 8258 * @property {boolean} clearBlockSelection Whether the block editor should clear selection on mousedown when a block is not clicked. 8259 * @property {boolean} __experimentalCanUserUseUnfilteredHTML Whether the user should be able to use unfiltered HTML or the HTML should be filtered e.g., to remove elements considered insecure like iframes. 8260 * @property {boolean} __experimentalBlockDirectory Whether the user has enabled the Block Directory 8261 * @property {Array} __experimentalBlockPatterns Array of objects representing the block patterns 8262 * @property {Array} __experimentalBlockPatternCategories Array of objects representing the block pattern categories 8263 * @property {boolean} __unstableGalleryWithImageBlocks Whether the user has enabled the refactored gallery block which uses InnerBlocks 8264 */ 8265 const SETTINGS_DEFAULTS = { 8266 alignWide: false, 8267 supportsLayout: true, 8268 // colors setting is not used anymore now defaults are passed from theme.json on the server and core has its own defaults. 8269 // The setting is only kept for backward compatibility purposes. 8270 colors: [{ 8271 name: (0,external_wp_i18n_namespaceObject.__)('Black'), 8272 slug: 'black', 8273 color: '#000000' 8274 }, { 8275 name: (0,external_wp_i18n_namespaceObject.__)('Cyan bluish gray'), 8276 slug: 'cyan-bluish-gray', 8277 color: '#abb8c3' 8278 }, { 8279 name: (0,external_wp_i18n_namespaceObject.__)('White'), 8280 slug: 'white', 8281 color: '#ffffff' 8282 }, { 8283 name: (0,external_wp_i18n_namespaceObject.__)('Pale pink'), 8284 slug: 'pale-pink', 8285 color: '#f78da7' 8286 }, { 8287 name: (0,external_wp_i18n_namespaceObject.__)('Vivid red'), 8288 slug: 'vivid-red', 8289 color: '#cf2e2e' 8290 }, { 8291 name: (0,external_wp_i18n_namespaceObject.__)('Luminous vivid orange'), 8292 slug: 'luminous-vivid-orange', 8293 color: '#ff6900' 8294 }, { 8295 name: (0,external_wp_i18n_namespaceObject.__)('Luminous vivid amber'), 8296 slug: 'luminous-vivid-amber', 8297 color: '#fcb900' 8298 }, { 8299 name: (0,external_wp_i18n_namespaceObject.__)('Light green cyan'), 8300 slug: 'light-green-cyan', 8301 color: '#7bdcb5' 8302 }, { 8303 name: (0,external_wp_i18n_namespaceObject.__)('Vivid green cyan'), 8304 slug: 'vivid-green-cyan', 8305 color: '#00d084' 8306 }, { 8307 name: (0,external_wp_i18n_namespaceObject.__)('Pale cyan blue'), 8308 slug: 'pale-cyan-blue', 8309 color: '#8ed1fc' 8310 }, { 8311 name: (0,external_wp_i18n_namespaceObject.__)('Vivid cyan blue'), 8312 slug: 'vivid-cyan-blue', 8313 color: '#0693e3' 8314 }, { 8315 name: (0,external_wp_i18n_namespaceObject.__)('Vivid purple'), 8316 slug: 'vivid-purple', 8317 color: '#9b51e0' 8318 }], 8319 // fontSizes setting is not used anymore now defaults are passed from theme.json on the server and core has its own defaults. 8320 // The setting is only kept for backward compatibility purposes. 8321 fontSizes: [{ 8322 name: (0,external_wp_i18n_namespaceObject._x)('Small', 'font size name'), 8323 size: 13, 8324 slug: 'small' 8325 }, { 8326 name: (0,external_wp_i18n_namespaceObject._x)('Normal', 'font size name'), 8327 size: 16, 8328 slug: 'normal' 8329 }, { 8330 name: (0,external_wp_i18n_namespaceObject._x)('Medium', 'font size name'), 8331 size: 20, 8332 slug: 'medium' 8333 }, { 8334 name: (0,external_wp_i18n_namespaceObject._x)('Large', 'font size name'), 8335 size: 36, 8336 slug: 'large' 8337 }, { 8338 name: (0,external_wp_i18n_namespaceObject._x)('Huge', 'font size name'), 8339 size: 42, 8340 slug: 'huge' 8341 }], 8342 // Image default size slug. 8343 imageDefaultSize: 'large', 8344 imageSizes: [{ 8345 slug: 'thumbnail', 8346 name: (0,external_wp_i18n_namespaceObject.__)('Thumbnail') 8347 }, { 8348 slug: 'medium', 8349 name: (0,external_wp_i18n_namespaceObject.__)('Medium') 8350 }, { 8351 slug: 'large', 8352 name: (0,external_wp_i18n_namespaceObject.__)('Large') 8353 }, { 8354 slug: 'full', 8355 name: (0,external_wp_i18n_namespaceObject.__)('Full Size') 8356 }], 8357 // Allow plugin to disable Image Editor if need be. 8358 imageEditing: true, 8359 // This is current max width of the block inner area 8360 // It's used to constraint image resizing and this value could be overridden later by themes 8361 maxWidth: 580, 8362 // Allowed block types for the editor, defaulting to true (all supported). 8363 allowedBlockTypes: true, 8364 // Maximum upload size in bytes allowed for the site. 8365 maxUploadFileSize: 0, 8366 // List of allowed mime types and file extensions. 8367 allowedMimeTypes: null, 8368 // Allows to disable block locking interface. 8369 canLockBlocks: true, 8370 // Allows to disable Openverse media category in the inserter. 8371 enableOpenverseMediaCategory: true, 8372 clearBlockSelection: true, 8373 __experimentalCanUserUseUnfilteredHTML: false, 8374 __experimentalBlockDirectory: false, 8375 __mobileEnablePageTemplates: false, 8376 __experimentalBlockPatterns: [], 8377 __experimentalBlockPatternCategories: [], 8378 __unstableGalleryWithImageBlocks: false, 8379 __unstableIsPreviewMode: false, 8380 // These settings will be completely revamped in the future. 8381 // The goal is to evolve this into an API which will instruct 8382 // the block inspector to animate transitions between what it 8383 // displays based on the relationship between the selected block 8384 // and its parent, and only enable it if the parent is controlling 8385 // its children blocks. 8386 blockInspectorAnimation: { 8387 animationParent: 'core/navigation', 8388 'core/navigation': { 8389 enterDirection: 'leftToRight' 8390 }, 8391 'core/navigation-submenu': { 8392 enterDirection: 'rightToLeft' 8393 }, 8394 'core/navigation-link': { 8395 enterDirection: 'rightToLeft' 8396 }, 8397 'core/search': { 8398 enterDirection: 'rightToLeft' 8399 }, 8400 'core/social-links': { 8401 enterDirection: 'rightToLeft' 8402 }, 8403 'core/page-list': { 8404 enterDirection: 'rightToLeft' 8405 }, 8406 'core/spacer': { 8407 enterDirection: 'rightToLeft' 8408 }, 8409 'core/home-link': { 8410 enterDirection: 'rightToLeft' 8411 }, 8412 'core/site-title': { 8413 enterDirection: 'rightToLeft' 8414 }, 8415 'core/site-logo': { 8416 enterDirection: 'rightToLeft' 8417 } 8418 }, 8419 generateAnchors: false, 8420 // gradients setting is not used anymore now defaults are passed from theme.json on the server and core has its own defaults. 8421 // The setting is only kept for backward compatibility purposes. 8422 gradients: [{ 8423 name: (0,external_wp_i18n_namespaceObject.__)('Vivid cyan blue to vivid purple'), 8424 gradient: 'linear-gradient(135deg,rgba(6,147,227,1) 0%,rgb(155,81,224) 100%)', 8425 slug: 'vivid-cyan-blue-to-vivid-purple' 8426 }, { 8427 name: (0,external_wp_i18n_namespaceObject.__)('Light green cyan to vivid green cyan'), 8428 gradient: 'linear-gradient(135deg,rgb(122,220,180) 0%,rgb(0,208,130) 100%)', 8429 slug: 'light-green-cyan-to-vivid-green-cyan' 8430 }, { 8431 name: (0,external_wp_i18n_namespaceObject.__)('Luminous vivid amber to luminous vivid orange'), 8432 gradient: 'linear-gradient(135deg,rgba(252,185,0,1) 0%,rgba(255,105,0,1) 100%)', 8433 slug: 'luminous-vivid-amber-to-luminous-vivid-orange' 8434 }, { 8435 name: (0,external_wp_i18n_namespaceObject.__)('Luminous vivid orange to vivid red'), 8436 gradient: 'linear-gradient(135deg,rgba(255,105,0,1) 0%,rgb(207,46,46) 100%)', 8437 slug: 'luminous-vivid-orange-to-vivid-red' 8438 }, { 8439 name: (0,external_wp_i18n_namespaceObject.__)('Very light gray to cyan bluish gray'), 8440 gradient: 'linear-gradient(135deg,rgb(238,238,238) 0%,rgb(169,184,195) 100%)', 8441 slug: 'very-light-gray-to-cyan-bluish-gray' 8442 }, { 8443 name: (0,external_wp_i18n_namespaceObject.__)('Cool to warm spectrum'), 8444 gradient: 'linear-gradient(135deg,rgb(74,234,220) 0%,rgb(151,120,209) 20%,rgb(207,42,186) 40%,rgb(238,44,130) 60%,rgb(251,105,98) 80%,rgb(254,248,76) 100%)', 8445 slug: 'cool-to-warm-spectrum' 8446 }, { 8447 name: (0,external_wp_i18n_namespaceObject.__)('Blush light purple'), 8448 gradient: 'linear-gradient(135deg,rgb(255,206,236) 0%,rgb(152,150,240) 100%)', 8449 slug: 'blush-light-purple' 8450 }, { 8451 name: (0,external_wp_i18n_namespaceObject.__)('Blush bordeaux'), 8452 gradient: 'linear-gradient(135deg,rgb(254,205,165) 0%,rgb(254,45,45) 50%,rgb(107,0,62) 100%)', 8453 slug: 'blush-bordeaux' 8454 }, { 8455 name: (0,external_wp_i18n_namespaceObject.__)('Luminous dusk'), 8456 gradient: 'linear-gradient(135deg,rgb(255,203,112) 0%,rgb(199,81,192) 50%,rgb(65,88,208) 100%)', 8457 slug: 'luminous-dusk' 8458 }, { 8459 name: (0,external_wp_i18n_namespaceObject.__)('Pale ocean'), 8460 gradient: 'linear-gradient(135deg,rgb(255,245,203) 0%,rgb(182,227,212) 50%,rgb(51,167,181) 100%)', 8461 slug: 'pale-ocean' 8462 }, { 8463 name: (0,external_wp_i18n_namespaceObject.__)('Electric grass'), 8464 gradient: 'linear-gradient(135deg,rgb(202,248,128) 0%,rgb(113,206,126) 100%)', 8465 slug: 'electric-grass' 8466 }, { 8467 name: (0,external_wp_i18n_namespaceObject.__)('Midnight'), 8468 gradient: 'linear-gradient(135deg,rgb(2,3,129) 0%,rgb(40,116,252) 100%)', 8469 slug: 'midnight' 8470 }], 8471 __unstableResolvedAssets: { 8472 styles: [], 8473 scripts: [] 8474 } 8475 }; 8476 8477 ;// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/store/array.js 8478 /** 8479 * Insert one or multiple elements into a given position of an array. 8480 * 8481 * @param {Array} array Source array. 8482 * @param {*} elements Elements to insert. 8483 * @param {number} index Insert Position. 8484 * 8485 * @return {Array} Result. 8486 */ 8487 function insertAt(array, elements, index) { 8488 return [...array.slice(0, index), ...(Array.isArray(elements) ? elements : [elements]), ...array.slice(index)]; 8489 } 8490 8491 /** 8492 * Moves an element in an array. 8493 * 8494 * @param {Array} array Source array. 8495 * @param {number} from Source index. 8496 * @param {number} to Destination index. 8497 * @param {number} count Number of elements to move. 8498 * 8499 * @return {Array} Result. 8500 */ 8501 function moveTo(array, from, to, count = 1) { 8502 const withoutMovedElements = [...array]; 8503 withoutMovedElements.splice(from, count); 8504 return insertAt(withoutMovedElements, array.slice(from, from + count), to); 8505 } 8506 8507 ;// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/store/reducer.js 8508 /** 8509 * External dependencies 8510 */ 8511 8512 8513 /** 8514 * WordPress dependencies 8515 */ 8516 8517 8518 8519 /** 8520 * Internal dependencies 8521 */ 8522 8523 8524 const identity = x => x; 8525 8526 /** 8527 * Given an array of blocks, returns an object where each key is a nesting 8528 * context, the value of which is an array of block client IDs existing within 8529 * that nesting context. 8530 * 8531 * @param {Array} blocks Blocks to map. 8532 * @param {?string} rootClientId Assumed root client ID. 8533 * 8534 * @return {Object} Block order map object. 8535 */ 8536 function mapBlockOrder(blocks, rootClientId = '') { 8537 const result = new Map(); 8538 const current = []; 8539 result.set(rootClientId, current); 8540 blocks.forEach(block => { 8541 const { 8542 clientId, 8543 innerBlocks 8544 } = block; 8545 current.push(clientId); 8546 mapBlockOrder(innerBlocks, clientId).forEach((order, subClientId) => { 8547 result.set(subClientId, order); 8548 }); 8549 }); 8550 return result; 8551 } 8552 8553 /** 8554 * Given an array of blocks, returns an object where each key contains 8555 * the clientId of the block and the value is the parent of the block. 8556 * 8557 * @param {Array} blocks Blocks to map. 8558 * @param {?string} rootClientId Assumed root client ID. 8559 * 8560 * @return {Object} Block order map object. 8561 */ 8562 function mapBlockParents(blocks, rootClientId = '') { 8563 const result = []; 8564 const stack = [[rootClientId, blocks]]; 8565 while (stack.length) { 8566 const [parent, currentBlocks] = stack.shift(); 8567 currentBlocks.forEach(({ 8568 innerBlocks, 8569 ...block 8570 }) => { 8571 result.push([block.clientId, parent]); 8572 if (innerBlocks?.length) { 8573 stack.push([block.clientId, innerBlocks]); 8574 } 8575 }); 8576 } 8577 return result; 8578 } 8579 8580 /** 8581 * Helper method to iterate through all blocks, recursing into inner blocks, 8582 * applying a transformation function to each one. 8583 * Returns a flattened object with the transformed blocks. 8584 * 8585 * @param {Array} blocks Blocks to flatten. 8586 * @param {Function} transform Transforming function to be applied to each block. 8587 * 8588 * @return {Array} Flattened object. 8589 */ 8590 function flattenBlocks(blocks, transform = identity) { 8591 const result = []; 8592 const stack = [...blocks]; 8593 while (stack.length) { 8594 const { 8595 innerBlocks, 8596 ...block 8597 } = stack.shift(); 8598 stack.push(...innerBlocks); 8599 result.push([block.clientId, transform(block)]); 8600 } 8601 return result; 8602 } 8603 function getFlattenedClientIds(blocks) { 8604 const result = {}; 8605 const stack = [...blocks]; 8606 while (stack.length) { 8607 const { 8608 innerBlocks, 8609 ...block 8610 } = stack.shift(); 8611 stack.push(...innerBlocks); 8612 result[block.clientId] = true; 8613 } 8614 return result; 8615 } 8616 8617 /** 8618 * Given an array of blocks, returns an object containing all blocks, without 8619 * attributes, recursing into inner blocks. Keys correspond to the block client 8620 * ID, the value of which is the attributes object. 8621 * 8622 * @param {Array} blocks Blocks to flatten. 8623 * 8624 * @return {Array} Flattened block attributes object. 8625 */ 8626 function getFlattenedBlocksWithoutAttributes(blocks) { 8627 return flattenBlocks(blocks, block => { 8628 const { 8629 attributes, 8630 ...restBlock 8631 } = block; 8632 return restBlock; 8633 }); 8634 } 8635 8636 /** 8637 * Given an array of blocks, returns an object containing all block attributes, 8638 * recursing into inner blocks. Keys correspond to the block client ID, the 8639 * value of which is the attributes object. 8640 * 8641 * @param {Array} blocks Blocks to flatten. 8642 * 8643 * @return {Array} Flattened block attributes object. 8644 */ 8645 function getFlattenedBlockAttributes(blocks) { 8646 return flattenBlocks(blocks, block => block.attributes); 8647 } 8648 8649 /** 8650 * Returns true if the two object arguments have the same keys, or false 8651 * otherwise. 8652 * 8653 * @param {Object} a First object. 8654 * @param {Object} b Second object. 8655 * 8656 * @return {boolean} Whether the two objects have the same keys. 8657 */ 8658 function hasSameKeys(a, b) { 8659 return es6_default()(Object.keys(a), Object.keys(b)); 8660 } 8661 8662 /** 8663 * Returns true if, given the currently dispatching action and the previously 8664 * dispatched action, the two actions are updating the same block attribute, or 8665 * false otherwise. 8666 * 8667 * @param {Object} action Currently dispatching action. 8668 * @param {Object} lastAction Previously dispatched action. 8669 * 8670 * @return {boolean} Whether actions are updating the same block attribute. 8671 */ 8672 function isUpdatingSameBlockAttribute(action, lastAction) { 8673 return action.type === 'UPDATE_BLOCK_ATTRIBUTES' && lastAction !== undefined && lastAction.type === 'UPDATE_BLOCK_ATTRIBUTES' && es6_default()(action.clientIds, lastAction.clientIds) && hasSameKeys(action.attributes, lastAction.attributes); 8674 } 8675 function updateBlockTreeForBlocks(state, blocks) { 8676 const treeToUpdate = state.tree; 8677 const stack = [...blocks]; 8678 const flattenedBlocks = [...blocks]; 8679 while (stack.length) { 8680 const block = stack.shift(); 8681 stack.push(...block.innerBlocks); 8682 flattenedBlocks.push(...block.innerBlocks); 8683 } 8684 // Create objects before mutating them, that way it's always defined. 8685 for (const block of flattenedBlocks) { 8686 treeToUpdate.set(block.clientId, {}); 8687 } 8688 for (const block of flattenedBlocks) { 8689 treeToUpdate.set(block.clientId, Object.assign(treeToUpdate.get(block.clientId), { 8690 ...state.byClientId.get(block.clientId), 8691 attributes: state.attributes.get(block.clientId), 8692 innerBlocks: block.innerBlocks.map(subBlock => treeToUpdate.get(subBlock.clientId)) 8693 })); 8694 } 8695 } 8696 function updateParentInnerBlocksInTree(state, updatedClientIds, updateChildrenOfUpdatedClientIds = false) { 8697 const treeToUpdate = state.tree; 8698 const uncontrolledParents = new Set([]); 8699 const controlledParents = new Set(); 8700 for (const clientId of updatedClientIds) { 8701 let current = updateChildrenOfUpdatedClientIds ? clientId : state.parents.get(clientId); 8702 do { 8703 if (state.controlledInnerBlocks[current]) { 8704 // Should stop on controlled blocks. 8705 // If we reach a controlled parent, break out of the loop. 8706 controlledParents.add(current); 8707 break; 8708 } else { 8709 // Else continue traversing up through parents. 8710 uncontrolledParents.add(current); 8711 current = state.parents.get(current); 8712 } 8713 } while (current !== undefined); 8714 } 8715 8716 // To make sure the order of assignments doesn't matter, 8717 // we first create empty objects and mutates the inner blocks later. 8718 for (const clientId of uncontrolledParents) { 8719 treeToUpdate.set(clientId, { 8720 ...treeToUpdate.get(clientId) 8721 }); 8722 } 8723 for (const clientId of uncontrolledParents) { 8724 treeToUpdate.get(clientId).innerBlocks = (state.order.get(clientId) || []).map(subClientId => treeToUpdate.get(subClientId)); 8725 } 8726 8727 // Controlled parent blocks, need a dedicated key for their inner blocks 8728 // to be used when doing getBlocks( controlledBlockClientId ). 8729 for (const clientId of controlledParents) { 8730 treeToUpdate.set('controlled||' + clientId, { 8731 innerBlocks: (state.order.get(clientId) || []).map(subClientId => treeToUpdate.get(subClientId)) 8732 }); 8733 } 8734 } 8735 8736 /** 8737 * Higher-order reducer intended to compute full block objects key for each block in the post. 8738 * This is a denormalization to optimize the performance of the getBlock selectors and avoid 8739 * recomputing the block objects and avoid heavy memoization. 8740 * 8741 * @param {Function} reducer Original reducer function. 8742 * 8743 * @return {Function} Enhanced reducer function. 8744 */ 8745 const withBlockTree = reducer => (state = {}, action) => { 8746 const newState = reducer(state, action); 8747 if (newState === state) { 8748 return state; 8749 } 8750 newState.tree = state.tree ? state.tree : new Map(); 8751 switch (action.type) { 8752 case 'RECEIVE_BLOCKS': 8753 case 'INSERT_BLOCKS': 8754 { 8755 newState.tree = new Map(newState.tree); 8756 updateBlockTreeForBlocks(newState, action.blocks); 8757 updateParentInnerBlocksInTree(newState, action.rootClientId ? [action.rootClientId] : [''], true); 8758 break; 8759 } 8760 case 'UPDATE_BLOCK': 8761 newState.tree = new Map(newState.tree); 8762 newState.tree.set(action.clientId, { 8763 ...newState.tree.get(action.clientId), 8764 ...newState.byClientId.get(action.clientId), 8765 attributes: newState.attributes.get(action.clientId) 8766 }); 8767 updateParentInnerBlocksInTree(newState, [action.clientId], false); 8768 break; 8769 case 'SYNC_DERIVED_BLOCK_ATTRIBUTES': 8770 case 'UPDATE_BLOCK_ATTRIBUTES': 8771 { 8772 newState.tree = new Map(newState.tree); 8773 action.clientIds.forEach(clientId => { 8774 newState.tree.set(clientId, { 8775 ...newState.tree.get(clientId), 8776 attributes: newState.attributes.get(clientId) 8777 }); 8778 }); 8779 updateParentInnerBlocksInTree(newState, action.clientIds, false); 8780 break; 8781 } 8782 case 'REPLACE_BLOCKS_AUGMENTED_WITH_CHILDREN': 8783 { 8784 const inserterClientIds = getFlattenedClientIds(action.blocks); 8785 newState.tree = new Map(newState.tree); 8786 action.replacedClientIds.forEach(clientId => { 8787 newState.tree.delete(clientId); 8788 // Controlled inner blocks are only removed 8789 // if the block doesn't move to another position 8790 // otherwise their content will be lost. 8791 if (!inserterClientIds[clientId]) { 8792 newState.tree.delete('controlled||' + clientId); 8793 } 8794 }); 8795 updateBlockTreeForBlocks(newState, action.blocks); 8796 updateParentInnerBlocksInTree(newState, action.blocks.map(b => b.clientId), false); 8797 8798 // If there are no replaced blocks, it means we're removing blocks so we need to update their parent. 8799 const parentsOfRemovedBlocks = []; 8800 for (const clientId of action.clientIds) { 8801 const parentId = state.parents.get(clientId); 8802 if (parentId !== undefined && (parentId === '' || newState.byClientId.get(parentId))) { 8803 parentsOfRemovedBlocks.push(parentId); 8804 } 8805 } 8806 updateParentInnerBlocksInTree(newState, parentsOfRemovedBlocks, true); 8807 break; 8808 } 8809 case 'REMOVE_BLOCKS_AUGMENTED_WITH_CHILDREN': 8810 const parentsOfRemovedBlocks = []; 8811 for (const clientId of action.clientIds) { 8812 const parentId = state.parents.get(clientId); 8813 if (parentId !== undefined && (parentId === '' || newState.byClientId.get(parentId))) { 8814 parentsOfRemovedBlocks.push(parentId); 8815 } 8816 } 8817 newState.tree = new Map(newState.tree); 8818 action.removedClientIds.forEach(clientId => { 8819 newState.tree.delete(clientId); 8820 newState.tree.delete('controlled||' + clientId); 8821 }); 8822 updateParentInnerBlocksInTree(newState, parentsOfRemovedBlocks, true); 8823 break; 8824 case 'MOVE_BLOCKS_TO_POSITION': 8825 { 8826 const updatedBlockUids = []; 8827 if (action.fromRootClientId) { 8828 updatedBlockUids.push(action.fromRootClientId); 8829 } else { 8830 updatedBlockUids.push(''); 8831 } 8832 if (action.toRootClientId) { 8833 updatedBlockUids.push(action.toRootClientId); 8834 } 8835 newState.tree = new Map(newState.tree); 8836 updateParentInnerBlocksInTree(newState, updatedBlockUids, true); 8837 break; 8838 } 8839 case 'MOVE_BLOCKS_UP': 8840 case 'MOVE_BLOCKS_DOWN': 8841 { 8842 const updatedBlockUids = [action.rootClientId ? action.rootClientId : '']; 8843 newState.tree = new Map(newState.tree); 8844 updateParentInnerBlocksInTree(newState, updatedBlockUids, true); 8845 break; 8846 } 8847 case 'SAVE_REUSABLE_BLOCK_SUCCESS': 8848 { 8849 const updatedBlockUids = []; 8850 newState.attributes.forEach((attributes, clientId) => { 8851 if (newState.byClientId.get(clientId).name === 'core/block' && attributes.ref === action.updatedId) { 8852 updatedBlockUids.push(clientId); 8853 } 8854 }); 8855 newState.tree = new Map(newState.tree); 8856 updatedBlockUids.forEach(clientId => { 8857 newState.tree.set(clientId, { 8858 ...newState.byClientId.get(clientId), 8859 attributes: newState.attributes.get(clientId), 8860 innerBlocks: newState.tree.get(clientId).innerBlocks 8861 }); 8862 }); 8863 updateParentInnerBlocksInTree(newState, updatedBlockUids, false); 8864 } 8865 } 8866 return newState; 8867 }; 8868 8869 /** 8870 * Higher-order reducer intended to augment the blocks reducer, assigning an 8871 * `isPersistentChange` property value corresponding to whether a change in 8872 * state can be considered as persistent. All changes are considered persistent 8873 * except when updating the same block attribute as in the previous action. 8874 * 8875 * @param {Function} reducer Original reducer function. 8876 * 8877 * @return {Function} Enhanced reducer function. 8878 */ 8879 function withPersistentBlockChange(reducer) { 8880 let lastAction; 8881 let markNextChangeAsNotPersistent = false; 8882 let explicitPersistent; 8883 return (state, action) => { 8884 let nextState = reducer(state, action); 8885 let nextIsPersistentChange; 8886 if (action.type === 'SET_EXPLICIT_PERSISTENT') { 8887 var _state$isPersistentCh; 8888 explicitPersistent = action.isPersistentChange; 8889 nextIsPersistentChange = (_state$isPersistentCh = state.isPersistentChange) !== null && _state$isPersistentCh !== void 0 ? _state$isPersistentCh : true; 8890 } 8891 if (explicitPersistent !== undefined) { 8892 nextIsPersistentChange = explicitPersistent; 8893 return nextIsPersistentChange === nextState.isPersistentChange ? nextState : { 8894 ...nextState, 8895 isPersistentChange: nextIsPersistentChange 8896 }; 8897 } 8898 const isExplicitPersistentChange = action.type === 'MARK_LAST_CHANGE_AS_PERSISTENT' || markNextChangeAsNotPersistent; 8899 8900 // Defer to previous state value (or default) unless changing or 8901 // explicitly marking as persistent. 8902 if (state === nextState && !isExplicitPersistentChange) { 8903 var _state$isPersistentCh2; 8904 markNextChangeAsNotPersistent = action.type === 'MARK_NEXT_CHANGE_AS_NOT_PERSISTENT'; 8905 nextIsPersistentChange = (_state$isPersistentCh2 = state?.isPersistentChange) !== null && _state$isPersistentCh2 !== void 0 ? _state$isPersistentCh2 : true; 8906 if (state.isPersistentChange === nextIsPersistentChange) { 8907 return state; 8908 } 8909 return { 8910 ...nextState, 8911 isPersistentChange: nextIsPersistentChange 8912 }; 8913 } 8914 nextState = { 8915 ...nextState, 8916 isPersistentChange: isExplicitPersistentChange ? !markNextChangeAsNotPersistent : !isUpdatingSameBlockAttribute(action, lastAction) 8917 }; 8918 8919 // In comparing against the previous action, consider only those which 8920 // would have qualified as one which would have been ignored or not 8921 // have resulted in a changed state. 8922 lastAction = action; 8923 markNextChangeAsNotPersistent = action.type === 'MARK_NEXT_CHANGE_AS_NOT_PERSISTENT'; 8924 return nextState; 8925 }; 8926 } 8927 8928 /** 8929 * Higher-order reducer intended to augment the blocks reducer, assigning an 8930 * `isIgnoredChange` property value corresponding to whether a change in state 8931 * can be considered as ignored. A change is considered ignored when the result 8932 * of an action not incurred by direct user interaction. 8933 * 8934 * @param {Function} reducer Original reducer function. 8935 * 8936 * @return {Function} Enhanced reducer function. 8937 */ 8938 function withIgnoredBlockChange(reducer) { 8939 /** 8940 * Set of action types for which a blocks state change should be ignored. 8941 * 8942 * @type {Set} 8943 */ 8944 const IGNORED_ACTION_TYPES = new Set(['RECEIVE_BLOCKS']); 8945 return (state, action) => { 8946 const nextState = reducer(state, action); 8947 if (nextState !== state) { 8948 nextState.isIgnoredChange = IGNORED_ACTION_TYPES.has(action.type); 8949 } 8950 return nextState; 8951 }; 8952 } 8953 8954 /** 8955 * Higher-order reducer targeting the combined blocks reducer, augmenting 8956 * block client IDs in remove action to include cascade of inner blocks. 8957 * 8958 * @param {Function} reducer Original reducer function. 8959 * 8960 * @return {Function} Enhanced reducer function. 8961 */ 8962 const withInnerBlocksRemoveCascade = reducer => (state, action) => { 8963 // Gets all children which need to be removed. 8964 const getAllChildren = clientIds => { 8965 let result = clientIds; 8966 for (let i = 0; i < result.length; i++) { 8967 if (!state.order.get(result[i]) || action.keepControlledInnerBlocks && action.keepControlledInnerBlocks[result[i]]) { 8968 continue; 8969 } 8970 if (result === clientIds) { 8971 result = [...result]; 8972 } 8973 result.push(...state.order.get(result[i])); 8974 } 8975 return result; 8976 }; 8977 if (state) { 8978 switch (action.type) { 8979 case 'REMOVE_BLOCKS': 8980 action = { 8981 ...action, 8982 type: 'REMOVE_BLOCKS_AUGMENTED_WITH_CHILDREN', 8983 removedClientIds: getAllChildren(action.clientIds) 8984 }; 8985 break; 8986 case 'REPLACE_BLOCKS': 8987 action = { 8988 ...action, 8989 type: 'REPLACE_BLOCKS_AUGMENTED_WITH_CHILDREN', 8990 replacedClientIds: getAllChildren(action.clientIds) 8991 }; 8992 break; 8993 } 8994 } 8995 return reducer(state, action); 8996 }; 8997 8998 /** 8999 * Higher-order reducer which targets the combined blocks reducer and handles 9000 * the `RESET_BLOCKS` action. When dispatched, this action will replace all 9001 * blocks that exist in the post, leaving blocks that exist only in state (e.g. 9002 * reusable blocks and blocks controlled by inner blocks controllers) alone. 9003 * 9004 * @param {Function} reducer Original reducer function. 9005 * 9006 * @return {Function} Enhanced reducer function. 9007 */ 9008 const withBlockReset = reducer => (state, action) => { 9009 if (action.type === 'RESET_BLOCKS') { 9010 const newState = { 9011 ...state, 9012 byClientId: new Map(getFlattenedBlocksWithoutAttributes(action.blocks)), 9013 attributes: new Map(getFlattenedBlockAttributes(action.blocks)), 9014 order: mapBlockOrder(action.blocks), 9015 parents: new Map(mapBlockParents(action.blocks)), 9016 controlledInnerBlocks: {} 9017 }; 9018 newState.tree = new Map(state?.tree); 9019 updateBlockTreeForBlocks(newState, action.blocks); 9020 newState.tree.set('', { 9021 innerBlocks: action.blocks.map(subBlock => newState.tree.get(subBlock.clientId)) 9022 }); 9023 return newState; 9024 } 9025 return reducer(state, action); 9026 }; 9027 9028 /** 9029 * Higher-order reducer which targets the combined blocks reducer and handles 9030 * the `REPLACE_INNER_BLOCKS` action. When dispatched, this action the state 9031 * should become equivalent to the execution of a `REMOVE_BLOCKS` action 9032 * containing all the child's of the root block followed by the execution of 9033 * `INSERT_BLOCKS` with the new blocks. 9034 * 9035 * @param {Function} reducer Original reducer function. 9036 * 9037 * @return {Function} Enhanced reducer function. 9038 */ 9039 const withReplaceInnerBlocks = reducer => (state, action) => { 9040 if (action.type !== 'REPLACE_INNER_BLOCKS') { 9041 return reducer(state, action); 9042 } 9043 9044 // Finds every nested inner block controller. We must check the action blocks 9045 // and not just the block parent state because some inner block controllers 9046 // should be deleted if specified, whereas others should not be deleted. If 9047 // a controlled should not be deleted, then we need to avoid deleting its 9048 // inner blocks from the block state because its inner blocks will not be 9049 // attached to the block in the action. 9050 const nestedControllers = {}; 9051 if (Object.keys(state.controlledInnerBlocks).length) { 9052 const stack = [...action.blocks]; 9053 while (stack.length) { 9054 const { 9055 innerBlocks, 9056 ...block 9057 } = stack.shift(); 9058 stack.push(...innerBlocks); 9059 if (!!state.controlledInnerBlocks[block.clientId]) { 9060 nestedControllers[block.clientId] = true; 9061 } 9062 } 9063 } 9064 9065 // The `keepControlledInnerBlocks` prop will keep the inner blocks of the 9066 // marked block in the block state so that they can be reattached to the 9067 // marked block when we re-insert everything a few lines below. 9068 let stateAfterBlocksRemoval = state; 9069 if (state.order.get(action.rootClientId)) { 9070 stateAfterBlocksRemoval = reducer(stateAfterBlocksRemoval, { 9071 type: 'REMOVE_BLOCKS', 9072 keepControlledInnerBlocks: nestedControllers, 9073 clientIds: state.order.get(action.rootClientId) 9074 }); 9075 } 9076 let stateAfterInsert = stateAfterBlocksRemoval; 9077 if (action.blocks.length) { 9078 stateAfterInsert = reducer(stateAfterInsert, { 9079 ...action, 9080 type: 'INSERT_BLOCKS', 9081 index: 0 9082 }); 9083 9084 // We need to re-attach the controlled inner blocks to the blocks tree and 9085 // preserve their block order. Otherwise, an inner block controller's blocks 9086 // will be deleted entirely from its entity. 9087 const stateAfterInsertOrder = new Map(stateAfterInsert.order); 9088 Object.keys(nestedControllers).forEach(key => { 9089 if (state.order.get(key)) { 9090 stateAfterInsertOrder.set(key, state.order.get(key)); 9091 } 9092 }); 9093 stateAfterInsert.order = stateAfterInsertOrder; 9094 stateAfterInsert.tree = new Map(stateAfterInsert.tree); 9095 Object.keys(nestedControllers).forEach(_key => { 9096 const key = `controlled||$_key}`; 9097 if (state.tree.has(key)) { 9098 stateAfterInsert.tree.set(key, state.tree.get(key)); 9099 } 9100 }); 9101 } 9102 return stateAfterInsert; 9103 }; 9104 9105 /** 9106 * Higher-order reducer which targets the combined blocks reducer and handles 9107 * the `SAVE_REUSABLE_BLOCK_SUCCESS` action. This action can't be handled by 9108 * regular reducers and needs a higher-order reducer since it needs access to 9109 * both `byClientId` and `attributes` simultaneously. 9110 * 9111 * @param {Function} reducer Original reducer function. 9112 * 9113 * @return {Function} Enhanced reducer function. 9114 */ 9115 const withSaveReusableBlock = reducer => (state, action) => { 9116 if (state && action.type === 'SAVE_REUSABLE_BLOCK_SUCCESS') { 9117 const { 9118 id, 9119 updatedId 9120 } = action; 9121 9122 // If a temporary reusable block is saved, we swap the temporary id with the final one. 9123 if (id === updatedId) { 9124 return state; 9125 } 9126 state = { 9127 ...state 9128 }; 9129 state.attributes = new Map(state.attributes); 9130 state.attributes.forEach((attributes, clientId) => { 9131 const { 9132 name 9133 } = state.byClientId.get(clientId); 9134 if (name === 'core/block' && attributes.ref === id) { 9135 state.attributes.set(clientId, { 9136 ...attributes, 9137 ref: updatedId 9138 }); 9139 } 9140 }); 9141 } 9142 return reducer(state, action); 9143 }; 9144 /** 9145 * Higher-order reducer which removes blocks from state when switching parent block controlled state. 9146 * 9147 * @param {Function} reducer Original reducer function. 9148 * 9149 * @return {Function} Enhanced reducer function. 9150 */ 9151 const withResetControlledBlocks = reducer => (state, action) => { 9152 if (action.type === 'SET_HAS_CONTROLLED_INNER_BLOCKS') { 9153 // when switching a block from controlled to uncontrolled or inverse, 9154 // we need to remove its content first. 9155 const tempState = reducer(state, { 9156 type: 'REPLACE_INNER_BLOCKS', 9157 rootClientId: action.clientId, 9158 blocks: [] 9159 }); 9160 return reducer(tempState, action); 9161 } 9162 return reducer(state, action); 9163 }; 9164 9165 /** 9166 * Reducer returning the blocks state. 9167 * 9168 * @param {Object} state Current state. 9169 * @param {Object} action Dispatched action. 9170 * 9171 * @return {Object} Updated state. 9172 */ 9173 const blocks = (0,external_wp_compose_namespaceObject.pipe)(external_wp_data_namespaceObject.combineReducers, withSaveReusableBlock, 9174 // Needs to be before withBlockCache. 9175 withBlockTree, 9176 // Needs to be before withInnerBlocksRemoveCascade. 9177 withInnerBlocksRemoveCascade, withReplaceInnerBlocks, 9178 // Needs to be after withInnerBlocksRemoveCascade. 9179 withBlockReset, withPersistentBlockChange, withIgnoredBlockChange, withResetControlledBlocks)({ 9180 // The state is using a Map instead of a plain object for performance reasons. 9181 // You can run the "./test/performance.js" unit test to check the impact 9182 // code changes can have on this reducer. 9183 byClientId(state = new Map(), action) { 9184 switch (action.type) { 9185 case 'RECEIVE_BLOCKS': 9186 case 'INSERT_BLOCKS': 9187 { 9188 const newState = new Map(state); 9189 getFlattenedBlocksWithoutAttributes(action.blocks).forEach(([key, value]) => { 9190 newState.set(key, value); 9191 }); 9192 return newState; 9193 } 9194 case 'UPDATE_BLOCK': 9195 { 9196 // Ignore updates if block isn't known. 9197 if (!state.has(action.clientId)) { 9198 return state; 9199 } 9200 9201 // Do nothing if only attributes change. 9202 const { 9203 attributes, 9204 ...changes 9205 } = action.updates; 9206 if (Object.values(changes).length === 0) { 9207 return state; 9208 } 9209 const newState = new Map(state); 9210 newState.set(action.clientId, { 9211 ...state.get(action.clientId), 9212 ...changes 9213 }); 9214 return newState; 9215 } 9216 case 'REPLACE_BLOCKS_AUGMENTED_WITH_CHILDREN': 9217 { 9218 if (!action.blocks) { 9219 return state; 9220 } 9221 const newState = new Map(state); 9222 action.replacedClientIds.forEach(clientId => { 9223 newState.delete(clientId); 9224 }); 9225 getFlattenedBlocksWithoutAttributes(action.blocks).forEach(([key, value]) => { 9226 newState.set(key, value); 9227 }); 9228 return newState; 9229 } 9230 case 'REMOVE_BLOCKS_AUGMENTED_WITH_CHILDREN': 9231 { 9232 const newState = new Map(state); 9233 action.removedClientIds.forEach(clientId => { 9234 newState.delete(clientId); 9235 }); 9236 return newState; 9237 } 9238 } 9239 return state; 9240 }, 9241 // The state is using a Map instead of a plain object for performance reasons. 9242 // You can run the "./test/performance.js" unit test to check the impact 9243 // code changes can have on this reducer. 9244 attributes(state = new Map(), action) { 9245 switch (action.type) { 9246 case 'RECEIVE_BLOCKS': 9247 case 'INSERT_BLOCKS': 9248 { 9249 const newState = new Map(state); 9250 getFlattenedBlockAttributes(action.blocks).forEach(([key, value]) => { 9251 newState.set(key, value); 9252 }); 9253 return newState; 9254 } 9255 case 'UPDATE_BLOCK': 9256 { 9257 // Ignore updates if block isn't known or there are no attribute changes. 9258 if (!state.get(action.clientId) || !action.updates.attributes) { 9259 return state; 9260 } 9261 const newState = new Map(state); 9262 newState.set(action.clientId, { 9263 ...state.get(action.clientId), 9264 ...action.updates.attributes 9265 }); 9266 return newState; 9267 } 9268 case 'SYNC_DERIVED_BLOCK_ATTRIBUTES': 9269 case 'UPDATE_BLOCK_ATTRIBUTES': 9270 { 9271 // Avoid a state change if none of the block IDs are known. 9272 if (action.clientIds.every(id => !state.get(id))) { 9273 return state; 9274 } 9275 let hasChange = false; 9276 const newState = new Map(state); 9277 for (const clientId of action.clientIds) { 9278 var _action$attributes; 9279 const updatedAttributeEntries = Object.entries(action.uniqueByBlock ? action.attributes[clientId] : (_action$attributes = action.attributes) !== null && _action$attributes !== void 0 ? _action$attributes : {}); 9280 if (updatedAttributeEntries.length === 0) { 9281 continue; 9282 } 9283 let hasUpdatedAttributes = false; 9284 const existingAttributes = state.get(clientId); 9285 const newAttributes = {}; 9286 updatedAttributeEntries.forEach(([key, value]) => { 9287 if (existingAttributes[key] !== value) { 9288 hasUpdatedAttributes = true; 9289 newAttributes[key] = value; 9290 } 9291 }); 9292 hasChange = hasChange || hasUpdatedAttributes; 9293 if (hasUpdatedAttributes) { 9294 newState.set(clientId, { 9295 ...existingAttributes, 9296 ...newAttributes 9297 }); 9298 } 9299 } 9300 return hasChange ? newState : state; 9301 } 9302 case 'REPLACE_BLOCKS_AUGMENTED_WITH_CHILDREN': 9303 { 9304 if (!action.blocks) { 9305 return state; 9306 } 9307 const newState = new Map(state); 9308 action.replacedClientIds.forEach(clientId => { 9309 newState.delete(clientId); 9310 }); 9311 getFlattenedBlockAttributes(action.blocks).forEach(([key, value]) => { 9312 newState.set(key, value); 9313 }); 9314 return newState; 9315 } 9316 case 'REMOVE_BLOCKS_AUGMENTED_WITH_CHILDREN': 9317 { 9318 const newState = new Map(state); 9319 action.removedClientIds.forEach(clientId => { 9320 newState.delete(clientId); 9321 }); 9322 return newState; 9323 } 9324 } 9325 return state; 9326 }, 9327 // The state is using a Map instead of a plain object for performance reasons. 9328 // You can run the "./test/performance.js" unit test to check the impact 9329 // code changes can have on this reducer. 9330 order(state = new Map(), action) { 9331 switch (action.type) { 9332 case 'RECEIVE_BLOCKS': 9333 { 9334 var _state$get; 9335 const blockOrder = mapBlockOrder(action.blocks); 9336 const newState = new Map(state); 9337 blockOrder.forEach((order, clientId) => { 9338 if (clientId !== '') { 9339 newState.set(clientId, order); 9340 } 9341 }); 9342 newState.set('', ((_state$get = state.get('')) !== null && _state$get !== void 0 ? _state$get : []).concat(blockOrder[''])); 9343 return newState; 9344 } 9345 case 'INSERT_BLOCKS': 9346 { 9347 const { 9348 rootClientId = '' 9349 } = action; 9350 const subState = state.get(rootClientId) || []; 9351 const mappedBlocks = mapBlockOrder(action.blocks, rootClientId); 9352 const { 9353 index = subState.length 9354 } = action; 9355 const newState = new Map(state); 9356 mappedBlocks.forEach((order, clientId) => { 9357 newState.set(clientId, order); 9358 }); 9359 newState.set(rootClientId, insertAt(subState, mappedBlocks.get(rootClientId), index)); 9360 return newState; 9361 } 9362 case 'MOVE_BLOCKS_TO_POSITION': 9363 { 9364 var _state$get$filter; 9365 const { 9366 fromRootClientId = '', 9367 toRootClientId = '', 9368 clientIds 9369 } = action; 9370 const { 9371 index = state.get(toRootClientId).length 9372 } = action; 9373 9374 // Moving inside the same parent block. 9375 if (fromRootClientId === toRootClientId) { 9376 const subState = state.get(toRootClientId); 9377 const fromIndex = subState.indexOf(clientIds[0]); 9378 const newState = new Map(state); 9379 newState.set(toRootClientId, moveTo(state.get(toRootClientId), fromIndex, index, clientIds.length)); 9380 return newState; 9381 } 9382 9383 // Moving from a parent block to another. 9384 const newState = new Map(state); 9385 newState.set(fromRootClientId, (_state$get$filter = state.get(fromRootClientId)?.filter(id => !clientIds.includes(id))) !== null && _state$get$filter !== void 0 ? _state$get$filter : []); 9386 newState.set(toRootClientId, insertAt(state.get(toRootClientId), clientIds, index)); 9387 return newState; 9388 } 9389 case 'MOVE_BLOCKS_UP': 9390 { 9391 const { 9392 clientIds, 9393 rootClientId = '' 9394 } = action; 9395 const firstClientId = clientIds[0]; 9396 const subState = state.get(rootClientId); 9397 if (!subState.length || firstClientId === subState[0]) { 9398 return state; 9399 } 9400 const firstIndex = subState.indexOf(firstClientId); 9401 const newState = new Map(state); 9402 newState.set(rootClientId, moveTo(subState, firstIndex, firstIndex - 1, clientIds.length)); 9403 return newState; 9404 } 9405 case 'MOVE_BLOCKS_DOWN': 9406 { 9407 const { 9408 clientIds, 9409 rootClientId = '' 9410 } = action; 9411 const firstClientId = clientIds[0]; 9412 const lastClientId = clientIds[clientIds.length - 1]; 9413 const subState = state.get(rootClientId); 9414 if (!subState.length || lastClientId === subState[subState.length - 1]) { 9415 return state; 9416 } 9417 const firstIndex = subState.indexOf(firstClientId); 9418 const newState = new Map(state); 9419 newState.set(rootClientId, moveTo(subState, firstIndex, firstIndex + 1, clientIds.length)); 9420 return newState; 9421 } 9422 case 'REPLACE_BLOCKS_AUGMENTED_WITH_CHILDREN': 9423 { 9424 const { 9425 clientIds 9426 } = action; 9427 if (!action.blocks) { 9428 return state; 9429 } 9430 const mappedBlocks = mapBlockOrder(action.blocks); 9431 const newState = new Map(state); 9432 action.replacedClientIds.forEach(clientId => { 9433 newState.delete(clientId); 9434 }); 9435 mappedBlocks.forEach((order, clientId) => { 9436 if (clientId !== '') { 9437 newState.set(clientId, order); 9438 } 9439 }); 9440 newState.forEach((order, clientId) => { 9441 const newSubOrder = Object.values(order).reduce((result, subClientId) => { 9442 if (subClientId === clientIds[0]) { 9443 return [...result, ...mappedBlocks.get('')]; 9444 } 9445 if (clientIds.indexOf(subClientId) === -1) { 9446 result.push(subClientId); 9447 } 9448 return result; 9449 }, []); 9450 newState.set(clientId, newSubOrder); 9451 }); 9452 return newState; 9453 } 9454 case 'REMOVE_BLOCKS_AUGMENTED_WITH_CHILDREN': 9455 { 9456 const newState = new Map(state); 9457 // Remove inner block ordering for removed blocks. 9458 action.removedClientIds.forEach(clientId => { 9459 newState.delete(clientId); 9460 }); 9461 newState.forEach((order, clientId) => { 9462 var _order$filter; 9463 const newSubOrder = (_order$filter = order?.filter(id => !action.removedClientIds.includes(id))) !== null && _order$filter !== void 0 ? _order$filter : []; 9464 if (newSubOrder.length !== order.length) { 9465 newState.set(clientId, newSubOrder); 9466 } 9467 }); 9468 return newState; 9469 } 9470 } 9471 return state; 9472 }, 9473 // While technically redundant data as the inverse of `order`, it serves as 9474 // an optimization for the selectors which derive the ancestry of a block. 9475 parents(state = new Map(), action) { 9476 switch (action.type) { 9477 case 'RECEIVE_BLOCKS': 9478 { 9479 const newState = new Map(state); 9480 mapBlockParents(action.blocks).forEach(([key, value]) => { 9481 newState.set(key, value); 9482 }); 9483 return newState; 9484 } 9485 case 'INSERT_BLOCKS': 9486 { 9487 const newState = new Map(state); 9488 mapBlockParents(action.blocks, action.rootClientId || '').forEach(([key, value]) => { 9489 newState.set(key, value); 9490 }); 9491 return newState; 9492 } 9493 case 'MOVE_BLOCKS_TO_POSITION': 9494 { 9495 const newState = new Map(state); 9496 action.clientIds.forEach(id => { 9497 newState.set(id, action.toRootClientId || ''); 9498 }); 9499 return newState; 9500 } 9501 case 'REPLACE_BLOCKS_AUGMENTED_WITH_CHILDREN': 9502 { 9503 const newState = new Map(state); 9504 action.replacedClientIds.forEach(clientId => { 9505 newState.delete(clientId); 9506 }); 9507 mapBlockParents(action.blocks, state.get(action.clientIds[0])).forEach(([key, value]) => { 9508 newState.set(key, value); 9509 }); 9510 return newState; 9511 } 9512 case 'REMOVE_BLOCKS_AUGMENTED_WITH_CHILDREN': 9513 { 9514 const newState = new Map(state); 9515 action.removedClientIds.forEach(clientId => { 9516 newState.delete(clientId); 9517 }); 9518 return newState; 9519 } 9520 } 9521 return state; 9522 }, 9523 controlledInnerBlocks(state = {}, { 9524 type, 9525 clientId, 9526 hasControlledInnerBlocks 9527 }) { 9528 if (type === 'SET_HAS_CONTROLLED_INNER_BLOCKS') { 9529 return { 9530 ...state, 9531 [clientId]: hasControlledInnerBlocks 9532 }; 9533 } 9534 return state; 9535 } 9536 }); 9537 9538 /** 9539 * Reducer returning visibility status of block interface. 9540 * 9541 * @param {boolean} state Current state. 9542 * @param {Object} action Dispatched action. 9543 * 9544 * @return {boolean} Updated state. 9545 */ 9546 function isBlockInterfaceHidden(state = false, action) { 9547 switch (action.type) { 9548 case 'HIDE_BLOCK_INTERFACE': 9549 return true; 9550 case 'SHOW_BLOCK_INTERFACE': 9551 return false; 9552 } 9553 return state; 9554 } 9555 9556 /** 9557 * Reducer returning typing state. 9558 * 9559 * @param {boolean} state Current state. 9560 * @param {Object} action Dispatched action. 9561 * 9562 * @return {boolean} Updated state. 9563 */ 9564 function isTyping(state = false, action) { 9565 switch (action.type) { 9566 case 'START_TYPING': 9567 return true; 9568 case 'STOP_TYPING': 9569 return false; 9570 } 9571 return state; 9572 } 9573 9574 /** 9575 * Reducer returning dragging state. It is possible for a user to be dragging 9576 * data from outside of the editor, so this state is separate from `draggedBlocks`. 9577 * 9578 * @param {boolean} state Current state. 9579 * @param {Object} action Dispatched action. 9580 * 9581 * @return {boolean} Updated state. 9582 */ 9583 function isDragging(state = false, action) { 9584 switch (action.type) { 9585 case 'START_DRAGGING': 9586 return true; 9587 case 'STOP_DRAGGING': 9588 return false; 9589 } 9590 return state; 9591 } 9592 9593 /** 9594 * Reducer returning dragged block client id. 9595 * 9596 * @param {string[]} state Current state. 9597 * @param {Object} action Dispatched action. 9598 * 9599 * @return {string[]} Updated state. 9600 */ 9601 function draggedBlocks(state = [], action) { 9602 switch (action.type) { 9603 case 'START_DRAGGING_BLOCKS': 9604 return action.clientIds; 9605 case 'STOP_DRAGGING_BLOCKS': 9606 return []; 9607 } 9608 return state; 9609 } 9610